@axiom-lattice/cli-a2a 0.1.5 → 0.1.6

package/src/executors/claude/client.ts

@@ -3,10 +3,12 @@
  *
  * Spawns the Anthropic Claude Code CLI as a child process in non-interactive
  * print mode (`-p`). Sends prompts, captures stdout as the response.
- * Supports configurable CLI path, working directory, model, and timeout.
+ * Supports session persistence: first call uses `--session-id <uuid>` to
+ * create a named session; subsequent calls use `--resume <uuid>` to continue.
  */
 
 import { spawn } from 'node:child_process';
+import { v4 as uuidv4 } from 'uuid';
 import { logger } from '../../logger.js';
 
 const log = logger.child('claude:client');
@@ -26,6 +28,11 @@ export interface ClaudeClientConfig {
   timeout?: number;
 }
 
+export interface ClaudeExecuteResult {
+  text: string;
+  sessionId: string;
+}
+
 // ─── Client ─────────────────────────────────────────────────────────────────
 
 export class ClaudeClient {
@@ -46,15 +53,36 @@ export class ClaudeClient {
   }
 
   /**
-   * Execute a prompt via the Claude Code CLI and return the response text.
+   * Execute a prompt via the Claude Code CLI.
+   *
+   * @param prompt - The user prompt text.
+   * @param sessionId - If provided, resumes the session with `--resume`.
+   *   Otherwise creates a new session with `--session-id <new-uuid>`.
+   * @param workingDirectory - Optional per-request working directory override.
+   * @returns The response text and the session ID (new or existing).
    */
-  async execute(prompt: string): Promise<string> {
+  async execute(prompt: string, sessionId?: string, workingDirectory?: string): Promise<ClaudeExecuteResult> {
+    if (sessionId) {
+      const text = await this.run(['-p', '--resume', sessionId, prompt], workingDirectory);
+      return { text, sessionId };
+    }
+
+    const newSessionId = uuidv4();
+    const text = await this.run(['-p', '--session-id', newSessionId, prompt], workingDirectory);
+    return { text, sessionId: newSessionId };
+  }
+
+  // ── Internal ──────────────────────────────────────────────────────────
+
+  private async run(args: string[], workingDirectory?: string): Promise<string> {
     const cliPath = this.config.cliPath || 'claude';
     const timeout = this.config.timeout ?? 300_000;
     const MAX_PROMPT = 100_000;
 
-    if (prompt.length > MAX_PROMPT) {
-      throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}). Split into smaller messages.`);
+    // Validate prompt size
+    const promptArg = args[args.length - 1];
+    if (promptArg && promptArg.length > MAX_PROMPT) {
+      throw new Error(`Prompt too large (${promptArg.length} chars, max ${MAX_PROMPT}). Split into smaller messages.`);
     }
 
     // Only pass relevant env vars to child process
@@ -62,26 +90,29 @@ export class ClaudeClient {
       PATH: process.env.PATH ?? '',
       HOME: process.env.HOME ?? '',
     };
-    // Forward common proxy/no-proxy settings
     for (const key of ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy']) {
       if (process.env[key]) env[key] = process.env[key];
     }
-
     if (this.config.apiKey) {
       env['ANTHROPIC_API_KEY'] = this.config.apiKey;
     }
 
-    const args: string[] = ['-p'];
+    // Build full args: base args + model + prompt
+    const fullArgs: string[] = [];
+    for (const arg of args.slice(0, -1)) {
+      fullArgs.push(arg);
+    }
     if (this.config.model) {
-      args.push('--model', this.config.model);
+      fullArgs.push('--model', this.config.model);
     }
-    args.push(prompt);
+    fullArgs.push(promptArg);
 
-    log.info('Spawning claude', { cliPath, workdir: this.config.workdir, model: this.config.model });
+    const workdir = workingDirectory || this.config.workdir || process.cwd();
+    log.info('Spawning claude', { cliPath, workdir, model: this.config.model });
 
     return new Promise<string>((resolve, reject) => {
-      const child = spawn(cliPath, args, {
-        cwd: this.config.workdir || process.cwd(),
+      const child = spawn(cliPath, fullArgs, {
+        cwd: workdir,
         env,
         stdio: ['ignore', 'pipe', 'pipe'],
       });
@@ -94,7 +125,6 @@ export class ClaudeClient {
 
       const timer = setTimeout(() => {
         child.kill('SIGTERM');
-        // Force kill after 5s grace period
         const forceTimer = setTimeout(() => {
           if (child.exitCode === null) child.kill('SIGKILL');
         }, 5000);

package/src/executors/claude/executor.ts

@@ -2,21 +2,23 @@
  * Claude Code A2A Executor
  *
  * Bridges the local Claude Code CLI to the A2A protocol. Spawns Claude Code
- * in non-interactive print mode (`-p`) for each request and captures stdout
- * as the response.
+ * in non-interactive print mode (`-p`) for each request. Supports multi-turn
+ * conversation via contextId → sessionId binding through SessionBindingStore.
  */
 
 import type { A2AExecutor } from '../index.js';
 import type { RequestContext, ExecutionEventBus } from '@a2a-js/sdk/server';
-import type { Message as A2AMessage } from '@a2a-js/sdk';
 
 import type { AgentConfig } from '../../config/types.js';
+import type { SessionBindingStore } from '../../session-store.js';
+import { generateContextId } from '../../session-store.js';
 import { logger } from '../../logger.js';
 import { ClaudeClient } from './client.js';
 import {
   publishTask,
   publishStatus,
   publishFinalArtifact,
+  extractText,
 } from '../events.js';
 
 const log = logger.child('claude:executor');
@@ -27,9 +29,11 @@ export class ClaudeExecutor implements A2AExecutor {
   private config: Required<AgentConfig>;
   private client: ClaudeClient | null = null;
   private initialized = false;
+  private sessionStore: SessionBindingStore;
 
-  constructor(config: Required<AgentConfig>) {
+  constructor(config: Required<AgentConfig>, sessionStore: SessionBindingStore) {
     this.config = config;
+    this.sessionStore = sessionStore;
   }
 
   async initialize(): Promise<void> {
@@ -55,31 +59,70 @@ export class ClaudeExecutor implements A2AExecutor {
   }
 
   async execute(ctx: RequestContext, bus: ExecutionEventBus): Promise<void> {
-    const { taskId, contextId, userMessage, task } = ctx;
+    const { taskId, userMessage } = ctx;
     await this.initialize();
 
+    const reuseByContext = this.config.session?.reuseByContext ?? true;
+
+    let contextId = ctx.contextId;
+    if (!contextId) {
+      contextId = generateContextId();
+      log.info('Generated new contextId', { contextId, taskId });
+    }
+
+    const binding = reuseByContext
+      ? this.sessionStore.get(contextId, 'claude')
+      : null;
+
+    const sessionId = binding?.sessionId;
+
     try {
-      if (!task) {
+      const existingTask = ctx.task;
+      if (!existingTask) {
         publishTask(bus, taskId, contextId);
         publishStatus(bus, taskId, contextId, 'submitted');
       }
 
-      publishStatus(bus, taskId, contextId, 'working', 'Processing request...');
-
-      const promptText = this.extractText(userMessage);
-      log.info('Sending prompt to Claude Code', { taskId, len: promptText.length });
-
-      const response = await this.client!.execute(promptText);
-
-      const finalText = response || 'No response from Claude Code.';
-      publishFinalArtifact(bus, taskId, contextId, finalText);
+      publishStatus(bus, taskId, contextId, 'working');
+
+      const promptText = extractText(userMessage);
+
+      // Extract per-request workingDirectory from A2A message metadata
+      const userMsg = userMessage as unknown as Record<string, unknown>;
+      const workingDirectory = userMsg.metadata &&
+        typeof userMsg.metadata === 'object'
+        ? (userMsg.metadata as Record<string, unknown>).workingDirectory as string | undefined
+        : undefined;
+
+      log.info('Sending prompt to Claude Code', {
+        taskId,
+        contextId,
+        sessionId: sessionId || '(new)',
+        len: promptText.length,
+        workingDirectory: workingDirectory || '(default)',
+      });
+
+      const result = await this.client!.execute(promptText, sessionId, workingDirectory);
+
+      this.sessionStore.set({
+        provider: 'claude',
+        contextId,
+        sessionId: result.sessionId,
+        activeTaskId: undefined,
+        activeTaskState: undefined,
+        createdAt: binding?.createdAt ?? new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        expiresAt: new Date(Date.now() + (this.config.session?.ttl ?? 24 * 60 * 60 * 1000)).toISOString(),
+      });
+
+      publishFinalArtifact(bus, taskId, contextId, result.text || 'No response from Claude Code.');
       publishStatus(bus, taskId, contextId, 'completed', undefined, true);
       bus.finished();
-      log.info('Task completed', { taskId, len: finalText.length });
+      log.info('Task completed', { taskId, contextId, sessionId: result.sessionId });
 
     } catch (error) {
       const msg = (error as Error).message ?? String(error);
-      log.error('Execution failed', { taskId, error: msg });
+      log.error('Execution failed', { taskId, contextId, error: msg });
       publishStatus(bus, taskId, contextId, 'failed', `Error: ${msg}`, true);
       bus.finished();
     }
@@ -91,21 +134,13 @@ export class ClaudeExecutor implements A2AExecutor {
     publishStatus(bus, taskId, '', 'canceled', 'Claude Code task cancelled', true);
     bus.finished();
   }
-
-  private extractText(message: A2AMessage): string {
-    return message.parts
-      .filter((p) => {
-        const part = p as unknown as Record<string, unknown>;
-        const text = part.text as string | undefined;
-        return text !== undefined && text !== null;
-      })
-      .map((p) => (p as unknown as { text: string }).text)
-      .join('\n');
-  }
 }
 
 // ─── Factory ────────────────────────────────────────────────────────────────
 
-export function createClaudeExecutor(config: Required<AgentConfig>): A2AExecutor {
-  return new ClaudeExecutor(config);
+export function createClaudeExecutor(
+  config: Required<AgentConfig>,
+  sessionStore: SessionBindingStore,
+): A2AExecutor {
+  return new ClaudeExecutor(config, sessionStore);
 }

package/src/executors/codex/client.ts

@@ -2,8 +2,9 @@
  * Codex CLI client wrapper.
  *
  * Spawns the OpenAI Codex CLI as a child process, sends prompts via stdin,
- * captures stdout as the response. Supports configurable CLI path, working
- * directory, model selection, and timeout.
+ * captures stdout as the response. Supports session persistence: on first
+ * call the thread_id is extracted from JSONL output, and subsequent calls
+ * use `codex exec resume <sessionId>` for multi-turn continuation.
  */
 
 import { spawn } from 'node:child_process';
@@ -26,6 +27,11 @@ export interface CodexClientConfig {
   timeout?: number;
 }
 
+export interface CodexExecuteResult {
+  text: string;
+  sessionId: string;
+}
+
 // ─── Client ─────────────────────────────────────────────────────────────────
 
 export class CodexClient {
@@ -46,9 +52,27 @@ export class CodexClient {
   }
 
   /**
-   * Execute a prompt via the Codex CLI and return the response text.
+   * Execute a prompt via the Codex CLI.
+   *
+   * @param prompt - The user prompt text.
+   * @param sessionId - If provided, resumes an existing session.
+   *   Otherwise creates a new session and extracts the thread_id from JSONL.
+   * @param workingDirectory - Optional per-request working directory override.
    */
-  async execute(prompt: string): Promise<string> {
+  async execute(prompt: string, sessionId?: string, workingDirectory?: string): Promise<CodexExecuteResult> {
+    if (sessionId) {
+      return this.executeResume(prompt, sessionId, workingDirectory);
+    }
+    return this.executeNew(prompt, workingDirectory);
+  }
+
+  private resolveWorkdir(override?: string): string {
+    return override || this.config.workdir || process.cwd();
+  }
+
+  // ── New session (first turn) ──────────────────────────────────────────
+
+  private async executeNew(prompt: string, workingDirectory?: string): Promise<CodexExecuteResult> {
     const cliPath = this.config.cliPath || 'codex';
     const timeout = this.config.timeout ?? 300_000;
     const MAX_PROMPT = 100_000;
@@ -57,32 +81,130 @@ export class CodexClient {
       throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}). Split into smaller messages.`);
     }
 
