@mcoda/codali 0.1.66

package/dist/providers/OllamaRemoteProvider.js

@@ -0,0 +1,300 @@
+const parseToolArgs = (raw) => {
+    if (typeof raw !== "string")
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+};
+const isObject = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const toToolCalls = (value) => {
+    if (!value)
+        return [];
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => toToolCalls(entry));
+    }
+    if (!isObject(value))
+        return [];
+    if (Array.isArray(value.tool_calls)) {
+        return toToolCalls(value.tool_calls);
+    }
+    const functionPayload = isObject(value.function) ? value.function : undefined;
+    if (functionPayload && typeof functionPayload.name === "string") {
+        const rawArgs = functionPayload.arguments ?? functionPayload.args ?? {};
+        return [
+            {
+                id: `call_1`,
+                name: functionPayload.name,
+                args: parseToolArgs(rawArgs),
+            },
+        ];
+    }
+    const name = (typeof value.tool === "string" && value.tool) ||
+        (typeof value.name === "string" && value.name) ||
+        (typeof value.tool_name === "string" && value.tool_name);
+    if (!name)
+        return [];
+    const rawArgs = (value.args ?? value.arguments ?? value.params ?? value.parameters ?? {});
+    return [
+        {
+            id: `call_1`,
+            name,
+            args: parseToolArgs(rawArgs),
+        },
+    ];
+};
+const extractToolCallsFromContent = (content) => {
+    if (!content)
+        return [];
+    const trimmed = content.trim();
+    const jsonBlocks = [];
+    const fenceRegex = /```(?:json)?\s*([\s\S]*?)```/gi;
+    let match;
+    while ((match = fenceRegex.exec(content)) !== null) {
+        const block = match[1]?.trim();
+        if (block)
+            jsonBlocks.push(block);
+    }
+    if (jsonBlocks.length === 0 && (trimmed.startsWith("{") || trimmed.startsWith("["))) {
+        jsonBlocks.push(trimmed);
+    }
+    for (const block of jsonBlocks) {
+        try {
+            const parsed = JSON.parse(block);
+            const calls = toToolCalls(parsed);
+            if (calls.length) {
+                return calls.map((call, index) => ({ ...call, id: `call_${index + 1}` }));
+            }
+        }
+        catch {
+            // ignore parsing errors
+        }
+    }
+    return [];
+};
+const normalizeBaseUrl = (baseUrl) => {
+    const root = baseUrl ?? "http://127.0.0.1:11434";
+    return root.endsWith("/") ? root : `${root}/`;
+};
+const parseModelNotFound = (errorBody) => {
+    const match = errorBody.match(/model ['"]?([^'"]+)['"]? not found/i);
+    return match?.[1];
+};
+const fetchModelTags = async (baseUrl) => {
+    const url = new URL("api/tags", baseUrl).toString();
+    const resp = await fetch(url, { method: "GET" });
+    if (!resp.ok) {
+        return [];
+    }
+    try {
+        const data = (await resp.json());
+        return (data.models ?? []).map((entry) => entry.name).filter((name) => Boolean(name));
+    }
+    catch {
+        return [];
+    }
+};
+const pickFallbackModel = (requested, available) => {
+    if (!available.length)
+        return undefined;
+    const normalized = requested.toLowerCase();
+    const exact = available.find((name) => name.toLowerCase() === normalized);
+    if (exact)
+        return undefined;
+    const base = requested.split(":")[0]?.toLowerCase();
+    if (!base)
+        return undefined;
+    const candidates = available.filter((name) => name.toLowerCase() === base || name.toLowerCase().startsWith(`${base}:`));
+    if (!candidates.length)
+        return undefined;
+    const latest = candidates.find((name) => name.toLowerCase() === `${base}:latest`);
+    return latest ?? candidates[0];
+};
+const applyResponseFormat = (body, format) => {
+    if (!format)
+        return;
+    if (format.type === "json") {
+        body.format = "json";
+        return;
+    }
+    if (format.type === "json_schema") {
+        body.format = format.schema ?? "json";
+        return;
+    }
+    if (format.type === "gbnf" && format.grammar) {
+        body.grammar = format.grammar;
+    }
+};
+export class OllamaRemoteProvider {
+    constructor(config) {
+        this.config = config;
+        this.name = "ollama-remote";
+    }
+    async generate(request) {
+        const baseUrl = normalizeBaseUrl(this.config.baseUrl);
+        const url = new URL("api/chat", baseUrl).toString();
+        let resolvedModel = this.config.model;
+        const emitToken = (token) => {
+            if (request.onEvent) {
+                request.onEvent({ type: "token", content: token });
+                return;
+            }
+            request.onToken?.(token);
+        };
+        const buildBody = (model) => {
+            const body = {
+                model,
+                messages: request.messages.map((message) => ({
+                    role: message.role,
+                    content: message.content,
+                    name: message.name,
+                })),
+                tools: request.tools?.map((tool) => ({
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: tool.inputSchema ?? {},
+                    },
+                })),
+                stream: request.stream ?? false,
+            };
+            if (request.temperature !== undefined) {
+                body.options = { temperature: request.temperature };
+            }
+            applyResponseFormat(body, request.responseFormat);
+            return body;
+        };
+        const execute = async (model) => {
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(buildBody(model)),
+            });
+            if (!response.ok) {
+                const errorBody = await response.text();
+                return { response, errorBody };
+            }
+            return { response };
+        };
+        let { response, errorBody } = await execute(resolvedModel);
+        if (!response.ok) {
+            const missingModel = errorBody ? parseModelNotFound(errorBody) : undefined;
+            if (response.status === 404 && missingModel) {
+                const available = await fetchModelTags(baseUrl);
+                const fallback = pickFallbackModel(resolvedModel, available);
+                if (fallback) {
+                    resolvedModel = fallback;
+                    const retry = await execute(resolvedModel);
+                    response = retry.response;
+                    errorBody = retry.errorBody;
+                }
+            }
+            if (!response.ok) {
+                throw new Error(`Ollama error ${response.status}: ${errorBody ?? ""}`.trim());
+            }
+        }
+        if (request.stream) {
+            if (!response.body) {
+                throw new Error("Ollama streaming response missing body");
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            let content = "";
+            let toolCalls;
+            const rawChunks = [];
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    try {
+                        const chunk = JSON.parse(trimmed);
+                        rawChunks.push(chunk);
+                        const message = chunk.message ?? {};
+                        if (message.content) {
+                            content += message.content;
+                            emitToken(message.content);
+                        }
+                        if (message.tool_calls && message.tool_calls.length > 0) {
+                            toolCalls = message.tool_calls.map((call, index) => ({
+                                id: call.id ?? `call_${index + 1}`,
+                                name: call.function.name,
+                                args: parseToolArgs(call.function.arguments),
+                            }));
+                        }
+                    }
+                    catch {
+                        // ignore malformed chunks
+                    }
+                }
+            }
+            if (buffer.trim()) {
+                try {
+                    const chunk = JSON.parse(buffer);
+                    rawChunks.push(chunk);
+                    const message = chunk.message ?? {};
+                    if (message.content) {
+                        content += message.content;
+                        emitToken(message.content);
+                    }
+                    if (message.tool_calls && message.tool_calls.length > 0) {
+                        toolCalls = message.tool_calls.map((call, index) => ({
+                            id: call.id ?? `call_${index + 1}`,
+                            name: call.function.name,
+                            args: parseToolArgs(call.function.arguments),
+                        }));
+                    }
+                }
+                catch {
+                    // ignore trailing parse errors
+                }
+            }
+            if (!toolCalls || toolCalls.length === 0) {
+                const fallback = extractToolCallsFromContent(content);
+                if (fallback.length) {
+                    toolCalls = fallback;
+                }
+            }
+            return {
+                message: { role: "assistant", content },
+                toolCalls,
+                raw: rawChunks,
+            };
+        }
+        const raw = (await response.json());
+        const message = raw.message ?? {};
+        let toolCalls = message.tool_calls?.map((call, index) => ({
+            id: call.id ?? `call_${index + 1}`,
+            name: call.function.name,
+            args: parseToolArgs(call.function.arguments),
+        }));
+        if (!toolCalls || toolCalls.length === 0) {
+            const fallback = extractToolCallsFromContent(message.content);
+            if (fallback.length) {
+                toolCalls = fallback;
+            }
+        }
+        return {
+            message: {
+                role: "assistant",
+                content: message.content ?? "",
+            },
+            toolCalls,
+            raw,
+        };
+    }
+}

