@mcoda/mswarm 0.1.57 → 0.1.61

package/dist/vendor/codali/eval/SuiteSchema.js

@@ -0,0 +1,357 @@
+export const EVAL_COMMANDS = ["run", "fix", "review", "explain", "test"];
+export const EVAL_VERIFICATION_EXPECTATIONS = [
+    "verified_passed",
+    "verified_failed",
+    "unverified_with_reason",
+    "any",
+];
+export class SuiteValidationError extends Error {
+    constructor(message, issues) {
+        super(message);
+        this.name = "SuiteValidationError";
+        this.issues = issues;
+    }
+}
+const asRecord = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+};
+const readAliased = (source, aliases) => {
+    for (const alias of aliases) {
+        if (Object.prototype.hasOwnProperty.call(source, alias))
+            return source[alias];
+    }
+    return undefined;
+};
+const readString = (source, aliases) => {
+    const value = readAliased(source, aliases);
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length ? normalized : undefined;
+};
+const readBoolean = (source, aliases) => {
+    const value = readAliased(source, aliases);
+    return typeof value === "boolean" ? value : undefined;
+};
+const readNumber = (source, aliases) => {
+    const value = readAliased(source, aliases);
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+};
+const readInteger = (source, aliases) => {
+    const value = readNumber(source, aliases);
+    return value !== undefined && Number.isInteger(value) ? value : undefined;
+};
+const normalizeRateField = (source, aliases, issues, pathLabel) => {
+    const value = readNumber(source, aliases);
+    if (value === undefined)
+        return undefined;
+    if (value < 0 || value > 1) {
+        issues.push({
+            path: pathLabel,
+            code: "invalid_rate_range",
+            message: "Expected a number between 0 and 1.",
+        });
+        return undefined;
+    }
+    return value;
+};
+const normalizeVerificationExpectation = (source, issues, pathLabel) => {
+    const value = readString(source, ["expect_verification", "expectVerification"]);
+    if (!value)
+        return undefined;
+    if (EVAL_VERIFICATION_EXPECTATIONS.includes(value)) {
+        return value;
+    }
+    if (["verified_passed", "verified_failed", "unverified_with_reason"].includes(value)) {
+        return value;
+    }
+    issues.push({
+        path: pathLabel,
+        code: "invalid_verification_expectation",
+        message: `Expected one of: ${EVAL_VERIFICATION_EXPECTATIONS.join(", ")}.`,
+    });
+    return undefined;
+};
+const normalizeTaskAssertions = (rawValue, taskPath, taskMode, issues) => {
+    const source = asRecord(rawValue) ?? {};
+    if (!asRecord(rawValue) && rawValue !== undefined) {
+        issues.push({
+            path: `${taskPath}.assertions`,
+            code: "invalid_object",
+            message: "Expected an object for assertions.",
+        });
+    }
+    const expectSuccess = readBoolean(source, ["expect_success", "expectSuccess"]) ?? (taskMode !== "failure");
+    const explicitExitCode = readInteger(source, ["expect_exit_code", "expectExitCode"]);
+    const expectExitCode = explicitExitCode ?? (expectSuccess ? 0 : undefined);
+    if (explicitExitCode !== undefined && explicitExitCode < 0) {
+        issues.push({
+            path: `${taskPath}.assertions.expect_exit_code`,
+            code: "invalid_exit_code",
+            message: "Expected a non-negative integer.",
+        });
+    }
+    const maxLatencyMs = readNumber(source, ["max_latency_ms", "maxLatencyMs"]);
+    if (maxLatencyMs !== undefined && maxLatencyMs <= 0) {
+        issues.push({
+            path: `${taskPath}.assertions.max_latency_ms`,
+            code: "invalid_latency",
+            message: "Expected max latency to be greater than 0.",
+        });
+    }
+    const maxCostUsd = readNumber(source, ["max_cost_usd", "maxCostUsd"]);
+    if (maxCostUsd !== undefined && maxCostUsd < 0) {
+        issues.push({
+            path: `${taskPath}.assertions.max_cost_usd`,
+            code: "invalid_cost",
+            message: "Expected max cost to be greater than or equal to 0.",
+        });
+    }
+    return {
+        expect_success: expectSuccess,
+        expect_exit_code: expectExitCode,
+        expect_patch_apply: readBoolean(source, ["expect_patch_apply", "expectPatchApply"]),
+        expect_verification: normalizeVerificationExpectation(source, issues, `${taskPath}.assertions.expect_verification`),
+        max_latency_ms: maxLatencyMs !== undefined && maxLatencyMs > 0 ? maxLatencyMs : undefined,
+        max_cost_usd: maxCostUsd !== undefined && maxCostUsd >= 0 ? maxCostUsd : undefined,
+        allow_hallucination: readBoolean(source, ["allow_hallucination", "allowHallucination"]) ?? false,
+        allow_scope_violation: readBoolean(source, ["allow_scope_violation", "allowScopeViolation"]) ?? false,
+    };
+};
+const normalizeTask = (value, index, issues) => {
+    const taskPath = `tasks[${index}]`;
+    const source = asRecord(value);
+    if (!source) {
+        issues.push({
+            path: taskPath,
+            code: "invalid_object",
+            message: "Expected task to be an object.",
+        });
+    }
+    const taskSource = source ?? {};
+    const id = readString(taskSource, ["id"]) ?? `task-${index + 1}`;
+    if (!readString(taskSource, ["id"])) {
+        issues.push({
+            path: `${taskPath}.id`,
+            code: "missing_required",
+            message: "Task id is required.",
+        });
+    }
+    const title = readString(taskSource, ["title"]) ?? id;
+    const modeValue = readString(taskSource, ["mode"]);
+    const mode = modeValue === "success" || modeValue === "failure"
+        ? modeValue
+        : (readBoolean(asRecord(readAliased(taskSource, ["assertions"])) ?? {}, ["expect_success", "expectSuccess"])
+            === false
+            ? "failure"
+            : "success");
+    if (modeValue && modeValue !== "success" && modeValue !== "failure") {
+        issues.push({
+            path: `${taskPath}.mode`,
+            code: "invalid_mode",
+            message: "Expected task mode to be success|failure.",
+        });
+    }
+    const commandValue = readString(taskSource, ["command"]);
+    const command = commandValue && EVAL_COMMANDS.includes(commandValue)
+        ? commandValue
+        : "run";
+    if (commandValue && !EVAL_COMMANDS.includes(commandValue)) {
+        issues.push({
+            path: `${taskPath}.command`,
+            code: "invalid_command",
+            message: `Expected command to be one of: ${EVAL_COMMANDS.join(", ")}.`,
+        });
+    }
+    const taskFile = readString(taskSource, ["task_file", "taskFile"]);
+    const inlineTask = readString(taskSource, ["inline_task", "inlineTask"]);
+    if (!taskFile && !inlineTask) {
+        issues.push({
+            path: taskPath,
+            code: "missing_task_input",
+            message: "Expected exactly one of task_file or inline_task.",
+        });
+    }
+    if (taskFile && inlineTask) {
+        issues.push({
+            path: taskPath,
+            code: "ambiguous_task_input",
+            message: "Provide only one of task_file or inline_task.",
+        });
+    }
+    const argsValue = readAliased(taskSource, ["args"]);
+    const args = [];
+    if (Array.isArray(argsValue)) {
+        for (let argIndex = 0; argIndex < argsValue.length; argIndex += 1) {
+            const entry = argsValue[argIndex];
+            if (typeof entry !== "string") {
+                issues.push({
+                    path: `${taskPath}.args[${argIndex}]`,
+                    code: "invalid_arg",
+                    message: "Expected every task arg to be a string.",
+                });
+                continue;
+            }
+            const normalized = entry.trim();
+            if (normalized)
+                args.push(normalized);
+        }
+    }
+    else if (argsValue !== undefined) {
+        issues.push({
+            path: `${taskPath}.args`,
+            code: "invalid_args",
+            message: "Expected args to be an array of strings.",
+        });
+    }
+    return {
+        id,
+        title,
+        description: readString(taskSource, ["description"]),
+        mode,
+        command,
+        task_file: taskFile,
+        inline_task: inlineTask,
+        args,
+        assertions: normalizeTaskAssertions(readAliased(taskSource, ["assertions"]), taskPath, mode, issues),
+    };
+};
+const normalizeThresholds = (value, issues) => {
+    if (value === undefined)
+        return undefined;
+    const source = asRecord(value);
+    if (!source) {
+        issues.push({
+            path: "thresholds",
+            code: "invalid_object",
+            message: "Expected thresholds to be an object.",
+        });
+        return undefined;
+    }
+    const thresholds = {};
+    const patchApplyDropMax = normalizeRateField(source, ["patch_apply_drop_max", "patchApplyDropMax"], issues, "thresholds.patch_apply_drop_max");
+    if (patchApplyDropMax !== undefined)
+        thresholds.patch_apply_drop_max = patchApplyDropMax;
+    const verificationPassRateMin = normalizeRateField(source, ["verification_pass_rate_min", "verificationPassRateMin"], issues, "thresholds.verification_pass_rate_min");
+    if (verificationPassRateMin !== undefined) {
+        thresholds.verification_pass_rate_min = verificationPassRateMin;
+    }
+    const hallucinationRateMax = normalizeRateField(source, ["hallucination_rate_max", "hallucinationRateMax"], issues, "thresholds.hallucination_rate_max");
+    if (hallucinationRateMax !== undefined)
+        thresholds.hallucination_rate_max = hallucinationRateMax;
+    const scopeViolationRateMax = normalizeRateField(source, ["scope_violation_rate_max", "scopeViolationRateMax"], issues, "thresholds.scope_violation_rate_max");
+    if (scopeViolationRateMax !== undefined) {
+        thresholds.scope_violation_rate_max = scopeViolationRateMax;
+    }
+    return Object.keys(thresholds).length ? thresholds : undefined;
+};
+const normalizeBaseline = (value, issues) => {
+    if (value === undefined)
+        return undefined;
+    const source = asRecord(value);
+    if (!source) {
+        issues.push({
+            path: "baseline",
+            code: "invalid_object",
+            message: "Expected baseline to be an object.",
+        });
+        return undefined;
+    }
+    const modeValue = readString(source, ["mode"]);
+    let mode = "previous";
+    if (modeValue === "previous" || modeValue === "none") {
+        mode = modeValue;
+    }
+    else if (modeValue) {
+        issues.push({
+            path: "baseline.mode",
+            code: "invalid_baseline_mode",
+            message: "Expected baseline.mode to be previous|none.",
+        });
+    }
+    return {
+        mode,
+        report_path: readString(source, ["report_path", "reportPath"]),
+    };
+};
+export const normalizeSuiteDefinition = (raw, label = "suite") => {
+    const issues = [];
+    const source = asRecord(raw);
+    if (!source) {
+        throw new SuiteValidationError(`${label} is invalid.`, [
+            {
+                path: label,
+                code: "invalid_object",
+                message: "Expected suite root to be an object.",
+            },
+        ]);
+    }
+    const schemaVersion = readInteger(source, ["schema_version", "schemaVersion"]) ?? 1;
+    if (schemaVersion !== 1) {
+        issues.push({
+            path: "schema_version",
+            code: "unsupported_schema_version",
+            message: "Only schema_version=1 is supported.",
+        });
+    }
+    const suiteId = readString(source, ["suite_id", "suiteId"]);
+    if (!suiteId) {
+        issues.push({
+            path: "suite_id",
+            code: "missing_required",
+            message: "suite_id is required.",
+        });
+    }
+    const tasksValue = readAliased(source, ["tasks"]);
+    if (!Array.isArray(tasksValue) || tasksValue.length === 0) {
+        issues.push({
+            path: "tasks",
+            code: "missing_tasks",
+            message: "tasks must be a non-empty array.",
+        });
+    }
+    const tasksRaw = Array.isArray(tasksValue) ? tasksValue : [];
+    const tasks = tasksRaw.map((entry, index) => normalizeTask(entry, index, issues));
+    const seenTaskIds = new Set();
+    for (const task of tasks) {
+        if (seenTaskIds.has(task.id)) {
+            issues.push({
+                path: `tasks.${task.id}`,
+                code: "duplicate_task_id",
+                message: `Task id "${task.id}" is duplicated.`,
+            });
+            continue;
+        }
+        seenTaskIds.add(task.id);
+    }
+    if (issues.length > 0) {
+        throw new SuiteValidationError(`${label} validation failed.`, issues);
+    }
+    const normalized = {
+        schema_version: 1,
+        suite_id: suiteId ?? "unknown-suite",
+        name: readString(source, ["name"]) ?? (suiteId ?? "unnamed-suite"),
+        description: readString(source, ["description"]),
+        thresholds: normalizeThresholds(readAliased(source, ["thresholds"]), issues),
+        baseline: normalizeBaseline(readAliased(source, ["baseline"]), issues),
+        tasks,
+    };
+    if (issues.length > 0) {
+        throw new SuiteValidationError(`${label} validation failed.`, issues);
+    }
+    return normalized;
+};
+const stableSort = (value) => {
+    if (Array.isArray(value))
+        return value.map(stableSort);
+    if (!value || typeof value !== "object")
+        return value;
+    const source = value;
+    const sortedEntries = Object.keys(source)
+        .sort((left, right) => left.localeCompare(right))
+        .map((key) => [key, stableSort(source[key])]);
+    return Object.fromEntries(sortedEntries);
+};
+export const stableJsonStringify = (value) => JSON.stringify(stableSort(value));

