@jsonstudio/llms 0.6.54 → 0.6.74

package/dist/conversion/codecs/responses-openai-codec.js

@@ -1,5 +1,6 @@
 import { buildResponsesPayloadFromChat, runStandardChatRequestFilters } from '../index.js';
-import { captureResponsesContext, buildChatRequestFromResponses } from '../responses/responses-openai-bridge.js';
+import { captureResponsesContext, buildChatRequestFromResponses, buildResponsesRequestFromChat } from '../responses/responses-openai-bridge.js';
+import { captureResponsesRequestContext } from '../shared/responses-conversation-store.js';
 import { FilterEngine, ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } from '../../filters/index.js';
 // Ported from root package (no behavior change). Types relaxed.
 export class ResponsesOpenAIConversionCodec {
@@ -83,6 +84,20 @@ export class ResponsesOpenAIConversionCodec {
             endpoint: context.endpoint ?? dto.metadata?.endpoint
         };
         const filtered = await runStandardChatRequestFilters(chatRequest, profile, ctxForFilters);
+        try {
+            const rebuilt = buildResponsesRequestFromChat(filtered, ctx);
+            const payloadForStore = rebuilt?.request;
+            if (payloadForStore && typeof payloadForStore === 'object') {
+                captureResponsesRequestContext({
+                    requestId: dto.route.requestId,
+                    payload: payloadForStore,
+                    context: ctx
+                });
+            }
+        }
+        catch {
+            // best-effort capture
+        }
         if (filtered && typeof filtered === 'object') {
             const maybe = filtered;
             if (maybe.max_tokens === undefined && typeof maybe.max_output_tokens === 'number') {

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.js

@@ -1,5 +1,4 @@
 import { captureResponsesContext, buildChatRequestFromResponses } from '../../../../../responses/responses-openai-bridge.js';
-import { captureResponsesRequestContext } from '../../../../../shared/responses-conversation-store.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqInboundStage3ContextCapture(options) {
     let context;
@@ -54,16 +53,6 @@ export function captureResponsesContextSnapshot(options) {
     catch {
         // best-effort context capture
     }
-    try {
-        captureResponsesRequestContext({
-            requestId: options.adapterContext.requestId,
-            payload: options.rawRequest,
-            context
-        });
-    }
-    catch {
-        // ignore store capture failures
-    }
     return context;
 }
 function captureChatContextSnapshot(options) {

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -48,6 +48,7 @@ export declare function buildResponsesRequestFromChat(payload: Record<string, un
     bridgeHistory?: BridgeInputBuildResult;
     systemInstruction?: string;
 }): BuildResponsesRequestResult;
+export declare function ensureResponsesApplyPatchArguments(input?: BridgeInputItem[]): void;
 export declare function buildResponsesPayloadFromChat(payload: unknown, context?: ResponsesRequestContext): Record<string, unknown> | unknown;
 export declare function extractRequestIdFromResponse(response: any): string | undefined;
 export { buildChatResponseFromResponses } from '../shared/responses-response-utils.js';

package/dist/conversion/responses/responses-openai-bridge.js

@@ -18,6 +18,7 @@ function isObject(v) {
 // --- Public bridge functions ---
 export function captureResponsesContext(payload, dto) {
     const preservedInput = cloneBridgeEntries(payload.input);
+    ensureResponsesApplyPatchArguments(preservedInput);
     ensureBridgeInstructions(payload);
     const context = {
         requestId: dto?.route?.requestId,
@@ -298,6 +299,76 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     ensureBridgeInstructions(out);
     return { request: out, originalSystemMessages };
 }
+export function ensureResponsesApplyPatchArguments(input) {
+    if (!Array.isArray(input) || !input.length) {
+        return;
+    }
+    for (const entry of input) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
+        if (type !== 'function_call')
+            continue;
+        const name = (typeof entry.name === 'string' && entry.name.trim()) ||
+            (entry.function && typeof entry.function === 'object' && typeof entry.function.name === 'string' && entry.function.name.trim()) ||
+            '';
+        if (name !== 'apply_patch')
+            continue;
+        let normalized;
+        try {
+            normalized = normalizeApplyPatchArguments(entry.arguments ?? entry.function?.arguments);
+        }
+        catch {
+            // best-effort: do not fail the whole request due to a malformed historical tool call
+            normalized = undefined;
+        }
+        if (normalized === undefined) {
+            continue;
+        }
+        entry.arguments = normalized;
+        if (entry.function && typeof entry.function === 'object') {
+            entry.function.arguments = normalized;
+        }
+    }
+}
+function normalizeApplyPatchArguments(source) {
+    let parsed;
+    if (typeof source === 'string' && source.trim()) {
+        try {
+            parsed = JSON.parse(source);
+        }
+        catch {
+            parsed = { patch: source };
+        }
+    }
+    else if (source && typeof source === 'object') {
+        parsed = { ...source };
+    }
+    else if (source === undefined) {
+        parsed = {};
+    }
+    else {
+        return typeof source === 'string' ? source : undefined;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return typeof source === 'string' ? source : undefined;
+    }
+    const patchText = typeof parsed.patch === 'string' && parsed.patch.trim().length
+        ? parsed.patch
+        : typeof parsed.input === 'string' && parsed.input.trim().length
+            ? parsed.input
+            : undefined;
+    if (patchText) {
+        parsed.patch = patchText;
+        parsed.input = patchText;
+    }
+    try {
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return typeof source === 'string' ? source : undefined;
+    }
+}
 function readToolCallIdStyleFromContext(ctx) {
     if (!ctx) {
         return undefined;

package/dist/conversion/shared/tool-filter-pipeline.js

@@ -1,6 +1,30 @@
 import { FilterEngine } from '../../filters/index.js';
 import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
 import { createSnapshotWriter } from './snapshot-utils.js';
+const REQUEST_FILTER_STAGES = [
+    'request_pre',
+    'request_map',
+    'request_post',
+    'request_finalize'
+];
+const RESPONSE_FILTER_STAGES = [
+    'response_pre',
+    'response_map',
+    'response_post',
+    'response_finalize'
+];
+function assertStageCoverage(label, registeredStages, skeletonStages) {
+    const allowed = new Set(skeletonStages);
+    const uncovered = [];
+    for (const stage of registeredStages) {
+        if (!allowed.has(stage)) {
+            uncovered.push(stage);
+        }
+    }
+    if (uncovered.length) {
+        throw new Error(`[tool-filter-pipeline] ${label}: registered filter stage(s) not covered by skeleton: ${uncovered.join(', ')}`);
+    }
+}
 export async function runChatRequestToolFilters(chatRequest, options = {}) {
     const reqCtxBase = {
         requestId: options.requestId ?? `req_${Date.now()}`,
@@ -23,22 +47,27 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
     };
     recordStage('req_process_tool_filters_input', chatRequest);
     const engine = new FilterEngine();
+    const registeredStages = new Set();
+    const register = (filter) => {
+        registeredStages.add(filter.stage);
+        engine.registerFilter(filter);
+    };
     const profile = (reqCtxBase.profile || '').toLowerCase();
     const endpoint = (reqCtxBase.endpoint || '').toLowerCase();
     const isAnthropic = profile === 'anthropic-messages' || endpoint.includes('/v1/messages');
     if (!isAnthropic) {
         try {
             const { RequestToolListFilter } = await import('../../filters/index.js');
-            engine.registerFilter(new RequestToolListFilter());
+            register(new RequestToolListFilter());
         }
         catch {
             /* optional */
         }
     }
     const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } = await import('../../filters/index.js');
-    engine.registerFilter(new RequestToolCallsStringifyFilter());
+    register(new RequestToolCallsStringifyFilter());
     if (!isAnthropic) {
-        engine.registerFilter(new RequestToolChoicePolicyFilter());
+        register(new RequestToolChoicePolicyFilter());
     }
     try {
         const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
@@ -52,12 +81,20 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
         } })());
     }
     catch { /* ignore */ }
-    let staged = await engine.run('request_pre', chatRequest, reqCtxBase);
-    recordStage('req_process_tool_filters_request_pre', staged);
-    staged = await engine.run('request_map', staged, reqCtxBase);
-    recordStage('req_process_tool_filters_request_map', staged);
-    staged = await engine.run('request_post', staged, reqCtxBase);
-    recordStage('req_process_tool_filters_request_post', staged);
+    try {
+        const { RequestOpenAIToolsNormalizeFilter, ToolPostConstraintsFilter } = await import('../../filters/index.js');
+        register(new RequestOpenAIToolsNormalizeFilter());
+        register(new ToolPostConstraintsFilter('request_finalize'));
+    }
+    catch {
+        // optional; keep prior behavior when filter not available
+    }
+    assertStageCoverage('request', registeredStages, REQUEST_FILTER_STAGES);
+    let staged = chatRequest;
+    for (const stage of REQUEST_FILTER_STAGES) {
+        staged = await engine.run(stage, staged, reqCtxBase);
+        recordStage(`req_process_tool_filters_${stage}`, staged);
+    }
     recordStage('req_process_tool_filters_output', staged);
     return staged;
 }
@@ -81,20 +118,25 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
     };
     recordStage('resp_process_tool_filters_input', chatJson);
     const engine = new FilterEngine();
