@jsonstudio/llms 0.6.802 → 0.6.938

package/dist/servertool/handlers/followup-message-trimmer.js

@@ -0,0 +1,198 @@
+function isMessageRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeRole(role) {
+    return typeof role === 'string' ? role.trim().toLowerCase() : '';
+}
+function isSystemRole(role) {
+    const normalized = role.trim().toLowerCase();
+    return normalized === 'system' || normalized === 'developer';
+}
+function isUserMessage(msg) {
+    return normalizeRole(msg.role) === 'user';
+}
+function isToolResponseMessage(msg) {
+    const role = normalizeRole(msg.role);
+    return role === 'tool' || role === 'function';
+}
+function isAssistantToolCallMessage(msg) {
+    const role = normalizeRole(msg.role);
+    if (role !== 'assistant' && role !== 'model') {
+        return false;
+    }
+    const toolCalls = Array.isArray(msg.tool_calls)
+        ? (msg.tool_calls)
+        : [];
+    if (toolCalls.length > 0) {
+        return true;
+    }
+    const fnCall = msg.function_call;
+    if (fnCall && typeof fnCall === 'object' && !Array.isArray(fnCall)) {
+        return true;
+    }
+    return false;
+}
+function findPrevIndex(messages, startIndexExclusive, predicate) {
+    for (let i = startIndexExclusive - 1; i >= 0; i -= 1) {
+        const msg = messages[i];
+        if (!msg)
+            continue;
+        if (predicate(msg))
+            return i;
+    }
+    return null;
+}
+/**
+ * Trim OpenAI-style messages for internal servertool followups.
+ *
+ * Goal: avoid sending a massive chat history on auto-followup requests (e.g. stop_message_flow),
+ * which can push Gemini/Antigravity into empty/malformed responses under long-context loads.
+ *
+ * Strategy:
+ * - Always keep system/developer messages (regardless of position).
+ * - Keep only the tail of non-system messages (maxNonSystemMessages), preserving original order.
+ */
+export function trimOpenAiMessagesForFollowup(rawMessages, options) {
+    const maxNonSystemMessages = typeof options?.maxNonSystemMessages === 'number' && Number.isFinite(options.maxNonSystemMessages)
+        ? Math.max(1, Math.floor(options.maxNonSystemMessages))
+        : 16;
+    const messages = Array.isArray(rawMessages) ? rawMessages : [];
+    if (!messages.length) {
+        return [];
+    }
+    const messageRecords = messages.filter(isMessageRecord);
+    if (!messageRecords.length) {
+        return [];
+    }
+    const nonSystemIndices = [];
+    for (let i = 0; i < messageRecords.length; i += 1) {
+        const entry = messageRecords[i];
+        const role = typeof entry.role === 'string' ? entry.role : '';
+        if (!role || isSystemRole(role)) {
+            continue;
+        }
+        nonSystemIndices.push(i);
+    }
+    if (nonSystemIndices.length <= maxNonSystemMessages) {
+        return messageRecords;
+    }
+    const keepSet = new Set(nonSystemIndices.slice(nonSystemIndices.length - maxNonSystemMessages));
+    // Expand keepSet to preserve tool-call adjacency:
+    // - If we keep tool responses, keep their preceding tool call + its anchor.
+    // - If we keep tool calls, keep their anchor + following tool responses.
+    //
+    // Gemini tool-calling constraint: functionCall turn must come immediately after a user turn
+    // or after a functionResponse turn. When trimming, we must not cut away the user anchor.
+    let changed = true;
+    let guard = 0;
+    while (changed && guard < 8) {
+        changed = false;
+        guard += 1;
+        const sorted = Array.from(keepSet).sort((a, b) => a - b);
+        for (const idx of sorted) {
+            const msg = messageRecords[idx];
+            if (!msg)
+                continue;
+            if (isToolResponseMessage(msg)) {
+                const toolCallIndex = findPrevIndex(messageRecords, idx, isAssistantToolCallMessage);
+                if (toolCallIndex !== null && !keepSet.has(toolCallIndex)) {
+                    keepSet.add(toolCallIndex);
+                    changed = true;
+                }
+                if (toolCallIndex !== null) {
+                    const anchorIndex = findPrevIndex(messageRecords, toolCallIndex, (m) => isUserMessage(m) || isToolResponseMessage(m));
+                    if (anchorIndex !== null && !keepSet.has(anchorIndex)) {
+                        keepSet.add(anchorIndex);
+                        changed = true;
+                    }
+                }
+                continue;
+            }
+            if (isAssistantToolCallMessage(msg)) {
+                const anchorIndex = findPrevIndex(messageRecords, idx, (m) => isUserMessage(m) || isToolResponseMessage(m));
+                if (anchorIndex !== null && !keepSet.has(anchorIndex)) {
+                    keepSet.add(anchorIndex);
+                    changed = true;
+                }
+                for (let i = idx + 1; i < messageRecords.length; i += 1) {
+                    const next = messageRecords[i];
+                    if (!next)
+                        continue;
+                    if (!isToolResponseMessage(next)) {
+                        break;
+                    }
+                    if (!keepSet.has(i)) {
+                        keepSet.add(i);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    // Ensure the first kept non-system message is a user turn (do not drop history; add an anchor).
+    const firstKeptNonSystem = (() => {
+        for (let i = 0; i < messageRecords.length; i += 1) {
+            const role = normalizeRole(messageRecords[i]?.role);
+            if (!role || isSystemRole(role))
+                continue;
+            if (keepSet.has(i))
+                return i;
+        }
+        return null;
+    })();
+    if (firstKeptNonSystem !== null && !isUserMessage(messageRecords[firstKeptNonSystem])) {
+        const userAnchor = findPrevIndex(messageRecords, firstKeptNonSystem, isUserMessage);
+        if (userAnchor !== null) {
+            keepSet.add(userAnchor);
+            // One more pass to ensure tool adjacency around the newly added anchor.
+            for (const idx of Array.from(keepSet).sort((a, b) => a - b)) {
+                const msg = messageRecords[idx];
+                if (!msg)
+                    continue;
+                if (isToolResponseMessage(msg)) {
+                    const toolCallIndex = findPrevIndex(messageRecords, idx, isAssistantToolCallMessage);
+                    if (toolCallIndex !== null)
+                        keepSet.add(toolCallIndex);
+                }
+                else if (isAssistantToolCallMessage(msg)) {
+                    const anchorIndex = findPrevIndex(messageRecords, idx, (m) => isUserMessage(m) || isToolResponseMessage(m));
+                    if (anchorIndex !== null)
+                        keepSet.add(anchorIndex);
+                }
+            }
+        }
+        else {
+            // If there is no user message before the kept window, the history prefix is already invalid
+            // for Gemini tool-calling (tool_calls/functionCall must be preceded by user or tool response).
+            // In this case, preserve system/developer messages and start the followup from the first user
+            // message that exists inside the kept window.
+            let firstUserAfter = null;
+            for (let i = firstKeptNonSystem; i < messageRecords.length; i += 1) {
+                if (keepSet.has(i) && isUserMessage(messageRecords[i])) {
+                    firstUserAfter = i;
+                    break;
+                }
+            }
+            if (firstUserAfter !== null) {
+                for (const idx of Array.from(keepSet)) {
+                    if (idx < firstUserAfter) {
+                        keepSet.delete(idx);
+                    }
+                }
+            }
+        }
+    }
+    const trimmed = [];
+    for (let i = 0; i < messageRecords.length; i += 1) {
+        const entry = messageRecords[i];
+        const role = typeof entry.role === 'string' ? entry.role : '';
+        if (role && isSystemRole(role)) {
+            trimmed.push(entry);
+            continue;
+        }
+        if (keepSet.has(i)) {
+            trimmed.push(entry);
+        }
+    }
+    return trimmed;
+}

package/dist/servertool/handlers/followup-request-builder.d.ts

@@ -0,0 +1,17 @@
+import type { JsonObject } from '../../conversion/hub/types/json.js';
+export type CapturedChatSeed = {
+    model?: string;
+    messages: JsonObject[];
+    tools?: JsonObject[];
+    parameters?: Record<string, unknown>;
+};
+export declare function extractCapturedChatSeed(source: unknown): CapturedChatSeed | null;
+export declare function normalizeFollowupParameters(value: unknown): Record<string, unknown> | undefined;
+export declare function buildEntryAwareFollowupPayload(args: {
+    entryEndpoint: string;
+    model?: string;
+    messages: JsonObject[];
+    tools?: JsonObject[];
+    parameters?: Record<string, unknown>;
+}): JsonObject;
+export declare function dropToolByFunctionName(tools: JsonObject[] | undefined, dropName: string): JsonObject[] | undefined;

package/dist/servertool/handlers/followup-request-builder.js

@@ -0,0 +1,122 @@
+import { buildAnthropicRequestFromOpenAIChat } from '../../conversion/codecs/anthropic-openai-codec.js';
+import { buildChatRequestFromResponses, buildResponsesRequestFromChat, captureResponsesContext } from '../../conversion/responses/responses-openai-bridge.js';
+import { cloneJson } from '../server-side-tools.js';
+function extractResponsesTopLevelParameters(record) {
+    const allowed = new Set([
+        'temperature',
+        'top_p',
+        'max_output_tokens',
+        'seed',
+        'logit_bias',
+        'user',
+        'parallel_tool_calls',
+        'tool_choice',
+        'response_format',
+        'stream'
+    ]);
+    const out = {};
+    // Back-compat: StandardizedRequest uses max_tokens; map to Responses max_output_tokens.
+    if (record.max_output_tokens === undefined && record.max_tokens !== undefined) {
+        out.max_output_tokens = record.max_tokens;
+    }
+    for (const key of Object.keys(record)) {
+        if (!allowed.has(key))
+            continue;
+        out[key] = record[key];
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+export function extractCapturedChatSeed(source) {
+    if (!source || typeof source !== 'object' || Array.isArray(source)) {
+        return null;
+    }
+    const record = source;
+    const model = typeof record.model === 'string' && record.model.trim().length ? record.model.trim() : undefined;
+    const rawMessages = Array.isArray(record.messages) ? record.messages : null;
+    if (rawMessages) {
+        const tools = Array.isArray(record.tools) ? cloneJson(record.tools) : undefined;
+        const parameters = normalizeFollowupParameters(record.parameters ?? extractResponsesTopLevelParameters(record));
+        return {
+            ...(model ? { model } : {}),
+            messages: cloneJson(rawMessages),
+            ...(tools ? { tools } : {}),
+            ...(parameters ? { parameters } : {})
+        };
+    }
+    // Backward/compat: some hosts may have captured the raw /v1/responses payload.
+    const rawInput = Array.isArray(record.input) ? record.input : null;
+    if (rawInput) {
+        try {
+            const ctx = captureResponsesContext(record);
+            if (!ctx.isResponsesPayload) {
+                return null;
+            }
+            const rebuilt = buildChatRequestFromResponses(record, ctx).request;
+            const rebuiltModel = typeof rebuilt.model === 'string' && rebuilt.model.trim().length ? String(rebuilt.model).trim() : model;
+            const rebuiltMessages = Array.isArray(rebuilt.messages) ? rebuilt.messages : [];
+            const rebuiltTools = Array.isArray(rebuilt.tools) ? rebuilt.tools : undefined;
+            const parameters = normalizeFollowupParameters(record.parameters ?? rebuilt.parameters ?? extractResponsesTopLevelParameters(record));
+            return {
+                ...(rebuiltModel ? { model: rebuiltModel } : {}),
+                messages: cloneJson(rebuiltMessages),
+                ...(rebuiltTools ? { tools: cloneJson(rebuiltTools) } : {}),
+                ...(parameters ? { parameters } : {})
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export function normalizeFollowupParameters(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const cloned = cloneJson(value);
+    // Followup requests are always non-streaming (servertool orchestration enforces this),
+    // so remove any inherited stream hints to avoid conflicting flags.
+    delete cloned.stream;
+    return Object.keys(cloned).length ? cloned : undefined;
+}
+export function buildEntryAwareFollowupPayload(args) {
+    const chatPayload = {
+        ...(args.model ? { model: args.model } : {}),
+        messages: args.messages,
+        ...(args.tools ? { tools: args.tools } : {})
+    };
+    const normalizedEntry = typeof args.entryEndpoint === 'string' ? args.entryEndpoint.trim().toLowerCase() : '';
+    if (normalizedEntry.includes('/v1/responses')) {
+        return buildResponsesRequestFromChat(chatPayload, {
+            stream: false,
+            ...(args.parameters ? { parameters: args.parameters } : {})
+        }).request;
+    }
+    if (normalizedEntry.includes('/v1/messages')) {
+        const anthropicChatPayload = {
+            ...chatPayload,
+            ...(args.parameters ? args.parameters : {})
+        };
+        return buildAnthropicRequestFromOpenAIChat(anthropicChatPayload);
+    }
+    const openaiChatPayload = {
+        ...chatPayload,
+        ...(args.parameters ? args.parameters : {})
+    };
+    return openaiChatPayload;
+}
+export function dropToolByFunctionName(tools, dropName) {
+    const name = typeof dropName === 'string' ? dropName.trim() : '';
+    if (!tools || !tools.length || !name) {
+        return tools;
+    }
+    return tools.filter((tool) => {
+        if (!tool || typeof tool !== 'object')
+            return false;
+        const fn = tool.function;
+        const toolName = fn && typeof fn.name === 'string' ? fn.name : '';
+        if (!toolName)
+            return true;
+        return toolName !== name;
+    });
+}