{"version":3,"sources":["../../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/diff/8.0.3/c2a1d77e3f595587fc71d833e2045f3b897998b15167d647e8b9eeaae17f7bb2/node_modules/diff/libesm/diff/base.js","../../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/diff/8.0.3/c2a1d77e3f595587fc71d833e2045f3b897998b15167d647e8b9eeaae17f7bb2/node_modules/diff/libesm/diff/line.js","../../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/diff/8.0.3/c2a1d77e3f595587fc71d833e2045f3b897998b15167d647e8b9eeaae17f7bb2/node_modules/diff/libesm/patch/create.js","../../memory/src/processors/working-memory-state/processor.ts"],"names":["value","createHash"],"mappings":"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","file":"chunk-2ONW75MN.cjs","sourcesContent":["export default class Diff {\n    diff(oldStr, newStr, \n    // Type below is not accurate/complete - see above for full possibilities - but it compiles\n    options = {}) {\n        let callback;\n        if (typeof options === 'function') {\n            callback = options;\n            options = {};\n        }\n        else if ('callback' in options) {\n            callback = options.callback;\n        }\n        // Allow subclasses to massage the input prior to running\n        const oldString = this.castInput(oldStr, options);\n        const newString = this.castInput(newStr, options);\n        const oldTokens = this.removeEmpty(this.tokenize(oldString, options));\n        const newTokens = this.removeEmpty(this.tokenize(newString, options));\n        return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);\n    }\n    diffWithOptionsObj(oldTokens, newTokens, options, callback) {\n        var _a;\n        const done = (value) => {\n            value = this.postProcess(value, options);\n            if (callback) {\n                setTimeout(function () { callback(value); }, 0);\n                return undefined;\n            }\n            else {\n                return value;\n            }\n        };\n        const newLen = newTokens.length, oldLen = oldTokens.length;\n        let editLength = 1;\n        let maxEditLength = newLen + oldLen;\n        if (options.maxEditLength != null) {\n            maxEditLength = Math.min(maxEditLength, options.maxEditLength);\n        }\n        const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;\n        const abortAfterTimestamp = Date.now() + maxExecutionTime;\n        const bestPath = [{ oldPos: -1, lastComponent: undefined }];\n        // Seed editLength = 0, i.e. the content starts with the same values\n        let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);\n        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {\n            // Identity per the equality and tokenizer\n            return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));\n        }\n        // Once we hit the right edge of the edit graph on some diagonal k, we can\n        // definitely reach the end of the edit graph in no more than k edits, so\n        // there's no point in considering any moves to diagonal k+1 any more (from\n        // which we're guaranteed to need at least k+1 more edits).\n        // Similarly, once we've reached the bottom of the edit graph, there's no\n        // point considering moves to lower diagonals.\n        // We record this fact by setting minDiagonalToConsider and\n        // maxDiagonalToConsider to some finite value once we've hit the edge of\n        // the edit graph.\n        // This optimization is not faithful to the original algorithm presented in\n        // Myers's paper, which instead pointlessly extends D-paths off the end of\n        // the edit graph - see page 7 of Myers's paper which notes this point\n        // explicitly and illustrates it with a diagram. This has major performance\n        // implications for some common scenarios. For instance, to compute a diff\n        // where the new text simply appends d characters on the end of the\n        // original text of length n, the true Myers algorithm will take O(n+d^2)\n        // time while this optimization needs only O(n+d) time.\n        let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;\n        // Main worker method. checks all permutations of a given edit length for acceptance.\n        const execEditLength = () => {\n            for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {\n                let basePath;\n                const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];\n                if (removePath) {\n                    // No one else is going to attempt to use this value, clear it\n                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.\n                    bestPath[diagonalPath - 1] = undefined;\n                }\n                let canAdd = false;\n                if (addPath) {\n                    // what newPos will be after we do an insertion:\n                    const addPathNewPos = addPath.oldPos - diagonalPath;\n                    canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;\n                }\n                const canRemove = removePath && removePath.oldPos + 1 < oldLen;\n                if (!canAdd && !canRemove) {\n                    // If this path is a terminal then prune\n                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.\n                    bestPath[diagonalPath] = undefined;\n                    continue;\n                }\n                // Select the diagonal that we want to branch from. We select the prior\n                // path whose position in the old string is the farthest from the origin\n                // and does not pass the bounds of the diff graph\n                if (!canRemove || (canAdd && removePath.oldPos < addPath.oldPos)) {\n                    basePath = this.addToPath(addPath, true, false, 0, options);\n                }\n                else {\n                    basePath = this.addToPath(removePath, false, true, 1, options);\n                }\n                newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);\n                if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {\n                    // If we have hit the end of both strings, then we are done\n                    return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;\n                }\n                else {\n                    bestPath[diagonalPath] = basePath;\n                    if (basePath.oldPos + 1 >= oldLen) {\n                        maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);\n                    }\n                    if (newPos + 1 >= newLen) {\n                        minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);\n                    }\n                }\n            }\n            editLength++;\n        };\n        // Performs the length of edit iteration. Is a bit fugly as this has to support the\n        // sync and async mode which is never fun. Loops over execEditLength until a value\n        // is produced, or until the edit length exceeds options.maxEditLength (if given),\n        // in which case it will return undefined.\n        if (callback) {\n            (function exec() {\n                setTimeout(function () {\n                    if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {\n                        return callback(undefined);\n                    }\n                    if (!execEditLength()) {\n                        exec();\n                    }\n                }, 0);\n            }());\n        }\n        else {\n            while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {\n                const ret = execEditLength();\n                if (ret) {\n                    return ret;\n                }\n            }\n        }\n    }\n    addToPath(path, added, removed, oldPosInc, options) {\n        const last = path.lastComponent;\n        if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {\n            return {\n                oldPos: path.oldPos + oldPosInc,\n                lastComponent: { count: last.count + 1, added: added, removed: removed, previousComponent: last.previousComponent }\n            };\n        }\n        else {\n            return {\n                oldPos: path.oldPos + oldPosInc,\n                lastComponent: { count: 1, added: added, removed: removed, previousComponent: last }\n            };\n        }\n    }\n    extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {\n        const newLen = newTokens.length, oldLen = oldTokens.length;\n        let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;\n        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {\n            newPos++;\n            oldPos++;\n            commonCount++;\n            if (options.oneChangePerToken) {\n                basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };\n            }\n        }\n        if (commonCount && !options.oneChangePerToken) {\n            basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };\n        }\n        basePath.oldPos = oldPos;\n        return newPos;\n    }\n    equals(left, right, options) {\n        if (options.comparator) {\n            return options.comparator(left, right);\n        }\n        else {\n            return left === right\n                || (!!options.ignoreCase && left.toLowerCase() === right.toLowerCase());\n        }\n    }\n    removeEmpty(array) {\n        const ret = [];\n        for (let i = 0; i < array.length; i++) {\n            if (array[i]) {\n                ret.push(array[i]);\n            }\n        }\n        return ret;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    castInput(value, options) {\n        return value;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    tokenize(value, options) {\n        return Array.from(value);\n    }\n    join(chars) {\n        // Assumes ValueT is string, which is the case for most subclasses.\n        // When it's false, e.g. in diffArrays, this method needs to be overridden (e.g. with a no-op)\n        // Yes, the casts are verbose and ugly, because this pattern - of having the base class SORT OF\n        // assume tokens and values are strings, but not completely - is weird and janky.\n        return chars.join('');\n    }\n    postProcess(changeObjects, \n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    options) {\n        return changeObjects;\n    }\n    get useLongestToken() {\n        return false;\n    }\n    buildValues(lastComponent, newTokens, oldTokens) {\n        // First we convert our linked list of components in reverse order to an\n        // array in the right order:\n        const components = [];\n        let nextComponent;\n        while (lastComponent) {\n            components.push(lastComponent);\n            nextComponent = lastComponent.previousComponent;\n            delete lastComponent.previousComponent;\n            lastComponent = nextComponent;\n        }\n        components.reverse();\n        const componentLen = components.length;\n        let componentPos = 0, newPos = 0, oldPos = 0;\n        for (; componentPos < componentLen; componentPos++) {\n            const component = components[componentPos];\n            if (!component.removed) {\n                if (!component.added && this.useLongestToken) {\n                    let value = newTokens.slice(newPos, newPos + component.count);\n                    value = value.map(function (value, i) {\n                        const oldValue = oldTokens[oldPos + i];\n                        return oldValue.length > value.length ? oldValue : value;\n                    });\n                    component.value = this.join(value);\n                }\n                else {\n                    component.value = this.join(newTokens.slice(newPos, newPos + component.count));\n                }\n                newPos += component.count;\n                // Common case\n                if (!component.added) {\n                    oldPos += component.count;\n                }\n            }\n            else {\n                component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));\n                oldPos += component.count;\n            }\n        }\n        return components;\n    }\n}\n","import Diff from './base.js';\nimport { generateOptions } from '../util/params.js';\nclass LineDiff extends Diff {\n    constructor() {\n        super(...arguments);\n        this.tokenize = tokenize;\n    }\n    equals(left, right, options) {\n        // If we're ignoring whitespace, we need to normalise lines by stripping\n        // whitespace before checking equality. (This has an annoying interaction\n        // with newlineIsToken that requires special handling: if newlines get their\n        // own token, then we DON'T want to trim the *newline* tokens down to empty\n        // strings, since this would cause us to treat whitespace-only line content\n        // as equal to a separator between lines, which would be weird and\n        // inconsistent with the documented behavior of the options.)\n        if (options.ignoreWhitespace) {\n            if (!options.newlineIsToken || !left.includes('\\n')) {\n                left = left.trim();\n            }\n            if (!options.newlineIsToken || !right.includes('\\n')) {\n                right = right.trim();\n            }\n        }\n        else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {\n            if (left.endsWith('\\n')) {\n                left = left.slice(0, -1);\n            }\n            if (right.endsWith('\\n')) {\n                right = right.slice(0, -1);\n            }\n        }\n        return super.equals(left, right, options);\n    }\n}\nexport const lineDiff = new LineDiff();\nexport function diffLines(oldStr, newStr, options) {\n    return lineDiff.diff(oldStr, newStr, options);\n}\nexport function diffTrimmedLines(oldStr, newStr, options) {\n    options = generateOptions(options, { ignoreWhitespace: true });\n    return lineDiff.diff(oldStr, newStr, options);\n}\n// Exported standalone so it can be used from jsonDiff too.\nexport function tokenize(value, options) {\n    if (options.stripTrailingCr) {\n        // remove one \\r before \\n to match GNU diff's --strip-trailing-cr behavior\n        value = value.replace(/\\r\\n/g, '\\n');\n    }\n    const retLines = [], linesAndNewlines = value.split(/(\\n|\\r\\n)/);\n    // Ignore the final empty token that occurs if the string ends with a new line\n    if (!linesAndNewlines[linesAndNewlines.length - 1]) {\n        linesAndNewlines.pop();\n    }\n    // Merge the content and line separators into single tokens\n    for (let i = 0; i < linesAndNewlines.length; i++) {\n        const line = linesAndNewlines[i];\n        if (i % 2 && !options.newlineIsToken) {\n            retLines[retLines.length - 1] += line;\n        }\n        else {\n            retLines.push(line);\n        }\n    }\n    return retLines;\n}\n","import { diffLines } from '../diff/line.js';\nexport const INCLUDE_HEADERS = {\n    includeIndex: true,\n    includeUnderline: true,\n    includeFileHeaders: true\n};\nexport const FILE_HEADERS_ONLY = {\n    includeIndex: false,\n    includeUnderline: false,\n    includeFileHeaders: true\n};\nexport const OMIT_HEADERS = {\n    includeIndex: false,\n    includeUnderline: false,\n    includeFileHeaders: false\n};\nexport function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n    let optionsObj;\n    if (!options) {\n        optionsObj = {};\n    }\n    else if (typeof options === 'function') {\n        optionsObj = { callback: options };\n    }\n    else {\n        optionsObj = options;\n    }\n    if (typeof optionsObj.context === 'undefined') {\n        optionsObj.context = 4;\n    }\n    // We copy this into its own variable to placate TypeScript, which thinks\n    // optionsObj.context might be undefined in the callbacks below.\n    const context = optionsObj.context;\n    // @ts-expect-error (runtime check for something that is correctly a static type error)\n    if (optionsObj.newlineIsToken) {\n        throw new Error('newlineIsToken may not be used with patch-generation functions, only with diffing functions');\n    }\n    if (!optionsObj.callback) {\n        return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));\n    }\n    else {\n        const { callback } = optionsObj;\n        diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {\n                const patch = diffLinesResultToPatch(diff);\n                // TypeScript is unhappy without the cast because it does not understand that `patch` may\n                // be undefined here only if `callback` is StructuredPatchCallbackAbortable:\n                callback(patch);\n            } }));\n    }\n    function diffLinesResultToPatch(diff) {\n        // STEP 1: Build up the patch with no \"\\ No newline at end of file\" lines and with the arrays\n        //         of lines containing trailing newline characters. We'll tidy up later...\n        if (!diff) {\n            return;\n        }\n        diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier\n        function contextLines(lines) {\n            return lines.map(function (entry) { return ' ' + entry; });\n        }\n        const hunks = [];\n        let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;\n        for (let i = 0; i < diff.length; i++) {\n            const current = diff[i], lines = current.lines || splitLines(current.value);\n            current.lines = lines;\n            if (current.added || current.removed) {\n                // If we have previous context, start with that\n                if (!oldRangeStart) {\n                    const prev = diff[i - 1];\n                    oldRangeStart = oldLine;\n                    newRangeStart = newLine;\n                    if (prev) {\n                        curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];\n                        oldRangeStart -= curRange.length;\n                        newRangeStart -= curRange.length;\n                    }\n                }\n                // Output our changes\n                for (const line of lines) {\n                    curRange.push((current.added ? '+' : '-') + line);\n                }\n                // Track the updated file position\n                if (current.added) {\n                    newLine += lines.length;\n                }\n                else {\n                    oldLine += lines.length;\n                }\n            }\n            else {\n                // Identical context lines. Track line changes\n                if (oldRangeStart) {\n                    // Close out any changes that have been output (or join overlapping)\n                    if (lines.length <= context * 2 && i < diff.length - 2) {\n                        // Overlapping\n                        for (const line of contextLines(lines)) {\n                            curRange.push(line);\n                        }\n                    }\n                    else {\n                        // end the range and output\n                        const contextSize = Math.min(lines.length, context);\n                        for (const line of contextLines(lines.slice(0, contextSize))) {\n                            curRange.push(line);\n                        }\n                        const hunk = {\n                            oldStart: oldRangeStart,\n                            oldLines: (oldLine - oldRangeStart + contextSize),\n                            newStart: newRangeStart,\n                            newLines: (newLine - newRangeStart + contextSize),\n                            lines: curRange\n                        };\n                        hunks.push(hunk);\n                        oldRangeStart = 0;\n                        newRangeStart = 0;\n                        curRange = [];\n                    }\n                }\n                oldLine += lines.length;\n                newLine += lines.length;\n            }\n        }\n        // Step 2: eliminate the trailing `\\n` from each line of each hunk, and, where needed, add\n        //         \"\\ No newline at end of file\".\n        for (const hunk of hunks) {\n            for (let i = 0; i < hunk.lines.length; i++) {\n                if (hunk.lines[i].endsWith('\\n')) {\n                    hunk.lines[i] = hunk.lines[i].slice(0, -1);\n                }\n                else {\n                    hunk.lines.splice(i + 1, 0, '\\\\ No newline at end of file');\n                    i++; // Skip the line we just added, then continue iterating\n                }\n            }\n        }\n        return {\n            oldFileName: oldFileName, newFileName: newFileName,\n            oldHeader: oldHeader, newHeader: newHeader,\n            hunks: hunks\n        };\n    }\n}\n/**\n * creates a unified diff patch.\n * @param patch either a single structured patch object (as returned by `structuredPatch`) or an array of them (as returned by `parsePatch`)\n */\nexport function formatPatch(patch, headerOptions) {\n    if (!headerOptions) {\n        headerOptions = INCLUDE_HEADERS;\n    }\n    if (Array.isArray(patch)) {\n        if (patch.length > 1 && !headerOptions.includeFileHeaders) {\n            throw new Error('Cannot omit file headers on a multi-file patch. '\n                + '(The result would be unparseable; how would a tool trying to apply '\n                + 'the patch know which changes are to which file?)');\n        }\n        return patch.map(p => formatPatch(p, headerOptions)).join('\\n');\n    }\n    const ret = [];\n    if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {\n        ret.push('Index: ' + patch.oldFileName);\n    }\n    if (headerOptions.includeUnderline) {\n        ret.push('===================================================================');\n    }\n    if (headerOptions.includeFileHeaders) {\n        ret.push('--- ' + patch.oldFileName + (typeof patch.oldHeader === 'undefined' ? '' : '\\t' + patch.oldHeader));\n        ret.push('+++ ' + patch.newFileName + (typeof patch.newHeader === 'undefined' ? '' : '\\t' + patch.newHeader));\n    }\n    for (let i = 0; i < patch.hunks.length; i++) {\n        const hunk = patch.hunks[i];\n        // Unified Diff Format quirk: If the chunk size is 0,\n        // the first number is one lower than one would expect.\n        // https://www.artima.com/weblogs/viewpost.jsp?thread=164293\n        if (hunk.oldLines === 0) {\n            hunk.oldStart -= 1;\n        }\n        if (hunk.newLines === 0) {\n            hunk.newStart -= 1;\n        }\n        ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines\n            + ' +' + hunk.newStart + ',' + hunk.newLines\n            + ' @@');\n        for (const line of hunk.lines) {\n            ret.push(line);\n        }\n    }\n    return ret.join('\\n') + '\\n';\n}\nexport function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n    if (typeof options === 'function') {\n        options = { callback: options };\n    }\n    if (!(options === null || options === void 0 ? void 0 : options.callback)) {\n        const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);\n        if (!patchObj) {\n            return;\n        }\n        return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);\n    }\n    else {\n        const { callback } = options;\n        structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: patchObj => {\n                if (!patchObj) {\n                    callback(undefined);\n                }\n                else {\n                    callback(formatPatch(patchObj, options.headerOptions));\n                }\n            } }));\n    }\n}\nexport function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n    return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n/**\n * Split `text` into an array of lines, including the trailing newline character (where present)\n */\nfunction splitLines(text) {\n    const hasTrailingNl = text.endsWith('\\n');\n    const result = text.split('\\n').map(line => line + '\\n');\n    if (hasTrailingNl) {\n        result.pop();\n    }\n    else {\n        result.push(result.pop().slice(0, -1));\n    }\n    return result;\n}\n","/**\n * WorkingMemoryStateProcessor\n *\n * Experimental: delivers working memory to the model as a state signal instead\n * of folding it into the system message. Storage and the `setWorkingMemory`\n * tool are unchanged — this processor only changes the delivery path.\n *\n * Pattern matches `BrowserContextProcessor` in `@mastra/core/browser`:\n * - `stateId` namespaces the state lane on the thread.\n * - `cacheKey` is derived from the rendered payload so dedup is automatic.\n * - `contextWindow.hasSnapshot` re-injection ensures the model still sees the\n *   current snapshot after older messages drop out of the window.\n *\n * Delta emission (markdown mode only): when a prior snapshot exists in the\n * context window, the processor emits a unified-diff delta against that\n * snapshot's contents. Schema mode and the snapshot fallback always emit a\n * full snapshot.\n *\n * @example\n * ```ts\n * new Memory({\n *   options: {\n *     workingMemory: {\n *       enabled: true,\n *       template: '...',\n *       useStateSignals: true, // auto-attaches this processor\n *     },\n *   },\n * });\n * ```\n */\n\nimport { createHash } from 'node:crypto';\n\nimport type { MastraMemory, MemoryConfigInternal, WorkingMemoryTemplate } from '@mastra/core/memory';\nimport type {\n  ComputeStateSignalArgs,\n  ComputeStateSignalResult,\n  Processor,\n  ProcessorActiveStateSignal,\n} from '@mastra/core/processors';\nimport { structuredPatch } from 'diff';\n\nexport const WORKING_MEMORY_STATE_ID = 'working-memory';\nexport const WORKING_MEMORY_STATE_PROCESSOR_ID = 'working-memory-state';\n\nexport class WorkingMemoryStateProcessor implements Processor<typeof WORKING_MEMORY_STATE_PROCESSOR_ID> {\n  readonly id = WORKING_MEMORY_STATE_PROCESSOR_ID;\n  readonly stateId = WORKING_MEMORY_STATE_ID;\n\n  constructor(\n    private readonly memory: MastraMemory,\n    private readonly memoryConfig?: MemoryConfigInternal,\n  ) {}\n\n  async computeStateSignal(args: ComputeStateSignalArgs): Promise<ComputeStateSignalResult> {\n    const template = await this.memory.getWorkingMemoryTemplate({ memoryConfig: this.memoryConfig });\n    if (!template) return;\n\n    const data = await this.memory.getWorkingMemory({\n      threadId: args.threadId,\n      resourceId: args.resourceId,\n      memoryConfig: this.memoryConfig,\n    });\n\n    // Nothing stored yet — no state to broadcast. The setWorkingMemory tool\n    // description tells the model the expected shape; the signal carries state.\n    const contents = data?.trim();\n    if (!contents) return;\n\n    const cacheKey = stableWorkingMemoryCacheKey({ format: template.format, data: contents });\n    const shouldMakeSnapshot = !args.contextWindow.hasSnapshot;\n    if (args.tracking?.currentCacheKey === cacheKey && !shouldMakeSnapshot) return;\n\n    const mergedConfig = this.memory.getMergedThreadConfig(this.memoryConfig);\n    const scope = mergedConfig.workingMemory?.scope ?? 'resource';\n\n    const deltaCandidate =\n      template.format === 'markdown' && !shouldMakeSnapshot\n        ? buildMarkdownDelta({\n            lastSnapshot: args.lastSnapshot,\n            deltasSinceSnapshot: args.deltasSinceSnapshot,\n            nextContents: contents,\n          })\n        : undefined;\n\n    if (deltaCandidate) {\n      return {\n        id: WORKING_MEMORY_STATE_ID,\n        mode: 'delta',\n        cacheKey,\n        tagName: 'working-memory',\n        contents: deltaCandidate.contents,\n        delta: deltaCandidate.contents,\n        // Stash the full post-edit text on the signal so the next turn can\n        // diff against the most recently emitted state instead of the older\n        // snapshot. Invisible to the model.\n        value: contents,\n        attributes: {\n          format: template.format,\n          scope,\n          patch: 'unified-diff',\n        },\n      };\n    }\n\n    return {\n      id: WORKING_MEMORY_STATE_ID,\n      mode: 'snapshot',\n      cacheKey,\n      tagName: 'working-memory',\n      contents,\n      // Mirror contents in value so the first delta after a snapshot has a\n      // typed prior-state to diff against without falling back to contents.\n      value: contents,\n      attributes: {\n        format: template.format,\n        scope,\n      },\n    };\n  }\n}\n\n/**\n * Stable cache key for the rendered working memory payload. Returns a SHA-256\n * digest so dedup metadata stays compact regardless of payload size (working\n * memory blobs can grow arbitrarily long).\n */\nexport function stableWorkingMemoryCacheKey(input: {\n  format: WorkingMemoryTemplate['format'];\n  data: string | null;\n}): string {\n  const hash = createHash('sha256');\n  hash.update(input.format);\n  hash.update('\\0');\n  hash.update(input.data ?? '');\n  return `sha256:${hash.digest('hex')}`;\n}\n\n/**\n * Build a unified-diff delta against the most recently emitted state. Prefers\n * the latest delta's `value` (the post-edit full text) when available, falling\n * back to the snapshot's `value` and finally the snapshot's `contents`. This\n * keeps deltas incremental (B→C) instead of cumulative against a stale\n * snapshot (A→C), which matters when many small edits land between snapshots.\n *\n * Returns undefined when:\n * - there's no prior state to diff against\n * - the prior state isn't a plain string (multimodal signal)\n *\n * In either case the caller falls back to emitting a full snapshot.\n */\nfunction buildMarkdownDelta(args: {\n  lastSnapshot?: ProcessorActiveStateSignal;\n  deltasSinceSnapshot: ProcessorActiveStateSignal[];\n  nextContents: string;\n}): { contents: string } | undefined {\n  const { lastSnapshot, deltasSinceSnapshot, nextContents } = args;\n\n  // `value` is stored on the persisted signal's metadata (see applyStateSignal\n  // in @mastra/core/agent/state-signals). Read from there to recover the\n  // post-edit full text from the most recently emitted state.\n  const latestDelta = deltasSinceSnapshot.at(-1);\n  const prior =\n    pickStringValue(readSignalValue(latestDelta)) ??\n    pickStringValue(readSignalValue(lastSnapshot)) ??\n    (typeof lastSnapshot?.contents === 'string' ? lastSnapshot.contents : undefined);\n  ('');\n  if (!prior) return;\n\n  const patch = renderHunksOnly(prior, nextContents);\n\n  return { contents: patch };\n}\n\nfunction pickStringValue(value: unknown): string | undefined {\n  return typeof value === 'string' ? value : undefined;\n}\n\nfunction readSignalValue(signal: ProcessorActiveStateSignal | undefined): unknown {\n  return (signal?.metadata as { value?: unknown } | undefined)?.value;\n}\n\n/**\n * Render a unified-diff-style patch body containing only `@@` hunks and their\n * lines — dropping the filename preamble (`Index:` / `===` / `---` / `+++`)\n * that `createPatch` emits and the `\\ No newline at end of file` trailer.\n * The preamble exists for tooling like `patch -p1` to know which file to\n * apply to; we only ever diff a single working-memory blob. The newline\n * trailer is semantically meaningless to the model and adds noise to the\n * state signal.\n */\nfunction renderHunksOnly(prior: string, next: string): string {\n  const { hunks } = structuredPatch('', '', prior, next, '', '', { context: 0 });\n  return hunks\n    .map(hunk => {\n      const header = `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;\n      const lines = hunk.lines.filter(line => !line.startsWith('\\\\ No newline at end of file'));\n      return [header, ...lines].join('\\n');\n    })\n    .join('\\n');\n}\n"]}