+    const registeredStages = new Set();
+    const register = (filter) => {
+        registeredStages.add(filter.stage);
+        engine.registerFilter(filter);
+    };
     const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } = await import('../../filters/index.js');
-    engine.registerFilter(new ResponseToolTextCanonicalizeFilter());
+    register(new ResponseToolTextCanonicalizeFilter());
     try {
         const { ResponseToolArgumentsToonDecodeFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
-        engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter());
+        register(new ResponseToolArgumentsToonDecodeFilter());
         try {
-            engine.registerFilter(new ResponseToolArgumentsSchemaConvergeFilter());
+            register(new ResponseToolArgumentsSchemaConvergeFilter());
         }
         catch { /* optional */ }
-        engine.registerFilter(new ResponseToolArgumentsBlacklistFilter());
+        register(new ResponseToolArgumentsBlacklistFilter());
     }
     catch { /* optional */ }
-    engine.registerFilter(new ResponseToolArgumentsStringifyFilter());
-    engine.registerFilter(new ResponseFinishInvariantsFilter());
+    register(new ResponseToolArgumentsStringifyFilter());
+    register(new ResponseFinishInvariantsFilter());
     try {
         const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
         if (cfg)
@@ -107,12 +149,12 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
         } })());
     }
     catch { /* ignore */ }
