@jsonstudio/llms 0.4.2 → 0.4.3

package/dist/conversion/conversion-v3/config/default-configs.js

@@ -644,23 +644,6 @@ export const DEFAULT_PIPELINE_DOCUMENT = {
             id: 'pipeline-responses',
             name: 'OpenAI Responses Pipeline',
             entryEndpoints: ['/v1/responses', '/responses'],
-            processMode: 'chat',
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-sse-input', kind: 'sse-input', implementation: 'sse-input' },
-                { id: 'responses-input', kind: 'input', implementation: 'responses-input' },
-                { id: 'responses-process', kind: 'process', implementation: 'passthrough-process' },
-                { id: 'responses-output', kind: 'output', implementation: 'responses-output' },
-                { id: 'responses-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-passthrough',
-            name: 'OpenAI Responses Passthrough Pipeline',
-            entryEndpoints: ['/v1/responses', '/responses'],
-            providerProtocols: ['openai-responses'],
-            processMode: 'passthrough',
-            mode: 'passthrough',
             streaming: 'always',
             nodes: [
                 { id: 'responses-sse-input', kind: 'sse-input', implementation: 'sse-input' },
@@ -670,37 +653,7 @@ export const DEFAULT_PIPELINE_DOCUMENT = {
                 { id: 'responses-sse-output', kind: 'sse-output', implementation: 'sse-output' }
             ]
         },
-        {
-            id: 'pipeline-responses-openai-chat',
-            name: 'OpenAI Responses Pipeline (Chat Provider)',
-            entryEndpoints: ['/v1/responses', '/responses'],
-            providerProtocols: ['openai'],
-            processMode: 'chat',
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-openai-sse-input', kind: 'sse-input', implementation: 'sse-input' },
-                { id: 'responses-openai-input', kind: 'input', implementation: 'responses-input' },
-                { id: 'responses-openai-process', kind: 'process', implementation: 'chat-process' },
-                { id: 'responses-openai-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'responses-openai-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-openai-chat-passthrough',
-            name: 'OpenAI Responses Pipeline (Chat Provider Passthrough)',
-            entryEndpoints: ['/v1/responses', '/responses'],
-            providerProtocols: ['openai'],
-            processMode: 'passthrough',
-            mode: 'passthrough',
-            streaming: 'never',
-            nodes: [
-                { id: 'responses-openai-sse-input', kind: 'sse-input', implementation: 'sse-input' },
-                { id: 'responses-openai-input', kind: 'input', implementation: 'responses-input' },
-                { id: 'responses-openai-process', kind: 'process', implementation: 'chat-process' },
-                { id: 'responses-openai-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'responses-openai-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
+        // Chat providers (openai-compatible) reuse the default response pipeline above.
         {
             id: 'pipeline-openai-chat-response',
             name: 'OpenAI Chat Response Pipeline',
@@ -729,21 +682,7 @@ export const DEFAULT_PIPELINE_DOCUMENT = {
             id: 'pipeline-responses-response',
             name: 'OpenAI Responses Response Pipeline',
             entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            processMode: 'chat',
             streaming: 'always',
-            nodes: [
-                { id: 'responses-response-input', kind: 'input', implementation: 'responses-response-input' },
-                { id: 'responses-response-sse-pass', kind: 'process', implementation: 'sse-passthrough' },
-                { id: 'responses-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-response-passthrough',
-            name: 'OpenAI Responses Response Pipeline (Passthrough)',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            processMode: 'passthrough',
-            mode: 'passthrough',
-            streaming: 'never',
             nodes: [
                 { id: 'responses-response-input', kind: 'input', implementation: 'responses-response-input' },
                 { id: 'responses-response-process', kind: 'process', implementation: 'response-process' },
@@ -756,25 +695,10 @@ export const DEFAULT_PIPELINE_DOCUMENT = {
             name: 'OpenAI Responses Response Pipeline (Chat Provider)',
             entryEndpoints: ['/v1/responses#response', '/responses#response'],
             providerProtocols: ['openai'],
-            processMode: 'chat',
-            streaming: 'never',
-            nodes: [
-                { id: 'responses-openai-response-input', kind: 'input', implementation: 'openai-response-input' },
-                { id: 'responses-openai-response-sse-pass', kind: 'process', implementation: 'sse-passthrough' },
-                { id: 'responses-openai-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-openai-chat-response-passthrough',
-            name: 'OpenAI Responses Response Pipeline (Chat Provider Passthrough)',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            providerProtocols: ['openai'],
-            processMode: 'passthrough',
-            mode: 'passthrough',
-            streaming: 'auto',
+            streaming: 'always',
             nodes: [
                 { id: 'responses-openai-response-input', kind: 'input', implementation: 'openai-response-input' },
-                { id: 'responses-openai-response-sse-pass', kind: 'process', implementation: 'sse-passthrough' },
+                { id: 'responses-openai-response-process', kind: 'process', implementation: 'response-process' },
                 { id: 'responses-openai-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
             ]
         },

package/dist/conversion/conversion-v3/nodes/process/tool-process-node.d.ts

@@ -22,5 +22,9 @@ export declare class ToolProcessNode extends BasePipelineNode {
     private ensureArgumentsString;
     private ensureToolChoiceIntegrity;
     private buildToolCallId;
+    private sanitizeToolIdentifier;
+    private ensureUniqueToolCallId;
+    private generateToolCallId;
+    private resolveToolCallId;
     private normalizeResponse;
 }

package/dist/conversion/conversion-v3/nodes/process/tool-process-node.js

@@ -160,6 +160,8 @@ export class ToolProcessNode extends BasePipelineNode {
             return undefined;
         }
         const normalized = [];
+        const toolIdRegistry = new Set();
+        const toolIdAliasMap = new Map();
         let lastToolCallId = null;
         let callCounter = 0;
         for (const msg of messages) {
@@ -169,17 +171,18 @@ export class ToolProcessNode extends BasePipelineNode {
             if (Array.isArray(next.tool_calls) && next.tool_calls.length > 0) {
                 next.content = null;
                 next.tool_calls = next.tool_calls
-                    .map(call => this.normalizeToolCall(call, callCounter++))
+                    .map(call => this.normalizeToolCall(call, callCounter++, toolIdRegistry, toolIdAliasMap))
                     .filter(Boolean);
                 if (next.tool_calls.length) {
                     lastToolCallId = next.tool_calls[next.tool_calls.length - 1].id;
                 }
             }
             if (next.role === 'tool') {
-                const toolCallId = typeof next.tool_call_id === 'string' && next.tool_call_id.trim()
-                    ? next.tool_call_id.trim()
-                    : lastToolCallId ?? this.buildToolCallId(callCounter++);
-                next.tool_call_id = toolCallId;
+                if (!lastToolCallId) {
+                    lastToolCallId = this.generateToolCallId(undefined, this.buildToolCallId(callCounter++), toolIdRegistry, toolIdAliasMap);
+                }
+                const resolvedId = this.resolveToolCallId(next.tool_call_id, lastToolCallId, toolIdRegistry, toolIdAliasMap);
+                next.tool_call_id = resolvedId;
                 if (next.content !== null && typeof next.content !== 'string') {
                     try {
                         next.content = JSON.stringify(next.content);
@@ -228,12 +231,10 @@ export class ToolProcessNode extends BasePipelineNode {
         }
         return ordered;
     }
-    normalizeToolCall(call, counter) {
+    normalizeToolCall(call, counter, registry, aliasMap) {
         if (!call || typeof call !== 'object')
             return null;
-        const id = typeof call.id === 'string' && call.id.trim()
-            ? call.id.trim()
-            : this.buildToolCallId(counter);
+        const id = this.generateToolCallId(call.id, this.buildToolCallId(counter), registry, aliasMap);
         const fn = call.function || { name: '', arguments: '' };
         const name = typeof fn.name === 'string' ? fn.name.trim() : '';
         const args = this.ensureArgumentsString(fn.arguments);
@@ -283,6 +284,66 @@ export class ToolProcessNode extends BasePipelineNode {
     buildToolCallId(counter) {
         return `${TOOL_CALL_ID_PREFIX}_${counter}_${Date.now()}`;
     }
+    sanitizeToolIdentifier(value) {
+        if (!value)
+            return '';
+        const trimmed = value.trim();
+        if (!trimmed)
+            return '';
+        const sanitized = trimmed.replace(/[^A-Za-z0-9_-]/g, '_');
+        return sanitized || '';
+    }
+    ensureUniqueToolCallId(base, registry) {
+        if (!registry.has(base)) {
+            return base;
+        }
+        let suffix = 1;
+        let candidate = `${base}_${suffix}`;
+        while (registry.has(candidate)) {
+            suffix += 1;
+            candidate = `${base}_${suffix}`;
+        }
+        return candidate;
+    }
+    generateToolCallId(rawCandidate, fallbackBase, registry, aliasMap) {
+        const candidate = typeof rawCandidate === 'string' ? rawCandidate.trim() : '';
+        const sanitizedCandidate = this.sanitizeToolIdentifier(candidate);
+        const sanitizedFallback = this.sanitizeToolIdentifier(fallbackBase) || this.buildToolCallId(Date.now());
+        const base = sanitizedCandidate || sanitizedFallback;
+        const unique = this.ensureUniqueToolCallId(base, registry);
+        registry.add(unique);
+        if (candidate)
+            aliasMap.set(candidate, unique);
+        aliasMap.set(unique, unique);
+        if (sanitizedCandidate && sanitizedCandidate !== candidate) {
+            aliasMap.set(sanitizedCandidate, unique);
+        }
+        return unique;
+    }
+    resolveToolCallId(rawCandidate, fallbackId, registry, aliasMap) {
+        const candidate = typeof rawCandidate === 'string' ? rawCandidate.trim() : '';
+        if (candidate) {
+            const cached = aliasMap.get(candidate);
+            if (cached) {
+                return cached;
+            }
+            const sanitized = this.sanitizeToolIdentifier(candidate);
+            if (sanitized) {
+                const cachedSanitized = aliasMap.get(sanitized);
+                if (cachedSanitized) {
+                    aliasMap.set(candidate, cachedSanitized);
+                    return cachedSanitized;
+                }
+                const unique = this.ensureUniqueToolCallId(sanitized, registry);
+                registry.add(unique);
+                aliasMap.set(candidate, unique);
+                aliasMap.set(sanitized, unique);
+                aliasMap.set(unique, unique);
+                return unique;
+            }
+        }
+        return fallbackId;
+    }
     normalizeResponse(response) {
         if (!response?.message)
             return;

package/dist/conversion/shared/responses-id-utils.js

@@ -1,16 +1,29 @@
+function sanitizeCore(value) {
+    return value
+        .replace(/[^A-Za-z0-9_-]/g, '_')
+        .replace(/_{2,}/g, '_')
+        .replace(/^_+/, '')
+        .replace(/_+$/, '');
+}
 function stripPrefix(value) {
     if (typeof value !== 'string')
         return null;
     const trimmed = value.trim();
     if (!trimmed)
         return null;
-    if (/^fc[_-]/i.test(trimmed)) {
-        return `fc_${trimmed.replace(/^fc[_-]?/i, '')}`;
+    let sanitized = sanitizeCore(trimmed);
+    if (!sanitized)
+        return null;
+    if (/^fc[_-]/i.test(sanitized)) {
+        sanitized = sanitized.replace(/^fc[_-]?/i, '');
+    }
+    else if (/^call[_-]/i.test(sanitized)) {
+        sanitized = sanitized.replace(/^call[_-]?/i, '');
     }
-    if (/^call[_-]/i.test(trimmed)) {
-        return `fc_${trimmed.replace(/^call[_-]?/i, '')}`;
+    if (!sanitized) {
+        sanitized = Math.random().toString(36).slice(2, 10);
     }
-    return `fc_${trimmed}`;
+    return `fc_${sanitized}`;
 }
 function normalizeWithFallback(options) {
     const normalized = stripPrefix(options.callId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -62,4 +62,4 @@
     "dist",
     "README.md"
   ]
-}
+}