indusagi-coding-agent 0.2.5 → 0.2.9

package/src/runtime-bridge/bridges/builtins.ts

@@ -0,0 +1,68 @@
+/**
+ * Built-in external-runtime catalog — the shipped {@link ExternalRuntimeSpec}
+ * entries and the helper that *annotates* a model with one.
+ */
+import type { Api, Model } from "indusagi/ai";
+import type { CatalogCard } from "../../conductor/catalog/index.js";
+import {
+  RUNTIME_ENDPOINT_SCHEME,
+  type ExternalRuntimeSpec,
+  type RuntimeAdapterId,
+} from "../contract.js";
+
+export const BUILTIN_RUNTIME_SPECS: Readonly<Record<RuntimeAdapterId, ExternalRuntimeSpec>> = {
+  "claude-cli": {
+    adapter: "claude-cli",
+    authMode: "external-cli",
+    binaryPath: "claude",
+    args: ["--output-format", "stream-json", "--verbose"],
+  },
+  "codex-cli": {
+    adapter: "codex-cli",
+    authMode: "external-cli",
+    binaryPath: "codex",
+    args: ["--json"],
+  },
+  "indusagi-cli": {
+    adapter: "indusagi-cli",
+    authMode: "external-cli",
+    binaryPath: "indusagi",
+    args: ["--rpc"],
+  },
+};
+
+export const BUILTIN_ADAPTERS: readonly RuntimeAdapterId[] = [
+  "claude-cli",
+  "codex-cli",
+  "indusagi-cli",
+];
+
+export function builtinRuntimeSpec(adapter: RuntimeAdapterId): ExternalRuntimeSpec | undefined {
+  return BUILTIN_RUNTIME_SPECS[adapter];
+}
+
+export interface RuntimeAnnotatedModel {
+  readonly model: Model<Api>;
+  readonly spec: ExternalRuntimeSpec;
+}
+
+export function withRuntimeEndpoint(model: Model<Api>, spec: ExternalRuntimeSpec): Model<Api> {
+  return { ...model, baseUrl: `${RUNTIME_ENDPOINT_SCHEME}${spec.adapter}` };
+}
+
+export function annotateCard(
+  card: CatalogCard,
+  adapter: RuntimeAdapterId,
+  spec?: ExternalRuntimeSpec,
+): RuntimeAnnotatedModel | undefined {
+  const resolved = spec ?? builtinRuntimeSpec(adapter);
+  if (!resolved) return undefined;
+  return { model: withRuntimeEndpoint(card.model, resolved), spec: resolved };
+}
+
+export function specFromModel(model: Model<Api>): ExternalRuntimeSpec | undefined {
+  const baseUrl = model.baseUrl;
+  if (!baseUrl.startsWith(RUNTIME_ENDPOINT_SCHEME)) return undefined;
+  const adapter = baseUrl.slice(RUNTIME_ENDPOINT_SCHEME.length);
+  return adapter.length > 0 ? builtinRuntimeSpec(adapter) : undefined;
+}

package/src/runtime-bridge/bridges/claude-cli.ts