-    let staged = await engine.run('response_pre', chatJson, resCtxBase);
-    recordStage('resp_process_tool_filters_response_pre', staged);
-    staged = await engine.run('response_map', staged, resCtxBase);
-    recordStage('resp_process_tool_filters_response_map', staged);
-    staged = await engine.run('response_post', staged, resCtxBase);
-    recordStage('resp_process_tool_filters_response_post', staged);
+    assertStageCoverage('response', registeredStages, RESPONSE_FILTER_STAGES);
+    let staged = chatJson;
+    for (const stage of RESPONSE_FILTER_STAGES) {
+        staged = await engine.run(stage, staged, resCtxBase);
+        recordStage(`resp_process_tool_filters_${stage}`, staged);
+    }
     recordStage('resp_process_tool_filters_output', staged);
     return staged;
 }

package/dist/conversion/shared/tool-mapping.js

@@ -8,6 +8,56 @@ export function stringifyArgs(args) {
         return String(args);
     }
 }
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function clonePlainObject(value) {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return { ...value };
+    }
+}
+function asSchema(value) {
+    if (isPlainObject(value)) {
+        return clonePlainObject(value);
+    }
+    return undefined;
+}
+function ensureApplyPatchSchema(seed) {
+    const schema = seed ? { ...seed } : {};
+    schema.type = typeof schema.type === 'string' ? schema.type : 'object';
+    const properties = isPlainObject(schema.properties) ? { ...schema.properties } : {};
+    properties.input = {
+        type: 'string',
+        description: 'Unified diff patch body between *** Begin Patch/*** End Patch.'
+    };
+    if (!properties.patch || typeof properties.patch !== 'object') {
+        properties.patch = {
+            type: 'string',
+            description: 'Alias of input for backwards compatibility.'
+        };
+    }
+    schema.properties = properties;
+    const requiredList = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === 'string') : [];
+    if (!requiredList.includes('input')) {
+        requiredList.push('input');
+    }
+    schema.required = requiredList;
+    if (typeof schema.additionalProperties !== 'boolean') {
+        schema.additionalProperties = false;
+    }
+    return schema;
+}
+function enforceBuiltinToolSchema(name, candidate) {
+    const normalizedName = typeof name === 'string' ? name.trim().toLowerCase() : '';
+    if (normalizedName === 'apply_patch') {
+        const base = asSchema(candidate);
+        return ensureApplyPatchSchema(base);
+    }
+    return asSchema(candidate);
+}
 const DEFAULT_SANITIZER = (value) => {
     if (typeof value === 'string') {
         const trimmed = value.trim();
@@ -66,7 +116,7 @@ export function bridgeToolToChatDefinition(rawTool, options) {
         return null;
     }
     const description = resolveToolDescription(fnNode?.description ?? tool.description);
-    const parameters = resolveToolParameters(fnNode, tool);
+    const parameters = enforceBuiltinToolSchema(name, resolveToolParameters(fnNode, tool));
     const strict = resolveToolStrict(fnNode, tool);
     const rawType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
     const normalizedType = rawType.toLowerCase() === 'custom' ? 'function' : rawType;
@@ -105,7 +155,7 @@ export function chatToolToBridgeDefinition(rawTool, options) {
         return null;
     }
     const description = resolveToolDescription(fnNode?.description);
-    const parameters = resolveToolParameters(fnNode, undefined);
+    const parameters = enforceBuiltinToolSchema(name, resolveToolParameters(fnNode, undefined));
     const strict = resolveToolStrict(fnNode, undefined);
     const normalizedType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
     const responseShape = {

package/dist/filters/special/request-tools-normalize.js

@@ -73,7 +73,7 @@ export class RequestOpenAIToolsNormalizeFilter {
                             delete dst.function.strict;
                     }
                     catch { /* ignore */ }
-                    // Switch schema for 'shell' at unified shaping point
+                    // Switch schema for specific built-in tools at unified shaping point
                     try {
                         const name = String(dst.function.name || '').toLowerCase();
                         if (name === 'shell') {
@@ -101,6 +101,25 @@ export class RequestOpenAIToolsNormalizeFilter {
                                 };
                             }
                         }
+                        else if (name === 'apply_patch') {
+                            dst.function.parameters = {
+                                type: 'object',
+                                properties: {
+                                    input: {
+                                        type: 'string',
+                                        description: 'Unified diff patch body between *** Begin Patch/*** End Patch.'
+                                    },
+                                    patch: {
+                                        type: 'string',
+                                        description: 'Alias of input for backwards compatibility.'
+                                    }
+                                },
+                                required: ['input'],
+                                additionalProperties: false
+                            };
+                            dst.function.description =
+                                'Use apply_patch to edit files. Provide the diff via the input field (*** Begin Patch ... *** End Patch).';
+                        }
                     }
                     catch { /* ignore */ }
                     finalTools.push(dst);

package/dist/tools/tool-registry.js

@@ -95,11 +95,12 @@ export function validateToolCall(name, argsString) {
     const rawArgs = tryParseJson(typeof argsString === 'string' ? argsString : '{}');
     switch (normalizedName) {
         case 'apply_patch': {
-            const patch = asString(rawArgs.patch);
+            const input = asString(rawArgs.input);
+            const patch = asString(rawArgs.patch) ?? input;
             if (!patch) {
-                return { ok: false, reason: 'missing_patch' };
+                return { ok: false, reason: 'missing_input' };
             }
-            return { ok: true, normalizedArgs: toJson({ patch }) };
+            return { ok: true, normalizedArgs: toJson({ input: patch, patch }) };
         }
         case 'shell': {
             const rawCommand = rawArgs.command;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.054",
+  "version": "0.6.074",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",