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

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

@@ -6,6 +6,7 @@
   "type": "module",
   "sideEffects": false,
   "exports": {
+    "./executor-catalog": "./dist/executor-catalog.js",
     "./executor-id": "./dist/executor-id.js",
     "./durable-tool-result-projection": "./dist/durable-tool-result-projection.js",
     "./model-projection-transition": "./dist/model-projection-transition.js",
@@ -29,6 +30,7 @@
     "./provider-retry-countdown": "./dist/provider-retry-countdown.js",
     "./interaction": "./dist/interaction.js",
     "./session": "./dist/session.js",
+    "./turn-origin": "./dist/turn-origin.js",
     "./session-reference": "./dist/session-reference.js",
     "./session-revisions": "./dist/session-revisions.js",
     "./collaboration": "./dist/collaboration.js",
@@ -133,6 +135,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/mcp/dist/credential-coordinator.js

@@ -44,7 +44,10 @@ export class McpCredentialCoordinator {
      *
      * The optional signal fences an ABANDONED erase: a logout whose round
      * timed out must not resume later, adopt whatever record a newer login
-     * just stored as its basis, and tombstone the fresh tokens. */
+     * just stored as its basis, and tombstone the fresh tokens.
+     *
+     * `spare` must be decided here, on the lane's read: checked outside, a
+     * login could land between the check and the erase. */
     async erase(serverId, options = {}) {
         this.epochs.set(serverId, this.epoch(serverId) + 1);
         await this.run(serverId, async () => {
@@ -54,6 +57,8 @@ export class McpCredentialCoordinator {
             // storage read was in flight — committing past it would erase a
             // record the caller no longer owns.
             this.assertNotAbandoned(serverId, options.signal);
+            if (basis && options.spare?.(basis))
+                return;
             // Absence still gets a tombstone: a cross-process flow that captured
             // generation 0 on absence must not CAS its credentials back in after
             // this revocation.

package/node_modules/@maka/mcp/dist/index.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { randomBytes } from 'node:crypto';
-import { auth, Client, extractWWWAuthenticateParams, LATEST_PROTOCOL_VERSION, CLIENT_CAPABILITIES_META_KEY, isInputRequiredResult, SdkErrorCode, SdkHttpError, SSEClientTransport, StreamableHTTPClientTransport, } from '@modelcontextprotocol/client';
+import { auth, validateAuthorizationResponseIssuer, Client, extractWWWAuthenticateParams, LATEST_PROTOCOL_VERSION, CLIENT_CAPABILITIES_META_KEY, isInputRequiredResult, SdkErrorCode, SdkHttpError, SSEClientTransport, StreamableHTTPClientTransport, } from '@modelcontextprotocol/client';
 import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
 import { setTimeout as delay } from 'node:timers/promises';
 import { containsMcpFormState, prepareMcpForm } from './form-elicitation.js';
@@ -34,7 +34,7 @@ import { McpToolCallPreparer } from './tool-output-validation.js';
 import { mapMcpToolProgress } from './tool-progress.js';
 import { McpCredentialCoordinator } from './credential-coordinator.js';
 import { assertTransportSecurity, urlProvenance, } from './transport-security.js';
-import { McpAuthRequiredError, McpOAuthProvider, } from './oauth.js';
+import { McpAuthRequiredError, McpOAuthProvider, authorizationCallbackError, mcpOAuthRecordBoundTo, } from './oauth.js';
 export { formatMcpDiagnosticText } from './diagnostic-text.js';
 export { McpToolCallError } from './tool-call-error.js';
 export { createCredentialMcpOAuthStorage, } from './credential-oauth-storage.js';
@@ -259,7 +259,7 @@ export class McpClientManager {
                         : undefined;
                 if (owed) {
                     try {
-                        await this.forgetAuthorization(serverId, owed);
+                        await this.forgetAuthorization(serverId, owed, { successor: serverConfig });
                     }
                     catch (error) {
                         await this.blockForCredentialCleanup(serverId, current, owed, error);
@@ -1272,7 +1272,6 @@ export class McpClientManager {
         }
     }
     async finishAuthorizationRound(serverId, callback, options = {}) {
-        const authorizationCode = callback.code;
         const { config } = this.requireRemoteEntry(serverId);
         // The immediate read doubles as the flow's generation/version pin.
         const storage = this.flowStorage(serverId, options.signal);
@@ -1298,6 +1297,25 @@ export class McpClientManager {
         if (record?.pendingServerUrl !== config.url) {
             throw new Error(`MCP server "${serverId}" changed its URL during authorization`);
         }
+        const metadata = record.discovery?.authorizationServerMetadata;
+        const expectedIssuer = metadata?.issuer ?? record.discovery?.authorizationServerUrl;
+        if (!expectedIssuer)
+            throw new Error('OAuth callback has no recorded issuer');
+        try {
+            validateAuthorizationResponseIssuer({
+                iss: callback.iss,
+                expectedIssuer: String(expectedIssuer),
+                issParameterSupported: metadata?.authorization_response_iss_parameter_supported === true,
+            });
+        }
+        catch {
+            // SDK errors echo the untrusted iss parameter; it must not cross IPC.
+            throw new Error('OAuth callback issuer validation failed');
+        }
+        if ('error' in callback) {
+            throw authorizationCallbackError(callback.error);
+        }
+        const authorizationCode = callback.code;
         const provider = new McpOAuthProvider({
             serverId,
             serverUrl: config.url,
@@ -1432,7 +1450,15 @@ export class McpClientManager {
             return;
         if (config && isMcpStdioConfig(config) && !(await this.coordinator.read(serverId)))
             return;
-        await this.coordinator.erase(serverId, options);
+        const { successor, ...eraseOptions } = options;
+        await this.coordinator.erase(serverId, {
+            ...eraseOptions,
+            // Another process may have applied the same change and signed in first.
+            ...(successor &&
+                !isMcpStdioConfig(successor) && {
+                spare: (record) => mcpOAuthRecordBoundTo(record, successor.url, successor.oauth),
+            }),
+        });
     }
     /** Drops stored tokens and registration, returning the server to needs-auth. */
     async clearAuthorization(serverId, options = {}) {

package/node_modules/@maka/mcp/dist/oauth.js

@@ -16,6 +16,25 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { createHash } from 'node:crypto';
+const OAUTH_ERROR_CODES = new Set([
+    'invalid_request',
+    'unauthorized_client',
+    'access_denied',
+    'unsupported_response_type',
+    'invalid_scope',
+    'server_error',
+    'temporarily_unavailable',
+    'invalid_client',
+    'invalid_grant',
+    'unsupported_grant_type',
+    'interaction_required',
+    'login_required',
+    'consent_required',
+]);
+export function authorizationCallbackError(code) {
+    return new Error(`Authorization failed: ${OAUTH_ERROR_CODES.has(code) ? code : 'unknown_error'}`);
+}
 export function createMemoryMcpOAuthStorage() {
     const records = new Map();
     return {
@@ -31,6 +50,16 @@ export function createMemoryMcpOAuthStorage() {
         },
     };
 }
+function mcpOAuthClientConfigHash(config) {
+    if (!config?.clientId)
+        return undefined;
+    return createHash('sha256')
+        .update(JSON.stringify([config.issuer, config.clientId, config.clientSecret]))
+        .digest('hex');
+}
+export function mcpOAuthRecordBoundTo(record, serverUrl, config) {
+    return (record.serverUrl === serverUrl && record.clientConfigHash === mcpOAuthClientConfigHash(config));
+}
 /** Thrown (via the SDK's UnauthorizedError path) when a background connect
  * would need the user in a browser. The manager maps it to `needs-auth`. */
 export class McpAuthRequiredError extends Error {
@@ -64,6 +93,9 @@ export class McpOAuthProvider {
         if (state)
             this.state = () => state;
     }
+    get clientConfigHash() {
+        return mcpOAuthClientConfigHash(this.options.config);
+    }
     get redirectUrl() {
         return this.options.interactive?.redirectUrl ?? BACKGROUND_REDIRECT_URL;
     }
@@ -82,10 +114,17 @@ export class McpOAuthProvider {
                 : {}),
         };
     }
-    async clientInformation() {
+    async clientInformation(context) {
         const configured = this.options.config;
         if (configured?.clientId) {
+            if (!configured.issuer) {
+                throw new Error(`MCP server "${this.options.serverId}" requires oauth.issuer for its pre-registered client`);
+            }
+            if (context && context.issuer !== configured.issuer) {
+                throw new Error(`MCP server "${this.options.serverId}" discovered a different OAuth issuer; reconfigure its client credentials`);
+            }
             return {
+                issuer: configured.issuer,
                 client_id: configured.clientId,
                 ...(configured.clientSecret ? { client_secret: configured.clientSecret } : {}),
             };
@@ -106,7 +145,13 @@ export class McpOAuthProvider {
         });
     }
     async tokens() {
-        return (await this.read()).tokens;
+        if (this.options.config?.clientId)
+            await this.clientInformation();
+        const record = await this.read();
+        const tokens = record.tokens;
+        if (this.options.config?.issuer && tokens?.issuer !== this.options.config.issuer)
+            return undefined;
+        return tokens;
     }
     async saveTokens(tokens) {
         await this.mutate((record) => {
@@ -148,9 +193,7 @@ export class McpOAuthProvider {
             // A dynamically registered client belongs to the authorization server
             // that issued it. When discovery moves the resource to a DIFFERENT
             // authorization server, carrying the old registration over would send
-            // one AS's client credentials (and any secret) to another. Static
-            // config-supplied clients are unaffected — they never live in the
-            // record.
+            // one AS's client credentials (and any secret) to another.
             const previousIssuer = record.discovery?.authorizationServerUrl;
             const nextIssuer = state.authorizationServerUrl;
             if (previousIssuer && nextIssuer && `${previousIssuer}` !== `${nextIssuer}`) {
@@ -217,7 +260,8 @@ export class McpOAuthProvider {
             record.pendingRedirectUrl ||
             record.pendingServerUrl ||
             record.pendingState;
-        return Boolean(boundable) && record.serverUrl !== this.options.serverUrl;
+        return (Boolean(boundable) &&
+            !mcpOAuthRecordBoundTo(record, this.options.serverUrl, this.options.config));
     }
     /** The same fail-closed binding rule as read(), applied to a mutation
      * basis: a record bound elsewhere contributes NOTHING to the new write —
@@ -239,6 +283,10 @@ export class McpOAuthProvider {
         const stamp = (record) => {
             apply(record);
             record.serverUrl = this.options.serverUrl;
+            if (this.clientConfigHash)
+                record.clientConfigHash = this.clientConfigHash;
+            else
+                delete record.clientConfigHash;
             return record;
         };
         // The coordinator-provided storage view makes read-apply-write one

package/node_modules/@maka/runtime/dist/agent-run-inspect.js

@@ -38,7 +38,7 @@ export async function inspectAgentRunReadModel(runStore, runtimeEventStore, opti
             diagnostics.push(inspectDiagnostic(invocation, 'runtime_terminal_missing', 'runtime ledger has no complete terminal RuntimeEvent fact'));
         }
     }
-    const projection = runtimeEvents.length > 0
+    const projection = runtimeEvents.length > 0 && options.includeProjection !== false
         ? projectRuntimeEventsToStoredMessages(runtimeEvents, { invocations: [invocation] })
         : undefined;
     if (projection) {

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