@mcoda/codali 0.1.108 → 0.1.110

package/dist/gateway/GatewayTracer.js

@@ -0,0 +1,214 @@
+/**
+ * Minimal run tracing.
+ *
+ * This ships with the first executable version rather than being deferred to a
+ * later observability phase. Tool-selection and iteration failures are the two
+ * things most likely to go wrong in an orchestrator, and both are close to
+ * undiagnosable without a record of what was chosen and why. Full trace replay
+ * can wait; knowing which model ran, which tools it picked, and why the run
+ * stopped cannot.
+ *
+ * Arguments are sanitized before they are recorded, because tool arguments
+ * routinely carry tokens and paths that must not reach a log.
+ */
+const SENSITIVE_KEY_PATTERN = /(?:authorization|api[_-]?key|bearer|credential|password|secret|signature|token)/i;
+/**
+ * Secret shapes redacted from *values*, not just from suspiciously named keys.
+ *
+ * A connector routinely returns a token inside an innocuously named field, and
+ * an MCP tool's arguments are model-generated, so key-name matching alone is
+ * not enough. These mirror the dataset privacy engine's patterns; both must
+ * catch a leak, because the trace is what gets printed to a terminal and pasted
+ * into an issue.
+ */
+const SENSITIVE_VALUE_PATTERNS = [
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi,
+    /\bsk-[A-Za-z0-9_-]{16,}\b/g,
+    /\bsk_[A-Za-z0-9]+_[A-Za-z0-9_]{8,}\b/g,
+    /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g,
+    /\bglpat-[A-Za-z0-9_-]{16,}\b/g,
+    /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bAIza[0-9A-Za-z_-]{30,}\b/g,
+    /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,
+];
+export const redactSecretValues = (value) => {
+    let output = value;
+    for (const pattern of SENSITIVE_VALUE_PATTERNS) {
+        output = output.replace(pattern, "[redacted]");
+    }
+    return output;
+};
+const MAX_ARG_STRING = 200;
+/**
+ * Redacts sensitive-looking values and truncates long ones. Applied to every
+ * argument before it is recorded or printed.
+ */
+export const sanitizeArgs = (value, depth = 0) => {
+    if (depth > 4)
+        return "[depth limit]";
+    if (typeof value === "string") {
+        // Redact before truncating: truncation could otherwise cut a secret in half
+        // and leave a recognizable prefix in the trace.
+        const redacted = redactSecretValues(value);
+        return redacted.length > MAX_ARG_STRING
+            ? `${redacted.slice(0, MAX_ARG_STRING)}…`
+            : redacted;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, 20).map((entry) => sanitizeArgs(entry, depth + 1));
+    }
+    if (value && typeof value === "object") {
+        const output = {};
+        for (const [key, entry] of Object.entries(value)) {
+            output[key] = SENSITIVE_KEY_PATTERN.test(key)
+                ? "[redacted]"
+                : sanitizeArgs(entry, depth + 1);
+        }
+        return output;
+    }
+    return value;
+};
+export class GatewayTracer {
+    constructor(query, options = {}) {
+        this.options = options;
+        this.startedMs = Date.now();
+        this.record = {
+            query,
+            startedAt: new Date().toISOString(),
+            roleBindings: {},
+            plannedTasks: [],
+            toolCalls: [],
+            rounds: 0,
+            warnings: [],
+        };
+    }
+    emit(line) {
+        if (!this.options.verbose)
+            return;
+        (this.options.write ?? ((text) => process.stderr.write(`${text}\n`)))(line);
+    }
+    setRunId(runId) {
+        this.record.runId = runId;
+    }
+    setRoleBindings(bindings) {
+        for (const [role, slug] of Object.entries(bindings)) {
+            if (slug)
+                this.record.roleBindings[role] = slug;
+        }
+        const rendered = Object.entries(this.record.roleBindings)
+            .map(([role, slug]) => `${role}=${slug}`)
+            .join(" ");
+        if (rendered)
+            this.emit(`· agents: ${rendered}`);
+    }
+    recordPlan(input) {
+        this.record.capabilities = input.capabilities;
+        this.record.plannedTasks = input.tasks.map((task) => ({
+            id: task.id,
+            role: task.workerRole,
+            objective: task.objective,
+            tools: task.toolsAllowed ?? [],
+        }));
+        if (input.capabilities?.length) {
+            this.emit(`· capabilities: ${input.capabilities.join(", ")}`);
+        }
+        this.emit(this.record.plannedTasks.length === 0
+            ? "· plan: answer directly, no tool tasks"
+            : `· plan: ${this.record.plannedTasks.length} task(s)`);
+        for (const task of this.record.plannedTasks) {
+            this.emit(`    ${task.id} [${task.role}] ${task.objective}`);
+        }
+    }
+    recordToolCall(input) {
+        this.record.toolCalls.push({
+            taskId: input.taskId,
+            tool: input.tool,
+            args: sanitizeArgs(input.args),
+        });
+        this.emit(`· tool → ${input.tool} ${JSON.stringify(sanitizeArgs(input.args))}`);
+    }
+    recordToolResult(input) {
+        // Attach to the most recent matching call rather than appending a row, so
+        // the trace reads as one line per call.
+        for (let index = this.record.toolCalls.length - 1; index >= 0; index -= 1) {
+            const call = this.record.toolCalls[index];
+            if (call && call.tool === input.tool && call.ok === undefined) {
+                call.ok = input.ok;
+                call.latencyMs = input.latencyMs;
+                call.errorCode = input.errorCode;
+                break;
+            }
+        }
+        this.emit(`· tool ← ${input.tool} ${input.ok ? "ok" : `failed (${input.errorCode ?? "unknown"})`} ${input.latencyMs}ms`);
+    }
+    recordRound(round) {
+        this.record.rounds = Math.max(this.record.rounds, round);
+        this.emit(`· round ${round}`);
+    }
+    addWarning(warning) {
+        this.record.warnings.push(warning);
+    }
+    finish(input) {
+        this.record.status = input.status;
+        this.record.finalizerMode = input.finalizerMode;
+        this.record.completionReason = input.completionReason;
+        this.record.warnings.push(...(input.warnings ?? []));
+        this.record.durationMs = Date.now() - this.startedMs;
+        this.emit(`· done: ${input.status}${input.finalizerMode ? ` via ${input.finalizerMode}` : ""} in ${this.record.durationMs}ms (${this.record.toolCalls.length} tool calls)`);
+        return this.record;
+    }
+    snapshot() {
+        return this.record;
+    }
+    /** Human-readable summary printed by `codali ask --trace`. */
+    render() {
+        const lines = [];
+        lines.push(`run: ${this.record.runId ?? "(unassigned)"}`);
+        lines.push(`status: ${this.record.status ?? "unknown"}`);
+        if (this.record.completionReason) {
+            lines.push(`completion: ${this.record.completionReason}`);
+        }
+        if (this.record.finalizerMode) {
+            lines.push(`finalizer: ${this.record.finalizerMode}`);
+        }
+        lines.push(`duration: ${this.record.durationMs ?? 0}ms`);
+        lines.push(`rounds: ${this.record.rounds}`);
+        const bindings = Object.entries(this.record.roleBindings);
+        if (bindings.length > 0) {
+            lines.push("agents:");
+            for (const [role, slug] of bindings)
+                lines.push(`  ${role}: ${slug}`);
+        }
+        if (this.record.capabilities?.length) {
+            lines.push(`capabilities: ${this.record.capabilities.join(", ")}`);
+        }
+        if (this.record.plannedTasks.length > 0) {
+            lines.push("tasks:");
+            for (const task of this.record.plannedTasks) {
+                lines.push(`  ${task.id} [${task.role}] tools=${task.tools.join(",") || "none"}`);
+                lines.push(`    ${task.objective}`);
+            }
+        }
+        if (this.record.toolCalls.length > 0) {
+            lines.push("tool calls:");
+            for (const call of this.record.toolCalls) {
+                const status = call.ok === undefined
+                    ? "pending"
+                    : call.ok
+                        ? "ok"
+                        : `failed(${call.errorCode ?? "unknown"})`;
+                lines.push(`  ${call.tool} ${status} ${call.latencyMs ?? 0}ms ${JSON.stringify(call.args)}`);
+            }
+        }
+        else {
+            lines.push("tool calls: none");
+        }
+        if (this.record.warnings.length > 0) {
+            lines.push("warnings:");
+            for (const warning of this.record.warnings)
+                lines.push(`  ${warning}`);
+        }
+        return lines.join("\n");
+    }
+}