-    // Only pass relevant env vars to child process
     const env: Record<string, string> = {
       PATH: process.env.PATH ?? '',
       HOME: process.env.HOME ?? '',
     };
-    // Forward common proxy/no-proxy settings
     for (const key of ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy']) {
       if (process.env[key]) env[key] = process.env[key];
     }
+    if (this.config.apiKey) {
+      env['OPENAI_API_KEY'] = this.config.apiKey;
+    }
+
+    const args: string[] = ['exec', '--json'];
+    if (this.config.model) {
+      args.push('--model', this.config.model);
+    }
+    args.push(
+      '--dangerously-bypass-approvals-and-sandbox',
+      '--skip-git-repo-check',
+      prompt,
+    );
+
+    const workdir = this.resolveWorkdir(workingDirectory);
+    log.info('Spawning codex (new session)', { cliPath, workdir, model: this.config.model });
+
+    return new Promise<CodexExecuteResult>((resolve, reject) => {
+      const child = spawn(cliPath, args, {
+        cwd: workdir,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      this.currentChild = child;
+
+      let stdout = '';
+      let stderr = '';
+      const MAX_OUTPUT = 10_000_000;
+
+      const timer = setTimeout(() => {
+        child.kill('SIGTERM');
+        const forceTimer = setTimeout(() => {
+          if (child.exitCode === null) child.kill('SIGKILL');
+        }, 5000);
+        child.on('close', () => clearTimeout(forceTimer));
+        reject(new Error(`Codex execution timed out after ${timeout}ms`));
+      }, timeout);
+
+      child.stdout?.on('data', (chunk: Buffer) => {
+        stdout += chunk.toString();
+        if (stdout.length > MAX_OUTPUT) {
+          child.kill('SIGTERM');
+          setTimeout(() => { if (child.exitCode === null) child.kill('SIGKILL'); }, 5000);
+        }
+      });
+
+      child.stderr?.on('data', (chunk: Buffer) => {
+        stderr += chunk.toString();
+        log.debug('Codex stderr', { text: chunk.toString().trim() });
+      });
+
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        this.currentChild = null;
+
+        if (code !== 0) {
+          const errMsg = stderr.trim() || stdout.trim() || `Codex exited with code ${code}`;
+          log.warn('Codex non-zero exit', { code, stderr: errMsg });
+          reject(new Error(errMsg));
+          return;
+        }
+
+        try {
+          const { text, sessionId } = this.parseJsonl(stdout);
+          resolve({ text, sessionId });
+        } catch (err) {
+          reject(new Error(`Failed to parse Codex JSONL output: ${(err as Error).message}`));
+        }
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timer);
+        log.error('Codex spawn failed', { error: err.message });
+        reject(new Error(`Failed to start codex: ${err.message}. Is it installed? (npm i -g @openai/codex)`));
+      });
+    });
+  }
+
+  // ── Resume session (subsequent turns) ─────────────────────────────────
+
+  private async executeResume(prompt: string, sessionId: string, workingDirectory?: string): Promise<CodexExecuteResult> {
+    const cliPath = this.config.cliPath || 'codex';
+    const timeout = this.config.timeout ?? 300_000;
+    const MAX_PROMPT = 100_000;
+
+    if (prompt.length > MAX_PROMPT) {
+      throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}). Split into smaller messages.`);
+    }
 
+    const env: Record<string, string> = {
+      PATH: process.env.PATH ?? '',
+      HOME: process.env.HOME ?? '',
+    };
+    for (const key of ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy']) {
+      if (process.env[key]) env[key] = process.env[key];
+    }
     if (this.config.apiKey) {
       env['OPENAI_API_KEY'] = this.config.apiKey;
     }
 
-    const args: string[] = [];
-    // Some codex versions support --model flag
+    const args: string[] = ['exec', 'resume', sessionId];
     if (this.config.model) {
       args.push('--model', this.config.model);
     }
-    args.push(prompt);
+    args.push(
+      '--dangerously-bypass-approvals-and-sandbox',
+      '--skip-git-repo-check',
+      prompt,
+    );
 
-    log.info('Spawning codex', { cliPath, workdir: this.config.workdir, model: this.config.model });
+    const workdir = this.resolveWorkdir(workingDirectory);
+    log.info('Spawning codex (resume)', { sessionId, workdir });
 
-    return new Promise<string>((resolve, reject) => {
+    return new Promise<CodexExecuteResult>((resolve, reject) => {
       const child = spawn(cliPath, args, {
-        cwd: this.config.workdir || process.cwd(),
+        cwd: workdir,
         env,
         stdio: ['ignore', 'pipe', 'pipe'],
       });
@@ -95,7 +217,6 @@ export class CodexClient {
 
       const timer = setTimeout(() => {
         child.kill('SIGTERM');
-        // Force kill after 5s grace period
         const forceTimer = setTimeout(() => {
           if (child.exitCode === null) child.kill('SIGKILL');
         }, 5000);
@@ -120,13 +241,27 @@ export class CodexClient {
         clearTimeout(timer);
         this.currentChild = null;
 
-        if (code === 0) {
-          resolve(stdout.trim());
-        } else {
+        if (code !== 0) {
           const errMsg = stderr.trim() || stdout.trim() || `Codex exited with code ${code}`;
           log.warn('Codex non-zero exit', { code, stderr: errMsg });
           reject(new Error(errMsg));
+          return;
         }
+
+        // Resume output: the CLI prints session metadata header + agent response.
+        // Strip the header lines (first 2+ lines before the actual output).
+        // The header looks like:
+        //   OpenAI Codex v0.142.0
+        //   --------
+        //   workdir: ...
+        //   ...
+        //   --------
+        //   user
+        //   ...
+        //   codex
+        //   <actual response>
+        const text = this.extractResumeText(stdout);
+        resolve({ text, sessionId });
       });
 
       child.on('error', (err) => {
@@ -136,4 +271,92 @@ export class CodexClient {
       });
     });
   }
+
+  // ── Parsers ───────────────────────────────────────────────────────────
+
+  /**
+   * Parse JSONL output to extract session thread_id and agent response text.
+   */
+  private parseJsonl(stdout: string): { text: string; sessionId: string } {
+    const lines = stdout.split('\n').filter((l) => l.trim());
+    let sessionId = '';
+    const textParts: string[] = [];
+
+    for (const line of lines) {
+      let event: Record<string, unknown>;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      // Extract thread_id from thread.started event
+      if (event.type === 'thread.started' && event.thread_id) {
+        sessionId = event.thread_id as string;
+      }
+
+      // Extract text from agent messages in item.completed events
+      if (event.type === 'item.completed') {
+        const item = event.item as Record<string, unknown> | undefined;
+        if (item && item.type === 'agent_message' && item.text) {
+          textParts.push(item.text as string);
+        }
+      }
+    }
+
+    if (!sessionId) {
+      throw new Error('No thread_id found in Codex JSONL output');
+    }
+
+    return {
+      text: textParts.join('\n').trim() || 'No response from Codex.',
+      sessionId,
+    };
+  }
+
+  /**
+   * Extract the agent response text from the resume mode output.
+   *
+   * The resume output includes a CLI header followed by the conversation.
+   * We extract everything after the last "codex" marker line as the
+   * latest agent response.
+   */
+  private extractResumeText(stdout: string): string {
+    const lines = stdout.split('\n');
+
+    // Find the separator: the last "codex" line marks the start of the response
+    let responseStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim() === 'codex') {
+        responseStart = i;
+      }
+    }
+
+    if (responseStart >= 0 && responseStart + 1 < lines.length) {
+      return lines.slice(responseStart + 1).join('\n').trim();
+    }
+
+    // Fallback: strip known header lines
+    let skipHeader = true;
+    const resultLines: string[] = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (skipHeader) {
+        if (trimmed === '--------' || trimmed === 'codex') {
+          skipHeader = false;
+        }
+        continue;
+      }
+      if (trimmed === 'user' || trimmed === 'codex') {
+        continue;
+      }
+      if (trimmed.startsWith('tokens used')) {
+        if (resultLines.length > 0) resultLines.pop();
+        break;
+      }
+      resultLines.push(line);
+    }
+
+    return resultLines.join('\n').trim() || stdout.trim();
+  }
 }