@@ -0,0 +1,123 @@
+/**
+ * `claude-cli` bridge — drives an Anthropic-flavoured CLI that emits
+ * line-delimited stream-json content blocks.
+ */
+import type {
+  Context,
+  ExchangeOptions,
+  ExternalRuntimeSpec,
+  RuntimeAdapterId,
+  RuntimeBridge,
+  ToolCall,
+} from "../contract.js";
+import {
+  asRecord,
+  driveExchange,
+  strField,
+  type ChildParser,
+} from "./_drive.js";
+
+const ADAPTER: RuntimeAdapterId = "claude-cli";
+const CONTINUE = { status: "continue" } as const;
+const DONE = { status: "done" } as const;
+
+function mapStopReason(raw: string | undefined): "stop" | "length" | "toolUse" {
+  switch (raw) {
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "toolUse";
+    default:
+      return "stop";
+  }
+}
+
+function toolCallFromBlock(block: Record<string, unknown>): ToolCall | undefined {
+  const id = strField(block, "id");
+  const name = strField(block, "name");
+  if (id === undefined || name === undefined) return undefined;
+  const input = asRecord(block["input"]) ?? {};
+  return { type: "toolCall", id, name, arguments: input };
+}
+
+function makeParser(): ChildParser {
+  let stopReason: "stop" | "length" | "toolUse" = "stop";
+  return (message, sink) => {
+    const payload = asRecord(message.payload);
+    if (!payload) return CONTINUE;
+    const type = strField(payload, "type");
+    switch (type) {
+      case "system": {
+        if (strField(payload, "subtype") === "init") {
+          const sessionId = strField(payload, "session_id");
+          if (sessionId !== undefined) {
+            sink.emit({ kind: "resume", resumeToken: sessionId });
+          }
+        }
+        return CONTINUE;
+      }
+      case "content_block_start": {
+        const block = asRecord(payload["content_block"]);
+        if (block && strField(block, "type") === "tool_use") {
+          const call = toolCallFromBlock(block);
+          if (call) sink.toolCall(call);
+        }
+        return CONTINUE;
+      }
+      case "content_block_delta": {
+        const delta = asRecord(payload["delta"]);
+        if (!delta) return CONTINUE;
+        const deltaType = strField(delta, "type");
+        if (deltaType === "text_delta") {
+          const text = strField(delta, "text");
+          if (text !== undefined) sink.text(text);
+        } else if (deltaType === "thinking_delta") {
+          const thinking = strField(delta, "thinking");
+          if (thinking !== undefined) sink.thinking(thinking);
+        }
+        return CONTINUE;
+      }
+      case "message_delta": {
+        const delta = asRecord(payload["delta"]);
+        stopReason = mapStopReason(delta ? strField(delta, "stop_reason") : undefined);
+        return CONTINUE;
+      }
+      case "error": {
+        const error = asRecord(payload["error"]);
+        const detail =
+          (error && strField(error, "message")) ?? "claude-cli error";
+        sink.finishError({ message: detail, cause: payload["error"] });
+        return DONE;
+      }
+      case "message_stop":
+      case "result": {
+        sink.finishSuccess(stopReason);
+        return DONE;
+      }
+      default:
+        return CONTINUE;
+    }
+  };
+}
+
+function openingRequest(context: Context, opts: ExchangeOptions): { body: unknown } {
+  return {
+    body: {
+      type: "user",
+      context,
+      resume: opts.resume,
+      cwd: opts.cwd,
+      sessionId: opts.sessionId,
+    },
+  };
+}
+
+export const claudeCliBridge: RuntimeBridge = {
+  adapter: ADAPTER,
+  runExchange(model, context, opts, transport) {
+    return driveExchange(model, opts, transport, openingRequest(context, opts), makeParser());
+  },
+  requiresCredential(spec: ExternalRuntimeSpec): boolean {
+    return spec.authMode === "api-key";
+  },
+};

package/src/runtime-bridge/bridges/codex-cli.ts