package/dist/gateway/LocalGatewayProvider.d.ts

@@ -0,0 +1,59 @@
+import type { Provider, ProviderConfig } from "../providers/ProviderTypes.js";
+import type { CodaliGatewayAgentAssignment } from "./AgentTierResolver.js";
+/**
+ * Builds a `Provider` from a resolved mcoda agent so the gateway can run
+ * in-process from the CLI, without a round trip through mswarm.
+ *
+ * mswarm keeps its own cloud path; both should end up sharing this factory so
+ * local and cloud behaviour cannot drift.
+ */
+export interface LocalProviderOptions {
+    timeoutMs?: number;
+    apiKey?: string;
+    /** Scheduling priority; lower runs sooner. Defaults to CODALI_MSWARM_PRIORITY. */
+    priority?: number;
+}
+/**
+ * Scheduling priority Codali asks mswarm for.
+ *
+ * mswarm sorts ascending, so a lower number runs sooner, and its nodes reserve
+ * capacity for priority <= -1. Codali runs are interactive — someone is waiting
+ * at a terminal or in a chat window — so they should not queue behind batch
+ * work. -10 sits comfortably inside the reserved band without claiming the
+ * extreme of the -100..100 range, leaving room for anything genuinely more
+ * urgent.
+ */
+export declare const CODALI_MSWARM_PRIORITY = -10;
+/**
+ * mcoda adapter -> Codali provider. Adapters not listed fall through to the
+ * OpenAI-compatible provider, which is the correct default for local runners
+ * (llama.cpp, vLLM, LocalAI) and most hosted endpoints.
+ */
+export declare const providerNameForAdapter: (adapter: string | undefined) => string;
+export declare const createProviderForName: (name: string, config: ProviderConfig) => Provider;
+export declare const resolveMswarmApiKey: () => string | undefined;
+/**
+ * Creates a provider for an assigned agent. The raw inventory entry carries the
+ * transport details (base URL, runner kind, auth mode) that the tier resolver
+ * does not model, so it is read here.
+ */
+export declare const createProviderForAssignment: (assignment: CodaliGatewayAgentAssignment, options?: LocalProviderOptions) => Provider;
+/**
+ * Routes each gateway role to its own provider.
+ *
+ * Codali's whole premise is that a small model does the errands and a large one
+ * writes the answer. A single shared provider would silently collapse that: the
+ * planner and the synthesizer would run on the same model and the cost/quality
+ * split would be lost. So role dispatch is explicit, with a declared fallback
+ * rather than an accidental one.
+ */
+export declare class RoleRoutingProvider implements Provider {
+    private readonly providers;
+    private readonly fallback;
+    private readonly resolveRole;
+    readonly name = "codali-role-router";
+    constructor(providers: Record<string, Provider>, fallback: Provider, resolveRole?: () => string | undefined);
+    providerForRole(role: string | undefined): Provider;
+    generate(request: Parameters<Provider["generate"]>[0]): ReturnType<Provider["generate"]>;
+}
+//# sourceMappingURL=LocalGatewayProvider.d.ts.map

