@mcoda/mswarm 0.1.107 → 0.1.109

package/dist/vendor/codali/agents/RoleResolution.js

@@ -0,0 +1,166 @@
+import { resolveCodaliGatewayAgentTiers, } from "../gateway/AgentTierResolver.js";
+/** Internal roles each configurable role stands in for. */
+const ROLE_EXPANSION = {
+    // Thinking stages: JSON in, JSON out, no tool calls. A small fast model is
+    // usually enough, and these run on every question.
+    orchestrator: [
+        "router",
+        "classifier",
+        "planner",
+        "query_expander",
+        "context_refiner",
+        "verifier",
+        "repair",
+    ],
+    // Tool-calling stages. Accuracy here decides whether a run gathers anything:
+    // a weak model invents dates and empty ids. Split out so a bigger model can
+    // be put exactly here without slowing down planning.
+    worker: ["rag_worker", "tool_worker", "extractor"],
+    synthesizer: ["final_synthesizer"],
+    media: ["image_worker"],
+};
+/** Phase 1 resolves only these; media arrives with image generation. */
+export const PHASE_ONE_ROLES = [
+    "orchestrator",
+    "worker",
+    "synthesizer",
+];
+/** Internal roles whose policies already demand tool support, best first. */
+const TOOL_CAPABLE_PREFERENCE = ["tool_worker", "rag_worker"];
+/**
+ * Adapters driven through a text CLI. They advertise `supportsTools: true`
+ * because the CLI itself has tools, but Codali's provider for them cannot
+ * surface a structured tool call — so choosing one as the tool worker yields a
+ * correct plan and zero tool calls.
+ */
+const NON_TOOL_CALLING_ADAPTERS = new Set(["claude-cli", "codex-cli", "gemini-cli"]);
+const canEmitToolCalls = (assignment) => assignment?.candidate.supportsTools === true &&
+    !NON_TOOL_CALLING_ADAPTERS.has((assignment.candidate.adapter ?? "").toLowerCase());
+const findToolCapableAssignment = (resolution, preferred) => {
+    if (canEmitToolCalls(preferred))
+        return preferred;
+    for (const role of TOOL_CAPABLE_PREFERENCE) {
+        const assignment = resolution.assignments[role];
+        if (canEmitToolCalls(assignment))
+            return assignment;
+    }
+    return Object.values(resolution.assignments).find((assignment) => canEmitToolCalls(assignment));
+};
+const findBySlug = (inventory, slug) => inventory.find((agent) => agent.slug === slug || agent.id === slug);
+/**
+ * Builds the tier policy the resolver consumes. An explicitly bound slug is
+ * honoured for every internal role the configurable role stands in for, so
+ * binding `orchestrator` really does move planning, verification and repair
+ * onto that agent.
+ */
+const buildAgentPolicy = (bindings, inventory, warnings) => {
+    if (!bindings)
+        return undefined;
+    const roles = {};
+    let hasBinding = false;
+    for (const [role, slug] of Object.entries(bindings)) {
+        if (!slug)
+            continue;
+        const agent = findBySlug(inventory, slug);
+        if (!agent) {
+            warnings.push(`agent_binding_not_found:${role}:${slug}`);
+            continue;
+        }
+        hasBinding = true;
+        // Use the bound agent's *own* tier for the role. Imposing the role's
+        // nominal tier here silently discards the operator's choice: binding
+        // `orchestrator` to a large agent left it failing a "medium" requirement
+        // and falling back to whatever the resolver preferred, with the config
+        // appearing to have no effect.
+        const boundTier = (typeof agent.tier === "string" ? agent.tier : undefined) ??
+            (role === "synthesizer" ? "large" : role === "media" ? "image" : "medium");
+        for (const internalRole of ROLE_EXPANSION[role] ?? []) {
+            roles[internalRole] = {
+                tier: boundTier,
+                preferredRunnerKinds: undefined,
+            };
+        }
+    }
+    return hasBinding ? { resolver: "mcoda_inventory", roles } : undefined;
+};
+export const resolveConfigurableRoles = (input) => {
+    const warnings = [];
+    const roles = input.roles ?? PHASE_ONE_ROLES;
+    const internalRoles = roles.flatMap((role) => ROLE_EXPANSION[role] ?? []);
+    const agentPolicy = buildAgentPolicy(input.bindings, input.inventory, warnings);
+    const resolution = resolveCodaliGatewayAgentTiers({
+        inventory: input.inventory,
+        agentPolicy,
+        roles: internalRoles,
+        allowImageWorker: input.allowImageWorker ?? roles.includes("media"),
+    });
+    const assignments = {};
+    const bindingsOut = {};
+    for (const role of roles) {
+        // An explicit binding is the operator's decision and overrides tier
+        // matching outright. Routing it through the tier policy silently discarded
+        // the choice: mcoda's inventory carries no `tier` field — the resolver
+        // infers one — so a bound large agent failed a nominal "medium"
+        // requirement and the config appeared to do nothing.
+        const boundSlug = input.bindings?.[role];
+        if (boundSlug) {
+            const candidate = resolution.candidates.find((entry) => entry.slug === boundSlug || entry.id === boundSlug);
+            if (candidate) {
+                const existing = Object.values(resolution.assignments).find((assignment) => assignment.candidate.slug === candidate.slug);
+                assignments[role] = existing ?? {
+                    role,
+                    policy: { tier: candidate.tier },
+                    candidate,
+                    agent: {
+                        slug: candidate.slug,
+                        adapter: candidate.adapter ?? "",
+                        model: candidate.model ?? "",
+                        supportsTools: candidate.supportsTools,
+                        contextWindow: candidate.contextWindow,
+                        maxOutputTokens: candidate.maxOutputTokens,
+                    },
+                    score: 0,
+                    reasons: ["explicit_binding"],
+                };
+                bindingsOut[role] = candidate.slug;
+                continue;
+            }
+            warnings.push(`agent_binding_unavailable:${role}:${boundSlug}`);
+        }
+        // Otherwise the role is served by the first of its internal roles that
+        // resolved. They share a tier, so any is a valid stand-in.
+        for (const internalRole of ROLE_EXPANSION[role] ?? []) {
+            const assignment = resolution.assignments[internalRole];
+            if (assignment) {
+                assignments[role] = assignment;
+                bindingsOut[role] = assignment.candidate.slug;
+                break;
+            }
+        }
+        if (!assignments[role]) {
+            warnings.push(`agent_role_unresolved:${role}`);
+        }
+    }
+    // An internal role that failed to resolve is only worth reporting when the
+    // configurable role standing in for it also failed. Otherwise every run on a
+    // sparse inventory emits a wall of errors for roles that fell back correctly
+    // and never affected the answer.
+    const servedInternalRoles = new Set(roles
+        .filter((role) => assignments[role])
+        .flatMap((role) => ROLE_EXPANSION[role] ?? []));
+    for (const error of resolution.errors) {
+        if (error.role && servedInternalRoles.has(error.role))
+            continue;
+        warnings.push(`agent_resolution_error:${error.code}${error.role ? `:${error.role}` : ""}`);
+    }
+    const toolCapable = findToolCapableAssignment(resolution, 
+    // An explicitly bound worker wins; otherwise fall back to the orchestrator.
+    assignments.worker ?? assignments.orchestrator);
+    if (!toolCapable) {
+        warnings.push("no_tool_capable_agent");
+    }
+    else if (toolCapable !== assignments.orchestrator) {
+        warnings.push(`tool_worker_substituted:${toolCapable.candidate.slug}`);
+    }
+    return { resolution, assignments, bindings: bindingsOut, toolCapable, warnings };
+};

