@jsonstudio/llms 0.6.2 → 0.6.34

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

@@ -262,6 +262,7 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     catch {
         // best-effort policy execution
     }
+    const normalizedFinishReason = toolCalls.length ? 'tool_calls' : finish_reason;
     const chatResp = {
         id: payload?.id || `chatcmpl_${Date.now()}`,
         object: 'chat.completion',
@@ -269,7 +270,7 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
         choices: [
             {
                 index: 0,
-                finish_reason,
+                finish_reason: normalizedFinishReason,
                 message: chatMsg
             }
         ]

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

@@ -1,4 +1,5 @@
 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;
@@ -18,6 +19,18 @@ export async function runReqInboundStage3ContextCapture(options) {
         ? augmentContextSnapshot(context, fallbackSnapshot)
         : fallbackSnapshot;
     recordStage(options.stageRecorder, 'req_inbound_stage3_context_capture', snapshot);
+    if (options.adapterContext.providerProtocol === 'openai-responses') {
+        try {
+            captureResponsesRequestContext({
+                requestId: options.adapterContext.requestId,
+                payload: options.rawRequest,
+                context: snapshot
+            });
+        }
+        catch {
+            /* ignore capture failures */
+        }
+    }
     return context ?? snapshot;
 }
 export function runChatContextCapture(options) {

package/dist/conversion/hub/response/response-mappers.d.ts

@@ -9,7 +9,7 @@ export declare class OpenAIChatResponseMapper implements ResponseMapper {
     toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
 }
 export declare class ResponsesResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+    toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): ChatCompletionLike;
 }
 export declare class AnthropicResponseMapper implements ResponseMapper {
     toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): ChatCompletionLike;

package/dist/conversion/hub/response/response-mappers.js

@@ -1,5 +1,6 @@
 import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-codec.js';
 import { buildChatResponseFromResponses } from '../../shared/responses-response-utils.js';