package/dist/gateway/LocalGatewayProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalGatewayProvider.d.ts","sourceRoot":"","sources":["../../src/gateway/LocalGatewayProvider.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAE3E;;;;;;GAMG;AAEH,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA0CD;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAwB1C;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAI,SAAS,MAAM,GAAG,SAAS,KAAG,MAapE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,MAAM,MAAM,EACZ,QAAQ,cAAc,KACrB,QAWF,CAAC;AAYF,eAAO,MAAM,mBAAmB,QAAO,MAAM,GAAG,SA4B/C,CAAC;AAKF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GACtC,YAAY,4BAA4B,EACxC,UAAS,oBAAyB,KACjC,QAkCF,CAAC;AAEF;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,YAAW,QAAQ;IAIhD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAL9B,QAAQ,CAAC,IAAI,wBAAwB;gBAGlB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACnC,QAAQ,EAAE,QAAQ,EAClB,WAAW,GAAE,MAAM,MAAM,GAAG,SAA2B;IAG1E,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ;IAK7C,QAAQ,CACZ,OAAO,EAAE,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,GAC3C,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;CAGpC"}

package/dist/gateway/LocalGatewayProvider.js

@@ -0,0 +1,195 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { ClaudeCliProvider } from "../providers/ClaudeCliProvider.js";
+import { CodexCliProvider } from "../providers/CodexCliProvider.js";
+import { OllamaRemoteProvider } from "../providers/OllamaRemoteProvider.js";
+import { OpenAiCompatibleProvider } from "../providers/OpenAiCompatibleProvider.js";
+/**
+ * Attaches the scheduling priority mswarm reads from `scheduling.priority`,
+ * without disturbing any runner settings the agent already carries.
+ */
+const buildLocalRunner = (nested, baseUrl, priority) => {
+    const existing = isRecord(nested.localRunner)
+        ? nested.localRunner
+        : undefined;
+    if (!isMswarmEndpoint(baseUrl)) {
+        return existing;
+    }
+    const existingExtra = isRecord(existing?.extraBody) ? existing.extraBody : {};
+    const existingScheduling = isRecord(existingExtra.scheduling) ? existingExtra.scheduling : {};
+    return {
+        ...(existing ?? {}),
+        extraBody: {
+            ...existingExtra,
+            scheduling: {
+                ...existingScheduling,
+                // An explicit value in the agent config wins over the default.
+                priority: existingScheduling.priority ?? priority ?? CODALI_MSWARM_PRIORITY,
+            },
+        },
+    };
+};
+/**
+ * Request timeout for a locally-hosted model.
+ *
+ * The providers default to 60s, which suits a hosted API and not a local one:
+ * qwen3.6 on the self-hosted node takes ~47s for a one-line prompt, so a full
+ * context pack aborted every time and surfaced as "the final model was
+ * unavailable" — a timeout wearing the costume of an outage.
+ */
+const LOCAL_MODEL_TIMEOUT_MS = 600000;
+/**
+ * Scheduling priority Codali asks mswarm for.
+ *
+ * mswarm sorts ascending, so a lower number runs sooner, and its nodes reserve
+ * capacity for priority <= -1. Codali runs are interactive — someone is waiting
+ * at a terminal or in a chat window — so they should not queue behind batch
+ * work. -10 sits comfortably inside the reserved band without claiming the
+ * extreme of the -100..100 range, leaving room for anything genuinely more
+ * urgent.
+ */
+export const CODALI_MSWARM_PRIORITY = -10;
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const readString = (record, keys) => {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+};
+const readBoolean = (record, keys) => {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "boolean")
+            return value;
+    }
+    return undefined;
+};
+/**
+ * mcoda adapter -> Codali provider. Adapters not listed fall through to the
+ * OpenAI-compatible provider, which is the correct default for local runners
+ * (llama.cpp, vLLM, LocalAI) and most hosted endpoints.
+ */
+export const providerNameForAdapter = (adapter) => {
+    switch ((adapter ?? "").toLowerCase()) {
+        case "claude-cli":
+            return "claude-cli";
+        case "codex-cli":
+            return "codex-cli";
+        case "ollama-cli":
+        case "ollama-remote":
+        case "ollama":
+            return "ollama";
+        default:
+            return "openai-compatible";
+    }
+};
+export const createProviderForName = (name, config) => {
+    switch (name) {
+        case "claude-cli":
+            return new ClaudeCliProvider(config);
+        case "codex-cli":
+            return new CodexCliProvider(config);
+        case "ollama":
+            return new OllamaRemoteProvider(config);
+        default:
+            return new OpenAiCompatibleProvider(config);
+    }
+};
+/**
+ * The mswarm API key, used to reach self-hosted agents served through the
+ * mswarm gateway. `mcoda agent list --json` reports `auth.configured: true` but
+ * never discloses the key itself, so it is read from local trusted config.
+ *
+ * Local CLI only. A multi-tenant deployment must receive credentials from its
+ * host rather than reading the operator's files.
+ */
+let cachedMswarmKey;
+export const resolveMswarmApiKey = () => {
+    if (cachedMswarmKey !== undefined)
+        return cachedMswarmKey ?? undefined;
+    const fromEnv = process.env.MSWARM_API_KEY?.trim();
+    if (fromEnv) {
+        cachedMswarmKey = fromEnv;
+        return fromEnv;
+    }
+    const configPath = path.join(homedir(), ".docdex", "config.toml");
+    if (existsSync(configPath)) {
+        try {
+            const raw = readFileSync(configPath, "utf8");
+            // Minimal TOML read: find api_key inside [integrations.mswarm].
+            const section = raw.split(/^\[integrations\.mswarm\]\s*$/m)[1];
+            const match = section?.match(/^\s*api_key\s*=\s*"([^"]+)"/m);
+            if (match?.[1]) {
+                cachedMswarmKey = match[1];
+                return cachedMswarmKey;
+            }
+        }
+        catch {
+            // Unreadable config is not fatal; the provider will fail with a clearer
+            // authentication error than anything we could raise here.
+        }
+    }
+    cachedMswarmKey = null;
+    return undefined;
+};
+const isMswarmEndpoint = (baseUrl) => Boolean(baseUrl && /(^|\/\/)([^/]*\.)?mswarm\.org/i.test(baseUrl));
+/**
+ * Creates a provider for an assigned agent. The raw inventory entry carries the
+ * transport details (base URL, runner kind, auth mode) that the tier resolver
+ * does not model, so it is read here.
+ */
+export const createProviderForAssignment = (assignment, options = {}) => {
+    const raw = isRecord(assignment.candidate.raw) ? assignment.candidate.raw : {};
+    // mcoda nests transport details under `config`; older entries put them at the
+    // top level. Read both, preferring the nested form.
+    const nested = isRecord(raw.config) ? raw.config : {};
+    const adapter = assignment.candidate.adapter ?? readString(raw, ["adapter"]);
+    const providerName = providerNameForAdapter(adapter);
+    const baseUrl = readString(nested, ["baseUrl", "base_url", "apiBaseUrl", "api_base_url"]) ??
+        readString(raw, ["baseUrl", "base_url"]);
+    const apiKey = options.apiKey ??
+        readString(nested, ["apiKey", "api_key"]) ??
+        readString(raw, ["apiKey", "api_key"]) ??
+        (isMswarmEndpoint(baseUrl) ? resolveMswarmApiKey() : undefined);
+    const config = {
+        model: assignment.candidate.model ?? readString(raw, ["defaultModel", "model"]) ?? "",
+        baseUrl,
+        apiKey,
+        timeoutMs: options.timeoutMs ?? LOCAL_MODEL_TIMEOUT_MS,
+        runnerKind: readString(nested, ["runnerKind", "runner_kind"]),
+        authMode: readString(nested, ["authMode", "auth_mode"]),
+        localRunner: buildLocalRunner(nested, baseUrl, options.priority),
+        supportsTools: assignment.candidate.supportsTools ?? readBoolean(raw, ["supportsTools"]),
+        supportsJsonSchema: assignment.candidate.supportsJsonSchema ?? readBoolean(raw, ["supportsJsonSchema"]),
+        supportsStreaming: assignment.candidate.supportsStreaming ?? readBoolean(raw, ["supportsStreaming"]),
+    };
+    return createProviderForName(providerName, config);
+};
+/**
+ * Routes each gateway role to its own provider.
+ *
+ * Codali's whole premise is that a small model does the errands and a large one
+ * writes the answer. A single shared provider would silently collapse that: the
+ * planner and the synthesizer would run on the same model and the cost/quality
+ * split would be lost. So role dispatch is explicit, with a declared fallback
+ * rather than an accidental one.
+ */
+export class RoleRoutingProvider {
+    constructor(providers, fallback, resolveRole = () => undefined) {
+        this.providers = providers;
+        this.fallback = fallback;
+        this.resolveRole = resolveRole;
+        this.name = "codali-role-router";
+    }
+    providerForRole(role) {
+        if (!role)
+            return this.fallback;
+        return this.providers[role] ?? this.fallback;
+    }
+    async generate(request) {
+        return this.providerForRole(this.resolveRole()).generate(request);
+    }
+}