package/dist/vendor/codali/api/ChatCompletionsAdapter.d.ts

@@ -0,0 +1,76 @@
+import { runCodali, type CodaliMessage, type CodaliRequest, type CodaliResult } from "./CodaliApi.js";
+import type { RunContext } from "../runcontext/RunContextResolver.js";
+/**
+ * OpenAI-compatible chat-completions adapter.
+ *
+ * okacam AI chat already speaks this shape. Rather than changing AI chat to
+ * learn Codali's contract, Codali speaks AI chat's — the product points its
+ * existing client at a different base URL and gets orchestration, tools, and
+ * citations without a rewrite.
+ *
+ * The adapter is deliberately thin. It maps message shapes and nothing else;
+ * all routing, tool selection and budget enforcement stay in the one code path
+ * `runCodali` provides, so the adapter cannot drift from the CLI's behaviour.
+ */
+export interface ChatCompletionMessage {
+    role: string;
+    content: string | null;
+}
+export interface ChatCompletionRequest {
+    model?: string;
+    messages: ChatCompletionMessage[];
+    stream?: boolean;
+    response_format?: {
+        type?: string;
+        json_schema?: {
+            schema?: Record<string, unknown>;
+        };
+    };
+    /** Codali-specific extras, ignored by a plain OpenAI client. */
+    codali?: {
+        runContext?: RunContext;
+        workspaceRoot?: string;
+        mode?: CodaliRequest["mode"];
+        media?: CodaliRequest["media"];
+        budgets?: CodaliRequest["budgets"];
+    };
+}
+export interface ChatCompletionResponse {
+    id: string;
+    object: "chat.completion";
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: "assistant";
+            content: string;
+        };
+        finish_reason: "stop" | "length" | "content_filter";
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    /**
+     * Codali's provenance, carried alongside the OpenAI shape. A plain client
+     * ignores this; a product that wants citations reads it. Without it the
+     * adapter would throw away the very thing that makes an orchestrated answer
+     * trustworthy.
+     */
+    codali: {
+        status: CodaliResult["status"];
+        sources: CodaliResult["sources"];
+        artifacts: CodaliResult["artifacts"];
+        warnings: string[];
+        traceId: string;
+        output?: unknown;
+    };
+}
+export declare const toCodaliMessages: (messages: readonly ChatCompletionMessage[]) => CodaliMessage[];
+export interface ChatAdapterDependencies {
+    run?: typeof runCodali;
+}
+export declare const handleChatCompletion: (request: ChatCompletionRequest, deps?: ChatAdapterDependencies) => Promise<ChatCompletionResponse>;
+//# sourceMappingURL=ChatCompletionsAdapter.d.ts.map

