maka-agent 0.2.0-dev.12.20260901 → 0.2.0-dev.14.20260902

package/node_modules/@maka/runtime/dist/archive-read-tool.js

@@ -27,28 +27,38 @@ export function buildArchiveReadTool(reader) {
             .string()
             .describe('A maka://archive/... ref returned in an archived tool-result placeholder'),
         operation: z
-            .enum(['inspect', 'read', 'query'])
+            .enum(['inspect', 'read', 'query', 'search'])
             .default('inspect')
-            .describe('inspect lists archive metadata/items; query reads one structured item; read returns one bounded raw page'),
+            .describe('inspect lists archive metadata/items and a preview; query reads one structured item; read returns one bounded page (by character or line); search locates a substring'),
+        unit: z
+            .enum(['char', 'line'])
+            .default('char')
+            .describe('For read: whether offset/limit count characters (default) or whole lines'),
         offset: z
             .number()
             .int()
             .nonnegative()
             .optional()
-            .describe('Zero-based character offset for read/query pagination'),
+            .describe('Zero-based start for pagination: character or line offset for read (per unit), character offset for query, or the character position to resume search from'),
         limit: z
             .number()
             .int()
             .positive()
             .max(TOOL_RESULT_ARCHIVE_MAX_LIMIT)
             .optional()
-            .describe(`Maximum returned characters, capped at ${TOOL_RESULT_ARCHIVE_MAX_LIMIT}`),
+            .describe(`Maximum returned characters (or lines when unit is "line"), capped at ${TOOL_RESULT_ARCHIVE_MAX_LIMIT}`),
         itemId: z
             .string()
             .min(1)
             .max(256)
             .optional()
             .describe('Structured item id returned by inspect; required for query'),
+        pattern: z
+            .string()
+            .min(1)
+            .max(256)
+            .optional()
+            .describe('Literal, case-insensitive substring to locate; required for search'),
     })
         .strip()
         .superRefine((value, ctx) => {
@@ -59,13 +69,20 @@ export function buildArchiveReadTool(reader) {
                 message: 'itemId is required for query',
             });
         }
