mcoda 0.1.0

package/packages/agents/src/adapters/ollama/OllamaCliRunner.ts

@@ -0,0 +1,70 @@
+import { spawn, spawnSync } from "node:child_process";
+
+export const ollamaHealthy = (throwOnError = false): { ok: boolean; details?: Record<string, unknown> } => {
+  const result = spawnSync("ollama", ["--version"], { encoding: "utf8" });
+  if (result.error || result.status !== 0) {
+    const details = {
+      reason: result.error ? "missing_cli" : "cli_error",
+      exitCode: result.status,
+      stderr: result.stderr?.toString(),
+      error: result.error?.message,
+    };
+    if (throwOnError) {
+      const error = new Error(`AUTH_ERROR: ollama CLI unavailable (${details.reason})`);
+      (error as any).details = details;
+      throw error;
+    }
+    return { ok: false, details };
+  }
+  return { ok: true, details: { version: result.stdout?.toString().trim() } };
+};
+
+export const runOllamaExec = (prompt: string, model?: string): { output: string; raw: string } => {
+  ollamaHealthy(true);
+  const args = ["run", model ?? "llama3"];
+  const result = spawnSync("ollama", args, { input: prompt, encoding: "utf8" });
+  if (result.error || result.status !== 0) {
+    const error = new Error(`AUTH_ERROR: ollama CLI failed (${result.error?.message ?? `exit ${result.status}`})`);
+    (error as any).details = { reason: "cli_error", exitCode: result.status, stderr: result.stderr };
+    throw error;
+  }
+  const stdout = result.stdout?.toString() ?? "";
+  const output = stdout.trim();
+  return { output, raw: stdout };
+};
+
+export async function* runOllamaExecStream(
+  prompt: string,
+  model?: string,
+): AsyncGenerator<{ output: string; raw: string }, void, unknown> {
+  ollamaHealthy(true);
+  const args = ["run", model ?? "llama3"];
+  const child = spawn("ollama", 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<number>((resolve, reject) => {
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => resolve(code ?? 0));
+  });
+
+  const stream = child.stdout;
+  stream?.setEncoding("utf8");
+  for await (const chunk of stream ?? []) {
+    if (!chunk) continue;
+    yield { output: chunk, raw: chunk };
+  }
+
+  const exitCode = await closePromise;
+  if (exitCode !== 0) {
+    const error = new Error(`AUTH_ERROR: ollama CLI failed (exit ${exitCode}): ${stderr || "no output"}`);
+    (error as any).details = { reason: "cli_error", exitCode, stderr };
+    throw error;
+  }
+}

package/packages/agents/src/adapters/ollama/OllamaRemoteAdapter.ts

