aos-harness 0.3.2 → 0.4.0

package/adapters/claude-code/package.json

@@ -1,20 +1,14 @@
 {
   "name": "@aos-harness/claude-code-adapter",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
-  "main": "src/generate.ts",
-  "scripts": {
-    "generate": "bun run src/generate.ts",
-    "typecheck": "bun x tsc --noEmit"
-  },
   "exports": { ".": "./src/index.ts" },
   "files": ["src/"],
   "dependencies": {
     "@aos-harness/runtime": "workspace:*",
-    "js-yaml": "^4.1.0"
+    "@aos-harness/adapter-shared": "workspace:*"
   },
   "devDependencies": {
-    "@types/js-yaml": "^4.0.9",
     "@types/bun": "latest",
     "typescript": "^5.8.0"
   }

package/adapters/claude-code/src/agent-runtime.ts

@@ -0,0 +1,182 @@
+// ── ClaudeCodeAgentRuntime (L1) ───────────────────────────────────
+// Extends BaseAgentRuntime with Claude Code CLI integration.
+
+import { execSync } from "node:child_process";
+import type {
+  AuthMode,
+  ModelCost,
+  ModelTier,
+  MessageOpts,
+} from "@aos-harness/runtime/types";
+import {
+  BaseAgentRuntime,
+  type HandleState,
+  type ParsedEvent,
+  type StdoutFormat,
+  type ModelInfo,
+} from "@aos-harness/adapter-shared";
+import type { BaseEventBus } from "@aos-harness/adapter-shared";
+
+// ── ClaudeCodeAgentRuntime ────────────────────────────────────────
+
+export class ClaudeCodeAgentRuntime extends BaseAgentRuntime {
+  constructor(eventBus: BaseEventBus, modelOverrides?: Partial<Record<ModelTier, string>>) {
+    super(eventBus, modelOverrides);
+  }
+
+  cliBinary(): string {
+    return "claude";
+  }
+
+  stdoutFormat(): StdoutFormat {
+    return "ndjson";
+  }
+
+  buildArgs(state: HandleState, message: string, isFirstCall: boolean, opts?: MessageOpts): string[] {
+    const args: string[] = ["--print", "--output-format", "json", "--verbose"];
+
+    if (isFirstCall) {
+      // System prompt
+      const systemPrompt = state.config.systemPrompt || "";
+      if (systemPrompt) {
+        args.push("--system-prompt", systemPrompt);
+      }
+
+      // Model
+      args.push("--model", this.resolveModelId(state.modelConfig.tier));
+
+      // Context files
+      const contextFiles = opts?.contextFiles?.length
+        ? opts.contextFiles
+        : state.contextFiles;
+      for (const file of contextFiles) {
+        args.push("--add-file", file);
+      }
+    } else {
+      // Resume session
+      args.push("--resume", state.sessionFile);
+    }
+
+    // Message is always the final argument
+    args.push(message);
+    return args;
+  }
+
+  parseEventLine(line: string): ParsedEvent | null {
+    let event: any;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return null;
+    }
+
+    // Final result with usage stats
+    if (event.type === "result") {
+      const usage = event.usage ?? {};
+      return {
+        type: "message_end",
+        text: event.result ?? "",
+        tokensIn: usage.input_tokens ?? 0,
+        tokensOut: usage.output_tokens ?? 0,
+        cost: event.cost_usd ?? 0,
+        contextTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+        model: event.model ?? "",
+      };
+    }
+
+    // Streaming text delta
+    if (event.type === "content_block_delta" && event.delta?.text !== undefined) {
+      return { type: "text_delta", text: event.delta.text };
+    }
+
+    // Tool call
+    if (event.type === "tool_use") {
+      return { type: "tool_call", name: event.name ?? "unknown", input: event.input ?? {} };
+    }
+
+    // Tool result — content or output field
+    if (event.type === "tool_result") {
+      const result = event.content ?? event.output ?? null;
+      return { type: "tool_result", name: event.name ?? "unknown", input: {}, result };
+    }
+
+    return { type: "ignored" };
+  }
+
+  buildSubprocessEnv(): Record<string, string> {
+    const env: Record<string, string> = {};
+    const allowlist = [
+      "PATH", "HOME", "USER", "SHELL", "TERM", "LANG",
+      "ANTHROPIC_API_KEY",
+      "AOS_MODEL_ECONOMY", "AOS_MODEL_STANDARD", "AOS_MODEL_PREMIUM",
+    ];
+    for (const key of allowlist) {
+      if (process.env[key] !== undefined) env[key] = process.env[key]!;
+    }
+    return env;
+  }
+
+  async discoverModels(): Promise<ModelInfo[]> {
+    try {
+      const output = execSync("claude model list --json", {
+        encoding: "utf-8",
+        timeout: 10_000,
+        env: this.buildSubprocessEnv(),
+      });
+      const parsed = JSON.parse(output);
+      if (Array.isArray(parsed)) {
+        return parsed.map((m: any) => ({
+          id: m.id ?? m.name,
+          name: m.name ?? m.id,
+          contextWindow: m.context_window ?? m.contextWindow ?? 200_000,
+          provider: "claude",
+        }));
+      }
+    } catch {
+      // Fall through to defaults
+    }
+    const defaults = this.defaultModelMap();
+    return Object.entries(defaults).map(([_tier, id]) => ({
+      id,
+      name: id,
+      contextWindow: 200_000,
+      provider: "claude",
+    }));
+  }
+
+  defaultModelMap(): Record<ModelTier, string> {
+    return {
+      economy: "claude-haiku-4-5",
+      standard: "claude-sonnet-4-6",
+      premium: "claude-opus-4-6",
+    };
+  }
+
+  getAuthMode(): AuthMode {
+    if (process.env.ANTHROPIC_API_KEY) {
+      return { type: "api_key", metered: true };
+    }
+    return { type: "subscription", metered: false };
+  }
+
+  getModelCost(tier: ModelTier): ModelCost {
+    const pricing: Record<ModelTier, ModelCost> = {
+      economy: {
+        inputPerMillionTokens: 0.80,
+        outputPerMillionTokens: 4.00,
+        currency: "USD",
+      },
+      standard: {
+        inputPerMillionTokens: 3.00,
+        outputPerMillionTokens: 15.00,
+        currency: "USD",
+      },
+      premium: {
+        inputPerMillionTokens: 15.00,
+        outputPerMillionTokens: 75.00,
+        currency: "USD",
+      },
+    };
+    return pricing[tier];
+  }
+}

