@mcoda/agents 0.1.4

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## Unreleased
+- Initial public packaging for @mcoda/agents.
+
+## 0.1.4
+- Initial release.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 bekir dag
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @mcoda/agents
+
+Agent registry and capability definitions for mcoda.
+
+## Usage
+This package is primarily an internal dependency of `mcoda`.
+
+## License
+MIT - see `LICENSE`.

package/dist/AgentService/AgentService.d.ts

@@ -0,0 +1,22 @@
+import { Agent, AgentAuthMetadata, AgentHealth, AgentPromptManifest } from "@mcoda/shared";
+import { GlobalRepository } from "@mcoda/db";
+import { AgentAdapter, InvocationRequest, InvocationResult } from "../adapters/AdapterTypes.js";
+export declare class AgentService {
+    private repo;
+    constructor(repo: GlobalRepository);
+    static create(): Promise<AgentService>;
+    close(): Promise<void>;
+    resolveAgent(identifier: string): Promise<Agent>;
+    getPrompts(agentId: string): Promise<AgentPromptManifest | undefined>;
+    getCapabilities(agentId: string): Promise<string[]>;
+    getAuthMetadata(agentId: string): Promise<AgentAuthMetadata>;
+    private getDecryptedSecret;
+    private buildAdapterConfig;
+    private resolveAdapterType;
+    getAdapter(agent: Agent): Promise<AgentAdapter>;
+    healthCheck(agentId: string): Promise<AgentHealth>;
+    invoke(agentId: string, request: InvocationRequest): Promise<InvocationResult>;
+    invokeStream(agentId: string, request: InvocationRequest): Promise<AsyncGenerator<InvocationResult>>;
+    private applyGatewayHandoff;
+}
+//# sourceMappingURL=AgentService.d.ts.map

package/dist/AgentService/AgentService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentService.d.ts","sourceRoot":"","sources":["../../src/AgentService/AgentService.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzG,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAU7C,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAoFhG,qBAAa,YAAY;IACX,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,gBAAgB;WAE7B,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;IAKtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAUhD,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IAIrE,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAInD,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;YAIpD,kBAAkB;YAMlB,kBAAkB;IA6BhC,OAAO,CAAC,kBAAkB;IA+BpB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC;IAsC/C,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAmBlD,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmB9E,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC;YA0B5F,mBAAmB;CASlC"}

package/dist/AgentService/AgentService.js

