maka-agent 0.2.0-dev.45.20260921 → 0.2.0-dev.47.20260922

package/node_modules/@maka/core/dist/provider-registry.js

@@ -614,7 +614,6 @@ const providerRegistry = {
         runtimeAdapter: {
             kind: 'openai-compatible',
             name: 'provider',
-            applyPatchProtocol: 'codex-v4a-freeform',
             responses: { adapter: 'open-responses', reasoningReplay: 'plaintext-content' },
         },
         modelDiscovery: { kind: 'protocol' },

package/node_modules/@maka/core/dist/refresh-read-coordinator.js

@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Coordinates a debounced read of an authority-owned projection.
+ *
+ * The freshness invariant is intentionally stronger than "only the latest
+ * query may apply": an authority event also invalidates a read that is
+ * already in flight. That read may have captured the projection before the
+ * event and can otherwise resolve after the newer state has reached the
+ * caller. Callers decide which events are relevant; this module owns the
+ * ordering and cancellation rule behind that small interface.
+ */
+export function createRefreshReadCoordinator(input) {
+    let cancelScheduled;
+    let revision = 0;
+    const dropScheduled = () => {
+        cancelScheduled?.();
+        cancelScheduled = undefined;
+    };
+    const run = () => {
+        cancelScheduled = undefined;
+        const readRevision = ++revision;
+        void input.read().then((result) => {
+            if (readRevision !== revision)
+                return;
+            input.apply(result);
+        }, () => { });
+    };
+    return {
+        observe() {
+            // Invalidate before scheduling. The previous read can resolve during the
+            // debounce window, before the replacement read is issued.
+            revision += 1;
+            dropScheduled();
+            cancelScheduled = input.schedule(run, input.delayMs);
+        },
+        refresh() {
+            dropScheduled();
+            run();
+        },
+        cancel() {
+            dropScheduled();
+            revision += 1;
+        },
+    };
+}

package/node_modules/@maka/core/dist/runtime-policy/connection-catalog-codec.js

@@ -170,6 +170,7 @@ export function decodeModelOverridesTable(value) {
             'thinkingLevels',
             'defaultThinkingLevel',
             'vision',
+            'applyPatch',
             'contextWindow',
             'serviceTier',
             'compactionThreshold',
@@ -210,6 +211,9 @@ export function decodeModelOverridesTable(value) {
         if (entry.vision !== undefined) {
             declared.vision = booleanValue(entry.vision, `declared vision for ${modelId}`);
         }
+        if (entry.applyPatch !== undefined) {
+            declared.applyPatch = booleanValue(entry.applyPatch, `declared ApplyPatch for ${modelId}`);
+        }
         for (const field of [
             'contextWindow',
             'compactionThreshold',

package/node_modules/@maka/core/dist/session.js

@@ -18,6 +18,7 @@
  */
 import { isWorkHubActionReceipt } from './workhub-action-result.js';
 import { isExecutorId } from './executor-id.js';
+import { isThinkingLevel } from './model-thinking.js';
 import { MODEL_FAILURE_MESSAGE_MAX_BYTES, isModelRetryDecision, } from './model-failure.js';
 import { decodeMessageContent, TOOL_ACTIVITY_KINDS, } from './events.js';
 import { isPermissionMode, isToolCategory, } from './permission.js';
@@ -304,16 +305,31 @@ export function isConversationTextMessage(message) {
 export const WORKHUB_COORDINATION_RECORD_SCHEMA_VERSION = 1;
 export const WORKHUB_COORDINATION_REPLACEMENT_SCHEMA_VERSION = 2;
 export const WORKHUB_COORDINATION_STOP_SCHEMA_VERSION = 3;
+/** UTF-8 wire limit shared by persisted and protocol Session model identifiers. */
+export const SESSION_MODEL_ID_MAX_BYTES = 512;
 export function isWorkHubCreateDefaults(value) {
     if (!isRecord(value) ||
-        Object.keys(value).some((key) => key !== 'executorId' && key !== 'model' && key !== 'permissionMode'))
+        Object.keys(value).some((key) => key !== 'executorId' &&
+            key !== 'executorModel' &&
+            key !== 'model' &&
+            key !== 'thinkingLevel' &&
+            key !== 'permissionMode'))
         return false;
     if (value.permissionMode !== undefined && !isPermissionMode(value.permissionMode))
         return false;
     if (value.executorId !== undefined && !isExecutorId(value.executorId))
         return false;
+    if (value.executorModel !== undefined &&
+        (typeof value.executorModel !== 'string' ||
+            value.executorModel.trim().length === 0 ||
+            new TextEncoder().encode(value.executorModel).byteLength > SESSION_MODEL_ID_MAX_BYTES))
+        return false;
+    if (value.executorModel !== undefined && value.executorId === undefined)
+        return false;
     if (value.executorId !== undefined && value.model !== undefined)
         return false;
+    if (value.thinkingLevel !== undefined && !isThinkingLevel(value.thinkingLevel))
+        return false;
     if (value.model === undefined)
         return true;
     const model = value.model;

package/node_modules/@maka/core/dist/settings.js

@@ -340,6 +340,7 @@ export function createDefaultSettings() {
             activeTab: 'requests',
         },
         appearance: {
+            workbarTogglePosition: 'edge',
             theme: 'auto',
             palette: 'default',
             appIcon: DEFAULT_APP_ICON,
@@ -515,6 +516,7 @@ export function normalizeSettings(input) {
         // position; UI density is no longer a product setting.
         appearance: {
             ...appearanceWithoutLegacyFields,
+            workbarTogglePosition: base.appearance.workbarTogglePosition === 'titlebar' ? 'titlebar' : 'edge',
             palette: isThemePalette(base.appearance.palette) ? base.appearance.palette : 'default',
             // Same fail-closed rule as `palette` above, for the same reason: an
             // unknown id would otherwise reach the main process and resolve to a

package/node_modules/@maka/core/package.json

@@ -133,6 +133,7 @@
     "./computer-use": "./dist/computer-use.js",
     "./connection-error-copy": "./dist/connection-error-copy.js",
     "./connection-usage": "./dist/connection-usage.js",
+    "./refresh-read-coordinator": "./dist/refresh-read-coordinator.js",
     "./git-review": "./dist/git-review.js",
     "./graph-command": "./dist/graph-command.js",
     "./project": "./dist/project.js",

package/node_modules/@maka/runtime/dist/ai-sdk-message-projection.js

@@ -59,7 +59,7 @@ function isImageToolResult(value) {
         typeof image.ref === 'object');
 }
 function toolResultText(text) {
-    return { type: 'content', value: [{ type: 'text', text }] };
+    return { type: 'text', text };
 }
 function nativeApplyPatchFailureOutput(output) {
     const value = output.type === 'json' || output.type === 'error-json' ? output.value : undefined;
@@ -538,18 +538,24 @@ export class AiSdkMessageProjection {
     async materializeToolResultOutput(budget, output, isError, decisionKey) {
         if (isError || !isImageToolResult(output))
             return toolResultOutput(output, isError);
+        return {
+            type: 'content',
+            value: [await this.materializeImage(budget, output.ref, output.mimeType, decisionKey)],
+        };
+    }
+    async materializeImage(budget, ref, mediaType, decisionKey) {
         if (this.input.supportsVision !== true) {
             return toolResultText('Image was read, but the selected model does not support image input.');
         }
         if (!this.input.readAttachmentBytes) {
             return toolResultText('Image was read, but its stored bytes are unavailable.');
         }
-        if (budget && budget.decisions.get(decisionKey) === false) {
+        if (budget.decisions.get(decisionKey) === false) {
             return toolResultText(PROVIDER_IMAGE_BUDGET_EXCEEDED_MESSAGE);
         }
         let read;
         try {
-            read = await this.input.readAttachmentBytes(output.ref);
+            read = await this.input.readAttachmentBytes(ref);
         }
         catch {
             return toolResultText('Image could not be loaded from artifact storage: read_failed.');
@@ -561,18 +567,9 @@ export class AiSdkMessageProjection {
             return toolResultText(PROVIDER_IMAGE_BUDGET_EXCEEDED_MESSAGE);
         }
         return {
-            type: 'content',
-            value: [
-                { type: 'text', text: 'Image read successfully.' },
-                {
-                    type: 'file',
-                    data: {
-                        type: 'data',
-                        data: Buffer.from(read.bytes).toString('base64'),
-                    },
-                    mediaType: output.mimeType,
-                },
-            ],
+            type: 'file',
+            data: { type: 'data', data: Buffer.from(read.bytes).toString('base64') },
+            mediaType,
         };
     }
     async materializeDurableToolResultProjection(budget, projection, decisionKey) {
@@ -580,51 +577,9 @@ export class AiSdkMessageProjection {
             return durableProjectionToToolResultOutput(projection);
         const value = [];
         for (const [index, part] of projection.parts.entries()) {
-            if (part.kind === 'text') {
-                value.push({ type: 'text', text: part.text });
-                continue;
-            }
-            if (this.input.supportsVision !== true) {
-                value.push({
-                    type: 'text',
-                    text: 'Image was read, but the selected model does not support image input.',
-                });
-                continue;
-            }
-            if (!this.input.readAttachmentBytes) {
-                value.push({
-                    type: 'text',
-                    text: 'Image was read, but its stored bytes are unavailable.',
-                });
-                continue;
-            }
-            let read;
-            try {
-                read = await this.input.readAttachmentBytes(part.ref);
-            }
-            catch {
-                value.push({
-                    type: 'text',
-                    text: 'Image could not be loaded from artifact storage: read_failed.',
-                });
-                continue;
-            }
-            if (!read.ok) {
-                value.push({
-                    type: 'text',
-                    text: `Image could not be loaded from artifact storage: ${read.reason}.`,
-                });
-                continue;
-            }
-            if (!this.chargeImageBudget(budget, read.bytes.length, `${decisionKey}:artifact:${index}`)) {
-                value.push({ type: 'text', text: PROVIDER_IMAGE_BUDGET_EXCEEDED_MESSAGE });
-                continue;
-            }
-            value.push({
-                type: 'file',
-                data: { type: 'data', data: Buffer.from(read.bytes).toString('base64') },
-                mediaType: part.mediaType,
-            });
+            value.push(part.kind === 'text'
+                ? toolResultText(part.text)
+                : await this.materializeImage(budget, part.ref, part.mediaType, `${decisionKey}:artifact:${index}`));
         }
         return { type: 'content', value };
     }

package/node_modules/@maka/runtime/dist/ai-sdk-turn.js

@@ -35,6 +35,7 @@ import { decodePlaintextResponsesReasoningState, responsesReasoningItemId, } fro
 import { finitePositive } from './context-budget-helpers.js';
 import { contextDiagnosticsCompactionOf, } from './context-diagnostics.js';
 import { hasBlockingReplayDiagnostics } from './ai-sdk-compaction.js';
+import { portableApplyPatchTool } from './apply-patch-profile.js';
 import { RunTrace } from './run-trace.js';
 import { REQUEST_SANDBOX_BOUNDARY_TOOL_NAME, SANDBOX_BOUNDARY_DENIED_FOR_TURN, SANDBOX_BOUNDARY_FINALIZATION_PROMPT, } from './sandbox-boundary-tool.js';
 import { buildRuntimeEventModelReplayPlan, buildSteeringEnvelope, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, formatTextWithInlineRefs, steeringMessagesMissingFromBase, steeringModelMessage, } from './model-history.js';
@@ -251,6 +252,10 @@ function renderCodeModeCatalogPrompt(nested) {
 function nestableToolSnapshot(providerTools, activeToolNames) {
     const active = new Set(activeToolNames);
     return new Map(providerTools
+        .map((tool) => tool.providerTool?.kind === 'openai-apply-patch' ||
+        tool.providerTool?.kind === 'codex-apply-patch'
+        ? portableApplyPatchTool(tool)
+        : tool)
         .filter((tool) => active.has(tool.name) &&
         tool.name !== INVALID_TOOL_NAME &&
         tool.name !== 'exec' &&
@@ -348,6 +353,7 @@ function joinPromptFragments(fragments) {
 }
 const MAX_WAITING_CODE_MODE_CELLS = 1;
 const MAX_PROVIDER_ATTEMPTS_PER_STEP = 10;
+const CONTEXT_RECOVERY_MAX_OUTPUT_TOKENS = 8_000;
 const PROVIDER_RETRY_BASE_DELAY_MS = 1_000;
 const PROVIDER_RETRY_MAX_DELAY_MS = 32_000;
 const PROVIDER_RETRY_JITTER_FACTOR = 0.25;
@@ -1168,6 +1174,7 @@ export class AiSdkTurn {
                         : undefined;
                     providerRequestTracker?.setStep(runtimeSteps, requestCompositionId);
                     let attemptMessages = projectedMessages;
+                    let overflowRecoveryMaxOutputTokens;
                     let providerAttempt = 0;
                     const returnedToolCalls = [];
                     const providerToolInputs = new Map();
@@ -1205,6 +1212,8 @@ export class AiSdkTurn {
                                 ? nestedTools
                                 : undefined;
                         const requestWatchdog = watchdogState.current;
+                        const requestMaxOutputTokens = overflowRecoveryMaxOutputTokens ??
+                            this.deps.modelAdapter.maxOutputTokensForInput(midTurnState?.baselineTokens ?? midTurnState?.lastAcceptedTotalTokens);
                         // Read here, beside the messages it describes: `attemptMessages` is
                         // rebuilt in place by overflow recovery, and the boundary it folded
                         // under must travel with that rebuild, not with the step.
@@ -1232,6 +1241,9 @@ export class AiSdkTurn {
                             ...(providerRequestTracker ? { providerRequestTracker } : {}),
                             ...(historyCompactBoundary ? { historyCompactBoundary } : {}),
                             continuationKey: this.turnId,
+                            ...(requestMaxOutputTokens !== undefined
+                                ? { maxOutputTokens: requestMaxOutputTokens }
+                                : {}),
                         });
                         for await (const event of result.events) {
                             if (this.aborted)
@@ -1418,6 +1430,11 @@ export class AiSdkTurn {
                         consumeWatchdogTimeout();
                         providerOutcome = await result.outcome;
                         if (providerOutcome.kind === 'completed') {
+                            // A compacted overflow retry only needs the conservative cap for
+                            // that one request. Once the provider accepts the request, the
+                            // next step can use the fresh provider count to derive a larger
+                            // safe cap again.
+                            overflowRecoveryMaxOutputTokens = undefined;
                             runtimeSteps += 1;
                             const stepUsage = providerOutcome.usage;
                             providerStepUsage = stepUsage;
@@ -1616,6 +1633,7 @@ export class AiSdkTurn {
                                 : undefined;
                             if (recovered) {
                                 attemptMessages = recovered.messages;
+                                overflowRecoveryMaxOutputTokens = Math.min(this.deps.modelAdapter.maxOutputTokens() ?? CONTEXT_RECOVERY_MAX_OUTPUT_TOKENS, CONTEXT_RECOVERY_MAX_OUTPUT_TOKENS);
                                 continue;
                             }
                             // Window suggestion (#4559): the provider rejected a request and

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

@@ -16,17 +16,30 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { parseCodexV4aPatch } from './codex-v4a-patch.js';
+import { modelApplyPatchEnabled } from '@maka/core/model-thinking';
+import { z } from 'zod';
+import { CODEX_PATCH_DESCRIPTION, parseCodexV4aPatch } from './codex-v4a-patch.js';
 import { openAiModelSupportsApplyPatch } from './openai-apply-patch.js';
-/** Resolve the exact provider/model/wire contract; unknown combinations fail closed. */
+const portableApplyPatchParameters = z.object({ patch: z.string() });
+/** Project a provider-native ApplyPatch tool into the portable client-executed shape. */
+export function portableApplyPatchTool(tool) {
+    return {
+        ...tool,
+        description: CODEX_PATCH_DESCRIPTION,
+        parameters: portableApplyPatchParameters,
+        providerTool: undefined,
+    };
+}
+/** User overrides take precedence; new models can opt in through ordinary function calling. */
 export function resolveApplyPatchProfile(runtime, modelId) {
-    if (runtime.wire !== 'openai-responses' || !runtime.applyPatchProtocol)
+    if (!modelApplyPatchEnabled(modelId, { applyPatch: runtime.enabled }))
         return null;
-    const id = modelId.trim().toLowerCase();
-    if (runtime.applyPatchProtocol === 'openai-structured' && openAiModelSupportsApplyPatch(id)) {
+    const structured = runtime.wire === 'openai-responses' &&
+        runtime.applyPatchProtocol === 'openai-structured' &&
+        openAiModelSupportsApplyPatch(modelId.trim().toLowerCase());
+    if (structured)
         return { kind: 'openai-structured' };
-    }
-    return null;
+    return runtime.customTools ? { kind: 'codex-v4a-freeform' } : { kind: 'portable-v4a' };
 }
 /** Project one verified profile into an exclusive model-facing editing surface. */
 export function routeApplyPatchTools(tools, profile) {
@@ -35,19 +48,40 @@ export function routeApplyPatchTools(tools, profile) {
         return [...tools];
     if (!profile)
         return tools.filter((tool) => tool !== applyPatchTool);
-    return tools.filter((tool) => tool.name !== 'Write' && tool.name !== 'Edit');
+    const routed = tools.filter((tool) => tool.name !== 'Write' && tool.name !== 'Edit');
+    if (profile.kind === 'openai-structured')
+        return routed;
+    return routed.map((tool) => tool !== applyPatchTool
+        ? tool
+        : profile.kind === 'codex-v4a-freeform'
+            ? {
+                ...tool,
+                description: CODEX_PATCH_DESCRIPTION,
+                parameters: z.string(),
+                providerTool: { kind: 'codex-apply-patch' },
+            }
+            : portableApplyPatchTool(tool));
 }
-/** Convert historical freeform calls for a structured target, or reject an undeclared target. */
+/** Re-encode history for the current tool transport, or preserve it as facts when disabled. */
 export function normalizeApplyPatchReplayInput(profile, toolCallId, input) {
     // A missing profile means the target request does not advertise ApplyPatch.
     // Returning the historical input would serialize a call to an undeclared
     // tool; route it through the durable-fact downgrade instead.
     if (!profile)
         return null;
-    if (typeof input !== 'string')
-        return input;
+    const patch = patchText(input);
+    if (profile.kind !== 'openai-structured') {
+        const text = patch ?? structuredPatchText(input);
+        if (text === null)
+            return null;
+        if (profile.kind === 'codex-v4a-freeform')
+            return text;
+        return patch !== null && typeof input === 'object' ? input : { patch: text };
+    }
+    if (patch === null)
+        return structuredApplyPatchOperation(input) ? input : null;
     try {
-        const operations = parseCodexV4aPatch(input);
+        const operations = parseCodexV4aPatch(patch);
         return operations.length === 1 ? { callId: toolCallId, operation: operations[0] } : null;
     }
     catch {
@@ -57,9 +91,10 @@ export function normalizeApplyPatchReplayInput(profile, toolCallId, input) {
 /** Preserve an executed multi-file patch when the target wire cannot replay one call for it. */
 export function applyPatchReplayFactText(input, output, isError) {
     let operations;
-    if (typeof input === 'string') {
+    const patch = patchText(input);
+    if (patch !== null) {
         try {
-            operations = parseCodexV4aPatch(input);
+            operations = parseCodexV4aPatch(patch);
         }
         catch {
             return null;
@@ -129,3 +164,18 @@ function structuredApplyPatchOperation(input) {
     }
     return null;
 }
+function patchText(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input && typeof input === 'object' && 'patch' in input && typeof input.patch === 'string')
+        return input.patch;
+    return null;
+}
+function structuredPatchText(input) {
+    const op = structuredApplyPatchOperation(input);
+    if (!op)
+        return null;
+    const action = op.type === 'create_file' ? 'Add' : op.type === 'delete_file' ? 'Delete' : 'Update';
+    const body = op.type === 'delete_file' ? '' : op.diff.endsWith('\n') ? op.diff : `${op.diff}\n`;
+    return `*** Begin Patch\n*** ${action} File: ${op.path}\n${body}*** End Patch`;
+}

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

@@ -161,10 +161,11 @@ export function buildBuiltinTools(options = {}) {
         providerTool: { kind: 'openai-apply-patch' },
         executionFacts,
         impl: async (input, ctx) => {
-            if (typeof input !== 'string') {
+            const patch = typeof input === 'string' ? input : input.patch;
+            if (typeof patch !== 'string') {
                 return await filesystem.applyPatch({ operation: input.operation, ...filesystemCall(ctx) });
             }
-            const operations = parseCodexV4aPatch(input);
+            const operations = parseCodexV4aPatch(patch);
             return await executeApplyPatchOperations(operations, async (operation) => {
                 await filesystem.applyPatch({ operation, ...filesystemCall(ctx) });
             }, ctx.abortSignal);

package/node_modules/@maka/runtime/dist/codex-v4a-patch.js

@@ -16,6 +16,24 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+export const CODEX_PATCH_DESCRIPTION = `Edit files using a patch enclosed in *** Begin Patch and *** End Patch.
+Use *** Add File: path with each content line prefixed by +; *** Delete File: path;
+or *** Update File: path with @@ context markers and lines prefixed by space (unchanged),
+- (removed), or + (added). Include enough unchanged context to locate each edit.
+One patch may contain multiple file operations. Moves are not supported: add the destination
+and delete the source instead. Read existing files before patching them.`;
+// Match the executor's supported subset: intentionally no Move to production.
+export const CODEX_PATCH_GRAMMAR = String.raw `start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+delete_hunk: "*** Delete File: " filename LF
+update_hunk: "*** Update File: " filename LF change+
+filename: /[^\r\n]+/
+add_line: "+" /[^\r\n]+/? LF
+change: ("@@" | "@@ " /[^\r\n]+/) LF | ("+" | "-" | " ") /[^\r\n]+/? LF | "*** End of File" LF
+%import common.LF`;
 export class CodexV4aPatchError extends Error {
     constructor(message) {
         super(message);

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),
     };
 }