package/dist/providers/OpenAiCompatibleProvider.d.ts

@@ -0,0 +1,8 @@
+import type { Provider, ProviderConfig, ProviderRequest, ProviderResponse } from "./ProviderTypes.js";
+export declare class OpenAiCompatibleProvider implements Provider {
+    private config;
+    name: string;
+    constructor(config: ProviderConfig);
+    generate(request: ProviderRequest): Promise<ProviderResponse>;
+}
+//# sourceMappingURL=OpenAiCompatibleProvider.d.ts.map

package/dist/providers/OpenAiCompatibleProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAiCompatibleProvider.d.ts","sourceRoot":"","sources":["../../src/providers/OpenAiCompatibleProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EACd,eAAe,EACf,gBAAgB,EAGjB,MAAM,oBAAoB,CAAC;AAuD5B,qBAAa,wBAAyB,YAAW,QAAQ;IAG3C,OAAO,CAAC,MAAM;IAF1B,IAAI,SAAuB;gBAEP,MAAM,EAAE,cAAc;IAEpC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;CA2KpE"}

package/dist/providers/OpenAiCompatibleProvider.js

@@ -0,0 +1,192 @@
+const parseToolArgs = (raw) => {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+};
+const normalizeBaseUrl = (baseUrl) => {
+    const root = baseUrl ?? "https://api.openai.com/v1";
+    return root.endsWith("/") ? root : `${root}/`;
+};
+const toResponseFormat = (format) => {
+    if (!format)
+        return undefined;
+    if (format.type === "json") {
+        return { type: "json_object" };
+    }
+    if (format.type === "json_schema") {
+        return { type: "json_schema", json_schema: format.schema ?? {} };
+    }
+    if (format.type === "text") {
+        return { type: "text" };
+    }
+    return undefined;
+};
+export class OpenAiCompatibleProvider {
+    constructor(config) {
+        this.config = config;
+        this.name = "openai-compatible";
+    }
+    async generate(request) {
+        const baseUrl = normalizeBaseUrl(this.config.baseUrl);
+        const url = new URL("chat/completions", baseUrl).toString();
+        const emitToken = (token) => {
+            if (request.onEvent) {
+                request.onEvent({ type: "token", content: token });
+                return;
+            }
+            request.onToken?.(token);
+        };
+        const headers = {
+            "content-type": "application/json",
+        };
+        if (this.config.apiKey) {
+            headers.authorization = `Bearer ${this.config.apiKey}`;
+        }
+        const body = {
+            model: this.config.model,
+            messages: request.messages.map((message) => ({
+                role: message.role,
+                content: message.content,
+                name: message.name,
+                tool_call_id: message.toolCallId,
+            })),
+            tools: request.tools?.map((tool) => ({
+                type: "function",
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.inputSchema ?? {},
+                },
+            })),
+            tool_choice: request.toolChoice,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+            response_format: toResponseFormat(request.responseFormat),
+            stream: request.stream ?? false,
+            stream_options: request.stream ? { include_usage: true } : undefined,
+        };
+        const controller = new AbortController();
+        const timeoutMs = this.config.timeoutMs ?? 60000;
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const errorBody = await response.text();
+                throw new Error(`OpenAI-compatible error ${response.status}: ${errorBody}`);
+            }
+            if (request.stream) {
+                if (!response.body) {
+                    throw new Error("OpenAI-compatible streaming response missing body");
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                let content = "";
+                const toolCallMap = new Map();
+                let usage;
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() ?? "";
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed.startsWith("data:"))
+                            continue;
+                        const data = trimmed.slice(5).trim();
+                        if (!data || data === "[DONE]")
+                            continue;
+                        try {
+                            const chunk = JSON.parse(data);
+                            const delta = chunk.choices?.[0]?.delta;
+                            if (delta?.content) {
+                                content += delta.content;
+                                emitToken(delta.content);
+                            }
+                            if (Array.isArray(delta?.tool_calls)) {
+                                for (const call of delta.tool_calls) {
+                                    const index = call.index ?? 0;
+                                    const existing = toolCallMap.get(index) ?? {
+                                        id: call.id ?? `call_${index + 1}`,
+                                        name: "",
+                                        args: "",
+                                    };
+                                    if (call.function?.name) {
+                                        existing.name = call.function.name;
+                                    }
+                                    if (typeof call.function?.arguments === "string") {
+                                        existing.args += call.function.arguments;
+                                    }
+                                    toolCallMap.set(index, existing);
+                                }
+                            }
+                            if (chunk.usage) {
+                                usage = chunk.usage;
+                            }
+                        }
+                        catch {
+                            // ignore malformed chunks
+                        }
+                    }
+                }
+                const toolCalls = toolCallMap.size > 0
+                    ? Array.from(toolCallMap.entries()).map(([index, call]) => ({
+                        id: call.id ?? `call_${index + 1}`,
+                        name: call.name,
+                        args: parseToolArgs(call.args),
+                    }))
+                    : undefined;
+                return {
+                    message: { role: "assistant", content },
+                    toolCalls,
+                    usage: usage
+                        ? {
+                            inputTokens: usage.prompt_tokens,
+                            outputTokens: usage.completion_tokens,
+                            totalTokens: usage.total_tokens,
+                        }
+                        : undefined,
+                    raw: { stream: true },
+                };
+            }
+            const raw = (await response.json());
+            const choice = raw.choices[0]?.message;
+            if (!choice) {
+                throw new Error("OpenAI-compatible response missing choices");
+            }
+            const toolCalls = choice.tool_calls?.map((call) => ({
+                id: call.id,
+                name: call.function.name,
+                args: parseToolArgs(call.function.arguments),
+            }));
+            return {
+                message: {
+                    role: "assistant",
+                    content: choice.content ?? "",
+                },
+                toolCalls,
+                usage: raw.usage
+                    ? {
+                        inputTokens: raw.usage.prompt_tokens,
+                        outputTokens: raw.usage.completion_tokens,
+                        totalTokens: raw.usage.total_tokens,
+                    }
+                    : undefined,
+                raw,
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist/providers/ProviderRegistry.d.ts

@@ -0,0 +1,12 @@
+import type { Provider, ProviderConfig } from "./ProviderTypes.js";
+export type ProviderFactory = (config: ProviderConfig) => Provider;
+export declare class ProviderRegistry {
+    private factories;
+    register(name: string, factory: ProviderFactory): void;
+    create(name: string, config: ProviderConfig): Provider;
+    list(): string[];
+}
+export declare const defaultProviderRegistry: ProviderRegistry;
+export declare const registerProvider: (name: string, factory: ProviderFactory) => void;
+export declare const createProvider: (name: string, config: ProviderConfig) => Provider;
+//# sourceMappingURL=ProviderRegistry.d.ts.map

package/dist/providers/ProviderRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProviderRegistry.d.ts","sourceRoot":"","sources":["../../src/providers/ProviderRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEnE,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,cAAc,KAAK,QAAQ,CAAC;AAEnE,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAsC;IAEvD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI;IAOtD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,QAAQ;IAQtD,IAAI,IAAI,MAAM,EAAE;CAGjB;AAED,eAAO,MAAM,uBAAuB,kBAAyB,CAAC;AAE9D,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,EAAE,SAAS,eAAe,KAAG,IAEzE,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,EAAE,QAAQ,cAAc,KAAG,QAErE,CAAC"}

package/dist/providers/ProviderRegistry.js

@@ -0,0 +1,28 @@
+export class ProviderRegistry {
+    constructor() {
+        this.factories = new Map();
+    }
+    register(name, factory) {
+        if (this.factories.has(name)) {
+            throw new Error(`Provider already registered: ${name}`);
+        }
+        this.factories.set(name, factory);
+    }
+    create(name, config) {
+        const factory = this.factories.get(name);
+        if (!factory) {
+            throw new Error(`Unknown provider: ${name}`);
+        }
+        return factory(config);
+    }
+    list() {
+        return Array.from(this.factories.keys());
+    }
+}
+export const defaultProviderRegistry = new ProviderRegistry();
+export const registerProvider = (name, factory) => {
+    defaultProviderRegistry.register(name, factory);
+};
+export const createProvider = (name, config) => {
+    return defaultProviderRegistry.create(name, config);
+};

package/dist/providers/ProviderTypes.d.ts

@@ -0,0 +1,81 @@
+export type ProviderRole = "system" | "user" | "assistant" | "tool";
+export interface ProviderToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+export interface ProviderToolCall {
+    id: string;
+    name: string;
+    args: unknown;
+}
+export type AgentStatusPhase = "thinking" | "executing" | "patching" | "done";
+export type AgentEvent = {
+    type: "token";
+    content: string;
+} | {
+    type: "tool_call";
+    name: string;
+    args: unknown;
+} | {
+    type: "tool_result";
+    name: string;
+    output: string;
+    ok?: boolean;
+    errorCode?: string;
+    retryable?: boolean;
+} | {
+    type: "status";
+    phase: AgentStatusPhase;
+    message?: string;
+} | {
+    type: "error";
+    message: string;
+};
+export interface ProviderResponseFormat {
+    type: "json" | "json_schema" | "text" | "gbnf";
+    schema?: Record<string, unknown>;
+    grammar?: string;
+}
+export interface ProviderMessage {
+    role: ProviderRole;
+    content: string;
+    name?: string;
+    toolCallId?: string;
+}
+export interface ProviderUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface ProviderRequest {
+    messages: ProviderMessage[];
+    tools?: ProviderToolDefinition[];
+    toolChoice?: "auto" | "none" | {
+        name: string;
+    };
+    maxTokens?: number;
+    temperature?: number;
+    responseFormat?: ProviderResponseFormat;
+    stream?: boolean;
+    onEvent?: (event: AgentEvent) => void;
+    onToken?: (token: string) => void;
+    streamFlushMs?: number;
+}
+export interface ProviderResponse {
+    message: ProviderMessage;
+    toolCalls?: ProviderToolCall[];
+    usage?: ProviderUsage;
+    raw?: unknown;
+}
+export interface ProviderConfig {
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+}
+export interface Provider {
+    name: string;
+    generate(request: ProviderRequest): Promise<ProviderResponse>;
+}
+//# sourceMappingURL=ProviderTypes.d.ts.map

package/dist/providers/ProviderTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProviderTypes.d.ts","sourceRoot":"","sources":["../../src/providers/ProviderTypes.ts"],"names":[],"mappings":"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"}

package/dist/providers/ProviderTypes.js

@@ -0,0 +1 @@
+export {};