@@ -0,0 +1,291 @@
+import { promises as fs } from "node:fs";
+import { CryptoHelper } from "@mcoda/shared";
+import { GlobalRepository } from "@mcoda/db";
+import { CodexAdapter } from "../adapters/codex/CodexAdapter.js";
+import { GeminiAdapter } from "../adapters/gemini/GeminiAdapter.js";
+import { LocalAdapter } from "../adapters/local/LocalAdapter.js";
+import { OllamaRemoteAdapter } from "../adapters/ollama/OllamaRemoteAdapter.js";
+import { OllamaCliAdapter } from "../adapters/ollama/OllamaCliAdapter.js";
+import { OpenAiAdapter } from "../adapters/openai/OpenAiAdapter.js";
+import { OpenAiCliAdapter } from "../adapters/openai/OpenAiCliAdapter.js";
+import { ZhipuApiAdapter } from "../adapters/zhipu/ZhipuApiAdapter.js";
+import { QaAdapter } from "../adapters/qa/QaAdapter.js";
+const CLI_BASED_ADAPTERS = new Set(["codex-cli", "gemini-cli", "openai-cli", "ollama-cli"]);
+const LOCAL_ADAPTERS = new Set(["local-model"]);
+const SUPPORTED_ADAPTERS = new Set([
+    "openai-api",
+    "codex-cli",
+    "gemini-cli",
+    "openai-cli",
+    "zhipu-api",
+    "local-model",
+    "qa-cli",
+    "ollama-remote",
+    "ollama-cli",
+]);
+const DEFAULT_JOB_PROMPT = "You are an mcoda agent that follows workspace runbooks and responds with actionable, concise output.";
+const DEFAULT_CHARACTER_PROMPT = "Write clearly, avoid hallucinations, cite assumptions, and prioritize risk mitigation for the user.";
+const HANDOFF_ENV_INLINE = "MCODA_GATEWAY_HANDOFF";
+const HANDOFF_ENV_PATH = "MCODA_GATEWAY_HANDOFF_PATH";
+const HANDOFF_HEADER = "[Gateway handoff]";
+const MAX_HANDOFF_CHARS = 8000;
+const IO_ENV = "MCODA_STREAM_IO";
+const IO_PROMPT_ENV = "MCODA_STREAM_IO_PROMPT";
+const IO_PREFIX = "[agent-io]";
+const isIoEnabled = () => {
+    const raw = process.env[IO_ENV];
+    if (!raw)
+        return false;
+    const normalized = raw.trim().toLowerCase();
+    return !["0", "false", "off", "no"].includes(normalized);
+};
+const isIoPromptEnabled = () => {
+    const raw = process.env[IO_PROMPT_ENV];
+    if (!raw)
+        return true;
+    const normalized = raw.trim().toLowerCase();
+    return !["0", "false", "off", "no"].includes(normalized);
+};
+const emitIoLine = (line) => {
+    const normalized = line.endsWith("\n") ? line : `${line}\n`;
+    process.stderr.write(normalized);
+};
+const renderIoHeader = (agent, request, mode) => {
+    emitIoLine(`${IO_PREFIX} begin agent=${agent.slug ?? agent.id} adapter=${agent.adapter} model=${agent.defaultModel ?? "default"} mode=${mode}`);
+    const command = request.metadata?.command ? ` command=${String(request.metadata.command)}` : "";
+    if (command)
+        emitIoLine(`${IO_PREFIX} meta${command}`);
+    if (isIoPromptEnabled()) {
+        emitIoLine(`${IO_PREFIX} input`);
+        emitIoLine(request.input ?? "");
+    }
+};
+const renderIoChunk = (chunk) => {
+    if (chunk.output) {
+        emitIoLine(`${IO_PREFIX} output ${chunk.output}`);
+    }
+};
+const renderIoEnd = () => {
+    emitIoLine(`${IO_PREFIX} end`);
+};
+const readGatewayHandoff = async () => {
+    const inline = process.env[HANDOFF_ENV_INLINE];
+    if (inline && inline.trim()) {
+        return inline.trim().slice(0, MAX_HANDOFF_CHARS);
+    }
+    const filePath = process.env[HANDOFF_ENV_PATH];
+    if (!filePath)
+        return undefined;
+    try {
+        const content = await fs.readFile(filePath, "utf8");
+        const trimmed = content.trim();
+        if (!trimmed)
+            return undefined;
+        return trimmed.slice(0, MAX_HANDOFF_CHARS);
+    }
+    catch {
+        return undefined;
+    }
+};
+export class AgentService {
+    constructor(repo) {
+        this.repo = repo;
+    }
+    static async create() {
+        const repo = await GlobalRepository.create();
+        return new AgentService(repo);
+    }
+    async close() {
+        await this.repo.close();
+    }
+    async resolveAgent(identifier) {
+        const byId = await this.repo.getAgentById(identifier);
+        if (byId)
+            return byId;
+        const bySlug = await this.repo.getAgentBySlug(identifier);
+        if (!bySlug) {
+            throw new Error(`Agent ${identifier} not found`);
+        }
+        return bySlug;
+    }
+    async getPrompts(agentId) {
+        return this.repo.getAgentPrompts(agentId);
+    }
+    async getCapabilities(agentId) {
+        return this.repo.getAgentCapabilities(agentId);
+    }
+    async getAuthMetadata(agentId) {
+        return this.repo.getAgentAuthMetadata(agentId);
+    }
+    async getDecryptedSecret(agentId) {
+        const secret = await this.repo.getAgentAuthSecret(agentId);
+        if (!secret?.encryptedSecret)
+            return undefined;
+        return CryptoHelper.decryptSecret(secret.encryptedSecret);
+    }
+    async buildAdapterConfig(agent) {
+        const [capabilities, prompts, authMetadata] = await Promise.all([
+            this.getCapabilities(agent.id),
+            this.getPrompts(agent.id),
+            this.getAuthMetadata(agent.id),
+        ]);
+        const secret = await this.getDecryptedSecret(agent.id);
+        const adapterConfig = (agent.config ?? {});
+        const mergedPrompts = {
+            agentId: agent.id,
+            jobPrompt: prompts?.jobPrompt ?? DEFAULT_JOB_PROMPT,
+            characterPrompt: prompts?.characterPrompt ?? DEFAULT_CHARACTER_PROMPT,
+            commandPrompts: prompts?.commandPrompts,
+            jobPath: prompts?.jobPath,
+            characterPath: prompts?.characterPath,
+        };
+        return {
+            ...adapterConfig,
+            agent,
+            capabilities,
+            model: agent.defaultModel,
+            apiKey: secret,
+            prompts: mergedPrompts,
+            authMetadata,
+        };
+    }
+    resolveAdapterType(agent, apiKey) {
+        const hasSecret = Boolean(apiKey);
+        const config = agent.config;
+        const cliAdapter = config?.cliAdapter;
+        const localAdapter = config?.localAdapter;
+        let adapterType = agent.adapter;
+        if (!SUPPORTED_ADAPTERS.has(adapterType)) {
+            throw new Error(`Unsupported adapter type: ${adapterType}`);
+        }
+        if (adapterType.endsWith("-api")) {
+            if (hasSecret)
+                return adapterType;
+            if (adapterType === "codex-api" || adapterType === "openai-api") {
+                // Default to the codex CLI when API creds are missing.
+                adapterType = "codex-cli";
+            }
+            else if (adapterType === "gemini-api") {
+                adapterType = "gemini-cli";
+            }
+            else if (cliAdapter && CLI_BASED_ADAPTERS.has(cliAdapter)) {
+                adapterType = cliAdapter;
+            }
+            else if (localAdapter) {
+                throw new Error(`AUTH_REQUIRED: API credentials missing for adapter ${adapterType}; configure cliAdapter (${localAdapter}) or provide credentials.`);
+            }
+            else {
+                throw new Error(`AUTH_REQUIRED: API credentials missing for adapter ${adapterType}`);
+            }
+        }
+        return adapterType;
+    }
+    async getAdapter(agent) {
+        const config = await this.buildAdapterConfig(agent);
+        const adapterType = this.resolveAdapterType(agent, config.apiKey);
+        const configWithAdapter = { ...config, adapter: adapterType };
+        if (adapterType === "openai-api") {
+            return new OpenAiAdapter(configWithAdapter);
+        }
+        if (adapterType === "zhipu-api") {
+            return new ZhipuApiAdapter(configWithAdapter);
+        }
+        if (adapterType === "codex-cli") {
+            return new CodexAdapter(configWithAdapter);
+        }
+        if (adapterType === "gemini-cli") {
+            return new GeminiAdapter(configWithAdapter);
+        }
+        if (adapterType === "openai-cli") {
+            return new OpenAiCliAdapter(configWithAdapter);
+        }
+        if (adapterType === "local-model" || LOCAL_ADAPTERS.has(adapterType)) {
+            return new LocalAdapter(configWithAdapter);
+        }
+        if (adapterType === "ollama-remote") {
+            return new OllamaRemoteAdapter(configWithAdapter);
+        }
+        if (adapterType === "ollama-cli") {
+            return new OllamaCliAdapter(configWithAdapter);
+        }
+        if (adapterType === "gemini-cli") {
+            return new GeminiAdapter(configWithAdapter);
+        }
+        if (adapterType === "qa-cli") {
+            return new QaAdapter(configWithAdapter);
+        }
+        throw new Error(`Unsupported adapter type: ${adapterType}`);
+    }
+    async healthCheck(agentId) {
+        const agent = await this.resolveAgent(agentId);
+        try {
+            const adapter = await this.getAdapter(agent);
+            const result = await adapter.healthCheck();
+            await this.repo.setAgentHealth(result);
+            return result;
+        }
+        catch (error) {
+            const failure = {
+                agentId: agent.id,
+                status: "unreachable",
+                lastCheckedAt: new Date().toISOString(),
+                details: { error: error.message },
+            };
+            await this.repo.setAgentHealth(failure);
+            return failure;
+        }
+    }
+    async invoke(agentId, request) {
+        const agent = await this.resolveAgent(agentId);
+        const adapter = await this.getAdapter(agent);
+        if (!adapter.invoke) {
+            throw new Error("Adapter does not support invoke");
+        }
+        const enriched = await this.applyGatewayHandoff(request);
+        const ioEnabled = isIoEnabled();
+        if (ioEnabled) {
+            renderIoHeader(agent, enriched, "invoke");
+        }
+        const result = await adapter.invoke(enriched);
+        if (ioEnabled) {
+            renderIoChunk(result);
+            renderIoEnd();
+        }
+        return result;
+    }
+    async invokeStream(agentId, request) {
+        const agent = await this.resolveAgent(agentId);
+        const adapter = await this.getAdapter(agent);
+        if (!adapter.invokeStream) {
+            throw new Error("Adapter does not support streaming");
+        }
+        const enriched = await this.applyGatewayHandoff(request);
+        const ioEnabled = isIoEnabled();
+        const generator = await adapter.invokeStream(enriched);
+        async function* wrap() {
+            if (ioEnabled) {
+                renderIoHeader(agent, enriched, "stream");
+            }
+            for await (const chunk of generator) {
+                if (ioEnabled) {
+                    renderIoChunk(chunk);
+                }
+                yield chunk;
+            }
+            if (ioEnabled) {
+                renderIoEnd();
+            }
+        }
+        return wrap();
+    }
+    async applyGatewayHandoff(request) {
+        if (request.metadata?.command === "gateway-agent") {
+            return request;
+        }
+        const handoff = await readGatewayHandoff();
+        if (!handoff)
+            return request;
+        const suffix = `\n\n${HANDOFF_HEADER}\n${handoff}`;
+        return { ...request, input: `${request.input ?? ""}${suffix}` };
+    }
+}

