@jsonstudio/llms 0.6.938 → 0.6.1164

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

@@ -1,8 +1,14 @@
 import { chatEnvelopeToStandardized } from '../../../../standardized-bridge.js';
 import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
+import { applyHubOperationTableInbound } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqInboundStage2SemanticMap(options) {
     const chatEnvelope = await options.semanticMapper.toChat(options.formatEnvelope, options.adapterContext);
+    applyHubOperationTableInbound({
+        formatEnvelope: options.formatEnvelope,
+        chatEnvelope,
+        adapterContext: options.adapterContext
+    });
     validateChatEnvelope(chatEnvelope, {
         stage: 'req_inbound',
         direction: 'request'

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

@@ -312,9 +312,6 @@ function buildApplyPatchDiagnostics(output) {
 }
 function appendDiagnosticsToRecord(record) {
     const name = typeof record.name === 'string' ? record.name.trim() : undefined;
-    if (name !== 'apply_patch') {
-        return;
-    }
     let text;
     if (typeof record.output === 'string') {
         text = record.output;
@@ -329,6 +326,12 @@ function appendDiagnosticsToRecord(record) {
     if (!diag) {
         return;
     }
+    // Some providers / compatibility layers omit `name` on tool outputs.
+    // When the output text matches apply_patch argument-parse failures, still inject the diagnostics
+    // to keep user-visible behavior stable across modes.
+    if (name && name !== 'apply_patch') {
+        return;
+    }
     const merged = `${text}${diag}`;
     if (typeof record.output === 'string') {
         record.output = merged;

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -1,5 +1,6 @@
 import { standardizedToChatEnvelope } from '../../../../standardized-bridge.js';
 import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
+import { applyHubOperationTableOutboundPostMap, applyHubOperationTableOutboundPreMap } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqOutboundStage1SemanticMap(options) {
     const chatEnvelope = standardizedToChatEnvelope(options.request, {
@@ -16,7 +17,17 @@ export async function runReqOutboundStage1SemanticMap(options) {
         stage: 'req_outbound',
         direction: 'request'
     });
+    await applyHubOperationTableOutboundPreMap({
+        protocol: options.adapterContext.providerProtocol,
+        chatEnvelope,
+        adapterContext: options.adapterContext
+    });
     const formatEnvelope = (await options.semanticMapper.fromChat(chatEnvelope, options.adapterContext));
+    applyHubOperationTableOutboundPostMap({
+        chatEnvelope,
+        formatEnvelope,
+        adapterContext: options.adapterContext
+    });
     recordStage(options.stageRecorder, 'req_outbound_stage1_semantic_map', chatEnvelope);
     return { chatEnvelope, formatEnvelope };
 }

package/dist/conversion/hub/policy/policy-engine.js

@@ -38,6 +38,11 @@ function applyProviderOutboundPolicy(providerProtocol, payload) {
             out = { ...payload };
         }
     };
+    const allowedTopLevelKeys = Array.isArray(spec.providerOutbound.allowedTopLevelKeys) &&
+        spec.providerOutbound.allowedTopLevelKeys.length > 0 &&
+        spec.providerOutbound.enforceAllowedTopLevelKeys === true
+        ? new Set(spec.providerOutbound.allowedTopLevelKeys)
+        : undefined;
     // Reserved/private keys must never be sent upstream.
     for (const key of Object.keys(payload)) {
         if (spec.providerOutbound.reservedKeyPrefixes.some((prefix) => key.startsWith(prefix))) {
@@ -76,6 +81,18 @@ function applyProviderOutboundPolicy(providerProtocol, payload) {
         delete out[wrapperKey];
         flattenedWrappers.push(wrapperKey);
     }
+    // Enforce protocol allowlist (top-level). Only runs when explicitly enabled
+    // for this protocol, and only after wrapper flatten so allowed fields are
+    // present at the correct level.
+    if (allowedTopLevelKeys) {
+        for (const key of Object.keys(out)) {
+            if (allowedTopLevelKeys.has(key))
+                continue;
+            ensureOutClone();
+            delete out[key];
+            removedTopLevelKeys.push(key);
+        }
+    }
     return {
         payload: out,
         changed: out !== payload || removedTopLevelKeys.length > 0 || flattenedWrappers.length > 0,
@@ -83,16 +100,20 @@ function applyProviderOutboundPolicy(providerProtocol, payload) {
         flattenedWrappers
     };
 }
-function observeProviderOutboundPayload(providerProtocol, payload) {
+function observeProviderPayload(options) {
     const violations = [];
-    // V0 (observe-only): detect known "layout anti-patterns" and reserved keys.
+    // Observe-only: detect known layout anti-patterns and reserved keys.
     // Do NOT modify payload here.
-    const spec = resolveHubProtocolSpec(providerProtocol);
+    const spec = resolveHubProtocolSpec(options.providerProtocol);
+    const allowlistEnabled = options.phase === 'provider_outbound';
+    const allowedTopLevelKeys = allowlistEnabled && Array.isArray(spec.providerOutbound.allowedTopLevelKeys)
+        ? new Set(spec.providerOutbound.allowedTopLevelKeys)
+        : undefined;
     for (const rule of spec.providerOutbound.forbidWrappers) {
         if (rule.code !== 'forbid_wrapper') {
             continue;
         }
-        if (rule.path in payload && isJsonRecord(payload[rule.path])) {
+        if (rule.path in options.payload && isJsonRecord(options.payload[rule.path])) {
             violations.push({
                 code: 'unexpected_wrapper',
                 path: rule.path,
@@ -101,18 +122,26 @@ function observeProviderOutboundPayload(providerProtocol, payload) {
         }
     }
     // Always record unknown private wrapper keys (best-effort, conservative).
-    for (const key of Object.keys(payload)) {
+    for (const key of Object.keys(options.payload)) {
         if (spec.providerOutbound.reservedKeyPrefixes.some((prefix) => key.startsWith(prefix))) {
             violations.push({
                 code: 'unexpected_field',
                 path: key
             });
+            continue;
+        }
+        if (allowedTopLevelKeys && !allowedTopLevelKeys.has(key)) {
+            violations.push({
+                code: 'unexpected_field',
+                path: key,
+                detail: `Top-level key is not in protocol allowlist: ${options.providerProtocol}`
+            });
         }
     }
     const unexpectedFieldCount = violations.filter((v) => v.code === 'unexpected_field').length;
     return {
-        phase: 'provider_outbound',
-        providerProtocol,
+        phase: options.phase,
+        providerProtocol: options.providerProtocol,
         violations,
         summary: {
             totalViolations: violations.length,
@@ -136,8 +165,11 @@ export function recordHubPolicyObservation(options) {
     }
     try {
         const phase = options.phase ?? 'provider_outbound';
-        const observation = observeProviderOutboundPayload(options.providerProtocol, options.payload);
-        observation.phase = phase;
+        const observation = observeProviderPayload({
+            phase,
+            providerProtocol: options.providerProtocol,
+            payload: options.payload
+        });
         if (observation.summary.totalViolations <= 0) {
             return;
         }

package/dist/conversion/hub/policy/protocol-spec.d.ts

@@ -26,6 +26,19 @@ export interface ProviderOutboundPolicySpec {
      * Keep this false for protocols not yet migrated, to avoid behavior changes.
      */
     enforceEnabled: boolean;
+    /**
+     * Provider outbound payload allowlist (top-level keys), used for observation
+     * to detect drift.
+     */
+    allowedTopLevelKeys?: readonly string[];
+    /**
+     * When enabled, provider outbound payload will drop any top-level keys not
+     * present in allowedTopLevelKeys (after wrapper flatten).
+     *
+     * Keep this configurable for progressive rollout, but Phase 1 completion
+     * requires enabling it for all protocols.
+     */
+    enforceAllowedTopLevelKeys?: boolean;
     /**
      * Reserved/private key prefixes that must not be sent upstream.
      * (Enforced only when enforceEnabled=true.)
@@ -42,9 +55,21 @@ export interface ProviderOutboundPolicySpec {
      */
     flattenWrappers: ProviderOutboundWrapperFlattenRule[];
 }
+export type ToolDefinitionFormat = 'openai' | 'anthropic' | 'gemini';
+export type ProviderOutboundHistoryCarrier = 'messages' | 'input';
+export interface ToolSurfaceSpec {
+    expectedToolFormat: ToolDefinitionFormat;
+    /**
+     * For OpenAI protocols, tool call/result history may be carried in either
+     * chat `messages[]` or responses `input[]`. This spec describes the expected
+     * carrier so toolSurface can normalize or at least record diffs.
+     */
+    expectedHistoryCarrier?: ProviderOutboundHistoryCarrier;
+}
 export interface ProtocolSpec {
     id: HubProviderProtocol;
     providerOutbound: ProviderOutboundPolicySpec;
+    toolSurface: ToolSurfaceSpec;
 }
 export declare const HUB_PROTOCOL_SPECS: Record<HubProviderProtocol, ProtocolSpec>;
 export declare function resolveHubProtocolSpec(protocol: string): ProtocolSpec;

package/dist/conversion/hub/policy/protocol-spec.js

@@ -1,7 +1,10 @@
+import { ANTHROPIC_ALLOWED_FIELDS, ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS, OPENAI_RESPONSES_ALLOWED_FIELDS, OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS } from '../../shared/protocol-field-allowlists.js';
 const RESPONSES_SPEC = {
     id: 'openai-responses',
     providerOutbound: {
         enforceEnabled: true,
+        allowedTopLevelKeys: OPENAI_RESPONSES_ALLOWED_FIELDS,
+        enforceAllowedTopLevelKeys: true,
         forbidWrappers: [
             {
                 code: 'forbid_wrapper',
@@ -26,30 +29,21 @@ const RESPONSES_SPEC = {
                 aliasKeys: {
                     max_tokens: 'max_output_tokens'
                 },
-                allowKeys: [
-                    'temperature',
-                    'top_p',
-                    'max_output_tokens',
-                    'seed',
-                    'logit_bias',
-                    'user',
-                    'parallel_tool_calls',
-                    'tool_choice',
-                    'response_format',
-                    'stream',
-                    'stop',
-                    'stop_sequences',
-                    'modalities',
-                    'top_k'
-                ]
+                allowKeys: [...OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS]
             }
         ]
+    },
+    toolSurface: {
+        expectedToolFormat: 'openai',
+        expectedHistoryCarrier: 'input'
     }
 };
 const DEFAULT_SPEC = {
     id: 'openai-chat',
     providerOutbound: {
-        enforceEnabled: false,
+        enforceEnabled: true,
+        allowedTopLevelKeys: OPENAI_CHAT_ALLOWED_FIELDS,
+        enforceAllowedTopLevelKeys: true,
         forbidWrappers: [
             {
                 code: 'forbid_wrapper',
@@ -63,7 +57,24 @@ const DEFAULT_SPEC = {
             }
         ],
         reservedKeyPrefixes: ['__', '_'],
-        flattenWrappers: []
+        flattenWrappers: [
+            {
+                wrapperKey: 'request',
+                onlyIfTargetMissing: true
+            },
+            {
+                wrapperKey: 'parameters',
+                onlyIfTargetMissing: true,
+                aliasKeys: {
+                    max_output_tokens: 'max_tokens'
+                },
+                allowKeys: [...OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS]
+            }
+        ]
+    },
+    toolSurface: {
+        expectedToolFormat: 'openai',
+        expectedHistoryCarrier: 'messages'
     }
 };
 export const HUB_PROTOCOL_SPECS = {
@@ -72,7 +83,9 @@ export const HUB_PROTOCOL_SPECS = {
     'anthropic-messages': {
         id: 'anthropic-messages',
         providerOutbound: {
-            enforceEnabled: false,
+            enforceEnabled: true,
+            allowedTopLevelKeys: ANTHROPIC_ALLOWED_FIELDS,
+            enforceAllowedTopLevelKeys: true,
             forbidWrappers: [
                 {
                     code: 'forbid_wrapper',
@@ -86,16 +99,53 @@ export const HUB_PROTOCOL_SPECS = {
                 }
             ],
             reservedKeyPrefixes: ['__', '_'],
-            flattenWrappers: []
+            flattenWrappers: [
+                {
+                    wrapperKey: 'request',
+                    onlyIfTargetMissing: true
+                },
+                {
+                    wrapperKey: 'parameters',
+                    onlyIfTargetMissing: true,
+                    aliasKeys: {
+                        max_output_tokens: 'max_tokens'
+                    },
+                    allowKeys: [...ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS]
+                }
+            ]
+        },
+        toolSurface: {
+            expectedToolFormat: 'anthropic'
         }
     },
     'gemini-chat': {
         id: 'gemini-chat',
         providerOutbound: {
-            enforceEnabled: false,
-            forbidWrappers: [],
+            enforceEnabled: true,
+            allowedTopLevelKeys: GEMINI_ALLOWED_FIELDS,
+            enforceAllowedTopLevelKeys: true,
+            forbidWrappers: [
+                {
+                    code: 'forbid_wrapper',
+                    path: 'parameters',
+                    detail: 'Gemini provider payload must not contain a top-level parameters wrapper.'
+                },
+                {
+                    code: 'forbid_wrapper',
+                    path: 'request',
+                    detail: 'Gemini provider payload must not contain a nested request wrapper.'
+                }
+            ],
             reservedKeyPrefixes: ['__', '_'],
-            flattenWrappers: []
+            flattenWrappers: [
+                {
+                    wrapperKey: 'request',
+                    onlyIfTargetMissing: true
+                }
+            ]
+        },
+        toolSurface: {
+            expectedToolFormat: 'gemini'
         }
     }
 };