package/dist/vendor/codali/api/ChatCompletionsAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatCompletionsAdapter.d.ts","sourceRoot":"","sources":["../../src/api/ChatCompletionsAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACtG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEtE;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,qBAAqB,EAAE,CAAC;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;SAAE,CAAA;KAAE,CAAC;IACxF,gEAAgE;IAChE,MAAM,CAAC,EAAE;QACP,UAAU,CAAC,EAAE,UAAU,CAAC;QACxB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QAC7B,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;QAC/B,OAAO,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;KACpC,CAAC;CACH;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,KAAK,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE;YAAE,IAAI,EAAE,WAAW,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC;QAChD,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,gBAAgB,CAAC;KACrD,CAAC,CAAC;IACH,KAAK,CAAC,EAAE;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IACnF;;;;;OAKG;IACH,MAAM,EAAE;QACN,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC/B,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;QACjC,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;QACrC,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,CAAC;CACH;AAID,eAAO,MAAM,gBAAgB,GAC3B,UAAU,SAAS,qBAAqB,EAAE,KACzC,aAAa,EAMT,CAAC;AAWR,MAAM,WAAW,uBAAuB;IACtC,GAAG,CAAC,EAAE,OAAO,SAAS,CAAC;CACxB;AAED,eAAO,MAAM,oBAAoB,GAC/B,SAAS,qBAAqB,EAC9B,OAAM,uBAA4B,KACjC,OAAO,CAAC,sBAAsB,CAsChC,CAAC"}

package/dist/vendor/codali/api/ChatCompletionsAdapter.js