@@ -0,0 +1,142 @@
+/**
+ * `codex-cli` bridge — drives an OpenAI-flavoured CLI emitting `--json`
+ * turn/item events.
+ */
+import type {
+  Context,
+  ExchangeOptions,
+  ExternalRuntimeSpec,
+  RuntimeAdapterId,
+  RuntimeBridge,
+  ToolCall,
+} from "../contract.js";
+import {
+  asRecord,
+  driveExchange,
+  strField,
+  type ChildParser,
+} from "./_drive.js";
+
+const ADAPTER: RuntimeAdapterId = "codex-cli";
+const CONTINUE = { status: "continue" } as const;
+const DONE = { status: "done" } as const;
+
+function parseArguments(value: unknown): Record<string, unknown> {
+  if (typeof value === "string") {
+    if (value.length === 0) return {};
+    try {
+      const parsed = JSON.parse(value);
+      return asRecord(parsed) ?? {};
+    } catch {
+      return {};
+    }
+  }
+  return asRecord(value) ?? {};
+}
+
+function toolCallFromItem(item: Record<string, unknown>): ToolCall | undefined {
+  const name = strField(item, "name");
+  if (name === undefined) return undefined;
+  const id = strField(item, "call_id") ?? strField(item, "id") ?? name;
+  return {
+    type: "toolCall",
+    id,
+    name,
+    arguments: parseArguments(item["arguments"]),
+  };
+}
+
+function isToolItem(item: Record<string, unknown>): boolean {
+  const itemType = strField(item, "type");
+  return itemType === "function_call" || itemType === "tool_call";
+}
+
+function makeParser(): ChildParser {
+  let sawToolCall = false;
+  const handleCompletedItem = (item: Record<string, unknown>, sink: {
+    toolCall: (call: ToolCall) => void;
+    text: (delta: string) => void;
+  }): void => {
+    if (isToolItem(item)) {
+      const call = toolCallFromItem(item);
+      if (call) {
+        sink.toolCall(call);
+        sawToolCall = true;
+      }
+      return;
+    }
+    const text = strField(item, "text");
+    if (text !== undefined && text.length > 0) sink.text(text);
+  };
+  return (message, sink) => {
+    const payload = asRecord(message.payload);
+    if (!payload) return CONTINUE;
+    const type = strField(payload, "type");
+    switch (type) {
+      case "thread.started": {
+        const threadId = strField(payload, "thread_id");
+        if (threadId !== undefined) {
+          sink.emit({ kind: "resume", resumeToken: threadId });
+        }
+        return CONTINUE;
+      }
+      case "response.output_text.delta": {
+        const delta = strField(payload, "delta");
+        if (delta !== undefined) sink.text(delta);
+        return CONTINUE;
+      }
+      case "response.reasoning_text.delta":
+      case "response.reasoning.delta": {
+        const delta = strField(payload, "delta");
+        if (delta !== undefined) sink.thinking(delta);
+        return CONTINUE;
+      }
+      case "response.output_item.done":
+      case "item.completed": {
+        const item = asRecord(payload["item"]);
+        if (item) handleCompletedItem(item, sink);
+        return CONTINUE;
+      }
+      case "error":
+      case "turn.failed": {
+        const error = asRecord(payload["error"]);
+        const detail =
+          (error && strField(error, "message")) ??
+          strField(payload, "message") ??
+          "codex-cli error";
+        sink.finishError({ message: detail, cause: payload["error"] ?? payload });
+        return DONE;
+      }
+      case "turn.completed":
+      case "response.completed": {
+        const reason = sawToolCall ? "toolUse" : "stop";
+        sink.finishSuccess(reason);
+        return DONE;
+      }
+      default:
+        return CONTINUE;
+    }
+  };
+}
+
+function openingRequest(context: Context, opts: ExchangeOptions): { body: unknown } {
+  return {
+    body: {
+      type: "turn",
+      context,
+      thread: opts.resume,
+      cwd: opts.cwd,
+      sessionId: opts.sessionId,
+    },
+  };
+}
+
+export const codexCliBridge: RuntimeBridge = {
+  adapter: ADAPTER,
+  runExchange(model, context, opts, transport) {
+    return driveExchange(model, opts, transport, openingRequest(context, opts), makeParser());
+  },
+  requiresCredential(spec: ExternalRuntimeSpec): boolean {
+    return spec.authMode === "api-key";
+  },
+};

package/src/runtime-bridge/bridges/index.ts

@@ -0,0 +1,33 @@
+// @ts-nocheck
+// Type declarations recovered from dist/types (no runtime body)
+/**
+ * Bridges subsystem — public barrel.
+ *
+ * Bundles the three shipped external-runtime {@link RuntimeBridge}s — the
+ * Anthropic-flavoured `claude-cli`, the OpenAI-flavoured `codex-cli`, and the
+ * peer JSON-RPC `indusagi-cli` — plus the built-in runtime spec catalog and the
+ * model-annotation helpers. Consumers register the bridges with a
+ * {@link RuntimeBroker} and annotate catalog cards via this barrel rather than
+ * reaching into the individual modules.
+ */
+export { claudeCliBridge } from "./claude-cli.js";
+export { codexCliBridge } from "./codex-cli.js";
+export { indusagiCliBridge, makeIndusagiCliBridge } from "./indusagi-cli.js";
+export {
+  BUILTIN_RUNTIME_SPECS,
+  BUILTIN_ADAPTERS,
+  builtinRuntimeSpec,
+  annotateCard,
+  withRuntimeEndpoint,
+  specFromModel,
+  type RuntimeAnnotatedModel,
+} from "./builtins.js";
+export {
+  driveExchange,
+  seedFromModel,
+  asRecord,
+  strField,
+  errorText,
+  type ChildParser,
+  type ParseStep,
+} from "./_drive.js";

package/src/runtime-bridge/bridges/indusagi-cli.ts