package/adapters/claude-code/src/index.ts

@@ -1,13 +1,2 @@
-/**
- * AOS Harness — Claude Code Adapter
- *
- * Barrel file re-exporting the adapter's public API.
- */
-
-export { generateClaudeCodeArtifacts } from "./generate";
-export {
-  generateAgentFile,
-  generateCommandFile,
-  generateClaudeMdFragment,
-  mapTierToModel,
-} from "./templates";
+export { ClaudeCodeAgentRuntime } from "./agent-runtime";
+export { BaseEventBus, TerminalUI, BaseWorkflow, composeAdapter } from "@aos-harness/adapter-shared";

package/adapters/claude-code/tests/agent-runtime.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { ClaudeCodeAgentRuntime } from "../src/agent-runtime";
+import { BaseEventBus } from "@aos-harness/adapter-shared";
+
+// Minimal stub for BaseEventBus
+class StubEventBus extends BaseEventBus {}
+
+function makeRuntime(env: Record<string, string> = {}): ClaudeCodeAgentRuntime {
+  const saved: Record<string, string | undefined> = {};
+  for (const [k, v] of Object.entries(env)) {
+    saved[k] = process.env[k];
+    process.env[k] = v;
+  }
+  const runtime = new ClaudeCodeAgentRuntime(new StubEventBus());
+  // restore after construction (actual calls may still read process.env at call time)
+  for (const [k] of Object.entries(env)) {
+    if (saved[k] === undefined) delete process.env[k];
+    else process.env[k] = saved[k];
+  }
+  return runtime;
+}
+
+describe("ClaudeCodeAgentRuntime", () => {
+  it("cliBinary returns 'claude'", () => {
+    const rt = new ClaudeCodeAgentRuntime(new StubEventBus());
+    expect(rt.cliBinary()).toBe("claude");
+  });
+
+  it("stdoutFormat returns 'ndjson'", () => {
+    const rt = new ClaudeCodeAgentRuntime(new StubEventBus());
+    expect(rt.stdoutFormat()).toBe("ndjson");
+  });
+
+  describe("buildArgs", () => {
+    const state = {
+      config: {
+        id: "test-agent",
+        systemPrompt: "You are a helpful assistant.",
+        model: { tier: "standard" as const, thinking: "on" as const },
+        tools: [],
+        skills: [],
+      },
+      sessionFile: "/tmp/test-session.jsonl",
+      contextFiles: ["/tmp/context.md"],
+      modelConfig: { tier: "standard" as const, thinking: "on" as const },
+      lastContextTokens: 0,
+    };
+
+    it("first call includes --print, --output-format, --system-prompt, --model, and message", () => {
+      const rt = new ClaudeCodeAgentRuntime(new StubEventBus());
+      const args = rt.buildArgs(state, "Hello world", true);
+
+      expect(args).toContain("--print");
+      expect(args).toContain("--output-format");
+      expect(args).toContain("json");
+      expect(args).toContain("--verbose");
+      expect(args).toContain("--system-prompt");
+      expect(args).toContain("You are a helpful assistant.");
+      expect(args).toContain("--model");
+      // Message should be the last argument
+      expect(args[args.length - 1]).toBe("Hello world");
+    });
+
+    it("first call includes --add-file for context files", () => {
+      const rt = new ClaudeCodeAgentRuntime(new StubEventBus());
+      const args = rt.buildArgs(state, "Hello", true);
+
+      expect(args).toContain("--add-file");
+      expect(args).toContain("/tmp/context.md");
+    });
+
+    it("subsequent call includes --resume and no --system-prompt", () => {
+      const rt = new ClaudeCodeAgentRuntime(new StubEventBus());
+      const args = rt.buildArgs(state, "Follow-up message", false);
+
+      expect(args).toContain("--print");
+      expect(args).toContain("--output-format");
+      expect(args).toContain("json");
+      expect(args).toContain("--verbose");
+      expect(args).toContain("--resume");
+      expect(args).toContain("/tmp/test-session.jsonl");
+      expect(args).not.toContain("--system-prompt");
+      expect(args[args.length - 1]).toBe("Follow-up message");
+    });
+  });
+
+  describe("parseEventLine", () => {
+    const rt = new ClaudeCodeAgentRuntime(new StubEventBus());
+
+    it("parses result type → message_end", () => {
+      const line = JSON.stringify({
+        type: "result",
+        result: "Hello from Claude",
+        usage: { input_tokens: 100, output_tokens: 50 },
+        cost_usd: 0.002,
+        model: "claude-sonnet-4-6",
+      });
+      const event = rt.parseEventLine(line);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe("message_end");
+      if (event!.type === "message_end") {
+        expect(event.text).toBe("Hello from Claude");
+        expect(event.tokensIn).toBe(100);
+        expect(event.tokensOut).toBe(50);
+        expect(event.cost).toBe(0.002);
+        expect(event.model).toBe("claude-sonnet-4-6");
+      }
+    });
+
+    it("parses content_block_delta → text_delta", () => {
+      const line = JSON.stringify({
+        type: "content_block_delta",
+        delta: { text: "streaming text" },
+      });
+      const event = rt.parseEventLine(line);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe("text_delta");
+      if (event!.type === "text_delta") {
+        expect(event.text).toBe("streaming text");
+      }
+    });
+
+    it("parses tool_use → tool_call", () => {
+      const line = JSON.stringify({
+        type: "tool_use",
+        name: "bash",
+        input: { command: "ls" },
+      });
+      const event = rt.parseEventLine(line);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe("tool_call");
+      if (event!.type === "tool_call") {
+        expect(event.name).toBe("bash");
+        expect(event.input).toEqual({ command: "ls" });
+      }
+    });
+
+    it("parses tool_result → tool_result", () => {
+      const line = JSON.stringify({
+        type: "tool_result",
+        name: "bash",
+        content: "file1.txt\nfile2.txt",
+      });
+      const event = rt.parseEventLine(line);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe("tool_result");
+      if (event!.type === "tool_result") {
+        expect(event.name).toBe("bash");
+      }
+    });
+
+    it("returns ignored for unknown event types", () => {
+      const line = JSON.stringify({ type: "unknown_event", data: "foo" });
+      const event = rt.parseEventLine(line);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe("ignored");
+    });
+
+    it("returns null for invalid JSON", () => {
+      const event = rt.parseEventLine("not valid json");
+      expect(event).toBeNull();
+    });
+  });
+
+  it("defaultModelMap returns correct models", () => {
+    const rt = new ClaudeCodeAgentRuntime(new StubEventBus());
+    const map = rt.defaultModelMap();
+    expect(map.economy).toBe("claude-haiku-4-5");
+    expect(map.standard).toBe("claude-sonnet-4-6");
+    expect(map.premium).toBe("claude-opus-4-6");
+  });
+
+  describe("getAuthMode", () => {
+    let savedKey: string | undefined;
+
+    beforeEach(() => {
+      savedKey = process.env.ANTHROPIC_API_KEY;
+    });
+
+    afterEach(() => {
+      if (savedKey === undefined) delete process.env.ANTHROPIC_API_KEY;
+      else process.env.ANTHROPIC_API_KEY = savedKey;
+    });
+
+    it("returns api_key when ANTHROPIC_API_KEY is set", () => {
+      process.env.ANTHROPIC_API_KEY = "sk-test-key";
+      const rt = new ClaudeCodeAgentRuntime(new StubEventBus());
+      const auth = rt.getAuthMode();
+      expect(auth.type).toBe("api_key");
+      expect(auth.metered).toBe(true);
+    });
+
+    it("returns subscription when ANTHROPIC_API_KEY is not set", () => {
+      delete process.env.ANTHROPIC_API_KEY;
+      const rt = new ClaudeCodeAgentRuntime(new StubEventBus());
+      const auth = rt.getAuthMode();
+      expect(auth.type).toBe("subscription");
+      expect(auth.metered).toBe(false);
+    });
+  });
+});