@@ -0,0 +1,54 @@
+import { runCodali } from "./CodaliApi.js";
+const CHAT_ROLES = new Set(["system", "user", "assistant"]);
+export const toCodaliMessages = (messages) => messages
+    .filter((message) => CHAT_ROLES.has(message.role) && typeof message.content === "string")
+    .map((message) => ({
+    role: message.role,
+    content: message.content,
+}));
+const readResponseSchema = (request) => {
+    const format = request.response_format;
+    if (!format)
+        return undefined;
+    if (format.type === "json_schema")
+        return format.json_schema?.schema;
+    return undefined;
+};
+export const handleChatCompletion = async (request, deps = {}) => {
+    const run = deps.run ?? runCodali;
+    const result = await run({
+        messages: toCodaliMessages(request.messages),
+        runContext: request.codali?.runContext,
+        workspaceRoot: request.codali?.workspaceRoot,
+        mode: request.codali?.mode,
+        media: request.codali?.media,
+        budgets: request.codali?.budgets,
+        responseSchema: readResponseSchema(request),
+        responseMode: request.response_format?.type === "json_object" ? "json" : "text",
+        product: { name: "chat-completions" },
+    });
+    return {
+        id: `chatcmpl-${result.traceId}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model: request.model ?? "codali",
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content: result.answer },
+                // A partial or clarification-seeking answer is not a normal stop. A
+                // client that only inspects finish_reason must not mistake it for a
+                // complete response.
+                finish_reason: result.status === "succeeded" ? "stop" : "length",
+            },
+        ],
+        codali: {
+            status: result.status,
+            sources: result.sources,
+            artifacts: result.artifacts,
+            warnings: result.warnings,
+            traceId: result.traceId,
+            output: result.output,
+        },
+    };
+};

package/dist/vendor/codali/api/CodaliApi.d.ts

@@ -0,0 +1,78 @@
+import { attachMcpTools } from "../connectors/mcp/McpToolSource.js";
+import { type ImageGenerationConfig } from "../connectors/media/ImageGenerationTool.js";
+import { createProviderForAssignment } from "../gateway/LocalGatewayProvider.js";
+import { getAgentInventory } from "../agents/AgentInventory.js";
+import { ToolRegistry } from "../tools/ToolRegistry.js";
+import type { RunContext } from "../runcontext/RunContextResolver.js";
+import type { CodaliArtifactRef, CodaliGatewayMode, CodaliGatewaySource, CodaliGatewayStatus } from "../gateway/CodaliGatewayTypes.js";
+/**
+ * The canonical Codali API.
+ *
+ * This is the contract products integrate against — okacam AI chat, line items,
+ * badges, employee daily-log review. One entry point, one result shape, the
+ * same behaviour the CLI gets, so a product never has to reimplement routing,
+ * tool selection, evidence handling, or budget enforcement.
+ *
+ * Everything a run is allowed to touch arrives on the request as `runContext`.
+ * Codali does not call back into the host to fetch tenant configuration: the
+ * authenticated host already holds it, and a callback would make every request
+ * a circular distributed dependency.
+ */
+export interface CodaliMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface CodaliRequest {
+    messages: CodaliMessage[];
+    /** Tenant scope, tools, credentials, agent bindings, limits. */
+    runContext?: RunContext;
+    /** JSON Schema the answer must satisfy. Enforced, with one repair attempt. */
+    responseSchema?: Record<string, unknown>;
+    responseMode?: "text" | "json" | "artifact";
+    mode?: CodaliGatewayMode;
+    /** Workspace the run resolves paths against. Defaults to `process.cwd()`. */
+    workspaceRoot?: string;
+    requestId?: string;
+    product?: {
+        name?: string;
+        version?: string;
+        surface?: string;
+    };
+    /** Image generation config; absent means the media tool is not offered. */
+    media?: ImageGenerationConfig;
+    budgets?: {
+        maxRounds?: number;
+        maxToolCalls?: number;
+        maxModelCalls?: number;
+        deadlineMs?: number;
+    };
+}
+export interface CodaliSourceRef extends CodaliGatewaySource {
+}
+export interface CodaliResult {
+    status: CodaliGatewayStatus;
+    /** Text answer, or the clarifying question when status is needs_clarification. */
+    answer: string;
+    /** Schema-conformant structured output when a responseSchema was supplied. */
+    output: unknown;
+    sources: CodaliSourceRef[];
+    artifacts: CodaliArtifactRef[];
+    warnings: string[];
+    traceId: string;
+}
+/** Flattens a message list into the single query the gateway plans against. */
+export declare const messagesToQuery: (messages: readonly CodaliMessage[]) => string;
+export interface CodaliRunDependencies {
+    loadInventory?: typeof getAgentInventory;
+    resolveRunContext?: (workspaceRoot: string) => Promise<RunContext>;
+    buildRegistry?: (workspaceRoot: string, context: RunContext) => ToolRegistry;
+    createProvider?: typeof createProviderForAssignment;
+    attachMcp?: typeof attachMcpTools;
+}
+/**
+ * Runs one Codali request end to end.
+ *
+ * The same code path the CLI uses, so a product and the terminal cannot drift.
+ */
+export declare const runCodali: (request: CodaliRequest, deps?: CodaliRunDependencies) => Promise<CodaliResult>;
+//# sourceMappingURL=CodaliApi.d.ts.map

package/dist/vendor/codali/api/CodaliApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodaliApi.d.ts","sourceRoot":"","sources":["../../src/api/CodaliApi.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,4CAA4C,CAAC;AAIpD,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAGjF,OAAO,EAAE,iBAAiB,EAAyB,MAAM,6BAA6B,CAAC;AAGvF,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAGxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACtE,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EAEjB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,kCAAkC,CAAC;AAE1C;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,gEAAgE;IAChE,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC;IAC5C,IAAI,CAAC,EAAE,iBAAiB,CAAC;IACzB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChE,2EAA2E;IAC3E,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,MAAM,WAAW,eAAgB,SAAQ,mBAAmB;CAAG;AAE/D,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,kFAAkF;IAClF,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAsBD,+EAA+E;AAC/E,eAAO,MAAM,eAAe,GAAI,UAAU,SAAS,aAAa,EAAE,KAAG,MAWpE,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,aAAa,CAAC,EAAE,OAAO,iBAAiB,CAAC;IACzC,iBAAiB,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACnE,aAAa,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,KAAK,YAAY,CAAC;IAC7E,cAAc,CAAC,EAAE,OAAO,2BAA2B,CAAC;IACpD,SAAS,CAAC,EAAE,OAAO,cAAc,CAAC;CACnC;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,GACpB,SAAS,aAAa,EACtB,OAAM,qBAA0B,KAC/B,OAAO,CAAC,YAAY,CAkOtB,CAAC"}

package/dist/vendor/codali/api/CodaliApi.js

@@ -0,0 +1,273 @@
+import { randomUUID } from "node:crypto";
+import { attachHttpTools } from "../connectors/http/HttpToolSource.js";
+import { attachMcpTools } from "../connectors/mcp/McpToolSource.js";
+import { createImageGenerationTool, } from "../connectors/media/ImageGenerationTool.js";
+import { DocdexClient } from "../docdex/DocdexClient.js";
+import { createCodaliGateway } from "../gateway/CodaliGateway.js";
+import { createLocalGatewayTaskRunner } from "../gateway/LocalGatewayTaskRunner.js";
+import { createProviderForAssignment } from "../gateway/LocalGatewayProvider.js";
+import { gatewayToolDescriptorsFromRegistry } from "../gateway/ToolDescriptorSource.js";
+import { GatewayTracer } from "../gateway/GatewayTracer.js";
+import { getAgentInventory, filterLocallyDrivable } from "../agents/AgentInventory.js";
+import { resolveConfigurableRoles } from "../agents/RoleResolution.js";
+import { providerSupportsToolCalls } from "../providers/ProviderTypes.js";
+import { ToolRegistry } from "../tools/ToolRegistry.js";
+import { createDocdexTools } from "../tools/docdex/DocdexTools.js";
+import { LocalConfigRunContextResolver } from "../runcontext/RunContextResolver.js";
+const DEFAULTS = {
+    maxRounds: 3,
+    maxToolCalls: 20,
+    maxModelCalls: 12,
+    deadlineMs: 600000,
+    maxParallelWorkers: 3,
+};
+const DEFAULT_DOCDEX_TOOLS = [
+    "docdex_search",
+    "docdex_open",
+    "docdex_symbols",
+    "docdex_tree",
+    "docdex_files",
+    "docdex_impact_graph",
+    "docdex_batch_search",
+    "docdex_web_research",
+    "docdex_stats",
+];
+/** Flattens a message list into the single query the gateway plans against. */
+export const messagesToQuery = (messages) => {
+    const lastUser = [...messages].reverse().find((message) => message.role === "user");
+    if (!lastUser)
+        return "";
+    const priorContext = messages
+        .slice(0, messages.indexOf(lastUser))
+        .filter((message) => message.role !== "system")
+        .slice(-4)
+        .map((message) => `${message.role}: ${message.content}`);
+    return priorContext.length > 0
+        ? `${priorContext.join("\n")}\n\nCurrent question: ${lastUser.content}`
+        : lastUser.content;
+};
+/**
+ * Runs one Codali request end to end.
+ *
+ * The same code path the CLI uses, so a product and the terminal cannot drift.
+ */
+export const runCodali = async (request, deps = {}) => {
+    const workspaceRoot = request.workspaceRoot ?? process.cwd();
+    const query = messagesToQuery(request.messages);
+    const tracer = new GatewayTracer(query);
+    if (!query.trim()) {
+        return {
+            status: "failed",
+            answer: "The request contained no user message.",
+            output: undefined,
+            sources: [],
+            artifacts: [],
+            warnings: ["empty_request"],
+            traceId: request.requestId ?? randomUUID(),
+        };
+    }
+    // Host-supplied context wins; otherwise fall back to local trusted config.
+    const context = request.runContext ??
+        (deps.resolveRunContext
+            ? await deps.resolveRunContext(workspaceRoot)
+            : await new LocalConfigRunContextResolver().resolve({ workspaceRoot }));
+    for (const warning of context.warnings ?? [])
+        tracer.addWarning(warning);
+    const inventory = await (deps.loadInventory ?? getAgentInventory)();
+    const drivable = filterLocallyDrivable(inventory.agents);
+    const roles = resolveConfigurableRoles({
+        inventory: drivable,
+        bindings: context.agentRoles,
+        roles: request.media ? ["orchestrator", "synthesizer", "media"] : undefined,
+    });
+    for (const warning of roles.warnings)
+        tracer.addWarning(warning);
+    const orchestrator = roles.assignments.orchestrator;
+    const synthesizer = roles.assignments.synthesizer;
+    if (!orchestrator && !synthesizer) {
+        return {
+            status: "failed",
+            answer: "No usable model agent could be resolved for this run.",
+            output: undefined,
+            sources: [],
+            artifacts: [],
+            warnings: [...tracer.snapshot().warnings, "no_agents_resolved"],
+            traceId: request.requestId ?? randomUUID(),
+        };
+    }
+    const makeProvider = deps.createProvider ?? createProviderForAssignment;
+    const primary = makeProvider((synthesizer ?? orchestrator));
+    const orchestratorProvider = orchestrator ? makeProvider(orchestrator) : undefined;
+    const workerCandidates = [roles.toolCapable, orchestrator, synthesizer].filter(Boolean);
+    let worker = primary;
+    for (const candidate of workerCandidates) {
+        const provider = makeProvider(candidate);
+        if (providerSupportsToolCalls(provider)) {
+            worker = provider;
+            break;
+        }
+    }
+    const toolsExecutable = providerSupportsToolCalls(worker);
+    // ---- Tools ------------------------------------------------------------
+    const registry = deps.buildRegistry?.(workspaceRoot, context) ?? buildDefaultRegistry(workspaceRoot, context);
+    const mcp = await (deps.attachMcp ?? attachMcpTools)({ context, toolRegistry: registry });
+    for (const warning of mcp.warnings)
+        tracer.addWarning(warning);
+    const http = attachHttpTools({ context, toolRegistry: registry });
+    for (const warning of http.warnings)
+        tracer.addWarning(warning);
+    const artifacts = [];
+    const runId = request.requestId ?? `codali-${randomUUID()}`;
+    if (request.media) {
+        registry.register(createImageGenerationTool({
+            config: request.media,
+            workspaceRoot,
+            runId,
+            onArtifact: (artifact) => artifacts.push(artifact),
+        }));
+    }
+    const registered = registry.list().map((tool) => tool.name);
+    const readOnlyMcpTools = registry
+        .catalog(mcp.registered)
+        .filter((descriptor) => descriptor.readOnly)
+        .map((descriptor) => descriptor.name);
+    const defaultAllowed = [
+        ...DEFAULT_DOCDEX_TOOLS,
+        ...readOnlyMcpTools,
+        ...http.registered,
+        ...(request.media ? ["media_generate_image"] : []),
+    ];
+    const allowedTools = toolsExecutable
+        ? (context.allowedTools ?? defaultAllowed).filter((tool) => registered.includes(tool))
+        : [];
+    // Every allowed tool must be declared to the capability compiler, which
+    // otherwise discards it as `not_declared` — including docdex tools outside
+    // its hardcoded backing-tool set, such as `docdex_web_research`. That
+    // omission kept the "web" capability off the classifier's list entirely, so
+    // no question could ever reach the public web.
+    const connectorTools = allowedTools;
+    // ---- Budgets ----------------------------------------------------------
+    const min = (a, b) => (b === undefined ? a : Math.min(a, b));
+    const maxRounds = min(request.budgets?.maxRounds ?? DEFAULTS.maxRounds, context.limits?.maxRounds);
+    const maxToolCalls = min(request.budgets?.maxToolCalls ?? DEFAULTS.maxToolCalls, context.limits?.maxToolCalls);
+    const deadlineMs = min(request.budgets?.deadlineMs ?? DEFAULTS.deadlineMs, context.limits?.deadlineMs);
+    const gatewayRequest = {
+        id: runId,
+        query,
+        mode: request.mode ?? "balanced",
+        product: request.product ?? { name: "codali-api" },
+        tenant: context.tenant,
+        tools: connectorTools.length > 0
+            ? { actualTools: connectorTools, readOnlyTools: connectorTools }
+            : undefined,
+        docdex: {
+            enabled: true,
+            baseUrl: context.docdex?.baseUrl,
+            repoRoot: context.repo?.root ?? workspaceRoot,
+            repoId: context.docdex?.repoId,
+        },
+        policy: {
+            allowedTools,
+            deniedTools: context.deniedTools,
+            maxIterations: maxRounds,
+            maxRuntimeMs: deadlineMs,
+            maxToolCalls,
+            maxModelCalls: request.budgets?.maxModelCalls ?? DEFAULTS.maxModelCalls,
+            maxEvidenceItems: 40,
+            maxImageArtifacts: request.media ? 4 : 0,
+            maxContextPackTokens: 16000,
+            allowWrites: false,
+            allowShell: false,
+            allowDestructiveOperations: false,
+            allowOutsideWorkspace: false,
+            requireFinalLargeModel: false,
+            allowDegradedFinalAnswer: true,
+            allowImageWorker: Boolean(request.media),
+        },
+        response: {
+            format: request.responseSchema ? "json" : (request.responseMode === "json" ? "json" : "text"),
+            schema: request.responseSchema,
+        },
+    };
+    const gateway = createCodaliGateway({
+        provider: primary,
+        // Classify and plan on the orchestrator model; only the final answer pays
+        // for the large one.
+        plannerProvider: orchestratorProvider ?? primary,
+        // So the trace names the model that actually ran.
+        finalAgent: synthesizer ?? orchestrator,
+        agentInventory: drivable,
+        toolDescriptors: gatewayToolDescriptorsFromRegistry(registry, allowedTools),
+        taskRunner: createLocalGatewayTaskRunner({
+            provider: worker,
+            registry,
+            toolContext: {
+                workspaceRoot,
+                allowShell: false,
+                allowDestructiveOperations: false,
+                allowOutsideWorkspace: false,
+            },
+            onEvent: (event) => {
+                if (event.type === "tool_call") {
+                    tracer.recordToolCall({ taskId: event.taskId, tool: event.tool, args: event.args });
+                }
+                else if (event.type === "tool_result") {
+                    tracer.recordToolResult({
+                        taskId: event.taskId,
+                        tool: event.tool,
+                        ok: event.ok,
+                        latencyMs: event.latencyMs,
+                        errorCode: event.errorCode,
+                    });
+                }
+            },
+        }),
+        workerOptions: {
+            maxRuntimeMs: deadlineMs,
+            maxToolCalls,
+            perTaskTimeoutMs: Math.max(60000, Math.floor(deadlineMs / 2)),
+            maxParallelWorkers: DEFAULTS.maxParallelWorkers,
+        },
+    });
+    try {
+        const result = await gateway.run(gatewayRequest);
+        return {
+            status: result.status,
+            answer: result.answer,
+            output: result.output ?? result.answer,
+            sources: result.sources,
+            // Artifacts collected by the media tool are authoritative; the gateway's
+            // own list covers anything a worker persisted directly.
+            artifacts: artifacts.length > 0 ? artifacts : result.artifacts,
+            warnings: [...tracer.snapshot().warnings, ...result.warnings],
+            traceId: result.runId,
+        };
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            answer: `Codali run failed: ${error instanceof Error ? error.message : String(error)}`,
+            output: undefined,
+            sources: [],
+            artifacts,
+            warnings: tracer.snapshot().warnings,
+            traceId: runId,
+        };
+    }
+    finally {
+        await mcp.registry?.close();
+    }
+};
+const buildDefaultRegistry = (workspaceRoot, context) => {
+    const registry = new ToolRegistry();
+    const client = new DocdexClient({
+        baseUrl: context.docdex?.baseUrl ?? "http://127.0.0.1:28491",
+        repoRoot: context.repo?.root ?? workspaceRoot,
+        repoId: context.docdex?.repoId,
+        apiKey: context.docdex?.apiKey,
+        allowedOperations: context.docdex?.allowedOperations,
+    });
+    for (const tool of createDocdexTools(client))
+        registry.register(tool);
+    return registry;
+};