@@ -0,0 +1,155 @@
+/**
+ * `indusagi-cli` bridge — drives a peer agent over JSON-RPC.
+ */
+import type {
+  Context,
+  ExchangeOptions,
+  ExternalRuntimeSpec,
+  RuntimeAdapterId,
+  RuntimeBridge,
+  ToolCall,
+} from "../contract.js";
+import {
+  asRecord,
+  driveExchange,
+  strField,
+  type ChildParser,
+} from "./_drive.js";
+
+const ADAPTER: RuntimeAdapterId = "indusagi-cli";
+const RPC_METHOD = "runExchange";
+const CONTINUE = { status: "continue" } as const;
+const DONE = { status: "done" } as const;
+
+function asFinishReason(raw: string | undefined): "stop" | "length" | "toolUse" {
+  const allowed = ["stop", "length", "toolUse"];
+  return (allowed as string[]).includes(raw ?? "") ? (raw as "stop" | "length" | "toolUse") : "stop";
+}
+
+function toolCallFromParams(params: Record<string, unknown> | undefined): ToolCall | undefined {
+  const id = params && strField(params, "id");
+  const name = params && strField(params, "name");
+  if (id === undefined || name === undefined) return undefined;
+  return {
+    type: "toolCall",
+    id,
+    name,
+    arguments: (params && asRecord(params["arguments"])) ?? {},
+  };
+}
+
+interface NotificationSink {
+  text: (delta: string) => void;
+  thinking: (delta: string) => void;
+  toolCall: (call: ToolCall) => void;
+  emit: (event: { kind: "resume"; resumeToken: string }) => void;
+  finishSuccess: (reason: "stop" | "length" | "toolUse") => void;
+  finishError: (error: { message: string; aborted: boolean; cause?: unknown }) => void;
+}
+
+function handleNotification(
+  method: string,
+  params: Record<string, unknown> | undefined,
+  sink: NotificationSink,
+): { status: "continue" | "done" } {
+  switch (method) {
+    case "stream/text": {
+      const delta = params && strField(params, "delta");
+      if (delta !== undefined) sink.text(delta);
+      return CONTINUE;
+    }
+    case "stream/thinking": {
+      const delta = params && strField(params, "delta");
+      if (delta !== undefined) sink.thinking(delta);
+      return CONTINUE;
+    }
+    case "stream/toolCall": {
+      const call = toolCallFromParams(params);
+      if (call) sink.toolCall(call);
+      return CONTINUE;
+    }
+    case "session/resume": {
+      const token = params && strField(params, "resumeToken");
+      if (token !== undefined) sink.emit({ kind: "resume", resumeToken: token });
+      return CONTINUE;
+    }
+    case "stream/done": {
+      sink.finishSuccess(asFinishReason(params ? strField(params, "reason") : undefined));
+      return DONE;
+    }
+    case "stream/error": {
+      const message = (params && strField(params, "message")) ?? "indusagi-cli error";
+      const aborted = params?.["aborted"] === true;
+      sink.finishError({ message, aborted, cause: params });
+      return DONE;
+    }
+    default:
+      return CONTINUE;
+  }
+}
+
+function parseFrame(message: { payload: unknown }, sink: {
+  text: (delta: string) => void;
+  thinking: (delta: string) => void;
+  toolCall: (call: ToolCall) => void;
+  emit: (event: { kind: "resume"; resumeToken: string }) => void;
+  finishSuccess: (reason: "stop" | "length" | "toolUse") => void;
+  finishError: (error: { message: string; aborted: boolean; cause?: unknown }) => void;
+}): { status: "continue" | "done" } {
+  const frame = asRecord(message.payload);
+  if (!frame) return CONTINUE;
+  const method = strField(frame, "method");
+  if (method !== undefined) {
+    return handleNotification(method, asRecord(frame["params"]), sink);
+  }
+  if ("error" in frame) {
+    const error = asRecord(frame["error"]);
+    const detail = (error && strField(error, "message")) ?? "indusagi-cli rpc error";
+    sink.finishError({ message: detail, cause: frame["error"] });
+    return DONE;
+  }
+  if ("result" in frame) {
+    return DONE;
+  }
+  return CONTINUE;
+}
+
+const parser = parseFrame;
+
+function openingRequest(
+  context: Context,
+  opts: ExchangeOptions,
+  spec: ExternalRuntimeSpec,
+): { body: unknown } {
+  return {
+    body: {
+      jsonrpc: "2.0",
+      id: opts.sessionId ?? RPC_METHOD,
+      method: RPC_METHOD,
+      params: {
+        context,
+        delegate: spec.delegate,
+        resume: opts.resume,
+        cwd: opts.cwd,
+        sessionId: opts.sessionId,
+      },
+    },
+  };
+}
+
+export function makeIndusagiCliBridge(spec: ExternalRuntimeSpec): RuntimeBridge {
+  return {
+    adapter: ADAPTER,
+    runExchange(model, context, opts, transport) {
+      return driveExchange(model, opts, transport, openingRequest(context, opts, spec), parser);
+    },
+    requiresCredential(s: ExternalRuntimeSpec): boolean {
+      return s.authMode === "api-key";
+    },
+  };
+}
+
+export const indusagiCliBridge: RuntimeBridge = makeIndusagiCliBridge({
+  adapter: ADAPTER,
+  authMode: "external-cli",
+});