+import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
 import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
 export class OpenAIChatResponseMapper {
     toChatCompletion(format, _ctx) {
@@ -7,8 +8,17 @@ export class OpenAIChatResponseMapper {
     }
 }
 export class ResponsesResponseMapper {
-    toChatCompletion(format, _ctx) {
-        return buildChatResponseFromResponses(format.payload ?? {});
+    toChatCompletion(format, ctx) {
+        const payload = (format.payload ?? {});
+        if (ctx?.requestId) {
+            try {
+                recordResponsesResponse({ requestId: ctx.requestId, response: payload });
+            }
+            catch {
+                /* ignore capture failures */
+            }
+        }
+        return buildChatResponseFromResponses(payload);
     }
 }
 export class AnthropicResponseMapper {

package/dist/conversion/shared/responses-conversation-store.d.ts

@@ -0,0 +1,35 @@
+type AnyRecord = Record<string, unknown>;
+interface CaptureContextArgs {
+    requestId?: string;
+    payload: AnyRecord;
+    context: AnyRecord;
+}
+interface RecordResponseArgs {
+    requestId?: string;
+    response: AnyRecord;
+}
+interface ResumeOptions {
+    requestId?: string;
+}
+interface ResumeResult {
+    payload: AnyRecord;
+    meta: AnyRecord;
+}
+declare class ResponsesConversationStore {
+    private requestMap;
+    private responseIndex;
+    rebindRequestId(oldId: string | undefined, newId: string | undefined): void;
+    captureRequestContext(args: CaptureContextArgs): void;
+    recordResponse(args: RecordResponseArgs): void;
+    resumeConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
+    clearRequest(requestId?: string): void;
+    private cleanupEntry;
+    private prune;
+}
+declare const store: ResponsesConversationStore;
+export declare function captureResponsesRequestContext(args: CaptureContextArgs): void;
+export declare function recordResponsesResponse(args: RecordResponseArgs): void;
+export declare function resumeResponsesConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
+export declare function clearResponsesConversationByRequestId(requestId?: string): void;
+export declare function rebindResponsesConversationRequestId(oldId?: string, newId?: string): void;
+export { store as responsesConversationStore };

package/dist/conversion/shared/responses-conversation-store.js

@@ -1,4 +1,4 @@
-const TTL_MS = 1000 * 60 * 30; // 30 minutes safety window
+const TTL_MS = 1000 * 60 * 30; // 30min
 function cloneDeep(value) {
     try {
         if (typeof globalThis.structuredClone === 'function') {
@@ -49,19 +49,26 @@ function pickPersistedFields(payload) {
         'input_audio',
         'output_audio'
     ];
-    const result = {};
+    const next = {};
     for (const key of fields) {
         if (payload[key] !== undefined) {
-            result[key] = cloneDeep(payload[key]);
+            next[key] = cloneDeep(payload[key]);
         }
     }
-    return result;
+    return next;
 }
 function normalizeOutputItemToInput(item) {
+    if (!item || typeof item !== 'object') {
+        return null;
+    }
     const type = typeof item.type === 'string' ? item.type : '';
     if (type === 'message' || type === 'reasoning') {
         const role = typeof item.role === 'string' ? item.role : 'assistant';
-        const content = Array.isArray(item.content) ? cloneDeep(item.content) : (typeof item.text === 'string' ? [{ type: 'text', text: item.text }] : []);
+        const content = Array.isArray(item.content)
+            ? cloneDeep(item.content)
+            : typeof item.text === 'string'
+                ? [{ type: 'text', text: item.text }]
+                : [];
         return {
             type: 'message',
             role,
@@ -70,7 +77,11 @@ function normalizeOutputItemToInput(item) {
         };
     }
     if (type === 'function_call') {
-        const callId = typeof item.call_id === 'string' ? item.call_id : (typeof item.id === 'string' ? item.id : undefined);
+        const callId = typeof item.call_id === 'string'
+            ? item.call_id
+            : typeof item.id === 'string'
+                ? item.id
+                : undefined;
         return {
             type: 'function_call',
             role: 'assistant',
@@ -80,9 +91,9 @@ function normalizeOutputItemToInput(item) {
             arguments: item.arguments,
             function: isRecord(item.function)
                 ? cloneDeep(item.function)
-                : (typeof item.name === 'string'
+                : typeof item.name === 'string'
                     ? { name: item.name, arguments: item.arguments }
-                    : undefined)
+                    : undefined
         };
     }
     return null;
@@ -139,6 +150,18 @@ function normalizeSubmittedToolOutputs(toolOutputs) {
 class ResponsesConversationStore {
     requestMap = new Map();
     responseIndex = new Map();
+    rebindRequestId(oldId, newId) {
+        if (!oldId || !newId || oldId === newId) {
+            return;
+        }
+        const entry = this.requestMap.get(oldId);
+        if (!entry) {
+            return;
+        }
+        this.requestMap.delete(oldId);
+        entry.requestId = newId;
+        this.requestMap.set(newId, entry);
+    }
     captureRequestContext(args) {
         const { requestId, payload, context } = args;
         if (!requestId || !payload)
@@ -148,7 +171,8 @@ class ResponsesConversationStore {
             requestId,
             basePayload: pickPersistedFields(payload),
             input: coerceInputArray(context.input),
-            tools: coerceTools(context.toolsRaw || (Array.isArray(payload.tools) ? payload.tools : undefined)),
+            tools: coerceTools(context.toolsRaw) ||
+                coerceTools(Array.isArray(payload.tools) ? payload.tools : undefined),
             createdAt: Date.now(),
             updatedAt: Date.now()
         };
@@ -164,7 +188,7 @@ class ResponsesConversationStore {
         this.requestMap.set(requestId, entry);
     }
     recordResponse(args) {
-        const entry = this.requestMap.get(args.requestId);
+        const entry = args.requestId ? this.requestMap.get(args.requestId) : undefined;
         if (!entry)
             return;
         const response = args.response;
@@ -188,9 +212,7 @@ class ResponsesConversationStore {
         if (!entry) {
             throw new Error('Responses conversation expired or not found');
         }
-        const toolOutputs = Array.isArray(submitPayload.tool_outputs)
-            ? submitPayload.tool_outputs
-            : [];
+        const toolOutputs = Array.isArray(submitPayload.tool_outputs) ? submitPayload.tool_outputs : [];
         if (!toolOutputs.length) {
             throw new Error('tool_outputs array is required when submitting Responses tool results');
         }
@@ -208,7 +230,8 @@ class ResponsesConversationStore {
             payload.model = submitPayload.model.trim();
         }
         if (submitPayload.metadata && isRecord(submitPayload.metadata)) {
-            payload.metadata = { ...payload.metadata, ...cloneDeep(submitPayload.metadata) };
+            const baseMeta = isRecord(payload.metadata) ? payload.metadata : {};
+            payload.metadata = { ...baseMeta, ...cloneDeep(submitPayload.metadata) };
         }
         delete payload.tool_outputs;
         delete payload.response_id;
@@ -225,6 +248,8 @@ class ResponsesConversationStore {
         };
     }
     clearRequest(requestId) {
+        if (!requestId)
+            return;
         const entry = this.requestMap.get(requestId);
         if (!entry)
             return;
@@ -254,10 +279,14 @@ class ResponsesConversationStore {
         }
     }
 }
-export const responsesConversationStore = new ResponsesConversationStore();
+const store = new ResponsesConversationStore();
+const RESPONSES_DEBUG = (process.env.ROUTECODEX_RESPONSES_DEBUG || '').trim() === '1';
 export function captureResponsesRequestContext(args) {
     try {
-        responsesConversationStore.captureRequestContext(args);
+        if (RESPONSES_DEBUG) {
+            console.log('[responses-store] capture', args.requestId);
+        }
+        store.captureRequestContext(args);
     }
     catch {
         /* ignore capture failures */
@@ -265,15 +294,31 @@ export function captureResponsesRequestContext(args) {
 }
 export function recordResponsesResponse(args) {
     try {
-        responsesConversationStore.recordResponse(args);
+        if (RESPONSES_DEBUG) {
+            console.log('[responses-store] record', args.requestId, args.response?.id);
+        }
+        store.recordResponse(args);
     }
     catch {
         /* ignore */
     }
 }
 export function resumeResponsesConversation(responseId, submitPayload, options) {
-    return responsesConversationStore.resumeConversation(responseId, submitPayload, options);
+    if (RESPONSES_DEBUG) {
+        console.log('[responses-store] resume', responseId);
+    }
+    return store.resumeConversation(responseId, submitPayload, options);
 }
 export function clearResponsesConversationByRequestId(requestId) {
-    responsesConversationStore.clearRequest(requestId);
+    if (RESPONSES_DEBUG && requestId) {
+        console.log('[responses-store] clear', requestId);
+    }
+    store.clearRequest(requestId);
+}
+export function rebindResponsesConversationRequestId(oldId, newId) {
+    if (RESPONSES_DEBUG && oldId && newId) {
+        console.log('[responses-store] rebind', oldId, '->', newId);
+    }
+    store.rebindRequestId(oldId, newId);
 }
+export { store as responsesConversationStore };

package/dist/conversion/shared/responses-output-builder.js

@@ -112,29 +112,50 @@ export function buildResponsesOutputFromChat(options) {
     };
 }
 function normalizeUsage(usageRaw) {
-    if (usageRaw && typeof usageRaw === 'object') {
-        const usage = { ...usageRaw };
-        if (usage.input_tokens != null && usage.prompt_tokens == null) {
-            usage.prompt_tokens = usage.input_tokens;
-        }
-        if (usage.output_tokens != null && usage.completion_tokens == null) {
-            usage.completion_tokens = usage.output_tokens;
-        }
-        if (usage.prompt_tokens != null && usage.completion_tokens != null && usage.total_tokens == null) {
-            const total = Number(usage.prompt_tokens) + Number(usage.completion_tokens);
-            if (!Number.isNaN(total))
-                usage.total_tokens = total;
-        }
-        try {
-            delete usage.input_tokens;
-            delete usage.output_tokens;
-        }
-        catch {
-            /* ignore */
-        }
-        return usage;
+    if (!usageRaw || typeof usageRaw !== 'object') {
+        return undefined;
+    }
+    const source = usageRaw;
+    const usage = {};
+    const inputValue = normalizeNumber(source.input_tokens ?? source.prompt_tokens);
+    if (inputValue !== undefined) {
+        usage.input_tokens = inputValue;
+    }
+    const outputValue = normalizeNumber(source.output_tokens ?? source.completion_tokens);
+    if (outputValue !== undefined) {
+        usage.output_tokens = outputValue;
+    }
+    const totalValue = normalizeNumber(source.total_tokens);
+    if (totalValue !== undefined) {
+        usage.total_tokens = totalValue;
+    }
+    else if (inputValue !== undefined && outputValue !== undefined) {
+        usage.total_tokens = inputValue + outputValue;
+    }
+    const inputDetails = extractTokenDetails(source.input_tokens_details ??
+        source.prompt_tokens_details);
+    if (inputDetails) {
+        usage.input_tokens_details = inputDetails;
+    }
+    const outputDetails = extractTokenDetails(source.output_tokens_details ??
+        source.completion_tokens_details);
+    if (outputDetails) {
+        usage.output_tokens_details = outputDetails;
+    }
+    return Object.keys(usage).length ? usage : undefined;
+}
+function normalizeNumber(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function extractTokenDetails(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
     }
-    return usageRaw;
+    return { ...raw };
 }
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {

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

@@ -167,7 +167,7 @@ export function buildChatResponseFromResponses(payload) {
     const created = typeof response.created_at === 'number'
         ? response.created_at
         : (response.created ?? Math.floor(Date.now() / 1000));
-    const usage = response.usage;
+    const usage = mapResponsesUsageToChat(response.usage);
     const toolCalls = collectToolCallsFromResponses(response);
     const { textParts, reasoningParts } = extractOutputSegments(response);
     const rawReasoningSegments = collectRawReasoningSegments(response);
@@ -237,3 +237,49 @@ export function buildChatResponseFromResponses(payload) {
     }
     return chat;
 }
+function mapResponsesUsageToChat(usageRaw) {
+    if (!usageRaw || typeof usageRaw !== 'object') {
+        return undefined;
+    }
+    const source = usageRaw;
+    const usage = {};
+    const promptValue = toNumber(source.prompt_tokens ?? source.input_tokens);
+    if (promptValue !== undefined) {
+        usage.prompt_tokens = promptValue;
+    }
+    const completionValue = toNumber(source.completion_tokens ?? source.output_tokens);
+    if (completionValue !== undefined) {
+        usage.completion_tokens = completionValue;
+    }
+    const totalValue = toNumber(source.total_tokens);
+    if (totalValue !== undefined) {
+        usage.total_tokens = totalValue;
+    }
+    else if (promptValue !== undefined && completionValue !== undefined) {
+        usage.total_tokens = promptValue + completionValue;
+    }
+    const promptDetails = extractDetailObject(source.prompt_tokens_details ??
+        source.input_tokens_details);
+    if (promptDetails) {
+        usage.prompt_tokens_details = promptDetails;
+    }
+    const completionDetails = extractDetailObject(source.completion_tokens_details ??
+        source.output_tokens_details);
+    if (completionDetails) {
+        usage.completion_tokens_details = completionDetails;
+    }
+    return Object.keys(usage).length ? usage : undefined;
+}
+function toNumber(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function extractDetailObject(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    return { ...raw };
+}

package/dist/conversion/shared/text-markup-normalizer.js

@@ -95,10 +95,10 @@ export function extractApplyPatchCallsFromText(text) {
                     continue;
                 let argsStr = '{}';
                 try {
-                    argsStr = JSON.stringify({ patch });
+                    argsStr = JSON.stringify({ input: patch });
                 }
                 catch {
-                    argsStr = '{"patch":""}';
+                    argsStr = '{"input":""}';
                 }
                 out.push({ id: genId(), name: 'apply_patch', args: argsStr });
             }

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

@@ -12,31 +12,133 @@ function repairArgumentsToString(args) {
         return String(args);
     }
 }
+function extractStringContent(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const parts = [];
+        for (const entry of value) {
+            if (typeof entry === 'string') {
+                parts.push(entry);
+            }
+            else if (entry && typeof entry === 'object') {
+                const text = entry.text;
+                if (typeof text === 'string') {
+                    parts.push(text);
+                }
+            }
+        }
+        if (parts.length) {
+            return parts.join('\n');
+        }
+    }
+    return null;
+}
+function readApplyPatchArgument(args) {
+    if (!args || typeof args !== 'object')
+        return undefined;
+    const input = args.input;
+    if (typeof input === 'string' && input.trim().length > 0) {
+        return input;
+    }
+    const legacy = args.patch;
+    if (typeof legacy === 'string' && legacy.trim().length > 0) {
+        return legacy;
+    }
+    return undefined;
+}
+function hasApplyPatchInput(argText) {
+    if (!argText) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(argText);
+        const content = readApplyPatchArgument(parsed);
+        return typeof content === 'string' && content.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function extractUnifiedDiff(content) {
+    if (!content)
+        return undefined;
+    const begin = content.indexOf('*** Begin Patch');
+    const end = content.indexOf('*** End Patch');
+    if (begin >= 0 && end > begin) {
+        return content.slice(begin, end + '*** End Patch'.length).trim();
+    }
+    return undefined;
+}
+function createToolCallId() {
+    return `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
 export function canonicalizeChatResponseTools(payload) {
     try {
         const out = isObject(payload) ? JSON.parse(JSON.stringify(payload)) : payload;
         const choices = Array.isArray(out?.choices) ? out.choices : [];
         for (const ch of choices) {
             const msg = ch && ch.message ? ch.message : undefined;
-            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
-            if (!tcs || !tcs.length)
+            const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : undefined;
+            const hasToolCalls = Array.isArray(toolCalls) && toolCalls.length > 0;
+            const originalContentText = extractStringContent(msg?.content);
+            const harvestedPatch = typeof originalContentText === 'string' ? extractUnifiedDiff(originalContentText) : undefined;
+            if (hasToolCalls) {
+                // ensure arguments is string and content is null when tool_calls present
+                try {
+                    if (!ch.finish_reason)
+                        ch.finish_reason = 'tool_calls';
+                }
+                catch { /* ignore */ }
+                try {
+                    if (msg && typeof msg === 'object')
+                        msg.content = null;
+                }
+                catch { /* ignore */ }
+                for (const tc of toolCalls) {
+                    try {
+                        const fn = tc && tc.function ? tc.function : undefined;
+                        if (fn) {
+                            const repaired = repairArgumentsToString(fn.arguments);
+                            let nextArgs = repaired;
+                            try {
+                                const parsed = JSON.parse(repaired);
+                                const diffText = readApplyPatchArgument(parsed);
+                                if (typeof diffText === 'string' && diffText.trim().length > 0) {
+                                    nextArgs = JSON.stringify({ input: diffText });
+                                }
+                            }
+                            catch {
+                                // fallback to repaired string
+                            }
+                            fn.arguments = nextArgs;
+                            if (typeof fn.name === 'string' &&
+                                fn.name === 'apply_patch' &&
+                                !hasApplyPatchInput(fn.arguments) &&
+                                harvestedPatch) {
+                                fn.arguments = JSON.stringify({ input: harvestedPatch });
+                            }
+                        }
+                    }
+                    catch { /* ignore */ }
+                }
                 continue;
-            // ensure arguments is string and content is null when tool_calls present
-            try {
-                if (!ch.finish_reason)
-                    ch.finish_reason = 'tool_calls';
             }
-            catch { /* ignore */ }
-            try {
-                if (msg && typeof msg === 'object')
-                    msg.content = null;
-            }
-            catch { /* ignore */ }
-            for (const tc of tcs) {
+            if (harvestedPatch) {
+                const id = createToolCallId();
+                const toolCall = {
+                    id,
+                    type: 'function',
+                    function: {
+                        name: 'apply_patch',
+                        arguments: JSON.stringify({ input: harvestedPatch })
+                    }
+                };
                 try {
-                    const fn = tc && tc.function ? tc.function : undefined;
-                    if (fn)
-                        fn.arguments = repairArgumentsToString(fn.arguments);
+                    msg.tool_calls = [toolCall];
+                    msg.content = null;
+                    ch.finish_reason = 'tool_calls';
                 }
                 catch { /* ignore */ }
             }

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

@@ -15,6 +15,28 @@ const DEFAULT_SANITIZER = (value) => {
     }
     return undefined;
 };
+const APPLY_PATCH_TOOL_NAME = 'apply_patch';
+const APPLY_PATCH_ARG_KEY = 'input';
+function isApplyPatchTool(name) {
+    return typeof name === 'string' && name.trim() === APPLY_PATCH_TOOL_NAME;
+}
+function buildApplyPatchParameters() {
+    return {
+        type: 'object',
+        properties: {
+            [APPLY_PATCH_ARG_KEY]: {
+                type: 'string',
+                description: 'Unified diff patch content (*** Begin Patch ... *** End Patch)'
+            }
+        },
+        required: [APPLY_PATCH_ARG_KEY],
+        additionalProperties: false
+    };
+}
+function applyPatchSchemaToFunction(fnNode) {
+    fnNode.parameters = buildApplyPatchParameters();
+    fnNode.strict = true;
+}
 function resolveToolName(candidate, options) {
     const sanitized = options?.sanitizeName?.(candidate);
     if (typeof sanitized === 'string' && sanitized.trim().length) {
@@ -80,6 +102,9 @@ export function bridgeToolToChatDefinition(rawTool, options) {
     if (strict !== undefined) {
         fnOut.strict = strict;
     }
+    if (isApplyPatchTool(name)) {
+        applyPatchSchemaToFunction(fnOut);
+    }
     return {
         type: normalizedType,
         function: fnOut
@@ -131,6 +156,11 @@ export function chatToolToBridgeDefinition(rawTool, options) {
     if (strict !== undefined) {
         fnOut.strict = strict;
     }
+    if (isApplyPatchTool(name)) {
+        applyPatchSchemaToFunction(fnOut);
+        responseShape.parameters = buildApplyPatchParameters();
+        responseShape.strict = true;
+    }
     responseShape.function = fnOut;
     return responseShape;
 }

package/dist/index.d.ts

@@ -7,4 +7,5 @@
 export * from './conversion/index.js';
 export * from './router/virtual-router/bootstrap.js';
 export * from './router/virtual-router/types.js';
+export { DEFAULT_THINKING_KEYWORDS } from './router/virtual-router/default-thinking-keywords.js';
 export declare const VERSION = "0.4.0";

package/dist/index.js

@@ -7,4 +7,5 @@
 export * from './conversion/index.js';
 export * from './router/virtual-router/bootstrap.js';
 export * from './router/virtual-router/types.js';
+export { DEFAULT_THINKING_KEYWORDS } from './router/virtual-router/default-thinking-keywords.js';
 export const VERSION = '0.4.0';

package/dist/router/virtual-router/bootstrap.js

@@ -1,10 +1,13 @@
 import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+import { DEFAULT_THINKING_KEYWORDS } from './default-thinking-keywords.js';
+const KEYWORD_INJECTION_KEYS = ['thinking', 'background', 'vision', 'coding'];
 const DEFAULT_CLASSIFIER = {
-    longContextThresholdTokens: 60000,
-    thinkingKeywords: ['think step', 'analysis', 'reasoning', '仔细分析', '深度思考'],
+    longContextThresholdTokens: 180000,
+    thinkingKeywords: DEFAULT_THINKING_KEYWORDS,
     codingKeywords: ['apply_patch', 'write_file', 'create_file', 'shell', '修改文件', '写入文件'],
     backgroundKeywords: ['background', 'context dump', '上下文'],
-    visionKeywords: ['vision', 'image', 'picture', 'photo']
+    visionKeywords: ['vision', 'image', 'picture', 'photo'],
+    keywordInjections: {}
 };
 const DEFAULT_LOAD_BALANCING = { strategy: 'round-robin' };
 const DEFAULT_HEALTH = { failureThreshold: 3, cooldownMs: 30_000, fatalCooldownMs: 300_000 };
@@ -186,7 +189,8 @@ function normalizeClassifier(input) {
         thinkingKeywords: normalizeStringArray(normalized.thinkingKeywords, DEFAULT_CLASSIFIER.thinkingKeywords),
         codingKeywords: normalizeStringArray(normalized.codingKeywords, DEFAULT_CLASSIFIER.codingKeywords),
         backgroundKeywords: normalizeStringArray(normalized.backgroundKeywords, DEFAULT_CLASSIFIER.backgroundKeywords),
-        visionKeywords: normalizeStringArray(normalized.visionKeywords, DEFAULT_CLASSIFIER.visionKeywords)
+        visionKeywords: normalizeStringArray(normalized.visionKeywords, DEFAULT_CLASSIFIER.visionKeywords),
+        keywordInjections: normalizeKeywordInjectionMap(normalized.keywordInjections)
     };
     return result;
 }
@@ -197,6 +201,26 @@ function normalizeStringArray(value, fallback) {
     const normalized = value.map((item) => (typeof item === 'string' ? item.trim() : '')).filter(Boolean);
     return normalized.length ? normalized : [...fallback];
 }
+function normalizeKeywordInjectionMap(value) {
+    const map = {};
+    const record = asRecord(value);
+    if (!record) {
+        return map;
+    }
+    for (const key of KEYWORD_INJECTION_KEYS) {
+        const rawList = record[key];
+        if (!Array.isArray(rawList)) {
+            continue;
+        }
+        const normalized = rawList
+            .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+            .filter(Boolean);
+        if (normalized.length) {
+            map[key] = normalized;
+        }
+    }
+    return map;
+}
 function normalizeProvider(providerId, raw) {
     const provider = asRecord(raw);
     const providerType = detectProviderType(provider);
@@ -234,9 +258,9 @@ function normalizeResponsesConfig(provider) {
     return undefined;
 }
 function resolveCompatibilityProfile(provider) {
-    const compat = provider.compat;
-    if (typeof compat === 'string' && compat.trim().length > 0) {
-        return compat.trim();
+    const profile = readOptionalString(provider.compatibilityProfile);
+    if (profile) {
+        return profile;
     }
     return 'default';
 }

package/dist/router/virtual-router/classifier.js

@@ -1,19 +1,42 @@
 import { DEFAULT_ROUTE, ROUTE_PRIORITY } from './types.js';
-const DEFAULT_LONG_CONTEXT_THRESHOLD = 60000;
+import { DEFAULT_THINKING_KEYWORDS } from './default-thinking-keywords.js';
+const DEFAULT_LONG_CONTEXT_THRESHOLD = 180000;
 export class RoutingClassifier {
     config;
     constructor(config) {
+        const keywordConfig = normalizeKeywordConfig(config);
         this.config = {
             longContextThresholdTokens: config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD,
-            thinkingKeywords: normalizeList(config.thinkingKeywords, ['think step', 'analysis', 'reasoning']),
-            backgroundKeywords: normalizeList(config.backgroundKeywords, ['background', 'context dump'])
+            thinkingKeywords: keywordConfig.thinking,
+            backgroundKeywords: keywordConfig.background,
+            visionKeywords: keywordConfig.vision,
+            codingKeywords: keywordConfig.coding
         };
     }
     classify(features) {
         const evaluations = [
+            {
+                route: 'longcontext',
+                triggered: features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD),
+                reason: 'longcontext:token-threshold'
+            },
+            {
+                route: 'thinking',
+                triggered: features.hasThinkingKeyword ||
+                    containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []) ||
+                    features.previousToolCategory === 'context_read' ||
+                    features.previousToolCategory === 'plan',
+                reason: 'thinking:keywords'
+            },
+            {
+                route: 'background',
+                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
+                reason: 'background:keywords'
+            },
             {
                 route: 'vision',
-                triggered: features.hasVisionTool && features.hasImageAttachment,
+                triggered: (features.hasVisionTool && features.hasImageAttachment) ||
+                    features.previousToolCategory === 'vision',
                 reason: 'vision:requires-tool+image'
             },
             {
@@ -23,29 +46,15 @@ export class RoutingClassifier {
             },
             {
                 route: 'coding',
-                triggered: features.hasCodingTool,
+                triggered: features.hasCodingTool ||
+                    containsKeywords(features.userTextSample, this.config.codingKeywords ?? []) ||
+                    features.previousToolCategory === 'coding',
                 reason: 'coding:coding-tools-detected'
             },
             {
                 route: 'tools',
                 triggered: features.hasTools || features.hasToolCallResponses,
                 reason: 'tools:tool-request-detected'
-            },
-            {
-                route: 'longcontext',
-                triggered: features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD),
-                reason: 'longcontext:token-threshold'
-            },
-            {
-                route: 'thinking',
-                triggered: features.hasThinkingKeyword ||
-                    containsKeywords(features.userTextSample, this.config.thinkingKeywords ?? []),
-                reason: 'thinking:keywords'
-            },
-            {
-                route: 'background',
-                triggered: containsKeywords(features.userTextSample, this.config.backgroundKeywords ?? []),
-                reason: 'background:keywords'
             }
         ];
         const triggeredEvaluations = evaluations.filter((evaluation) => evaluation.triggered);
@@ -84,12 +93,6 @@ export class RoutingClassifier {
         return index >= 0 ? index : ROUTE_PRIORITY.length;
     }
 }
-function normalizeList(source, fallback) {
-    if (!source || source.length === 0) {
-        return fallback;
-    }
-    return source.map((item) => item.toLowerCase());
-}
 function containsKeywords(text, keywords) {
     if (!text || !keywords.length) {
         return false;
@@ -97,3 +100,29 @@ function containsKeywords(text, keywords) {
     const normalized = text.toLowerCase();
     return keywords.some((keyword) => normalized.includes(keyword));
 }
+function normalizeKeywordConfig(config) {
+    const injections = config.keywordInjections ?? {};
+    return {
+        thinking: mergeKeywordLists(DEFAULT_THINKING_KEYWORDS, config.thinkingKeywords, injections.thinking),
+        background: mergeKeywordLists(['background', 'context dump', '上下文'], config.backgroundKeywords, injections.background),
+        vision: mergeKeywordLists(['vision', 'image', 'picture', 'photo'], config.visionKeywords, injections.vision),
+        coding: mergeKeywordLists(config.codingKeywords, injections.coding)
+    };
+}
+function mergeKeywordLists(...lists) {
+    const set = new Set();
+    for (const list of lists) {
+        if (!Array.isArray(list)) {
+            continue;
+        }
+        for (const item of list) {
+            if (!item)
+                continue;
+            const normalized = String(item).toLowerCase();
+            if (normalized) {
+                set.add(normalized);
+            }
+        }
+    }
+    return Array.from(set);
+}

package/dist/router/virtual-router/default-thinking-keywords.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_THINKING_KEYWORDS: string[];

package/dist/router/virtual-router/default-thinking-keywords.js

@@ -0,0 +1,13 @@
+export const DEFAULT_THINKING_KEYWORDS = [
+    '思考',
+    '深度思考',
+    '分析',
+    '推理',
+    '思路',
+    '一步一步',
+    '慢慢',
+    'think',
+    'thinking',
+    'step by step',
+    'reason'
+];

package/dist/router/virtual-router/features.js

@@ -1,3 +1,4 @@
+import { countRequestTokens } from './token-counter.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
 const WEB_TOOL_KEYWORDS = ['websearch', 'web_search', 'web-search', 'webfetch', 'web_fetch', 'web_request', 'search_web', 'internet_search'];
 export function buildRoutingFeatures(request, metadata) {
@@ -7,10 +8,11 @@ export function buildRoutingFeatures(request, metadata) {
     const normalizedUserText = latestUserText.toLowerCase();
     const hasTools = Array.isArray(request.tools) && request.tools.length > 0;
     const hasToolCallResponses = assistantMessages.some((msg) => Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0);
-    const estimatedTokens = estimateTokens(latestUserText, latestUserText ? 1 : 0);
+    const estimatedTokens = countRequestTokens(request);
     const hasThinking = detectKeyword(normalizedUserText, THINKING_KEYWORDS);
-    const hasVisionTool = detectVisionTool(request);
-    const hasImageAttachment = hasVisionTool && detectImageAttachment(latestUserMessage);
+    const previousToolCategory = detectPreviousToolCategory(request.messages);
+    const hasVisionTool = detectVisionTool(request) || previousToolCategory === 'vision';
+    const hasImageAttachment = previousToolCategory === 'vision' || (hasVisionTool && detectImageAttachment(latestUserMessage));
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
@@ -28,6 +30,7 @@ export function buildRoutingFeatures(request, metadata) {
         hasCodingTool,
         hasThinkingKeyword,
         estimatedTokens,
+        previousToolCategory,
         metadata: {
             ...metadata
         }
@@ -125,12 +128,111 @@ function detectExtendedThinkingKeyword(text) {
     const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
     return keywords.some((keyword) => text.includes(keyword));
 }
-function estimateTokens(text, messageCount) {
-    if (!text) {
-        return Math.max(32, messageCount * 16);
+function detectPreviousToolCategory(messages) {
+    if (!Array.isArray(messages) || !messages.length) {
+        return null;
+    }
+    let lastUserIndex = messages.length;
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        if (messages[idx]?.role === 'user') {
+            lastUserIndex = idx;
+            break;
+        }
+    }
+    for (let idx = lastUserIndex - 1; idx >= 0; idx -= 1) {
+        const candidate = messages[idx];
+        if (!candidate || candidate.role !== 'assistant') {
+            continue;
+        }
+        const messageRecord = candidate;
+        const rawCalls = Array.isArray(messageRecord.tool_calls)
+            ? messageRecord.tool_calls
+            : [];
+        if (!rawCalls.length) {
+            continue;
+        }
+        for (const call of rawCalls) {
+            const categorized = categorizeToolCall(call);
+            if (categorized) {
+                return categorized;
+            }
+        }
+    }
+    return null;
+}
+function categorizeToolCall(call) {
+    if (!call) {
+        return null;
+    }
+    const fn = (call.function ?? call);
+    const name = typeof (fn?.name ?? call.name) === 'string' ? String(fn?.name ?? call.name) : '';
+    if (!name) {
+        return null;
+    }
+    const args = parseFunctionArguments(typeof fn?.arguments === 'string' ? fn.arguments : undefined);
+    if (name === 'update_plan') {
+        return 'plan';
+    }
+    if (name === 'view_image') {
+        return hasImageLink(args) ? 'vision' : null;
+    }
+    if (name === 'apply_patch') {
+        return 'coding';
     }
-    const rough = Math.ceil(text.length / 4);
-    return Math.max(rough, messageCount * 32);
+    if (name === 'shell_command') {
+        const command = typeof args?.command === 'string' ? args.command : '';
+        return classifyShellCommand(command);
+    }
+    return null;
+}
+function parseFunctionArguments(raw) {
+    if (!raw) {
+        return null;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+const CONTEXT_READ_PATTERNS = [
+    /\brg\b/i,
+    /\bsed\b/i,
+    /\bcat\b/i,
+    /\btail\b/i,
+    /\bhead\b/i,
+    /\bls\b/i,
+    /\bwc\b/i,
+    /\bgrep\b/i,
+    /node\s+-\s*<<['"]/i,
+    /python\s+-\s*<<['"]/i
+];
+function classifyShellCommand(command) {
+    if (!command) {
+        return null;
+    }
+    const normalized = command.trim();
+    if (!normalized) {
+        return null;
+    }
+    if (CONTEXT_READ_PATTERNS.some((pattern) => pattern.test(normalized))) {
+        return 'context_read';
+    }
+    return null;
+}
+const IMAGE_LINK_KEYS = ['imagePath', 'path', 'filepath', 'file', 'url', 'image', 'src'];
+function hasImageLink(args) {
+    if (!args || typeof args !== 'object') {
+        return false;
+    }
+    for (const key of IMAGE_LINK_KEYS) {
+        const value = args[key];
+        if (typeof value === 'string' && value.trim()) {
+            return true;
+        }
+    }
+    return false;
 }
 function extractToolName(tool) {
     if (!tool || typeof tool !== 'object') {

package/dist/router/virtual-router/token-counter.d.ts

@@ -0,0 +1,2 @@
+import type { StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare function countRequestTokens(request: StandardizedRequest): number;

package/dist/router/virtual-router/token-counter.js

@@ -0,0 +1,105 @@
+import { encoding_for_model, get_encoding } from 'tiktoken';
+const DEFAULT_ENCODING = 'cl100k_base';
+const encoderCache = new Map();
+let defaultEncoder = null;
+function getEncoder(model) {
+    if (model) {
+        const normalized = model.trim();
+        if (encoderCache.has(normalized)) {
+            return encoderCache.get(normalized);
+        }
+        try {
+            const encoder = encoding_for_model(normalized);
+            encoderCache.set(normalized, encoder);
+            return encoder;
+        }
+        catch {
+            // fall back to default encoder
+        }
+    }
+    if (!defaultEncoder) {
+        defaultEncoder = get_encoding(DEFAULT_ENCODING);
+    }
+    return defaultEncoder;
+}
+export function countRequestTokens(request) {
+    const encoder = getEncoder(request.model);
+    let total = 0;
+    for (const message of request.messages || []) {
+        total += countMessageTokens(message, encoder);
+    }
+    if (Array.isArray(request.tools)) {
+        for (const tool of request.tools) {
+            total += encodeText(JSON.stringify(tool ?? {}), encoder);
+        }
+    }
+    if (request.parameters) {
+        total += encodeText(JSON.stringify(request.parameters), encoder);
+    }
+    if (request.metadata) {
+        total += encodeText(JSON.stringify(request.metadata), encoder);
+    }
+    return total;
+}
+function countMessageTokens(message, encoder) {
+    let total = 0;
+    total += encodeText(message.role, encoder);
+    total += encodeContent(message.content, encoder);
+    if (Array.isArray(message.tool_calls)) {
+        for (const call of message.tool_calls) {
+            total += encodeText(JSON.stringify(call ?? {}), encoder);
+        }
+    }
+    if (Array.isArray(message.metadata?.toolRuns)) {
+        total += encodeText(JSON.stringify(message.metadata?.toolRuns), encoder);
+    }
+    if (message.name) {
+        total += encodeText(message.name, encoder);
+    }
+    if (message.metadata) {
+        total += encodeText(JSON.stringify(message.metadata), encoder);
+    }
+    if (message.tool_call_id) {
+        total += encodeText(message.tool_call_id, encoder);
+    }
+    return total;
+}
+function encodeContent(content, encoder) {
+    if (content === null || content === undefined) {
+        return 0;
+    }
+    if (typeof content === 'string') {
+        return encodeText(content, encoder);
+    }
+    if (Array.isArray(content)) {
+        let total = 0;
+        for (const part of content) {
+            if (typeof part === 'string') {
+                total += encodeText(part, encoder);
+            }
+            else if (part && typeof part === 'object') {
+                if (typeof part.text === 'string') {
+                    total += encodeText(part.text, encoder);
+                }
+                else {
+                    total += encodeText(JSON.stringify(part), encoder);
+                }
+            }
+        }
+        return total;
+    }
+    if (typeof content === 'object') {
+        return encodeText(JSON.stringify(content), encoder);
+    }
+    return encodeText(String(content), encoder);
+}
+function encodeText(value, encoder) {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    const text = typeof value === 'string' ? value : String(value);
+    if (!text.trim()) {
+        return 0;
+    }
+    return encoder.encode(text).length;
+}

package/dist/router/virtual-router/types.d.ts

@@ -5,6 +5,7 @@ import type { StandardizedRequest } from '../../conversion/hub/types/standardize
 export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
 export type RoutingPools = Record<string, string[]>;
+export type PreviousToolCategory = 'context_read' | 'plan' | 'vision' | 'coding';
 export interface ProviderAuthConfig {
     type: 'apiKey' | 'oauth';
     secretRef?: string;
@@ -47,12 +48,14 @@ export interface ProviderRuntimeProfile {
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
 }
+export type RouteKeywordCategory = 'thinking' | 'background' | 'vision' | 'coding';
 export interface VirtualRouterClassifierConfig {
     longContextThresholdTokens?: number;
     thinkingKeywords?: string[];
     codingKeywords?: string[];
     backgroundKeywords?: string[];
     visionKeywords?: string[];
+    keywordInjections?: Partial<Record<RouteKeywordCategory, string[]>>;
 }
 export interface LoadBalancingPolicy {
     strategy: 'round-robin' | 'weighted' | 'sticky';
@@ -111,6 +114,7 @@ export interface RoutingFeatures {
     hasCodingTool: boolean;
     hasThinkingKeyword: boolean;
     estimatedTokens: number;
+    previousToolCategory?: PreviousToolCategory | null;
     metadata: RouterMetadataInput;
 }
 export interface ClassificationResult {

package/dist/router/virtual-router/types.js

@@ -3,12 +3,12 @@
  */
 export const DEFAULT_ROUTE = 'default';
 export const ROUTE_PRIORITY = [
+    'longcontext',
+    'thinking',
     'vision',
     'websearch',
     'coding',
     'tools',
-    'longcontext',
-    'thinking',
     'background',
     DEFAULT_ROUTE
 ];

package/dist/sse/sse-to-json/builders/response-builder.d.ts

@@ -77,6 +77,8 @@ export declare class ResponsesResponseBuilder {
      * 处理function_call.start事件
      */
     private handleFunctionCallStart;
+    private coerceArgumentsChunk;
+    private shouldOverrideArguments;
     /**
      * 处理function_call.delta事件
      */

package/dist/sse/sse-to-json/builders/response-builder.js

@@ -395,6 +395,36 @@ export class ResponsesResponseBuilder {
         outputItemState.arguments = '';
         outputItemState.lastEventTime = event.timestamp;
     }
+    coerceArgumentsChunk(raw) {
+        if (typeof raw === 'string') {
+            return raw;
+        }
+        if (raw && typeof raw === 'object') {
+            try {
+                return JSON.stringify(raw);
+            }
+            catch {
+                return String(raw);
+            }
+        }
+        return undefined;
+    }
+    shouldOverrideArguments(current, incoming) {
+        if (!incoming) {
+            return false;
+        }
+        const trimmed = incoming.trim();
+        if (!current || !current.length) {
+            return trimmed.length > 0;
+        }
+        if (!trimmed.length) {
+            return false;
+        }
+        if (trimmed === '{}' || trimmed.toLowerCase() === 'null') {
+            return false;
+        }
+        return true;
+    }
     /**
      * 处理function_call.delta事件
      */
@@ -404,10 +434,10 @@ export class ResponsesResponseBuilder {
         if (!outputItemState) {
             throw new Error(`Output item not found: ${data.item_id}`);
         }
-        const chunk = (data && data.delta && typeof data.delta === 'object' && typeof data.delta.arguments === 'string')
-            ? String(data.delta.arguments)
-            : (typeof (data?.delta) === 'string' ? String(data.delta) : (typeof data?.arguments === 'string' ? String(data.arguments) : undefined));
-        if (typeof chunk === 'string') {
+        const chunk = this.coerceArgumentsChunk(data?.delta?.arguments) ??
+            this.coerceArgumentsChunk(data?.delta) ??
+            this.coerceArgumentsChunk(data?.arguments);
+        if (chunk) {
             outputItemState.arguments = (outputItemState.arguments || '') + chunk;
         }
         outputItemState.lastEventTime = event.timestamp;
@@ -445,8 +475,16 @@ export class ResponsesResponseBuilder {
                 outputItemState.name = data.name;
             if (typeof data.call_id === 'string' && data.call_id)
                 outputItemState.callId = data.call_id;
-            if (typeof data.arguments === 'string' && data.arguments)
-                outputItemState.arguments = data.arguments;
+            const finalChunk = this.coerceArgumentsChunk(data?.arguments) ??
+                this.coerceArgumentsChunk(data?.delta?.arguments) ??
+                this.coerceArgumentsChunk(data?.delta);
+            if (this.shouldOverrideArguments(outputItemState.arguments, finalChunk)) {
+                outputItemState.arguments = finalChunk;
+            }
+            else if (!outputItemState.arguments && finalChunk) {
+                // 没有任何累计增量时，保底写入 done 事件里的值
+                outputItemState.arguments = finalChunk;
+            }
         }
         catch { /* ignore */ }
         outputItemState.status = 'completed';
@@ -630,14 +668,17 @@ export class ResponsesResponseBuilder {
         this.state = 'error';
     }
     handleResponseCompleted(event) {
-        const data = event.data;
-        if (data?.usage) {
-            this.response.usage = data.usage;
+        const payload = event.data?.response ?? event.data;
+        const usage = (payload && payload.usage)
+            ? payload.usage
+            : event.data?.usage;
+        if (usage) {
+            this.response.usage = usage;
         }
         // 标准化完成态：部分上游的 response.completed 不包含 status 字段
         // 若未提供明确的完成状态，统一标记为 'completed'，而不是沿用之前的 in_progress。
-        this.response.status = (data && data.status != null)
-            ? data.status
+        this.response.status = (payload && payload.status != null)
+            ? payload.status
             : 'completed';
         // 将已聚合的输出写回并标记完成（若为空数组也重建）
         try {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.002",
+  "version": "0.6.034",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "build:dev": "tsc -p tsconfig.json",
+    "build": "node scripts/bump-version.mjs && tsc -p tsconfig.json",
+    "build:dev": "node scripts/bump-version.mjs && tsc -p tsconfig.json",
     "lint": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache",
     "lint:fix": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache --fix",
     "postbuild": "node scripts/tests/run-matrix-ci.mjs",