package/adapters/codex/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@aos-harness/codex-adapter",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": { ".": "./src/index.ts" },
+  "files": ["src/"],
+  "dependencies": {
+    "@aos-harness/runtime": "workspace:*",
+    "@aos-harness/adapter-shared": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.8.0"
+  }
+}

package/adapters/codex/src/agent-runtime.ts

@@ -0,0 +1,197 @@
+// ── CodexAgentRuntime (L1) ────────────────────────────────────────
+// Extends BaseAgentRuntime with OpenAI Codex CLI integration.
+
+import { execSync } from "node:child_process";
+import type {
+  AuthMode,
+  ModelCost,
+  ModelTier,
+  MessageOpts,
+} from "@aos-harness/runtime/types";
+import {
+  BaseAgentRuntime,
+  type HandleState,
+  type ParsedEvent,
+  type StdoutFormat,
+  type ModelInfo,
+} from "@aos-harness/adapter-shared";
+import type { BaseEventBus } from "@aos-harness/adapter-shared";
+
+// ── CodexAgentRuntime ─────────────────────────────────────────────
+
+export class CodexAgentRuntime extends BaseAgentRuntime {
+  constructor(eventBus: BaseEventBus, modelOverrides?: Partial<Record<ModelTier, string>>) {
+    super(eventBus, modelOverrides);
+  }
+
+  cliBinary(): string {
+    return "codex";
+  }
+
+  stdoutFormat(): StdoutFormat {
+    return "ndjson";
+  }
+
+  buildArgs(state: HandleState, message: string, isFirstCall: boolean, opts?: MessageOpts): string[] {
+    const args: string[] = ["--full-auto", "--model", this.resolveModelId(state.modelConfig.tier)];
+
+    if (isFirstCall) {
+      // System prompt
+      const systemPrompt = state.config.systemPrompt || "";
+      if (systemPrompt) {
+        args.push("--system-prompt", systemPrompt);
+      }
+
+      // Context files
+      const contextFiles = opts?.contextFiles?.length
+        ? opts.contextFiles
+        : state.contextFiles;
+      for (const file of contextFiles) {
+        args.push("--file", file);
+      }
+    } else {
+      // Resume session
+      args.push("--session", state.sessionFile);
+    }
+
+    // Message is always the final argument
+    args.push(message);
+    return args;
+  }
+
+  parseEventLine(line: string): ParsedEvent | null {
+    let event: any;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return null;
+    }
+
+    // Codex result format with usage stats
+    if (event.type === "result") {
+      const usage = event.usage ?? {};
+      return {
+        type: "message_end",
+        text: event.result ?? "",
+        tokensIn: usage.input_tokens ?? 0,
+        tokensOut: usage.output_tokens ?? 0,
+        cost: event.cost_usd ?? 0,
+        contextTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+        model: event.model ?? "",
+      };
+    }
+
+    // Streaming text delta (Anthropic-style)
+    if (event.type === "content_block_delta" && event.delta?.text !== undefined) {
+      return { type: "text_delta", text: event.delta.text };
+    }
+
+    // OpenAI streaming choices format
+    if (Array.isArray(event.choices)) {
+      const choice = event.choices[0];
+
+      // Streaming delta with content
+      if (choice?.delta?.content !== undefined && choice.delta.content !== null) {
+        return { type: "text_delta", text: choice.delta.content };
+      }
+
+      // Non-streaming message with full content and usage
+      if (choice?.message?.content !== undefined) {
+        const usage = event.usage ?? {};
+        return {
+          type: "message_end",
+          text: choice.message.content ?? "",
+          tokensIn: usage.prompt_tokens ?? 0,
+          tokensOut: usage.completion_tokens ?? 0,
+          cost: 0,
+          contextTokens: (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0),
+          model: event.model ?? "",
+        };
+      }
+    }
+
+    // Tool call / function call
+    if (event.type === "tool_call" || event.type === "function_call") {
+      return { type: "tool_call", name: event.name ?? "unknown", input: event.input ?? event.args ?? {} };
+    }
+
+    return { type: "ignored" };
+  }
+
+  buildSubprocessEnv(): Record<string, string> {
+    const env: Record<string, string> = {};
+    const allowlist = [
+      "PATH", "HOME", "USER", "SHELL", "TERM", "LANG",
+      "OPENAI_API_KEY",
+      "AOS_MODEL_ECONOMY", "AOS_MODEL_STANDARD", "AOS_MODEL_PREMIUM",
+    ];
+    for (const key of allowlist) {
+      if (process.env[key] !== undefined) env[key] = process.env[key]!;
+    }
+    return env;
+  }
+
+  async discoverModels(): Promise<ModelInfo[]> {
+    try {
+      const output = execSync("codex model list --json", {
+        encoding: "utf-8",
+        timeout: 10_000,
+        env: this.buildSubprocessEnv(),
+      });
+      const parsed = JSON.parse(output);
+      if (Array.isArray(parsed)) {
+        return parsed.map((m: any) => ({
+          id: m.id ?? m.name,
+          name: m.name ?? m.id,
+          contextWindow: m.context_window ?? m.contextWindow ?? 200_000,
+          provider: "codex",
+        }));
+      }
+    } catch {
+      // Fall through to defaults
+    }
+    const defaults = this.defaultModelMap();
+    return Object.entries(defaults).map(([_tier, id]) => ({
+      id,
+      name: id,
+      contextWindow: 200_000,
+      provider: "codex",
+    }));
+  }
+
+  defaultModelMap(): Record<ModelTier, string> {
+    return {
+      economy: "o4-mini",
+      standard: "o3",
+      premium: "o3",
+    };
+  }
+
+  getAuthMode(): AuthMode {
+    if (process.env.OPENAI_API_KEY) {
+      return { type: "api_key", metered: true };
+    }
+    return { type: "unknown", metered: false };
+  }
+
+  getModelCost(tier: ModelTier): ModelCost {
+    const pricing: Record<ModelTier, ModelCost> = {
+      economy: {
+        inputPerMillionTokens: 1.10,
+        outputPerMillionTokens: 4.40,
+        currency: "USD",
+      },
+      standard: {
+        inputPerMillionTokens: 10.00,
+        outputPerMillionTokens: 40.00,
+        currency: "USD",
+      },
+      premium: {
+        inputPerMillionTokens: 10.00,
+        outputPerMillionTokens: 40.00,
+        currency: "USD",
+      },
+    };
+    return pricing[tier];
+  }
+}

package/adapters/codex/src/index.ts

@@ -0,0 +1,2 @@
+export { CodexAgentRuntime } from "./agent-runtime";
+export { BaseEventBus, TerminalUI, BaseWorkflow, composeAdapter } from "@aos-harness/adapter-shared";