@@ -0,0 +1,205 @@
+import { AgentHealth } from "@mcoda/shared";
+import { Agent as HttpsAgent } from "node:https";
+import { AdapterConfig, AgentAdapter, InvocationRequest, InvocationResult } from "../AdapterTypes.js";
+
+const normalizeBaseUrl = (value?: unknown): string | undefined => {
+  if (!value) return undefined;
+  const str = String(value).trim();
+  if (!str) return undefined;
+  return str.endsWith("/") ? str.slice(0, -1) : str;
+};
+
+export class OllamaRemoteAdapter implements AgentAdapter {
+  private baseUrl: string | undefined;
+  private headers: Record<string, string> | undefined;
+  private verifyTls: boolean | undefined;
+  private tlsAgent: HttpsAgent | undefined;
+
+  constructor(private config: AdapterConfig & { baseUrl?: string; headers?: Record<string, string>; verifyTls?: boolean }) {
+    this.baseUrl = normalizeBaseUrl((config as any).baseUrl);
+    const headers = (config as any).headers;
+    this.headers = headers && typeof headers === "object" ? headers : undefined;
+    this.verifyTls = typeof (config as any).verifyTls === "boolean" ? Boolean((config as any).verifyTls) : undefined;
+    if (this.verifyTls === false) {
+      this.tlsAgent = new HttpsAgent({ rejectUnauthorized: false });
+    }
+    this.assertConfig();
+  }
+
+  private assertConfig() {
+    if (!this.baseUrl) {
+      throw new Error("Ollama baseUrl is not configured; set config.baseUrl to http://host:11434");
+    }
+    if (!/^https?:\/\//i.test(this.baseUrl)) {
+      throw new Error("Ollama baseUrl must start with http:// or https://");
+    }
+  }
+
+  async getCapabilities(): Promise<string[]> {
+    return this.config.capabilities;
+  }
+
+  async healthCheck(): Promise<AgentHealth> {
+    const url = this.baseUrl;
+    if (!url) {
+      return {
+        agentId: this.config.agent.id,
+        status: "unreachable",
+        lastCheckedAt: new Date().toISOString(),
+        details: { reason: "missing_base_url" },
+      };
+    }
+    const started = Date.now();
+    try {
+      const resp = await fetch(`${url}/api/tags`);
+      const healthy = resp.ok;
+      return {
+        agentId: this.config.agent.id,
+        status: healthy ? "healthy" : "unreachable",
+        lastCheckedAt: new Date().toISOString(),
+        latencyMs: Date.now() - started,
+        details: { adapter: "ollama-remote", baseUrl: url, status: resp.status },
+      };
+    } catch (error) {
+      return {
+        agentId: this.config.agent.id,
+        status: "unreachable",
+        lastCheckedAt: new Date().toISOString(),
+        details: { reason: "connection_error", error: (error as Error).message, baseUrl: url },
+      };
+    }
+  }
+
+  private ensureBaseUrl(): string {
+    return this.baseUrl as string;
+  }
+
+  private ensureModel(): string {
+    const model = this.config.model;
+    if (!model) {
+      throw new Error("Ollama model is not configured for this agent");
+    }
+    return model;
+  }
+
+  private extractMetrics(data: any): Record<string, unknown> | undefined {
+    const metrics: Record<string, unknown> = {};
+    if (typeof data?.prompt_eval_count === "number") metrics.promptEvalCount = data.prompt_eval_count;
+    if (typeof data?.eval_count === "number") metrics.evalCount = data.eval_count;
+    if (typeof data?.total_duration === "number") metrics.totalDurationNs = data.total_duration;
+    if (Object.keys(metrics).length === 0) return undefined;
+    return metrics;
+  }
+
+  async invoke(request: InvocationRequest): Promise<InvocationResult> {
+    const url = this.ensureBaseUrl();
+    const model = this.ensureModel();
+    const init: any = {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...(this.headers ?? {}) },
+      body: JSON.stringify({ model, prompt: request.input, stream: false }),
+    };
+    if (this.tlsAgent) init.agent = this.tlsAgent;
+    const resp = await fetch(`${url}/api/generate`, init);
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`Ollama generate failed (${resp.status}): ${text}`);
+    }
+    const data: any = await resp.json().catch(() => ({}));
+    const metrics = this.extractMetrics(data);
+    const output: string =
+      typeof data?.response === "string"
+        ? data.response
+        : typeof data?.message === "string"
+          ? data.message
+          : JSON.stringify(data);
+    return {
+      output: output.trim(),
+      adapter: this.config.adapter ?? "ollama-remote",
+      model,
+      metadata: {
+        adapterType: this.config.adapter ?? "ollama-remote",
+        baseUrl: url,
+        capabilities: this.config.capabilities,
+        metrics,
+      },
+    };
+  }
+
+  async *invokeStream(request: InvocationRequest): AsyncGenerator<InvocationResult, void, unknown> {
+    const url = this.ensureBaseUrl();
+    const model = this.ensureModel();
+    const init: any = {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...(this.headers ?? {}) },
+      body: JSON.stringify({ model, prompt: request.input, stream: true }),
+    };
+    if (this.tlsAgent) init.agent = this.tlsAgent;
+    const resp = await fetch(`${url}/api/generate`, init);
+    if (!resp.ok || !resp.body) {
+      const text = !resp.ok ? await resp.text().catch(() => "") : "";
+      throw new Error(`Ollama generate (stream) failed (${resp.status}): ${text}`);
+    }
+
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      while (true) {
+        const idx = buffer.indexOf("\n");
+        if (idx === -1) break;
+        const line = buffer.slice(0, idx).trim();
+        buffer = buffer.slice(idx + 1);
+        if (!line) continue;
+        try {
+          const data = JSON.parse(line);
+          const chunk =
+            typeof data?.response === "string"
+              ? data.response
+              : typeof data?.message === "string"
+                ? data.message
+                : "";
+          const metrics = this.extractMetrics(data);
+          if (chunk) {
+            yield {
+              output: chunk,
+              adapter: this.config.adapter ?? "ollama-remote",
+              model,
+              metadata: {
+                adapterType: this.config.adapter ?? "ollama-remote",
+                baseUrl: url,
+                capabilities: this.config.capabilities,
+                streaming: true,
+                metrics,
+                raw: line,
+              },
+            };
+          }
+          if (data?.done) {
+            return;
+          }
+        } catch {
+          // Ignore malformed lines; keep streaming.
+        }
+      }
+    }
+    const tail = buffer.trim();
+    if (tail) {
+      yield {
+        output: tail,
+        adapter: this.config.adapter ?? "ollama-remote",
+        model,
+        metadata: {
+          adapterType: this.config.adapter ?? "ollama-remote",
+          baseUrl: url,
+          capabilities: this.config.capabilities,
+          streaming: true,
+          raw: tail,
+        },
+      };
+    }
+  }
+}