package/dist/vendor/codali/index.d.ts

@@ -0,0 +1,11 @@
+export { runCli } from "./cli.js";
+export { codaliEventToOpenAIChatCompletionChunk, codaliEventToOpenAISseData, createCodaliRuntime, runCodaliTask, } from "./runtime/CodaliRuntime.js";
+export { loadInstructionBlocks, formatInstructionBlocks } from "./session/InstructionLoader.js";
+export { SessionStore } from "./session/SessionStore.js";
+export { SubagentOrchestrator } from "./subagents/SubagentOrchestrator.js";
+export type { ProviderMessage, ProviderUsage, } from "./providers/ProviderTypes.js";
+export type { CodaliRuntime, CodaliOpenAIChunkOptions, CodaliRuntimeAgentInput, CodaliRuntimeDocdexInput, CodaliRuntimeEvent, CodaliRuntimeInput, CodaliRuntimePolicy, CodaliRuntimeProviderInput, CodaliRuntimeSessionInput, CodaliRuntimeSubagentsInput, CodaliRuntimeResult, CodaliRuntimeWorkspace, } from "./runtime/CodaliRuntime.js";
+export type { InstructionBlock, InstructionLoadOptions, } from "./session/InstructionLoader.js";
+export type { CodaliResumeBundle, CodaliSessionMetadata, CodaliSessionStatus, CodaliSessionSummary, CodaliSessionTranscriptEvent, } from "./session/SessionStore.js";
+export type { SubagentPermissions, SubagentResult, SubagentRole, SubagentSpec, SubagentStatus, } from "./subagents/SubagentOrchestrator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/vendor/codali/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EACL,sCAAsC,EACtC,0BAA0B,EAC1B,mBAAmB,EACnB,aAAa,GACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAChG,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,YAAY,EACV,eAAe,EACf,aAAa,GACd,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,aAAa,EACb,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,EACxB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,EAC3B,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACV,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,gCAAgC,CAAC;AACxC,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,cAAc,GACf,MAAM,qCAAqC,CAAC"}

package/dist/vendor/codali/index.js

@@ -0,0 +1,5 @@
+export { runCli } from "./cli.js";
+export { codaliEventToOpenAIChatCompletionChunk, codaliEventToOpenAISseData, createCodaliRuntime, runCodaliTask, } from "./runtime/CodaliRuntime.js";
+export { loadInstructionBlocks, formatInstructionBlocks } from "./session/InstructionLoader.js";
+export { SessionStore } from "./session/SessionStore.js";
+export { SubagentOrchestrator } from "./subagents/SubagentOrchestrator.js";

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

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

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