package/dist/gateway/LocalGatewayTaskRunner.d.ts

@@ -0,0 +1,79 @@
+import type { Provider } from "../providers/ProviderTypes.js";
+import type { ToolRegistry } from "../tools/ToolRegistry.js";
+import type { ToolContext } from "../tools/ToolTypes.js";
+import type { CodaliGatewayWorkerTaskRunInput, CodaliGatewayWorkerTaskRunResult, CodaliGatewayWorkerTaskRunner } from "./GatewayStateMachine.js";
+/**
+ * Bounded worker-task runner.
+ *
+ * ## Why this exists
+ *
+ * Codali previously executed every gateway worker task by handing it to the
+ * full `CodaliRuntime` agent loop (see `createGatewayTaskRunner` in
+ * `packages/mswarm/src/codali-executor.ts`). That nested one open-ended loop
+ * inside another: the gateway decided how many *rounds* to run, while the
+ * runtime independently decided how many *steps* to take inside each task.
+ * Neither could bound the other, so a single request could fan out
+ * unpredictably and a runaway task was near-impossible to attribute.
+ *
+ * This runner removes the inner loop. Exactly one component - the gateway state
+ * machine - owns iteration. A task here is a single bounded pass:
+ *
+ *   1. ask the model what it needs (one model call)
+ *   2. execute the tool calls it asked for, in parallel where independent
+ *   3. ask the model to turn the results into the task output (one model call)
+ *
+ * There is no step 4 and no "decide whether to keep going". If the evidence is
+ * insufficient, that is the verifier's judgement to make, and the gateway will
+ * schedule another round against `maxIterations`. A worker never extends its
+ * own budget.
+ *
+ * The upper bound on work per task is therefore fixed and knowable:
+ * 2 model calls and `min(remainingToolCalls, MAX_TOOL_CALLS_PER_TASK)` tool
+ * calls.
+ */
+/** Hard ceiling on tool calls in a single task, independent of run budget. */
+export declare const MAX_TOOL_CALLS_PER_TASK = 8;
+/** Model calls per task: one to select tools, one to summarize results. */
+export declare const MAX_MODEL_CALLS_PER_TASK = 2;
+export interface LocalGatewayTaskRunnerOptions {
+    provider: Provider;
+    registry: ToolRegistry;
+    toolContext: ToolContext;
+    maxTokens?: number;
+    temperature?: number;
+    /** Observability hook; see `GatewayTracer`. */
+    onEvent?: (event: LocalGatewayTaskRunnerEvent) => void;
+}
+export type LocalGatewayTaskRunnerEvent = {
+    type: "task_start";
+    taskId: string;
+    workerRole: string;
+    allowedTools: string[];
+} | {
+    type: "tool_call";
+    taskId: string;
+    tool: string;
+    args: unknown;
+} | {
+    type: "tool_result";
+    taskId: string;
+    tool: string;
+    ok: boolean;
+    latencyMs: number;
+    errorCode?: string;
+} | {
+    type: "task_end";
+    taskId: string;
+    status: "succeeded" | "failed";
+    toolCallCount: number;
+    modelCallCount: number;
+    durationMs: number;
+};
+export declare class LocalGatewayTaskRunner implements CodaliGatewayWorkerTaskRunner {
+    private readonly options;
+    constructor(options: LocalGatewayTaskRunnerOptions);
+    run(input: CodaliGatewayWorkerTaskRunInput): Promise<CodaliGatewayWorkerTaskRunResult>;
+}
+export declare const createLocalGatewayTaskRunner: (options: LocalGatewayTaskRunnerOptions) => LocalGatewayTaskRunner;
+export declare const isRecordValue: (value: unknown) => value is Record<string, unknown>;
+//# sourceMappingURL=LocalGatewayTaskRunner.d.ts.map

package/dist/gateway/LocalGatewayTaskRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalGatewayTaskRunner.d.ts","sourceRoot":"","sources":["../../src/gateway/LocalGatewayTaskRunner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAGT,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,KAAK,EAEV,+BAA+B,EAC/B,gCAAgC,EAChC,6BAA6B,EAE9B,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,2EAA2E;AAC3E,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAe1C,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,YAAY,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,2BAA2B,KAAK,IAAI,CAAC;CACxD;AAED,MAAM,MAAM,2BAA2B,GACnC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,GAClF;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAClE;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GACD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6DN,qBAAa,sBAAuB,YAAW,6BAA6B;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,6BAA6B;IAE7D,GAAG,CACP,KAAK,EAAE,+BAA+B,GACrC,OAAO,CAAC,gCAAgC,CAAC;CAqT7C;AAED,eAAO,MAAM,4BAA4B,GACvC,SAAS,6BAA6B,KACrC,sBAA6D,CAAC;AAEjE,eAAO,MAAM,aAAa,UA3XD,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CA2X7B,CAAC"}