package/dist/adapters/AdapterTypes.d.ts

@@ -0,0 +1,29 @@
+import { Agent, AgentAuthMetadata, AgentHealth, AgentPromptManifest } from "@mcoda/shared";
+export interface AdapterConfig {
+    agent: Agent;
+    capabilities: string[];
+    model?: string;
+    apiKey?: string;
+    prompts?: AgentPromptManifest;
+    authMetadata?: AgentAuthMetadata;
+    adapter?: string;
+}
+export interface AgentAdapter {
+    getCapabilities(): Promise<string[]>;
+    healthCheck(): Promise<AgentHealth>;
+    invoke?(request: InvocationRequest): Promise<InvocationResult>;
+    invokeStream?(_input: InvocationRequest): AsyncGenerator<InvocationResult, void, unknown>;
+}
+export interface InvocationRequest {
+    input: string;
+    adapterType?: string;
+    authMode?: "api" | "cli" | "local" | "none";
+    metadata?: Record<string, unknown>;
+}
+export interface InvocationResult {
+    output: string;
+    adapter: string;
+    model?: string;
+    metadata?: Record<string, unknown>;
+}
+//# sourceMappingURL=AdapterTypes.d.ts.map

package/dist/adapters/AdapterTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdapterTypes.d.ts","sourceRoot":"","sources":["../../src/adapters/AdapterTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAE3F,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACrC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;IACpC,MAAM,CAAC,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC/D,YAAY,CAAC,CAAC,MAAM,EAAE,iBAAiB,GAAG,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;CAC3F;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,CAAC;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC"}