package/packages/agents/src/adapters/openai/OpenAiAdapter.d.ts

@@ -0,0 +1,11 @@
+import { AgentHealth } from "@mcoda/shared";
+import { AdapterConfig, AgentAdapter, InvocationRequest, InvocationResult } from "../AdapterTypes.js";
+export declare class OpenAiAdapter 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=OpenAiAdapter.d.ts.map

package/packages/agents/src/adapters/openai/OpenAiAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAiAdapter.d.ts","sourceRoot":"","sources":["OpenAiAdapter.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;AAEtG,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;IAkBnC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgB5D,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,OAAO,CAAC;CAWjG"}

package/packages/agents/src/adapters/openai/OpenAiAdapter.js

@@ -0,0 +1,51 @@
+export class OpenAiAdapter {
+    constructor(config) {
+        this.config = config;
+    }
+    async getCapabilities() {
+        return this.config.capabilities;
+    }
+    async healthCheck() {
+        if (!this.config.apiKey) {
+            return {
+                agentId: this.config.agent.id,
+                status: "unreachable",
+                lastCheckedAt: new Date().toISOString(),
+                details: { reason: "missing_api_key" },
+            };
+        }
+        return {
+            agentId: this.config.agent.id,
+            status: "healthy",
+            lastCheckedAt: new Date().toISOString(),
+            latencyMs: 0,
+            details: { adapter: "openai-api", model: this.config.model },
+        };
+    }
+    async invoke(request) {
+        const authMode = this.config.apiKey ? "api" : "none";
+        return {
+            output: `openai-stub:${request.input}`,
+            adapter: this.config.adapter ?? "openai-api",
+            model: this.config.model,
+            metadata: {
+                mode: authMode,
+                capabilities: this.config.capabilities,
+                prompts: this.config.prompts,
+                authMode,
+                adapterType: this.config.adapter ?? "openai-api",
+            },
+        };
+    }
+    async *invokeStream(request) {
+        yield {
+            output: `openai-stream:${request.input}`,
+            adapter: this.config.adapter ?? "openai-api",
+            model: this.config.model,
+            metadata: {
+                mode: this.config.apiKey ? "api" : "none",
+                streaming: true,
+            },
+        };
+    }
+}

package/packages/agents/src/adapters/openai/OpenAiAdapter.ts

@@ -0,0 +1,56 @@
+import { AgentHealth } from "@mcoda/shared";
+import { AdapterConfig, AgentAdapter, InvocationRequest, InvocationResult } from "../AdapterTypes.js";
+
+export class OpenAiAdapter implements AgentAdapter {
+  constructor(private config: AdapterConfig) {}
+
+  async getCapabilities(): Promise<string[]> {
+    return this.config.capabilities;
+  }
+
+  async healthCheck(): Promise<AgentHealth> {
+    if (!this.config.apiKey) {
+      return {
+        agentId: this.config.agent.id,
+        status: "unreachable",
+        lastCheckedAt: new Date().toISOString(),
+        details: { reason: "missing_api_key" },
+      };
+    }
+    return {
+      agentId: this.config.agent.id,
+      status: "healthy",
+      lastCheckedAt: new Date().toISOString(),
+      latencyMs: 0,
+      details: { adapter: "openai-api", model: this.config.model },
+    };
+  }
+
+  async invoke(request: InvocationRequest): Promise<InvocationResult> {
+    const authMode = this.config.apiKey ? "api" : "none";
+    return {
+      output: `openai-stub:${request.input}`,
+      adapter: this.config.adapter ?? "openai-api",
+      model: this.config.model,
+      metadata: {
+        mode: authMode,
+        capabilities: this.config.capabilities,
+        prompts: this.config.prompts,
+        authMode,
+        adapterType: this.config.adapter ?? "openai-api",
+      },
+    };
+  }
+
+  async *invokeStream(request: InvocationRequest): AsyncGenerator<InvocationResult, void, unknown> {
+    yield {
+      output: `openai-stream:${request.input}`,
+      adapter: this.config.adapter ?? "openai-api",
+      model: this.config.model,
+      metadata: {
+        mode: this.config.apiKey ? "api" : "none",
+        streaming: true,
+      },
+    };
+  }
+}

package/packages/agents/src/adapters/openai/OpenAiCliAdapter.ts

