qlogicagent 0.2.1 → 0.4.0

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);
-}

package/dist/orchestration/transcript-repair.d.ts

@@ -1,42 +0,0 @@
-export type TranscriptMessageLike = {
-    role?: unknown;
-    content?: unknown;
-    stopReason?: unknown;
-    toolCallId?: unknown;
-    toolUseId?: unknown;
-    toolName?: unknown;
-    details?: unknown;
-    isError?: unknown;
-    timestamp?: unknown;
-};
-export type TranscriptToolCallLike = {
-    id: string;
-    name?: string;
-};
-export type ToolCallInputRepairReport<TMessage extends TranscriptMessageLike> = {
-    messages: TMessage[];
-    droppedToolCalls: number;
-    droppedAssistantMessages: number;
-};
-export type ToolUseRepairReport<TMessage extends TranscriptMessageLike> = {
-    messages: TMessage[];
-    added: TMessage[];
-    droppedDuplicateCount: number;
-    droppedOrphanCount: number;
-    moved: boolean;
-};
-export type ToolCallInputRepairOptions = {
-    allowedToolNames?: Iterable<string>;
-};
-export type ToolUseRepairOptions<TMessage extends TranscriptMessageLike> = {
-    createMissingToolResult?: (params: {
-        toolCallId: string;
-        toolName?: string;
-    }) => TMessage;
-};
-export declare function stripToolResultDetails<TMessage extends TranscriptMessageLike>(messages: readonly TMessage[]): TMessage[];
-export declare function repairToolCallInputs<TMessage extends TranscriptMessageLike>(messages: readonly TMessage[], options?: ToolCallInputRepairOptions): ToolCallInputRepairReport<TMessage>;
-export declare function sanitizeToolCallInputs<TMessage extends TranscriptMessageLike>(messages: readonly TMessage[], options?: ToolCallInputRepairOptions): TMessage[];
-export declare function repairToolUseResultPairing<TMessage extends TranscriptMessageLike>(messages: readonly TMessage[], options?: ToolUseRepairOptions<TMessage>): ToolUseRepairReport<TMessage>;
-export declare function sanitizeToolUseResultPairing<TMessage extends TranscriptMessageLike>(messages: readonly TMessage[], options?: ToolUseRepairOptions<TMessage>): TMessage[];
-export declare function stripTransientErrorMessages<TMessage extends TranscriptMessageLike>(messages: readonly TMessage[]): TMessage[];