+        if (value.operation === 'search' && !value.pattern) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['pattern'],
+                message: 'pattern is required for search',
+            });
+        }
     }));
     const providerSchema = zodSchema(parameters);
     return {
         name: ARCHIVE_READ_TOOL_NAME,
         displayName: 'Read archived result',
         activityKind: 'read',
-        description: 'Inspect or page through a tool-result archive returned as a maka://archive/... ref. Start with inspect. For agent_swarm archives, query one itemId at a time. Results are strictly bounded so reading an archive cannot immediately trigger another archive.',
+        description: 'Inspect, search, or page through a tool-result archive returned as a maka://archive/... ref. Start with inspect for a preview and the char/line coordinate space. Use operation "search" with a pattern to locate text, operation "read" with unit "line" for line-oriented terminal output, or operation "query" with an itemId for one agent_swarm item. Results are strictly bounded so reading an archive cannot immediately trigger another archive.',
         parameters: jsonSchema(async () => await providerSchema.jsonSchema, {
             validate: async (value) => {
                 const result = await parameters.safeParseAsync(value);
@@ -84,6 +101,10 @@ function cleanArchiveReadInput(input) {
     const operation = cleaned.operation ?? 'inspect';
     if (operation !== 'query')
         delete cleaned.itemId;
+    if (operation !== 'search')
+        delete cleaned.pattern;
+    if (operation !== 'read')
+        delete cleaned.unit;
     if (operation === 'inspect') {
         delete cleaned.offset;
         delete cleaned.limit;

package/node_modules/@maka/runtime/dist/builtin-tools.js

@@ -27,6 +27,7 @@ import { tmpdir } from 'node:os';
 import { basename, dirname } from 'node:path';
 import { compilePermissionProfile } from '@maka/core/permission-profile-compiler';
 import { parseAttachmentResourceRef } from '@maka/core/attachments';
+import { isStorageRef } from '@maka/core/events';
 import { bashToolResultToModelOutput } from './bash-model-output.js';
 import { fileWriteToolResultToModelOutput } from './file-tool-model-output.js';
 import { openAiApplyPatchInputSchema } from './openai-apply-patch.js';
@@ -236,6 +237,28 @@ export function buildBuiltinTools(options = {}) {
             description: readDescription,
             parameters: readParameters,
             executionFacts,
+            ...(options.releaseImageSnapshot
+                ? {
+                    compensateDurableOutcomeCommitFailure: async (input) => {
+                        const result = input.result;
+                        if (!result ||
+                            typeof result !== 'object' ||
+                            result.kind !== 'image') {
+                            return;
+                        }
+                        const ref = result.ref;
+                        if (!isStorageRef(ref) ||
+                            ref.kind !== 'session_context' ||
+                            ref.sessionId !== input.sessionId) {
+                            return;
+                        }
+                        await options.releaseImageSnapshot({
+                            sessionId: ref.sessionId,
+                            refId: ref.refId,
+                        });
+                    },
+                }
+                : {}),
             impl: async (input, ctx) => {
                 const { cwd, sessionId, abortSignal } = ctx;
                 if ('ref' in input) {
@@ -273,10 +296,12 @@ export function buildBuiltinTools(options = {}) {
                 if (result.kind === 'read_image') {
                     if (!options.snapshotImage)
                         throw new Error('Read image snapshots are not available in this toolset.');
+                    if (!ctx.operationId) {
+                        throw new Error('Read image snapshots require a durable tool operation identity.');
+                    }
                     const ref = await options.snapshotImage({
                         sessionId,
-                        turnId: ctx.turnId,
-                        name: basename(path),
+                        ownerId: ctx.operationId,
                         bytes: result.bytes,
                         mimeType: result.mimeType,
                     });

package/node_modules/@maka/runtime/dist/context-budget-policy.js

@@ -18,7 +18,6 @@
  */
 import { lookupModelMetadata } from '@maka/core/model-metadata';
 import { relayModelProfile } from '@maka/core/model-thinking';
-import { finitePositive } from './context-budget-helpers.js';
 export function buildDefaultContextBudgetPolicy(connection, options = {}) {
     const contextWindow = resolveSelectedModelContextWindow(connection, options.modelId);
     const reserveTokens = defaultCompactReserveTokens(contextWindow);
@@ -98,14 +97,3 @@ function narrowestPositiveLimit(...values) {
     const positiveValues = values.filter((value) => typeof value === 'number' && Number.isFinite(value) && value > 0);
     return positiveValues.length > 0 ? Math.min(...positiveValues) : undefined;
 }
-export function resolveContextBudgetCapacity(connection, modelId, policy) {
-    const selectedWindow = resolveSelectedModelContextWindow(connection, modelId);
-    if (selectedWindow !== undefined) {
-        return { tokens: selectedWindow, source: 'selected_model' };
-    }
-    const historyBudget = finitePositive(policy?.maxHistoryEstimatedTokens);
-    const reserveTokens = finitePositive(policy?.historyCompact?.midTurn?.reserveTokens);
-    if (historyBudget === undefined || reserveTokens === undefined)
-        return undefined;
-    return { tokens: historyBudget + reserveTokens, source: 'policy_fallback' };
-}

package/node_modules/@maka/runtime/dist/conversation-copy.js

@@ -34,6 +34,56 @@ import { rewriteDurableToolResultProjectionArtifactRefs } from './durable-tool-r
 import { buildModelProjectionTransition, decodeModelProjectionTransition, MODEL_PROJECTION_TRANSITION_EVENT_TYPE, } from '@maka/core/model-projection-transition';
 import { baseToolResultProjection, decodeLedgerTransition, reduceEffectiveModelProjections, } from './model-projection-transition-ledger.js';
 import { archivedToolResultProjection } from './tool-result-archive-transition.js';
+/** Walks every typed StorageRef site reached by conversation-copy rewriting. */
+function collectConversationCopyStorageRefs(input) {
+    const refs = [];
+    const addContent = (content) => {
+        if (content.kind === 'image')
+            refs.push(content.ref);
+    };
+    const addSerialized = (value) => {
+        if (isArchivedToolResultPlaceholder(value))
+            return;
+        try {
+            addContent(decodePersistedToolResultContent(markPersisted(value)));
+        }
+        catch {
+            // Opaque tool results carry no typed StorageRef.
+        }
+    };
+    for (const message of input.messages) {
+        if (message.type === 'user' && message.attachments) {
+            for (const attachment of message.attachments)
+                refs.push(attachment.ref);
+        }
+        else if (message.type === 'tool_result') {
+            addContent(message.content);
+        }
+    }
+    for (const event of input.runtimeEvents) {
+        if (event.content?.kind === 'text' && event.content.attachments) {
+            for (const attachment of event.content.attachments)
+                refs.push(attachment.ref);
+        }
+        else if (event.content?.kind === 'function_response') {
+            addSerialized(event.content.result);
+        }
+    }
+    for (const serializedResult of input.archivedResults) {
+        addSerialized(deserializeToolResultArchive(serializedResult));
+    }
+    return refs;
+}
+/** Finds durable Session context references that the exact copy will rewrite. */
+export function collectConversationCopySessionContextRefIds(input) {
+    const refIds = new Set();
+    for (const ref of collectConversationCopyStorageRefs(input)) {
+        if (ref.kind === 'session_context' && ref.sessionId === input.sourceSessionId) {
+            refIds.add(ref.refId);
+        }
+    }
+    return [...refIds].sort();
+}
 export function createConversationCopySlice(messages, sourceTurnId, boundary) {
     const turnOrder = [];
     const seen = new Set();
@@ -373,7 +423,8 @@ export function archivedToolResultContainsConversationOwnedReferences(serialized
     if (content.kind === 'archived_tool_result')
         return true;
     if (content.kind === 'image') {
-        return content.ref.kind === 'session_file' && content.ref.sessionId === sourceSessionId;
+        return ((content.ref.kind === 'session_file' || content.ref.kind === 'session_context') &&
+            content.ref.sessionId === sourceSessionId);
     }
     if (content.kind === 'subagent') {
         const [linked] = conversationCopyLinkedChildReferences(content);
@@ -473,45 +524,10 @@ export function collectConversationCopyLinkedChildReferences(input) {
  */
 export function collectConversationCopySessionFileRefs(input) {
     const refs = new Set();
-    const addRef = (ref) => {
+    for (const ref of collectConversationCopyStorageRefs(input)) {
         if (ref.kind === 'session_file' && ref.sessionId === input.sourceSessionId) {
             refs.add(ref.relativePath);
         }
-    };
-    const addContent = (content) => {
-        if (content.kind === 'image')
-            addRef(content.ref);
-    };
-    const addSerialized = (value) => {
-        if (isArchivedToolResultPlaceholder(value))
-            return;
-        try {
-            addContent(decodePersistedToolResultContent(markPersisted(value)));
-        }
-        catch {
-            // Opaque tool results carry no typed Session file reference.
-        }
-    };
-    for (const message of input.messages) {
-        if (message.type === 'user' && message.attachments) {
-            for (const attachment of message.attachments)
-                addRef(attachment.ref);
-        }
-        else if (message.type === 'tool_result') {
-            addContent(message.content);
-        }
-    }
-    for (const event of input.runtimeEvents) {
-        if (event.content?.kind === 'text' && event.content.attachments) {
-            for (const attachment of event.content.attachments)
-                addRef(attachment.ref);
-        }
-        else if (event.content?.kind === 'function_response') {
-            addSerialized(event.content.result);
-        }
-    }
-    for (const serializedResult of input.archivedResults) {
-        addSerialized(deserializeToolResultArchive(serializedResult));
     }
     return refs;
 }
@@ -1218,15 +1234,22 @@ function linkedChildReferencesAreExternal(linked, externalChildReferences) {
         linked.artifactIds.every((artifactId) => external.artifactIds.has(artifactId)));
 }
 function rewriteStorageRef(ref, references) {
-    if (ref.kind === 'session_context' && ref.sessionId === references.sourceSessionId) {
-        if (references.mode === 'preserve_external')
-            return ref;
-        throw new Error('Conversation copy does not support Session context references yet');
-    }
-    if (ref.kind !== 'session_file' || ref.sessionId !== references.sourceSessionId)
+    if ((ref.kind !== 'session_file' && ref.kind !== 'session_context') ||
+        ref.sessionId !== references.sourceSessionId) {
         return ref;
+    }
     if (references.mode === 'preserve_external')
         return ref;
+    if (ref.kind === 'session_context') {
+        const refId = references.contextRefs?.get(ref.refId);
+        if (!refId)
+            throw new Error(`Conversation copy is missing Session context ${ref.refId}`);
+        return {
+            ...ref,
+            sessionId: references.targetSessionId,
+            refId,
+        };
+    }
     const artifactId = references.artifactIds.get(ref.relativePath);
     if (artifactId) {
         return {

package/node_modules/@maka/runtime/dist/durable-tool-result-projection.js

@@ -121,6 +121,37 @@ export function durableProjectionToToolResultOutput(projection) {
             return { type: 'error-text', value: projection.message };
     }
 }
+/** The images the artifact parts of one durable projection put in the request. */
+export function projectionArtifactMedia(projection) {
+    if (projection.kind !== 'content')
+        return [];
+    return projection.parts.flatMap((part) => part.kind === 'artifact'
+        ? [
+            {
+                label: part.ref.kind === 'session_context' ? part.ref.refId : part.ref.relativePath,
+            },
+        ]
+        : []);
+}
+/**
+ * The images one Tool Result puts in the request: the artifact parts of its
+ * durable projection, or — for a pre-artifact image the decoder still hands to
+ * materialization raw — that legacy result.
+ */
+export function effectiveToolResultMedia(effective, sessionId) {
+    if (effective.kind === 'projection')
+        return projectionArtifactMedia(effective.projection);
+    if (effective.kind !== 'legacy_output')
+        return [];
+    const image = sessionImageResult(effective.output, sessionId);
+    if (!image)
+        return [];
+    return [
+        {
+            label: image.ref.kind === 'session_context' ? image.ref.refId : image.ref.relativePath,
+        },
+    ];
+}
 /**
  * The one pure decision of WHICH source a replayed Tool Result materializes
  * from: a durable projection wins, and only a response that has none (legacy

package/node_modules/@maka/runtime/dist/history-compact-error.js

@@ -16,9 +16,17 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { isContextBudgetExhaustedDetail, } from '@maka/core/events';
+/**
+ * Ways a summarizer's own output can be unusable. Owned here, in the
+ * history-compaction domain that produces and repairs them.
+ */
+const MALFORMED_HISTORY_COMPACT_SUMMARY_REASONS = [
+    'malformed_summary_missing_section',
+    'malformed_summary_truncated',
+    'malformed_summary_too_small_for_fold',
+];
 export function isMalformedHistoryCompactSummaryReason(reason) {
-    return isContextBudgetExhaustedDetail(reason) && reason.startsWith('malformed_summary_');
+    return MALFORMED_HISTORY_COMPACT_SUMMARY_REASONS.includes(reason);
 }
 export class HistoryCompactSummarizerError extends Error {
     reason;

package/node_modules/@maka/runtime/dist/history-compact-input-fit.js

@@ -38,6 +38,12 @@ export function fitHistoryCompactMessages(messages, options) {
         const message = bounded[messageIndex];
         if (message.role !== 'tool')
             continue;
+        // Accumulate replacements across the parts of this one tool message. A
+        // message that batches several tool results (one per parallel tool call)
+        // must keep every earlier placeholder, not just the last one — otherwise
+        // the returned history still carries full-size payloads even though the
+        // budget accounting already credited their removal.
+        let content = message.content;
         for (let partIndex = 0; partIndex < message.content.length; partIndex += 1) {
             const part = message.content[partIndex];
             if (part.type !== 'tool-result')
@@ -53,7 +59,7 @@ export function fitHistoryCompactMessages(messages, options) {
             const replacementChars = stableJsonLength(replacement);
             if (replacementChars >= originalChars)
                 continue;
-            const content = [...message.content];
+            content = [...content];
             content[partIndex] = replacement;
             bounded = [...bounded];
             bounded[messageIndex] = { ...message, content };

package/node_modules/@maka/runtime/dist/history-compaction.js

@@ -23,29 +23,24 @@ import { HistoryCompactSummarizerError, } from './history-compact-error.js';
 import { findCheckpointSummaryDefect } from './history-compact-summary-validation.js';
 import { buildHistoryCompactCheckpoint, historyCompactCheckpointToRuntimeEvent, matchHistoryCompactCheckpointPrefix, midTurnHeadAnchorEvent, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
 /**
- * Estimate the token size of the next provider request. Anchors on the last
- * step's real usage plus a signed char/4 payload delta for content the provider
- * has not yet counted (or no longer carries); cold-start (no usage) is a pure
- * char/4 estimate of the whole payload. This mirrors how surveyed peers avoid
- * pure character guessing.
+ * Estimate the token size of the next provider request: the last request's real
+ * usage plus a signed char/4 payload delta for content the provider has not yet
+ * counted (or no longer carries). Without a usable usage sample the caller
+ * passes the whole payload as the delta against a zero baseline, so this stays
+ * one formula. This mirrors how surveyed peers avoid pure character guessing.
  */
 export function estimateNextRequestTokens(input) {
     const charsPerToken = Math.max(1, input.charsPerToken ?? 4);
-    if (input.priorUsageTokens !== undefined && Number.isFinite(input.priorUsageTokens)) {
-        return Math.max(0, Math.max(0, Math.floor(input.priorUsageTokens)) +
-            estimateSignedChars(input.appendedChars, charsPerToken));
-    }
-    return Math.max(0, estimateSignedChars(input.coldStartChars ?? input.appendedChars, charsPerToken));
+    const prior = input.priorUsageTokens !== undefined && Number.isFinite(input.priorUsageTokens)
+        ? Math.max(0, Math.floor(input.priorUsageTokens))
+        : 0;
+    return Math.max(0, prior + estimateSignedChars(input.appendedChars, charsPerToken));
 }
 /** Proactive threshold: the next request would cross `contextWindow - reserve`. */
 export function exceedsHighWater(estimatedTokens, contextWindow, reserveTokens) {
     const highWater = Math.max(1, contextWindow - Math.max(0, reserveTokens));
     return estimatedTokens > highWater;
 }
-/** Hard cap: the estimate exceeds the raw context window even before the reserve. */
-export function exceedsContextWindow(estimatedTokens, contextWindow) {
-    return estimatedTokens > contextWindow;
-}
 /**
  * Select the largest contiguous covered prefix that is safe to fold:
  *
@@ -55,8 +50,8 @@ export function exceedsContextWindow(estimatedTokens, contextWindow) {
  *  - it leaves at least `reserveTailEvents` trailing events as the verbatim tail.
  *
  * Returns `no_safe_completed_span` when no such cut exists (e.g. the remaining
- * pool is a single atomic call/result pair), which the caller surfaces as an
- * explicit `context_budget_exhausted` outcome rather than a provider error.
+ * pool is a single atomic call/result pair); the caller then fails open and
+ * sends the request unchanged.
  */
 export function selectSafeCompactionPrefix(events, options = {}) {
     const reserveTail = Math.max(0, Math.floor(options.reserveTailEvents ?? 0));
@@ -129,12 +124,8 @@ function estimateSignedChars(chars, charsPerToken) {
  * Execute a triggered compaction command by deterministically folding the
  * largest safe prefix. Trigger policy is owned by callers; once this function
  * is called it always attempts the transaction. This plan is a pure shaper:
- * when it cannot fold a safe
- * completed prefix it FAILS OPEN (keep the raw projection + diagnostic) and
- * never terminates the turn itself. The two failure tiers — fail open under
- * the window, explicit `context_budget_exhausted` over it — are applied by the
- * backend's final-request estimate owner, which re-measures the actual outgoing
- * payload after all shaping (including this fold) has been applied.
+ * when it cannot fold a safe completed prefix it FAILS OPEN (keep the raw
+ * projection + diagnostic) and the request goes out unchanged.
  */
 export async function planHistoryCompaction(input) {
     const phase = input.phase ?? 'mid_turn';

package/node_modules/@maka/runtime/dist/model-history.js

@@ -52,7 +52,8 @@
  */
 import { isPartialRuntimeEvent, isTerminalRuntimeEvent, runtimeEventHasModelVisibleContent, } from '@maka/core/runtime-event';
 import { formatAttachmentResourceRef } from '@maka/core/attachments';
-import { decodeEffectiveToolResultProjection, durableProjectionToToolResultOutput, } from './durable-tool-result-projection.js';
+import { decodeEffectiveToolResultProjection, durableProjectionToToolResultOutput, effectiveToolResultMedia, } from './durable-tool-result-projection.js';
+import { MATERIALIZED_IMAGE_TOKENS } from '@maka/core/attachments';
 import { estimateTokens, stableJsonLength, turnKey } from './context-budget-helpers.js';
 export const PROVIDER_REPLAY_PROJECTION_VERSION = 2;
 /**
@@ -84,9 +85,9 @@ export function admitProviderReasoningReplayItems(items, providerReasoningReplay
 // Effective model-history sizing
 // ============================================================================
 /**
- * Model-visible character count of a `function_response`'s EFFECTIVE value —
- * the durable projection when the response has one, never the raw execution
- * fact the projection already bounded or redacted.
+ * Size of a `function_response`'s EFFECTIVE value — the durable projection
+ * when the response has one, never the raw execution fact the projection
+ * already bounded or redacted.
  *
  * Memoized on the content object because a legacy response (no durable
  * projection) is re-derived through the whole compatibility codec, and one
@@ -94,7 +95,7 @@ export function admitProviderReasoningReplayItems(items, providerReasoningReplay
  * compactable-content filter, and checkpoint prefix matching all walk the
  * history. Content is immutable once committed, so identity is a sound key.
  */
-const effectiveToolResultChars = new WeakMap();
+const effectiveToolResultSizes = new WeakMap();
 /** Model-visible character count of one materialized Tool Result output. */
 function estimateToolResultOutputChars(output) {
     switch (output.type) {
@@ -110,18 +111,24 @@ function estimateToolResultOutputChars(output) {
             return output.reason?.length ?? 0;
     }
 }
-export function estimateEffectiveToolResultChars(content, sessionId) {
-    const memoized = effectiveToolResultChars.get(content);
+function effectiveToolResultSize(content, sessionId) {
+    const memoized = effectiveToolResultSizes.get(content);
     if (memoized !== undefined)
         return memoized;
     const effective = decodeEffectiveToolResultProjection(content, sessionId);
-    const chars = effective.kind === 'projection'
-        ? estimateToolResultOutputChars(durableProjectionToToolResultOutput(effective.projection))
-        : effective.kind === 'invalid_legacy'
-            ? effective.message.length
-            : stableJsonLength(effective.output);
-    effectiveToolResultChars.set(content, chars);
-    return chars;
+    const size = {
+        chars: effective.kind === 'projection'
+            ? estimateToolResultOutputChars(durableProjectionToToolResultOutput(effective.projection))
+            : effective.kind === 'invalid_legacy'
+                ? effective.message.length
+                : stableJsonLength(effective.output),
+        mediaTokens: effectiveToolResultMedia(effective, sessionId).length * MATERIALIZED_IMAGE_TOKENS,
+    };
+    effectiveToolResultSizes.set(content, size);
+    return size;
+}
+export function estimateEffectiveToolResultChars(content, sessionId) {
+    return effectiveToolResultSize(content, sessionId).chars;
 }
 export function estimateRuntimeEventChars(event) {
     let total = 0;
@@ -136,9 +143,27 @@ export function estimateRuntimeEventChars(event) {
         total += content.message.length;
     return total;
 }
+/**
+ * Tokens one event costs beyond its characters. Stays in tokens instead of
+ * folding into the char count: `charsPerToken` calibrates text, and applying it
+ * to media would make an image cheaper on a session with a low text ratio.
+ */
+function estimateRuntimeEventMediaTokens(event) {
+    const content = event.content;
+    return content?.kind === 'function_response'
+        ? effectiveToolResultSize(content, event.sessionId).mediaTokens
+        : 0;
+}
 export function estimateRuntimeEventsTokens(events, charsPerToken = 4) {
-    const chars = events.reduce((total, event) => event.modelVisibility === 'hidden' ? total : total + estimateRuntimeEventChars(event), 0);
-    return estimateTokens(chars, charsPerToken);
+    let chars = 0;
+    let mediaTokens = 0;
+    for (const event of events) {
+        if (event.modelVisibility === 'hidden')
+            continue;
+        chars += estimateRuntimeEventChars(event);
+        mediaTokens += estimateRuntimeEventMediaTokens(event);
+    }
+    return estimateTokens(chars, charsPerToken) + mediaTokens;
 }
 export function groupEventsByTurn(events, charsPerToken) {
     const order = [];

package/node_modules/@maka/runtime/dist/provider-image-overflow-recovery.js

@@ -16,50 +16,31 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { decodeEffectiveToolResultProjection, effectiveToolResultMedia, } from './durable-tool-result-projection.js';
 function isRecord(value) {
     return value !== null && typeof value === 'object';
 }
-function storageRefLabel(value) {
-    if (!isRecord(value) || typeof value.kind !== 'string')
-        return undefined;
-    if ((value.kind === 'session_file' || value.kind === 'workspace_file') &&
-        typeof value.relativePath === 'string' &&
-        value.relativePath.length > 0) {
-        return value.relativePath;
-    }
-    if (value.kind === 'session_context' &&
-        typeof value.refId === 'string' &&
-        value.refId.length > 0) {
-        return value.refId;
-    }
-    if (value.kind === 'external_file' &&
-        typeof value.absolutePath === 'string' &&
-        value.absolutePath.length > 0) {
-        return value.absolutePath;
-    }
-    return undefined;
-}
+/**
+ * The image Tool Results a rejected request can give back, read through the
+ * same decode the budget measures — not from the raw execution fact, which the
+ * durable projection may already have bounded or redacted.
+ */
 export function collectHistoricalImageToolResults(events) {
     const collected = new Map();
     for (const event of events) {
         const content = event.content;
         if (content?.kind !== 'function_response' || content.isError === true)
             continue;
-        const result = content.result;
-        if (!isRecord(result) ||
-            result.kind !== 'image' ||
-            typeof result.mimeType !== 'string' ||
-            result.mimeType.length === 0) {
-            continue;
-        }
-        const artifactLabel = storageRefLabel(result.ref);
-        if (!artifactLabel)
+        const effective = decodeEffectiveToolResultProjection(content, event.sessionId);
+        const [media] = effectiveToolResultMedia(effective, event.sessionId);
+        if (!media || media.label.length === 0)
             continue;
-        collected.set(content.id, { toolName: content.name, artifactLabel });
+        collected.set(content.id, { toolName: content.name, artifactLabel: media.label });
     }
     return collected;
 }
-function isInlineImageFilePart(value) {
+/** A `file` part carrying inline image bytes, not a URL the provider fetches. */
+export function isInlineImageFilePart(value) {
     if (!isRecord(value) ||
         value.type !== 'file' ||
         typeof value.mediaType !== 'string' ||

package/node_modules/@maka/runtime/dist/runtime-event-backfill.js

@@ -446,6 +446,9 @@ function tokenUsageFromMessage(message) {
             : {}),
         ...(message.promptSegments !== undefined ? { promptSegments: message.promptSegments } : {}),
         ...(message.contextBudget !== undefined ? { contextBudget: message.contextBudget } : {}),
+        ...(message.lastRequestAnchor !== undefined
+            ? { lastRequestAnchor: message.lastRequestAnchor }
+            : {}),
     };
 }
 function messageTurnId(message) {

package/node_modules/@maka/runtime/dist/runtime-event-read-model.js

@@ -742,6 +742,9 @@ function projectTokenUsage(event, state, messages) {
             : {}),
         ...(usage.promptSegments !== undefined ? { promptSegments: usage.promptSegments } : {}),
         ...(usage.contextBudget !== undefined ? { contextBudget: usage.contextBudget } : {}),
+        ...(usage.lastRequestAnchor !== undefined
+            ? { lastRequestAnchor: usage.lastRequestAnchor }
+            : {}),
         ...(event.refs?.providerRequestTraceId !== undefined
             ? { providerRequestTraceId: event.refs.providerRequestTraceId }
             : {}),
@@ -857,13 +860,20 @@ function abortSourceFromRuntime(event, header) {
         stringRecordValue(header, 'abortSource'));
 }
 function failureClassFromRuntimeEvent(event, header) {
-    return (stringStateDelta(event, 'failureClass') ??
+    const failureClass = stringStateDelta(event, 'failureClass') ??
         stringStateDelta(event, 'errorClass') ??
         stringStateDelta(event, 'reason') ??
         stringStateDelta(event, 'code') ??
         (event.content?.kind === 'error' ? nonEmptyString(event.content.reason) : undefined) ??
         (event.content?.kind === 'error' ? nonEmptyString(event.content.code) : undefined) ??
-        header.failureClass);
+        header.failureClass;
+    // Retired outcome. The runtime no longer decides locally that a request
+    // cannot be shaped to fit — the provider rejects it and recovery compacts and
+    // retries — so a turn that ends over the window is a context overflow like any
+    // other. Sessions written before that still carry the old name; fold it here,
+    // at the one place the durable ledger is read, so nothing downstream has to
+    // know two names for one outcome.
+    return failureClass === 'context_budget_exhausted' ? 'context_overflow' : failureClass;
 }
 function stringRecordValue(value, key) {
     if (!value || typeof value !== 'object')
@@ -1107,6 +1117,7 @@ function semanticMessage(message) {
                 promptSegments: message.promptSegments,
                 contextBudget: message.contextBudget,
                 providerRequestTraceId: message.providerRequestTraceId,
+                lastRequestAnchor: message.lastRequestAnchor,
             };
         case 'turn_state':
             return {