package/dist/adapters/AdapterTypes.js

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

package/dist/adapters/codex/CodexAdapter.d.ts

@@ -0,0 +1,11 @@
+import { AgentHealth } from "@mcoda/shared";
+import { AdapterConfig, AgentAdapter, InvocationRequest, InvocationResult } from "../AdapterTypes.js";
+export declare class CodexAdapter implements AgentAdapter {
+    private config;
+    constructor(config: AdapterConfig);
+    getCapabilities(): Promise<string[]>;
+    healthCheck(): Promise<AgentHealth>;
+    invoke(request: InvocationRequest): Promise<InvocationResult>;
+    invokeStream(request: InvocationRequest): AsyncGenerator<InvocationResult, void, unknown>;
+}
+//# sourceMappingURL=CodexAdapter.d.ts.map

package/dist/adapters/codex/CodexAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodexAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/codex/CodexAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtG,qBAAa,YAAa,YAAW,YAAY;IACnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEnC,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAIpC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAYnC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmB5D,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,OAAO,CAAC;CAoBjG"}

package/dist/adapters/codex/CodexAdapter.js

@@ -0,0 +1,58 @@
+import { cliHealthy, runCodexExec, runCodexExecStream } from "./CodexCliRunner.js";
+export class CodexAdapter {
+    constructor(config) {
+        this.config = config;
+    }
+    async getCapabilities() {
+        return this.config.capabilities;
+    }
+    async healthCheck() {
+        const started = Date.now();
+        const result = cliHealthy();
+        return {
+            agentId: this.config.agent.id,
+            status: result.ok ? "healthy" : "unreachable",
+            lastCheckedAt: new Date().toISOString(),
+            latencyMs: Date.now() - started,
+            details: { adapter: "codex-cli", ...result.details },
+        };
+    }
+    async invoke(request) {
+        const health = cliHealthy(true);
+        const cliDetails = health.details;
+        const result = runCodexExec(request.input, this.config.model);
+        return {
+            output: result.output,
+            adapter: this.config.adapter ?? "codex-cli",
+            model: this.config.model,
+            metadata: {
+                mode: "cli",
+                capabilities: this.config.capabilities,
+                adapterType: this.config.adapter ?? "codex-cli",
+                authMode: "cli",
+                cli: cliDetails,
+                raw: result.raw,
+            },
+        };
+    }
+    async *invokeStream(request) {
+        const health = cliHealthy(true);
+        const cliDetails = health.details;
+        for await (const chunk of runCodexExecStream(request.input, this.config.model)) {
+            yield {
+                output: chunk.output,
+                adapter: this.config.adapter ?? "codex-cli",
+                model: this.config.model,
+                metadata: {
+                    mode: "cli",
+                    capabilities: this.config.capabilities,
+                    adapterType: this.config.adapter ?? "codex-cli",
+                    authMode: "cli",
+                    cli: cliDetails,
+                    raw: chunk.raw,
+                    streaming: true,
+                },
+            };
+        }
+    }
+}

