qlogicagent 0.2.1 → 0.3.0

package/dist/orchestration/tool-loop-state.js

@@ -1,133 +0,0 @@
-import { injectDanglingToolCallPlaceholders, repairOpenAiResponsesItems, stripForcedStopAssistantToolMetadata, sanitizeOpenAiChatMessages, } from "./conversation-repair.js";
-function collectChatPendingToolCallIds(messages) {
-    const called = new Set();
-    const completed = new Set();
-    for (const message of messages) {
-        if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
-            for (const toolCall of message.tool_calls) {
-                if (typeof toolCall.id === "string" && toolCall.id) {
-                    called.add(toolCall.id);
-                }
-            }
-        }
-        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
-            completed.add(message.tool_call_id);
-        }
-    }
-    return [...called].filter((callId) => !completed.has(callId));
-}
-function collectChatCompletedToolCallIds(messages) {
-    const completed = new Set();
-    for (const message of messages) {
-        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
-            completed.add(message.tool_call_id);
-        }
-    }
-    return [...completed];
-}
-function collectResponsesPendingToolCallIds(items) {
-    const called = new Set();
-    const completed = new Set();
-    for (const item of items) {
-        if (item.type === "function_call") {
-            const callId = typeof item.call_id === "string" && item.call_id
-                ? item.call_id
-                : typeof item.id === "string"
-                    ? item.id
-                    : "";
-            if (callId) {
-                called.add(callId);
-            }
-        }
-        if (item.type === "function_call_output" && typeof item.call_id === "string" && item.call_id) {
-            completed.add(item.call_id);
-        }
-    }
-    return [...called].filter((callId) => !completed.has(callId));
-}
-function collectResponsesCompletedToolCallIds(items) {
-    const completed = new Set();
-    for (const item of items) {
-        if (item.type === "function_call_output" && typeof item.call_id === "string" && item.call_id) {
-            completed.add(item.call_id);
-        }
-    }
-    return [...completed];
-}
-export function createToolLoopState(params) {
-    return {
-        round: params.round ?? 0,
-        maxRounds: params.maxRounds,
-        pendingToolCallIds: [...(params.pendingToolCallIds ?? [])],
-        completedToolCallIds: [...(params.completedToolCallIds ?? [])],
-        lastStopReason: params.lastStopReason,
-        replayMessages: [...(params.replayMessages ?? [])],
-    };
-}
-export function advanceToolLoopState(state, params) {
-    return {
-        round: state.round + 1,
-        maxRounds: state.maxRounds,
-        pendingToolCallIds: [...(params.pendingToolCallIds ?? state.pendingToolCallIds)],
-        completedToolCallIds: [...(params.completedToolCallIds ?? state.completedToolCallIds)],
-        lastStopReason: params.lastStopReason ?? state.lastStopReason,
-        replayMessages: [...(params.replayMessages ?? state.replayMessages)],
-    };
-}
-export function settleToolLoopState(state, params) {
-    return {
-        round: state.round,
-        maxRounds: state.maxRounds,
-        pendingToolCallIds: [],
-        completedToolCallIds: [...(params.completedToolCallIds ?? state.completedToolCallIds)],
-        lastStopReason: params.lastStopReason ?? state.lastStopReason,
-        replayMessages: [...(params.replayMessages ?? state.replayMessages)],
-    };
-}
-export function recoverToolLoopStateFromChatConversation(params) {
-    const recoveryActions = [];
-    const sanitizedMessages = sanitizeOpenAiChatMessages(params.replayMessages);
-    if (sanitizedMessages.length !== params.replayMessages.length) {
-        recoveryActions.push({ kind: "drop-orphan-tool-result", detail: "Removed orphan tool results or invalid assistant tool calls." });
-    }
-    const strippedMessages = stripForcedStopAssistantToolMetadata(sanitizedMessages, params.options);
-    if (strippedMessages.some((message, index) => message !== sanitizedMessages[index])) {
-        recoveryActions.push({ kind: "strip-forced-stop-tool-metadata", detail: "Removed assistant tool-call metadata after forced stop." });
-    }
-    const repairedMessages = injectDanglingToolCallPlaceholders(strippedMessages, params.options);
-    if (repairedMessages.length > strippedMessages.length) {
-        recoveryActions.push({ kind: "inject-placeholder-tool-result", detail: "Injected placeholder tool result for pending tool calls." });
-    }
-    return {
-        state: createToolLoopState({
-            maxRounds: params.maxRounds,
-            round: params.round,
-            lastStopReason: params.lastStopReason,
-            replayMessages: repairedMessages,
-            pendingToolCallIds: collectChatPendingToolCallIds(repairedMessages),
-            completedToolCallIds: collectChatCompletedToolCallIds(repairedMessages),
-        }),
-        recoveryActions,
-    };
-}
-export function recoverToolLoopStateFromResponsesItems(params) {
-    const repairedItems = repairOpenAiResponsesItems(params.replayItems, params.options);
-    const recoveryActions = [];
-    if (repairedItems.length !== params.replayItems.length) {
-        recoveryActions.push({ kind: "drop-trailing-reasoning", detail: "Dropped dangling reasoning blocks or injected missing function_call_output items." });
-    }
-    if (repairedItems.some((item, index) => item !== params.replayItems[index] && item.type === "function_call")) {
-        recoveryActions.push({ kind: "rewrite-openai-function-call-pair", detail: "Rewrote OpenAI function_call pairing ids for replay compatibility." });
-    }
-    return {
-        state: createToolLoopState({
-            maxRounds: params.maxRounds,
-            round: params.round,
-            lastStopReason: params.lastStopReason,
-            replayMessages: repairedItems,
-            pendingToolCallIds: collectResponsesPendingToolCallIds(repairedItems),
-            completedToolCallIds: collectResponsesCompletedToolCallIds(repairedItems),
-        }),
-        recoveryActions,
-    };
-}