@@ -0,0 +1,62 @@
+import { AgentHealth } from "@mcoda/shared";
+import { AdapterConfig, AgentAdapter, InvocationRequest, InvocationResult } from "../AdapterTypes.js";
+import { cliHealthy as codexCliHealthy, runCodexExec, runCodexExecStream } from "../codex/CodexCliRunner.js";
+
+export class OpenAiCliAdapter implements AgentAdapter {
+  constructor(private config: AdapterConfig) {}
+
+  async getCapabilities(): Promise<string[]> {
+    return this.config.capabilities;
+  }
+
+  async healthCheck(): Promise<AgentHealth> {
+    const started = Date.now();
+    const result = codexCliHealthy();
+    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: InvocationRequest): Promise<InvocationResult> {
+    const cliDetails = codexCliHealthy(true);
+    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,
+        prompts: this.config.prompts,
+        adapterType: this.config.adapter ?? "codex-cli",
+        cli: cliDetails.details,
+        raw: result.raw,
+      },
+    };
+  }
+
+  async *invokeStream(request: InvocationRequest): AsyncGenerator<InvocationResult, void, unknown> {
+    const health = codexCliHealthy(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,
+          prompts: this.config.prompts,
+          adapterType: this.config.adapter ?? "codex-cli",
+          cli: cliDetails,
+          raw: chunk.raw,
+          streaming: true,
+        },
+      };
+    }
+  }
+}

package/packages/agents/src/adapters/qa/QaAdapter.d.ts

@@ -0,0 +1,11 @@
+import { AgentHealth } from "@mcoda/shared";
+import { AdapterConfig, AgentAdapter, InvocationRequest, InvocationResult } from "../AdapterTypes.js";
+export declare class QaAdapter 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=QaAdapter.d.ts.map

package/packages/agents/src/adapters/qa/QaAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QaAdapter.d.ts","sourceRoot":"","sources":["QaAdapter.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;AAEtG,qBAAa,SAAU,YAAW,YAAY;IAChC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEnC,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAIpC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IASnC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAc5D,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,OAAO,CAAC;CAQjG"}

package/packages/agents/src/adapters/qa/QaAdapter.js

@@ -0,0 +1,37 @@
+export class QaAdapter {
+    constructor(config) {
+        this.config = config;
+    }
+    async getCapabilities() {
+        return this.config.capabilities;
+    }
+    async healthCheck() {
+        return {
+            agentId: this.config.agent.id,
+            status: "healthy",
+            lastCheckedAt: new Date().toISOString(),
+            details: { adapter: "qa-cli" },
+        };
+    }
+    async invoke(request) {
+        return {
+            output: `qa-stub:${request.input}`,
+            adapter: this.config.adapter ?? "qa-cli",
+            model: this.config.model,
+            metadata: {
+                mode: "cli",
+                capabilities: this.config.capabilities,
+                adapterType: this.config.adapter ?? "qa-cli",
+                authMode: "cli",
+            },
+        };
+    }
+    async *invokeStream(request) {
+        yield {
+            output: `qa-stream:${request.input}`,
+            adapter: this.config.adapter ?? "qa-cli",
+            model: this.config.model,
+            metadata: { mode: "cli", streaming: true },
+        };
+    }
+}

package/packages/agents/src/adapters/qa/QaAdapter.ts

@@ -0,0 +1,42 @@
+import { AgentHealth } from "@mcoda/shared";
+import { AdapterConfig, AgentAdapter, InvocationRequest, InvocationResult } from "../AdapterTypes.js";
+
+export class QaAdapter implements AgentAdapter {
+  constructor(private config: AdapterConfig) {}
+
+  async getCapabilities(): Promise<string[]> {
+    return this.config.capabilities;
+  }
+
+  async healthCheck(): Promise<AgentHealth> {
+    return {
+      agentId: this.config.agent.id,
+      status: "healthy",
+      lastCheckedAt: new Date().toISOString(),
+      details: { adapter: "qa-cli" },
+    };
+  }
+
+  async invoke(request: InvocationRequest): Promise<InvocationResult> {
+    return {
+      output: `qa-stub:${request.input}`,
+      adapter: this.config.adapter ?? "qa-cli",
+      model: this.config.model,
+      metadata: {
+        mode: "cli",
+        capabilities: this.config.capabilities,
+        adapterType: this.config.adapter ?? "qa-cli",
+        authMode: "cli",
+      },
+    };
+  }
+
+  async *invokeStream(request: InvocationRequest): AsyncGenerator<InvocationResult, void, unknown> {
+    yield {
+      output: `qa-stream:${request.input}`,
+      adapter: this.config.adapter ?? "qa-cli",
+      model: this.config.model,
+      metadata: { mode: "cli", streaming: true },
+    };
+  }
+}