package/dist/adapters/codex/CodexCliRunner.d.ts

@@ -0,0 +1,13 @@
+export declare const cliHealthy: (throwOnError?: boolean) => {
+    ok: boolean;
+    details?: Record<string, unknown>;
+};
+export declare const runCodexExec: (prompt: string, model?: string) => {
+    output: string;
+    raw: string;
+};
+export declare function runCodexExecStream(prompt: string, model?: string): AsyncGenerator<{
+    output: string;
+    raw: string;
+}, void, unknown>;
+//# sourceMappingURL=CodexCliRunner.d.ts.map

package/dist/adapters/codex/CodexCliRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodexCliRunner.d.ts","sourceRoot":"","sources":["../../../src/adapters/codex/CodexCliRunner.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,GAAI,sBAAoB,KAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CA2BjG,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,EAAE,QAAQ,MAAM,KAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAyC1F,CAAC;AAEF,wBAAuB,kBAAkB,CACvC,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM,GACb,cAAc,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CA0EhE"}

package/dist/adapters/codex/CodexCliRunner.js

@@ -0,0 +1,143 @@
+import { spawn, spawnSync } from "node:child_process";
+const CODEX_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+export const cliHealthy = (throwOnError = false) => {
+    if (process.env.MCODA_CLI_STUB === "1") {
+        return { ok: true, details: { stub: true } };
+    }
+    if (process.env.MCODA_SKIP_CLI_CHECKS === "1") {
+        return { ok: true, details: { skipped: true } };
+    }
+    const result = spawnSync("codex", ["--version"], { encoding: "utf8", maxBuffer: CODEX_MAX_BUFFER_BYTES });
+    if (result.error) {
+        const details = { reason: "missing_cli", error: result.error.message };
+        if (throwOnError) {
+            const error = new Error(`AUTH_ERROR: codex CLI unavailable (${details.reason})`);
+            error.details = details;
+            throw error;
+        }
+        return { ok: false, details };
+    }
+    if (result.status !== 0) {
+        const details = { reason: "cli_error", exitCode: result.status, stderr: result.stderr?.toString() };
+        if (throwOnError) {
+            const error = new Error(`AUTH_ERROR: codex CLI unavailable (${details.reason})`);
+            error.details = details;
+            throw error;
+        }
+        return { ok: false, details };
+    }
+    return { ok: true, details: { version: result.stdout?.toString().trim() } };
+};
+export const runCodexExec = (prompt, model) => {
+    if (process.env.MCODA_CLI_STUB === "1") {
+        const output = `qa-stub:${prompt}`;
+        const raw = JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: output } });
+        return { output, raw };
+    }
+    const health = cliHealthy(true);
+    const args = ["exec", "--model", model ?? "gpt-5.1-codex-max", "--full-auto", "--json"];
+    const result = spawnSync("codex", args, {
+        input: prompt,
+        encoding: "utf8",
+        maxBuffer: CODEX_MAX_BUFFER_BYTES,
+    });
+    if (result.error) {
+        const error = new Error(`AUTH_ERROR: codex CLI failed (${result.error.message})`);
+        error.details = { reason: "cli_error", cli: health.details };
+        throw error;
+    }
+    if (result.status !== 0) {
+        const error = new Error(`AUTH_ERROR: codex CLI failed (exit ${result.status}): ${result.stderr ?? result.stdout ?? ""}`);
+        error.details = { reason: "cli_error", exitCode: result.status, stderr: result.stderr };
+        throw error;
+    }
+    const raw = result.stdout?.toString() ?? "";
+    const lines = raw.split(/\r?\n/).filter((l) => l.trim().length > 0);
+    let message;
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed?.type === "item.completed" && parsed?.item?.type === "agent_message" && typeof parsed?.item?.text === "string") {
+                message = parsed.item.text;
+            }
+        }
+        catch {
+            /* ignore parse errors */
+        }
+    }
+    if (!message) {
+        message = lines[lines.length - 1] ?? "";
+    }
+    return { output: message.trim(), raw };
+};
+export async function* runCodexExecStream(prompt, model) {
+    if (process.env.MCODA_CLI_STUB === "1") {
+        const output = `qa-stub:${prompt}\n`;
+        const raw = JSON.stringify({ type: "item.delta", item: { type: "agent_message", text: output } });
+        yield { output, raw };
+        return;
+    }
+    cliHealthy(true);
+    const args = ["exec", "--model", model ?? "gpt-5.1-codex-max", "--full-auto", "--json"];
+    const child = spawn("codex", args, { stdio: ["pipe", "pipe", "pipe"] });
+    child.stdin.write(prompt);
+    child.stdin.end();
+    let stderr = "";
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    const closePromise = new Promise((resolve, reject) => {
+        child.on("error", (err) => reject(err));
+        child.on("close", (code) => resolve(code ?? 0));
+    });
+    const parseLine = (line) => {
+        try {
+            const parsed = JSON.parse(line);
+            const item = parsed?.item;
+            if (item?.type === "agent_message" && typeof item.text === "string") {
+                return item.text;
+            }
+            // The codex CLI emits many JSONL event types (thread/turn/task/tool events).
+            // We only want the agent's textual output here.
+            return null;
+        }
+        catch {
+            // `codex exec --json` is expected to emit JSONL, but it can still print non-JSON
+            // preamble lines (e.g., "Reading prompt from stdin..."). Treat those as noise.
+            return null;
+        }
+    };
+    const normalizeOutput = (value) => (value.endsWith("\n") ? value : `${value}\n`);
+    const stream = child.stdout;
+    stream?.setEncoding("utf8");
+    let buffer = "";
+    for await (const chunk of stream ?? []) {
+        buffer += chunk;
+        let idx;
+        while ((idx = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, idx);
+            buffer = buffer.slice(idx + 1);
+            const normalized = line.replace(/\r$/, "");
+            const parsed = parseLine(normalized);
+            if (!parsed)
+                continue;
+            const output = normalizeOutput(parsed);
+            yield { output, raw: normalized };
+        }
+    }
+    const trailing = buffer.replace(/\r$/, "");
+    if (trailing) {
+        const parsed = parseLine(trailing);
+        if (parsed) {
+            const output = normalizeOutput(parsed);
+            yield { output, raw: trailing };
+        }
+    }
+    const exitCode = await closePromise;
+    if (exitCode !== 0) {
+        const error = new Error(`AUTH_ERROR: codex CLI failed (exit ${exitCode}): ${stderr || "no output"}`);
+        error.details = { reason: "cli_error", exitCode, stderr };
+        throw error;
+    }
+}

package/dist/adapters/gemini/GeminiAdapter.d.ts

@@ -0,0 +1,11 @@
+import { AgentHealth } from "@mcoda/shared";
+import { AdapterConfig, AgentAdapter, InvocationRequest, InvocationResult } from "../AdapterTypes.js";
+export declare class GeminiAdapter implements AgentAdapter {
+    private config;
+    constructor(config: AdapterConfig);
+    getCapabilities(): Promise<string[]>;
+    healthCheck(): Promise<AgentHealth>;
+    invoke(request: InvocationRequest): Promise<InvocationResult>;
+    invokeStream(request: InvocationRequest): AsyncGenerator<InvocationResult, void, unknown>;
+}
+//# sourceMappingURL=GeminiAdapter.d.ts.map

package/dist/adapters/gemini/GeminiAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeminiAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/gemini/GeminiAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtG,qBAAa,aAAc,YAAW,YAAY;IACpC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEnC,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAIpC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAYnC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAkB5D,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,OAAO,CAAC;CAgBjG"}