package/dist/orchestration/tool-schema.js

@@ -1,297 +0,0 @@
-function extractEnumValues(schema) {
-    if (!schema || typeof schema !== "object") {
-        return undefined;
-    }
-    const record = schema;
-    if (Array.isArray(record.enum)) {
-        return record.enum;
-    }
-    if ("const" in record) {
-        return [record.const];
-    }
-    const variants = Array.isArray(record.anyOf)
-        ? record.anyOf
-        : Array.isArray(record.oneOf)
-            ? record.oneOf
-            : null;
-    if (!variants) {
-        return undefined;
-    }
-    const values = variants.flatMap((variant) => extractEnumValues(variant) ?? []);
-    return values.length > 0 ? values : undefined;
-}
-function mergePropertySchemas(existing, incoming) {
-    if (!existing)
-        return incoming;
-    if (!incoming)
-        return existing;
-    const existingEnum = extractEnumValues(existing);
-    const incomingEnum = extractEnumValues(incoming);
-    if (!existingEnum && !incomingEnum) {
-        return existing;
-    }
-    const values = Array.from(new Set([...(existingEnum ?? []), ...(incomingEnum ?? [])]));
-    const merged = {};
-    for (const source of [existing, incoming]) {
-        if (!source || typeof source !== "object") {
-            continue;
-        }
-        const record = source;
-        for (const key of ["title", "description", "default"]) {
-            if (!(key in merged) && key in record) {
-                merged[key] = record[key];
-            }
-        }
-    }
-    const types = new Set(values.map((value) => typeof value));
-    if (types.size === 1) {
-        merged.type = Array.from(types)[0];
-    }
-    merged.enum = values;
-    return merged;
-}
-const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = new Set([
-    "patternProperties",
-    "additionalProperties",
-    "$schema",
-    "$id",
-    "$ref",
-    "$defs",
-    "definitions",
-    "examples",
-    "minLength",
-    "maxLength",
-    "minimum",
-    "maximum",
-    "multipleOf",
-    "pattern",
-    "format",
-    "minItems",
-    "maxItems",
-    "uniqueItems",
-    "minProperties",
-    "maxProperties",
-]);
-const XAI_UNSUPPORTED_SCHEMA_KEYWORDS = new Set([
-    "minLength",
-    "maxLength",
-    "minItems",
-    "maxItems",
-    "minContains",
-    "maxContains",
-]);
-function cleanSchemaForGemini(schema) {
-    if (!schema || typeof schema !== "object") {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((item) => cleanSchemaForGemini(item));
-    }
-    const record = schema;
-    const cleaned = {};
-    for (const [key, value] of Object.entries(record)) {
-        if (GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS.has(key)) {
-            continue;
-        }
-        if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
-            cleaned[key] = Object.fromEntries(Object.entries(value).map(([nestedKey, nestedValue]) => [nestedKey, cleanSchemaForGemini(nestedValue)]));
-            continue;
-        }
-        if ((key === "items" || key === "additionalProperties") && value && typeof value === "object") {
-            cleaned[key] = Array.isArray(value) ? value.map((item) => cleanSchemaForGemini(item)) : cleanSchemaForGemini(value);
-            continue;
-        }
-        if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
-            cleaned[key] = value.map((item) => cleanSchemaForGemini(item));
-            continue;
-        }
-        cleaned[key] = value;
-    }
-    return cleaned;
-}
-function stripXaiUnsupportedKeywords(schema) {
-    if (!schema || typeof schema !== "object") {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((item) => stripXaiUnsupportedKeywords(item));
-    }
-    const record = schema;
-    const cleaned = {};
-    for (const [key, value] of Object.entries(record)) {
-        if (XAI_UNSUPPORTED_SCHEMA_KEYWORDS.has(key)) {
-            continue;
-        }
-        if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
-            cleaned[key] = Object.fromEntries(Object.entries(value).map(([nestedKey, nestedValue]) => [nestedKey, stripXaiUnsupportedKeywords(nestedValue)]));
-            continue;
-        }
-        if ((key === "items") && value && typeof value === "object") {
-            cleaned[key] = Array.isArray(value) ? value.map((item) => stripXaiUnsupportedKeywords(item)) : stripXaiUnsupportedKeywords(value);
-            continue;
-        }
-        if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
-            cleaned[key] = value.map((item) => stripXaiUnsupportedKeywords(item));
-            continue;
-        }
-        cleaned[key] = value;
-    }
-    return cleaned;
-}
-export function isXaiProvider(modelProvider, modelId) {
-    const provider = modelProvider?.toLowerCase() ?? "";
-    if (provider.includes("xai") || provider.includes("x-ai")) {
-        return true;
-    }
-    const lowerModelId = modelId?.toLowerCase() ?? "";
-    if (provider === "openrouter" && lowerModelId.startsWith("x-ai/")) {
-        return true;
-    }
-    if (provider === "venice" && lowerModelId.includes("grok")) {
-        return true;
-    }
-    return false;
-}
-export function normalizeFunctionToolParameters(parameters, options) {
-    const schema = parameters && typeof parameters === "object" ? parameters : { type: "object", properties: {}, additionalProperties: true };
-    const isGeminiProvider = options?.modelProvider?.toLowerCase().includes("google") || options?.modelProvider?.toLowerCase().includes("gemini");
-    const isAnthropicProvider = options?.modelProvider?.toLowerCase().includes("anthropic");
-    const isXai = isXaiProvider(options?.modelProvider, options?.modelId);
-    const applyProviderCleaning = (nextSchema) => {
-        if (isGeminiProvider && !isAnthropicProvider) {
-            return cleanSchemaForGemini(nextSchema);
-        }
-        if (isXai) {
-            return stripXaiUnsupportedKeywords(nextSchema);
-        }
-        return nextSchema;
-    };
-    if ("type" in schema && "properties" in schema && !Array.isArray(schema.anyOf)) {
-        return applyProviderCleaning(schema);
-    }
-    if (!("type" in schema)
-        && (typeof schema.properties === "object" || Array.isArray(schema.required))
-        && !Array.isArray(schema.anyOf)
-        && !Array.isArray(schema.oneOf)) {
-        return applyProviderCleaning({ ...schema, type: "object" });
-    }
-    const variantKey = Array.isArray(schema.anyOf)
-        ? "anyOf"
-        : Array.isArray(schema.oneOf)
-            ? "oneOf"
-            : null;
-    if (!variantKey) {
-        return applyProviderCleaning(schema);
-    }
-    const variants = schema[variantKey];
-    const mergedProperties = {};
-    const requiredCounts = new Map();
-    let objectVariants = 0;
-    for (const entry of variants) {
-        if (!entry || typeof entry !== "object") {
-            continue;
-        }
-        const props = entry.properties;
-        if (!props || typeof props !== "object") {
-            continue;
-        }
-        objectVariants += 1;
-        for (const [key, value] of Object.entries(props)) {
-            mergedProperties[key] = key in mergedProperties ? mergePropertySchemas(mergedProperties[key], value) : value;
-        }
-        const required = Array.isArray(entry.required)
-            ? entry.required
-            : [];
-        for (const key of required) {
-            if (typeof key === "string") {
-                requiredCounts.set(key, (requiredCounts.get(key) ?? 0) + 1);
-            }
-        }
-    }
-    const baseRequired = Array.isArray(schema.required) ? schema.required.filter((key) => typeof key === "string") : undefined;
-    const mergedRequired = baseRequired && baseRequired.length > 0
-        ? baseRequired
-        : objectVariants > 0
-            ? Array.from(requiredCounts.entries()).filter(([, count]) => count === objectVariants).map(([key]) => key)
-            : undefined;
-    return applyProviderCleaning({
-        type: "object",
-        ...(typeof schema.title === "string" ? { title: schema.title } : {}),
-        ...(typeof schema.description === "string" ? { description: schema.description } : {}),
-        properties: Object.keys(mergedProperties).length > 0 ? mergedProperties : (schema.properties ?? {}),
-        ...(mergedRequired && mergedRequired.length > 0 ? { required: mergedRequired } : {}),
-        additionalProperties: "additionalProperties" in schema ? schema.additionalProperties : true,
-    });
-}
-export function convertFunctionTools(tools, options) {
-    return tools.map((tool) => ({
-        type: "function",
-        function: {
-            name: tool.name,
-            ...(typeof tool.description === "string" ? { description: tool.description } : {}),
-            parameters: normalizeFunctionToolParameters(tool.parameters, options),
-        },
-    }));
-}
-export function convertCapabilityToolManifestsToFunctionTools(tools) {
-    return convertFunctionTools(tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: {
-            type: "object",
-            properties: Object.fromEntries((tool.requiredParameters ?? []).map((name) => [name, { type: "string" }])),
-            additionalProperties: true,
-            ...((tool.requiredParameters?.length ?? 0) > 0 ? { required: tool.requiredParameters } : {}),
-        },
-    })));
-}
-export function normalizeMessageTextContent(content) {
-    if (typeof content === "string") {
-        return content;
-    }
-    if (!Array.isArray(content)) {
-        return "";
-    }
-    return content.map((entry) => {
-        if (typeof entry === "string") {
-            return entry;
-        }
-        if (entry && typeof entry === "object" && "text" in entry && typeof entry.text === "string") {
-            return entry.text;
-        }
-        return "";
-    }).filter(Boolean).join("\n");
-}
-export function parseOpenAiToolCallsFromChatResponse(responseBody) {
-    try {
-        const parsed = JSON.parse(responseBody);
-        const firstChoice = parsed.choices?.[0]?.message;
-        const toolCalls = Array.isArray(firstChoice?.tool_calls)
-            ? firstChoice.tool_calls.filter((entry) => entry?.type === "function" && typeof entry.function?.name === "string")
-            : [];
-        return {
-            toolCalls,
-            responseText: normalizeMessageTextContent(firstChoice?.content),
-        };
-    }
-    catch {
-        return { toolCalls: [], responseText: "" };
-    }
-}
-export function buildAssistantToolCallMessage(toolCalls) {
-    return {
-        role: "assistant",
-        content: "",
-        tool_calls: toolCalls,
-    };
-}
-export function buildToolResultMessage(callId, result) {
-    return {
-        role: "tool",
-        tool_call_id: callId,
-        content: JSON.stringify(result.ok ? { ok: true, payload: result.payload } : { ok: false, error: result.error ?? "Tool invoke failed" }),
-    };
-}
-export function cleanToolSchemaForGemini(schema) {
-    return cleanSchemaForGemini(schema);
-}