maka-agent 0.2.0-dev.46.20260922 → 0.2.0-dev.48.20260923

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

@@ -23,6 +23,7 @@ import { decodePersistedToolResultContent } from '@maka/core/tool-result-record-
 import { isEmittedAgentRunEventType } from '@maka/core/agent-run';
 import { decodeModelCallAttempt, MODEL_CALL_ATTEMPT_EVENT_TYPE, } from '@maka/core/model-call-attempt';
 import { TOOL_RECOVERY_DECISION_FACT_KIND } from '@maka/core/tool-recovery-fact';
+import { canonicalToolArgsHash } from '@maka/core/tool-args-identity';
 import { buildHistoryCompactCheckpoint, historyCompactSourceDigest, matchHistoryCompactCheckpointPrefix, validateHistoryCompactCheckpointShape, } from './history-compact-checkpoint.js';
 import { findCheckpointSummaryDefect } from './history-compact-summary-validation.js';
 import { isHistoryCompactContentEvent } from './history-compaction.js';
@@ -281,6 +282,20 @@ function assertConversationRuntimeLedgerCopySupported(run, runtimeEvents) {
     error.code = 'branch_runtime_fact_rewrite_unsupported';
     throw error;
 }
+/**
+ * Mirrors the T1 scanner's identity semantics: a call whose args are not
+ * strict JSON cannot authenticate, which the scanner surfaces as a
+ * `canonical_args_hash_conflict` rather than an exception — so the copy pass
+ * must see `undefined` there, not a thrown error.
+ */
+const tryCanonicalToolArgsHash = (toolName, args) => {
+    try {
+        return canonicalToolArgsHash(toolName, args);
+    }
+    catch {
+        return undefined;
+    }
+};
 export async function cloneConversationRuntimeLedger(input) {
     if (input.plan.sourceSessionId !== input.referenceMap.sourceSessionId) {
         throw new Error('Conversation copy plan does not belong to the source Session');
@@ -386,10 +401,22 @@ export async function cloneConversationRuntimeLedger(input) {
     };
     for (const sourceId of clonedEventBySourceId.keys())
         finishTarget(sourceId);
+    // The identity rewrite changes a copied call's canonical args, so the paired
+    // dispatch's recorded hash stops authenticating them and the copied ledger
+    // fails its own T1 re-scan. Collect the source and rewritten identities per
+    // (invocation, tool call) and re-authenticate the dispatches after the
+    // rewrite pass — but only when the source dispatch actually authenticated
+    // the source call. Stamping the rewritten identity over a mismatched hash
+    // would launder an already-corrupt source ledger into a valid-looking copy
+    // instead of preserving the corruption for the re-scan to reject (#5466
+    // review). Identity derivation mirrors the scanner's semantics: args that
+    // are not strict JSON cannot authenticate at all.
+    const rewrittenArgsIdentities = new Map();
     for (const event of clonedEventBySourceId.values()) {
         if (event.content?.kind === 'function_call' && event.content.name === 'Read') {
             const args = event.content.args;
-            if (args && typeof args === 'object' && 'path' in args && typeof args.path === 'string')
+            if (args && typeof args === 'object' && 'path' in args && typeof args.path === 'string') {
+                const sourceArgsHash = tryCanonicalToolArgsHash(event.content.name, args);
                 event.content = {
                     ...event.content,
                     args: {
@@ -397,19 +424,47 @@ export async function cloneConversationRuntimeLedger(input) {
                         ...rewriteReadInput(args, references, clonedEventBySourceId),
                     },
                 };
+                rewrittenArgsIdentities.set(`${event.invocationId}\u0000${event.content.id}`, {
+                    sourceArgsHash,
+                    rewrittenArgsHash: tryCanonicalToolArgsHash(event.content.name, event.content.args),
+                });
+            }
         }
         if (event.content?.kind === 'text')
             event.content.text = rewriteCopiedText(event.content.text, references, clonedEventBySourceId);
         if (event.content?.kind === 'function_call' && event.content.name === 'ArchiveRead') {
             const args = event.content.args;
             if (args && typeof args === 'object' && 'ref' in args && typeof args.ref === 'string') {
+                const sourceArgsHash = tryCanonicalToolArgsHash(event.content.name, args);
                 event.content = {
                     ...event.content,
                     args: { ...args, ref: rewriteLedgerArchiveText(args.ref, references) },
                 };
+                rewrittenArgsIdentities.set(`${event.invocationId}\u0000${event.content.id}`, {
+                    sourceArgsHash,
+                    rewrittenArgsHash: tryCanonicalToolArgsHash(event.content.name, event.content.args),
+                });
             }
         }
     }
+    if (rewrittenArgsIdentities.size > 0) {
+        for (const event of clonedEventBySourceId.values()) {
+            const dispatch = event.actions?.toolDispatch;
+            if (dispatch?.canonicalArgsHash === undefined)
+                continue;
+            const identity = rewrittenArgsIdentities.get(`${event.invocationId}\u0000${dispatch.providerToolCallId}`);
+            if (identity === undefined)
+                continue;
+            if (identity.sourceArgsHash !== dispatch.canonicalArgsHash)
+                continue;
+            if (identity.rewrittenArgsHash === undefined)
+                continue;
+            event.actions = {
+                ...event.actions,
+                toolDispatch: { ...dispatch, canonicalArgsHash: identity.rewrittenArgsHash },
+            };
+        }
+    }
     const preparedPlans = flattenedPlans.map((plan) => {
         const runId = runIds.get(plan.run.runId);
         const clonedOperationalEvents = plan.operationalEvents.flatMap((event) => {

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

@@ -136,13 +136,20 @@ function mcpToolDescription(descriptor) {
 }
 export function mcpProxyToolName(serverId, toolName) {
     const raw = `mcp__${sanitizeNamePart(serverId)}__${sanitizeNamePart(toolName)}`;
-    if (raw.length <= MAX_PROVIDER_TOOL_NAME)
+    // Preserve existing simple names; hash identities whose spelling or separators are ambiguous.
+    if (raw.length <= MAX_PROVIDER_TOOL_NAME &&
+        sanitizeNamePart(serverId) === serverId &&
+        sanitizeNamePart(toolName) === toolName &&
+        !serverId.includes('__') &&
+        !toolName.includes('__'))
         return raw;
     const hash = createHash('sha256')
         .update(`${serverId}\0${toolName}`)
         .digest('hex')
         .slice(0, HASH_CHARS);
-    return `${raw.slice(0, MAX_PROVIDER_TOOL_NAME - HASH_CHARS - 2)}__${hash}`;
+    // A truncated name must not become another identity's unmodified name.
+    const hashed = `mcp_h__${sanitizeNamePart(serverId)}__${sanitizeNamePart(toolName)}`;
+    return `${hashed.slice(0, MAX_PROVIDER_TOOL_NAME - HASH_CHARS - 2)}__${hash}`;
 }
 function sanitizeNamePart(value) {
     const sanitized = value

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

@@ -22,13 +22,14 @@ import { providerAuthRequiresSecret, } from '@maka/core/llm-connections';
 import { lookupModelMetadata } from '@maka/core/model-metadata';
 import { rawFinishReasonString } from './model-protocol.js';
 import { resolveModelRuntime } from './model-runtime.js';
+import { resolveSelectedModelContextWindow } from './context-budget-policy.js';
 import { plaintextResponsesReasoningProviderOptions, withoutMakaResponsesState, safePlaintextResponsesReasoningItemId, } from './responses-reasoning-state.js';
 import { classifyError, providerModelFailure } from './provider-error-classification.js';
 import { withProviderStreamTracking, } from './provider-request-telemetry.js';
 import { createOpenAiChatReasoningTransportState, openAiChatReasoningFieldProviderOptions, restoreOpenAiChatEmptyReasoning, } from './openai-chat-reasoning-transport.js';
 import { mergeOpenAiResponsesProviderOptions, planOpenAiResponsesContinuation, } from './openai-responses-continuation.js';
 import { createOpenAiResponsesTransportState, OPENAI_RESPONSES_LANE_HEADER, } from './openai-responses-websocket.js';
-import { openAiApplyPatchProviderTool } from './openai-apply-patch.js';
+import { openAiApplyPatchProviderTool, codexApplyPatchProviderTool } from './openai-apply-patch.js';
 import { TOOL_SEARCH_NAME, TOOL_SEARCH_PROVIDER_NAME } from './tool-availability.js';
 export class ModelAdapter {
     input;
@@ -97,12 +98,40 @@ export class ModelAdapter {
     maxOutputTokens() {
         return selectedModelMaxOutputTokens(this.input.connection, this.input.modelId, this.input.providerOptions, this.runtime);
     }
+    /**
+     * Keep a provider-derived output limit from making a resumed request
+     * impossible. The token count is the last request the provider accepted, so
+     * it is a conservative lower bound for the next request. Leave a small
+     * amount of room for newly appended user/tool content because Runtime does
+     * not estimate the final prompt locally.
+     */
+    maxOutputTokensForInput(knownInputTokens) {
+        const outputLimit = this.maxOutputTokens();
+        if (outputLimit === undefined ||
+            knownInputTokens === undefined ||
+            !Number.isFinite(knownInputTokens) ||
+            knownInputTokens < 0) {
+            return outputLimit;
+        }
+        const contextWindow = resolveSelectedModelContextWindow(this.input.connection, this.input.modelId);
+        if (contextWindow === undefined)
+            return outputLimit;
+        const thinkingBudget = this.runtime.wire === 'anthropic-messages'
+            ? fixedAnthropicThinkingBudget(this.input.providerOptions)
+            : 0;
+        const available = contextWindow - Math.ceil(knownInputTokens) - CONTEXT_INPUT_GROWTH_HEADROOM - thinkingBudget;
+        // Do not turn a near-window request into a one-token success. A useful
+        // floor deliberately lets the provider reject the request, which keeps
+        // the existing reactive compaction path in control of recovery.
+        return Math.max(Math.min(outputLimit, CONTEXT_RECOVERY_OUTPUT_FLOOR), Math.min(outputLimit, available));
+    }
     async startStream(input) {
         const ai = await import('ai').catch((err) => {
             throw new Error(`Failed to load 'ai' package. Run \`npm install ai\`. Inner: ${err.message}`);
         });
         const { streamText, wrapLanguageModel } = ai;
-        const maxOutputTokens = selectedModelMaxOutputTokens(this.input.connection, this.input.modelId, this.input.providerOptions, this.runtime);
+        const maxOutputTokens = input.maxOutputTokens ??
+            selectedModelMaxOutputTokens(this.input.connection, this.input.modelId, this.input.providerOptions, this.runtime);
         let settleAccounting;
         const terminalModel = withProviderFinishBoundary(input.model, wrapLanguageModel);
         const trackedModel = input.providerRequestTracker
@@ -127,7 +156,7 @@ export class ModelAdapter {
             sdkTools[TOOL_SEARCH_PROVIDER_NAME] = sdkTools[TOOL_SEARCH_NAME];
             delete sdkTools[TOOL_SEARCH_NAME];
         }
-        const fullMessages = input.messages;
+        const fullMessages = this.runtime.wire === 'openai-chat' ? lowerChatToolImages(input.messages) : input.messages;
         const responsesLane = input.continuationKey && usesNativeOpenAiResponses(this.input.connection, this.runtime)
             ? input.continuationKey
             : undefined;
@@ -441,6 +470,12 @@ function failedStepOutcome(failure, usage) {
         continuation: 'none',
     };
 }
+/**
+ * A persisted provider count describes the preceding request, not the new
+ * user message or tool result that may be appended after a restart.
+ */
+const CONTEXT_INPUT_GROWTH_HEADROOM = 8_000;
+const CONTEXT_RECOVERY_OUTPUT_FLOOR = 8_000;
 function selectedModelMaxOutputTokens(connection, modelId, providerOptions, runtime) {
     const anthropicMessages = runtime.wire === 'anthropic-messages';
     const kimiOpenAiChat = connection.providerType === 'kimi-coding-plan' && runtime.wire === 'openai-chat';
@@ -835,6 +870,46 @@ function translateChunk(chunk, openAiChatReasoningTransportState, runtime, runti
             return [];
     }
 }
+function lowerChatToolImages(messages) {
+    const result = [];
+    let images = [];
+    const flush = () => {
+        if (images.length === 0)
+            return;
+        result.push({ role: 'user', content: images });
+        images = [];
+    };
+    for (const message of messages) {
+        if (message.role !== 'tool') {
+            flush();
+            result.push(message);
+            continue;
+        }
+        result.push({
+            ...message,
+            content: message.content.map((part) => {
+                if (part.type !== 'tool-result' || part.output.type !== 'content')
+                    return part;
+                return {
+                    ...part,
+                    output: {
+                        ...part.output,
+                        value: part.output.value.map((content) => {
+                            if (content.type !== 'file' || !content.mediaType.startsWith('image/'))
+                                return content;
+                            images.push({ type: 'text', text: `Image from tool ${part.toolName} (${part.toolCallId}):` }, content);
+                            return { type: 'text', text: 'Image supplied below.' };
+                        }),
+                    },
+                };
+            }),
+        });
+    }
+    // Chat tool messages are text-only; attach images after the whole result group
+    // so an assistant's parallel tool calls stay paired before the next user message.
+    flush();
+    return result;
+}
 /**
  * OpenAI Responses reserves the provider name `tool_search`. Keep Maka's
  * persisted/history name intact and translate only the provider-bound copy.
@@ -898,6 +973,8 @@ function compileProviderTool(tool) {
     switch (tool.kind) {
         case 'openai-apply-patch':
             return openAiApplyPatchProviderTool;
+        case 'codex-apply-patch':
+            return codexApplyPatchProviderTool;
         case 'openai-web-search':
             return openai.tools.webSearch({
                 ...(tool.searchContextSize ? { searchContextSize: tool.searchContextSize } : {}),

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

@@ -19,6 +19,7 @@
 import { PROVIDER_REGISTRY, effectiveBaseUrl, } from '@maka/core/llm-connections';
 import { lookupModelMetadata, lookupModelRuntimeOverride, openAiAdapterApiProtocol, } from '@maka/core/model-metadata';
 import { isRetiredProvider } from '@maka/core/provider-registry';
+import { modelOverride } from '@maka/core/model-thinking';
 import { anthropicV1BaseUrl, googleV1BetaBaseUrl, openAiResponsesBaseUrl, } from './provider-urls.js';
 import { resolveApplyPatchProfile } from './apply-patch-profile.js';
 export function resolveModelRuntime(connection, modelId) {
@@ -76,6 +77,11 @@ export function resolveModelRuntime(connection, modelId) {
         applyPatchProfile: resolveApplyPatchProfile({
             wire,
             applyPatchProtocol: adapter.applyPatchProtocol,
+            enabled: modelOverride(connection, modelId)?.applyPatch,
+            customTools: wire === 'openai-responses' &&
+                (connection.providerType === 'openai' || connection.providerType === 'openai-codex') &&
+                replay.kind === 'responses' &&
+                replay.contract.adapter === 'openai',
         }, modelId),
     };
 }

package/node_modules/@maka/runtime/dist/openai-apply-patch.js

@@ -17,6 +17,11 @@
  * under the License.
  */
 import { openai } from '@ai-sdk/openai';
+import { CODEX_PATCH_DESCRIPTION, CODEX_PATCH_GRAMMAR } from './codex-v4a-patch.js';
+export const codexApplyPatchProviderTool = openai.tools.customTool({
+    description: `${CODEX_PATCH_DESCRIPTION}\nPass raw patch text, not JSON.`,
+    format: { type: 'grammar', syntax: 'lark', definition: CODEX_PATCH_GRAMMAR },
+});
 export const openAiApplyPatchProviderTool = openai.tools.applyPatch({});
 const inputSchema = openAiApplyPatchProviderTool.inputSchema;
 export const openAiApplyPatchInputSchema = typeof inputSchema === 'function' ? inputSchema() : inputSchema;

package/node_modules/@maka/runtime/dist/plugin-executor-backend.js

@@ -17,13 +17,17 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
+import { redactSecrets } from '@maka/core/redaction';
 import { AsyncEventQueue } from './async-queue.js';
 /** Converts a small plugin executor contract into Maka's existing Run event stream. */
 export class PluginExecutorBackend {
     kind = 'plugin-executor';
     sessionId;
     #cwd;
+    #configuration;
     #instructions;
+    #model;
+    #thinkingLevel;
     #binding;
     #newId;
     #now;
@@ -32,7 +36,10 @@ export class PluginExecutorBackend {
     constructor(input) {
         this.sessionId = input.sessionId;
         this.#cwd = input.cwd;
+        this.#configuration = input.configuration;
         this.#instructions = input.instructions;
+        this.#model = input.model;
+        this.#thinkingLevel = input.thinkingLevel;
         this.#binding = input.binding;
         this.#newId = input.newId ?? randomUUID;
         this.#now = input.now ?? Date.now;
@@ -82,6 +89,7 @@ export class PluginExecutorBackend {
         const turnId = input.turnId;
         let thinkingText = '';
         const toolUseIds = new Map();
+        const toolOutputSequences = new Map();
         let result;
         let failure;
         let failed = false;
@@ -93,6 +101,9 @@ export class PluginExecutorBackend {
                 conversationKey: this.sessionId,
                 text: input.text,
                 cwd: this.#cwd,
+                ...(this.#model ? { model: this.#model } : {}),
+                reasoningEffort: this.#thinkingLevel ?? null,
+                ...(this.#configuration ? { configuration: this.#configuration } : {}),
                 ...(this.#instructions ? { instructions: this.#instructions } : {}),
                 ...(input.attachments ? { attachments: input.attachments } : {}),
                 ...(input.directoryReferences ? { directoryReferences: input.directoryReferences } : {}),
@@ -102,8 +113,9 @@ export class PluginExecutorBackend {
                 onEvent: (event) => {
                     if (event.type === 'thinking_delta')
                         thinkingText += event.text;
-                    this.#publishOutputEvent(turnId, messageId, event, toolUseIds, queue);
+                    this.#publishOutputEvent(turnId, messageId, event, toolUseIds, toolOutputSequences, queue);
                 },
+                onPermissionRequest: (request) => this.#requestPermission(input, request, signal, toolUseIds, queue),
             });
         }
         catch (error) {
@@ -124,6 +136,81 @@ export class PluginExecutorBackend {
         }
         this.#publishResult(turnId, messageId, result, queue);
     }
+    async #requestPermission(input, request, signal, toolUseIds, queue) {
+        const hosted = input.hostedInteraction;
+        if (!hosted || signal.aborted)
+            return { outcome: 'cancelled' };
+        const requestId = this.#newId();
+        const event = {
+            type: 'form_request',
+            id: this.#newId(),
+            turnId: input.turnId,
+            ts: this.#now(),
+            requestId,
+            toolUseId: toolUseIds.get(request.toolCallId) ?? request.toolCallId,
+            message: request.title,
+            requester: {
+                name: this.#binding.identity.displayName,
+                source: this.#binding.identity.extensionId,
+            },
+            fields: [
+                {
+                    kind: 'single_select',
+                    name: 'optionId',
+                    label: request.kind === 'question' ? 'Question' : 'Permission',
+                    required: true,
+                    options: request.options.map((option) => ({
+                        value: option.optionId,
+                        label: option.name,
+                    })),
+                },
+            ],
+        };
+        let settle;
+        const answer = new Promise((resolve) => {
+            settle = resolve;
+        });
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            settle(result);
+        };
+        const settlement = {
+            applyAnswer: async (result) => {
+                if (result.action !== 'accept')
+                    return finish({ outcome: 'cancelled' });
+                const selected = result.values.optionId;
+                if (typeof selected !== 'string' ||
+                    !request.options.some((option) => option.optionId === selected)) {
+                    return finish({ outcome: 'cancelled' });
+                }
+                finish({ outcome: 'selected', optionId: selected });
+            },
+            applyClosure: async () => finish({ outcome: 'cancelled' }),
+        };
+        let admission;
+        const onAbort = () => {
+            finish({ outcome: 'cancelled' });
+            void Promise.resolve().then(async () => {
+                await admission?.catch(() => undefined);
+                await hosted.withdrawFormRequest(requestId).catch(() => undefined);
+            });
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        try {
+            admission = hosted.admitFormRequest({ request: event, settlement });
+            await admission;
+            if (signal.aborted)
+                return { outcome: 'cancelled' };
+            queue.push(event);
+            return await answer;
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+        }
+    }
     #closeOptionalOutput(turnId, messageId, thinkingText, toolUseIds, queue) {
         if (thinkingText) {
             queue.push({
@@ -188,9 +275,10 @@ export class PluginExecutorBackend {
             turnId,
             ts: this.#now(),
             stopReason: 'user_stop',
+            ...(result.providerStopReason ? { providerStopReason: result.providerStopReason } : {}),
         });
     }
-    #publishOutputEvent(turnId, messageId, event, toolUseIds, queue) {
+    #publishOutputEvent(turnId, messageId, event, toolUseIds, toolOutputSequences, queue) {
         if (event.type === 'output_delta') {
             if (!event.text)
                 return;
@@ -233,6 +321,7 @@ export class PluginExecutorBackend {
             }
             const toolUseId = this.#newId();
             toolUseIds.set(event.toolCallId, toolUseId);
+            toolOutputSequences.set(event.toolCallId, 0);
             queue.push({
                 type: 'tool_start',
                 id: this.#newId(),
@@ -251,6 +340,31 @@ export class PluginExecutorBackend {
         const toolUseId = toolUseIds.get(event.toolCallId);
         if (!toolUseId)
             return;
+        if (event.type === 'tool_output_delta') {
+            if (!event.text)
+                return;
+            const chunk = redactSecrets(event.text);
+            if (!chunk)
+                return;
+            const now = this.#now();
+            const seq = (toolOutputSequences.get(event.toolCallId) ?? 0) + 1;
+            toolOutputSequences.set(event.toolCallId, seq);
+            queue.push({
+                type: 'tool_output_delta',
+                id: this.#newId(),
+                sessionId: this.sessionId,
+                turnId,
+                ts: now,
+                toolCallId: toolUseId,
+                toolUseId,
+                seq,
+                stream: event.stream ?? 'stdout',
+                chunk,
+                redacted: chunk !== event.text,
+                createdAt: now,
+            });
+            return;
+        }
         if (event.type === 'tool_progress') {
             if (!event.text)
                 return;
@@ -265,6 +379,7 @@ export class PluginExecutorBackend {
             return;
         }
         toolUseIds.delete(event.toolCallId);
+        toolOutputSequences.delete(event.toolCallId);
         queue.push({
             type: 'tool_result',
             id: this.#newId(),
@@ -273,7 +388,9 @@ export class PluginExecutorBackend {
             toolUseId,
             providerExecuted: true,
             isError: event.isError ?? false,
-            content: { kind: 'text', text: event.text },
+            content: event.content.kind === 'text'
+                ? event.content
+                : { kind: 'file_diff', paths: [...event.content.paths], diff: event.content.diff },
         });
     }
     #publishFailure(turnId, message, code, recoverable, queue) {
@@ -305,6 +422,8 @@ function cancellationEventReason(result) {
         return 'redirect';
     if (result.reason === 'timeout')
         return 'timeout';
+    if (result.reason === 'crash')
+        return 'crash';
     if (result.source === 'executor_retired')
         return 'crash';
     return 'user_stop';