@mcoda/mswarm 0.1.56 → 0.1.60

package/dist/vendor/codali/providers/CodexCliProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodexCliProvider.d.ts","sourceRoot":"","sources":["../../src/providers/CodexCliProvider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAmB,eAAe,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAqHvH,qBAAa,gBAAiB,YAAW,QAAQ;IAGnC,OAAO,CAAC,MAAM;IAF1B,IAAI,SAAe;gBAEC,MAAM,EAAE,cAAc;IAEpC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAoKpE"}

package/dist/vendor/codali/providers/CodexCliProvider.js

@@ -0,0 +1,282 @@
+import { spawn } from "node:child_process";
+const CODEX_NO_SANDBOX_ENV = "MCODA_CODEX_NO_SANDBOX";
+const CODEX_REASONING_ENV = "MCODA_CODEX_REASONING_EFFORT";
+const CODEX_REASONING_ENV_FALLBACK = "CODEX_REASONING_EFFORT";
+const CODEX_STUB_ENV = "MCODA_CLI_STUB";
+const CODEX_COMMAND_ENV = "MCODA_CODEX_COMMAND";
+const CODEX_COMMAND_ARGS_ENV = "MCODA_CODEX_COMMAND_ARGS";
+const ALLOWED_REASONING_EFFORTS = new Set(["low", "medium", "high"]);
+const DEFAULT_REASONING_EFFORT = "high";
+const normalizeReasoningEffort = (raw) => {
+    const normalized = raw.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    const compact = normalized.replace(/[\s_-]+/g, "");
+    if (compact === "xhigh" || compact === "veryhigh" || compact === "max")
+        return "high";
+    if (compact === "xmedium" || compact === "med")
+        return "medium";
+    if (compact === "xlow" || compact === "min")
+        return "low";
+    if (ALLOWED_REASONING_EFFORTS.has(normalized))
+        return normalized;
+    return undefined;
+};
+const resolveSandboxArgs = () => {
+    const raw = process.env[CODEX_NO_SANDBOX_ENV];
+    if (raw === undefined || raw.trim() === "") {
+        return { args: ["--dangerously-bypass-approvals-and-sandbox"], bypass: true };
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "0") {
+        return { args: [], bypass: false };
+    }
+    return { args: ["--dangerously-bypass-approvals-and-sandbox"], bypass: true };
+};
+const resolveReasoningEffort = () => {
+    const raw = process.env[CODEX_REASONING_ENV] ?? process.env[CODEX_REASONING_ENV_FALLBACK];
+    if (!raw)
+        return DEFAULT_REASONING_EFFORT;
+    return normalizeReasoningEffort(raw) ?? DEFAULT_REASONING_EFFORT;
+};
+const parseCommandArgs = (raw) => {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith("[")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed
+                    .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+                    .filter((entry) => entry.length > 0);
+            }
+        }
+        catch {
+            // fall through to whitespace parsing
+        }
+    }
+    return trimmed.split(/\s+/).filter(Boolean);
+};
+const resolveCodexCommand = () => {
+    const command = process.env[CODEX_COMMAND_ENV]?.trim() || "codex";
+    const preArgs = parseCommandArgs(process.env[CODEX_COMMAND_ARGS_ENV]);
+    return { command, preArgs };
+};
+const formatMessages = (messages) => {
+    return messages
+        .map((message) => {
+        const name = message.name ? `(${message.name})` : "";
+        return `${message.role}${name}: ${message.content}`;
+    })
+        .join("\n\n");
+};
+const extractAssistantText = (parsed) => {
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    const isDelta = type.includes("delta");
+    const item = parsed.item ?? parsed;
+    const contentParts = Array.isArray(item?.content)
+        ? item.content.map((entry) => entry?.text ?? entry?.content ?? "").filter(Boolean)
+        : [];
+    const text = (typeof item?.text === "string" && item.text) ||
+        (typeof item?.content === "string" && item.content) ||
+        (contentParts.length ? contentParts.join("") : "") ||
+        (typeof parsed.text === "string" && parsed.text) ||
+        (typeof parsed.delta === "string" && parsed.delta);
+    if (!text)
+        return null;
+    return { text, isDelta };
+};
+const parseCodexOutput = (raw) => {
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    let message = "";
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            const event = extractAssistantText(parsed);
+            if (!event)
+                continue;
+            if (event.isDelta) {
+                message += event.text;
+            }
+            else {
+                message = event.text;
+            }
+        }
+        catch {
+            // ignore parse errors
+        }
+    }
+    if (!message) {
+        return lines[lines.length - 1] ?? "";
+    }
+    return message;
+};
+const isIgnorableStdinError = (error) => error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED";
+export class CodexCliProvider {
+    constructor(config) {
+        this.config = config;
+        this.name = "codex-cli";
+    }
+    async generate(request) {
+        const last = request.messages[request.messages.length - 1];
+        const emitToken = (token) => {
+            if (request.onEvent) {
+                request.onEvent({ type: "token", content: token });
+                return;
+            }
+            request.onToken?.(token);
+        };
+        if (process.env[CODEX_STUB_ENV] === "1") {
+            const stubContent = `codex-stub:${last?.content ?? ""}`;
+            if (request.stream) {
+                emitToken(stubContent);
+            }
+            return {
+                message: {
+                    role: "assistant",
+                    content: stubContent,
+                },
+            };
+        }
+        const prompt = formatMessages(request.messages);
+        const resolvedModel = this.config.model?.trim();
+        if (!resolvedModel) {
+            throw new Error("AUTH_ERROR: codex-cli provider requires model from selected mcoda agent/config.");
+        }
+        const sandbox = resolveSandboxArgs();
+        const codexCommand = resolveCodexCommand();
+        const args = [...codexCommand.preArgs, ...sandbox.args, "exec", "--model", resolvedModel, "--json"];
+        if (!sandbox.bypass) {
+            args.push("--full-auto");
+        }
+        const reasoningEffort = resolveReasoningEffort();
+        if (reasoningEffort) {
+            args.push("-c", `reasoning_effort=${reasoningEffort}`);
+            args.push("-c", `model_reasoning_effort=${reasoningEffort}`);
+        }
+        const timeoutMs = Math.max(1, this.config.timeoutMs ?? 300000);
+        const childEnv = { ...process.env };
+        if (reasoningEffort) {
+            childEnv[CODEX_REASONING_ENV] = reasoningEffort;
+            childEnv[CODEX_REASONING_ENV_FALLBACK] = reasoningEffort;
+        }
+        else {
+            delete childEnv[CODEX_REASONING_ENV];
+            delete childEnv[CODEX_REASONING_ENV_FALLBACK];
+        }
+        return await new Promise((resolve, reject) => {
+            const child = spawn(codexCommand.command, args, { stdio: ["pipe", "pipe", "pipe"], env: childEnv });
+            let raw = "";
+            let stderr = "";
+            let lineBuffer = "";
+            let message = "";
+            let settled = false;
+            const finishResolve = (response) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeoutHandle);
+                resolve(response);
+            };
+            const finishReject = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeoutHandle);
+                reject(error);
+            };
+            const timeoutHandle = setTimeout(() => {
+                if (settled)
+                    return;
+                const reason = `AUTH_ERROR: codex CLI timed out after ${timeoutMs}ms` +
+                    (stderr.trim().length > 0 ? `: ${stderr.trim()}` : "");
+                child.kill("SIGTERM");
+                setTimeout(() => {
+                    if (!settled) {
+                        child.kill("SIGKILL");
+                    }
+                }, 500).unref();
+                finishReject(new Error(reason));
+            }, timeoutMs);
+            timeoutHandle.unref();
+            const handleLine = (line) => {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    return;
+                const parsedLine = (() => {
+                    try {
+                        return JSON.parse(trimmed);
+                    }
+                    catch {
+                        return null;
+                    }
+                })();
+                const event = extractAssistantText(parsedLine);
+                if (!event)
+                    return;
+                if (event.isDelta) {
+                    message += event.text;
+                    if (request.stream)
+                        emitToken(event.text);
+                    return;
+                }
+                message = event.text;
+                if (request.stream)
+                    emitToken(event.text);
+            };
+            child.stdout.on("data", (chunk) => {
+                const text = chunk.toString();
+                raw += text;
+                lineBuffer += text;
+                const lines = lineBuffer.split(/\r?\n/);
+                lineBuffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    handleLine(line);
+                }
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk.toString();
+            });
+            child.stdin.on("error", (error) => {
+                if (settled || isIgnorableStdinError(error))
+                    return;
+                finishReject(new Error(`AUTH_ERROR: codex CLI stdin failed (${error.message})`));
+            });
+            child.on("error", (error) => {
+                finishReject(new Error(`AUTH_ERROR: codex CLI failed (${error.message})`));
+            });
+            child.on("close", (code) => {
+                if (settled)
+                    return;
+                if (lineBuffer.trim()) {
+                    handleLine(lineBuffer);
+                }
+                if (code !== 0) {
+                    finishReject(new Error(`AUTH_ERROR: codex CLI failed (exit ${code}): ${stderr || raw}`.trim()));
+                    return;
+                }
+                const output = message.trim() || parseCodexOutput(raw).trim();
+                finishResolve({ message: { role: "assistant", content: output }, raw });
+            });
+            setImmediate(() => {
+                if (settled)
+                    return;
+                const stdin = child.stdin;
+                if (!stdin || stdin.destroyed || !stdin.writable)
+                    return;
+                try {
+                    stdin.end(prompt);
+                }
+                catch (error) {
+                    const err = error;
+                    if (!isIgnorableStdinError(err)) {
+                        finishReject(new Error(`AUTH_ERROR: codex CLI stdin failed (${err.message})`));
+                    }
+                }
+            });
+        });
+    }
+}

package/dist/vendor/codali/providers/OllamaRemoteProvider.d.ts

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

package/dist/vendor/codali/providers/OllamaRemoteProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OllamaRemoteProvider.d.ts","sourceRoot":"","sources":["../../src/providers/OllamaRemoteProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EACd,eAAe,EACf,gBAAgB,EAGjB,MAAM,oBAAoB,CAAC;AA2J5B,qBAAa,oBAAqB,YAAW,QAAQ;IAGvC,OAAO,CAAC,MAAM;IAF1B,IAAI,SAAmB;gBAEH,MAAM,EAAE,cAAc;IAEpC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAwKpE"}

package/dist/vendor/codali/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/vendor/codali/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/vendor/codali/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"}