@axiom-lattice/cli-a2a 0.1.5 → 0.1.7

package/src/executors/codex/executor.ts

@@ -2,20 +2,23 @@
  * Codex A2A Executor
  *
  * Bridges the local Codex CLI to the A2A protocol. Spawns Codex as a
- * child process for each request and captures stdout as the response.
+ * child process 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 { CodexClient } from './client.js';
 import {
   publishTask,
   publishStatus,
   publishFinalArtifact,
+  extractText,
 } from '../events.js';
 
 const log = logger.child('codex:executor');
@@ -26,9 +29,11 @@ export class CodexExecutor implements A2AExecutor {
   private config: Required<AgentConfig>;
   private client: CodexClient | 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> {
@@ -54,37 +59,75 @@ export class CodexExecutor implements A2AExecutor {
   }
 
   async execute(ctx: RequestContext, bus: ExecutionEventBus): Promise<void> {
-    const { taskId, contextId, userMessage, task } = ctx;
+    const { taskId, userMessage } = ctx;
     await this.initialize();
 
-    try {
-      // 1. Register task
-      if (!task) {
-        publishTask(bus, taskId, contextId);
-        publishStatus(bus, taskId, contextId, 'submitted');
-      }
+    const reuseByContext = this.config.session?.reuseByContext ?? true;
 
-      // 2. Working
-      publishStatus(bus, taskId, contextId, 'working', 'Processing request...');
+    // Resolve contextId: use provided one or generate new
+    let contextId = ctx.contextId;
+    if (!contextId) {
+      contextId = generateContextId();
+      log.info('Generated new contextId', { contextId, taskId });
+    }
 
-      // 3. Extract prompt text
-      const promptText = this.extractText(userMessage);
+    // Look up existing session binding
+    const binding = reuseByContext
+      ? this.sessionStore.get(contextId, 'codex')
+      : null;
 
-      log.info('Sending prompt to Codex', { taskId, len: promptText.length });
+    const sessionId = binding?.sessionId;
 
-      // 4. Execute
-      const response = await this.client!.execute(promptText);
+    try {
+      // Register task (always include contextId so client can track)
+      const existingTask = ctx.task;
+      if (!existingTask) {
+        publishTask(bus, taskId, contextId);
+        publishStatus(bus, taskId, contextId, 'submitted');
+      }
 
-      // 5. Finalize
-      const finalText = response || 'No response from Codex.';
-      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 Codex', {
+        taskId,
+        contextId,
+        sessionId: sessionId || '(new)',
+        len: promptText.length,
+        workingDirectory: workingDirectory || '(default)',
+      });
+
+      const result = await this.client!.execute(promptText, sessionId, workingDirectory);
+
+      // Save or update session binding
+      this.sessionStore.set({
+        provider: 'codex',
+        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(),
+      });
+
+      // Finalize
+      publishFinalArtifact(bus, taskId, contextId, result.text || 'No response from Codex.');
       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();
     }
@@ -96,23 +139,13 @@ export class CodexExecutor implements A2AExecutor {
     publishStatus(bus, taskId, '', 'canceled', 'Codex task cancelled', true);
     bus.finished();
   }
-
-  // ── Helpers ─────────────────────────────────────────────────────────────
-
-  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 createCodexExecutor(config: Required<AgentConfig>): A2AExecutor {
-  return new CodexExecutor(config);
+export function createCodexExecutor(
+  config: Required<AgentConfig>,
+  sessionStore: SessionBindingStore,
+): A2AExecutor {
+  return new CodexExecutor(config, sessionStore);
 }

package/src/executors/events.ts

@@ -6,10 +6,24 @@
  */
 
 import { TaskState } from '@a2a-js/sdk';
-import type { TaskStatusUpdateEvent, TaskArtifactUpdateEvent } from '@a2a-js/sdk';
+import type { TaskStatusUpdateEvent, TaskArtifactUpdateEvent, Message as A2AMessage } from '@a2a-js/sdk';
 import type { ExecutionEventBus } from '@a2a-js/sdk/server';
 import { v4 as uuidv4 } from 'uuid';
 
+/**
+ * Extract plain text content from an A2A message's parts.
+ */
+export function 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');
+}
+
 /**
  * Register a task with the execution event bus before publishing any events.
  */

package/src/executors/index.ts

@@ -7,6 +7,8 @@
  */
 
 import type { AgentExecutor } from '@a2a-js/sdk/server';
+import type { SessionBindingStore } from '../session-store.js';
+import type { AgentConfig, ProviderType } from '../config/types.js';
 
 /**
  * Extended executor interface with lifecycle methods.
@@ -24,12 +26,14 @@ export type { AgentExecutor, RequestContext, ExecutionEventBus } from '@a2a-js/s
 export { TaskState } from '@a2a-js/sdk';
 export { v4 as uuidv4 } from 'uuid';
 
-import type { AgentConfig, ProviderType } from '../config/types.js';
-
 /**
- * Factory function type: given resolved config, produce an executor.
+ * Factory function type: given resolved config and a session store,
+ * produce an executor.
  */
-export type ExecutorFactory = (config: Required<AgentConfig>) => A2AExecutor;
+export type ExecutorFactory = (
+  config: Required<AgentConfig>,
+  sessionStore: SessionBindingStore,
+) => A2AExecutor;
 
 /**
  * Map provider type to executor factory.
@@ -44,11 +48,14 @@ export function getExecutor(provider: ProviderType): ExecutorFactory | undefined
   return registry.get(provider);
 }
 
-export function createExecutor(config: Required<AgentConfig>): A2AExecutor {
+export function createExecutor(
+  config: Required<AgentConfig>,
+  sessionStore: SessionBindingStore,
+): A2AExecutor {
   const factory = registry.get(config.provider);
   if (!factory) {
     const available = Array.from(registry.keys()).join(', ');
     throw new Error(`Unknown provider: ${config.provider}. Available: ${available}`);
   }
-  return factory(config);
+  return factory(config, sessionStore);
 }

package/src/executors/opencode/client.ts

@@ -1,9 +1,10 @@
 /**
  * OpenCode CLI client wrapper.
  *
- * Spawns the OpenCode CLI as a child process. Uses `opencode run` with
- * optional `--attach` to connect to an existing server. Captures stdout
- * as the response. Same pattern as Codex and Claude Code clients.
+ * Spawns the OpenCode CLI as a child process. For the first turn, uses
+ * `--format json` to discover the session ID, then extracts the response
+ * text. For subsequent turns, uses `--session <id>` to continue the
+ * conversation with plain text output.
  */
 
 import { spawn } from 'node:child_process';
@@ -28,6 +29,11 @@ export interface OpenCodeClientConfig {
   timeout?: number;
 }
 
+export interface OpenCodeExecuteResult {
+  text: string;
+  sessionId: string;
+}
+
 // ─── Client ─────────────────────────────────────────────────────────────────
 
 export class OpenCodeClient {
@@ -35,7 +41,6 @@ export class OpenCodeClient {
 
   constructor(private config: OpenCodeClientConfig) {}
 
-  /** Abort the currently running child process (if any). */
   abort(): void {
     if (this.currentChild) {
       this.currentChild.kill('SIGTERM');
@@ -49,18 +54,38 @@ export class OpenCodeClient {
   }
 
   /**
-   * Execute a prompt via the OpenCode CLI and return the response text.
+   * Execute a prompt via the OpenCode CLI.
+   *
+   * @param prompt - The user prompt text.
+   * @param sessionId - If provided, continues the session with `--session`.
+   *   Otherwise creates a new session using `--format json` to capture the
+   *   session ID.
+   * @param workingDirectory - Optional per-request working directory override.
+   *   Falls back to config.workdir if not provided.
    */
-  async execute(prompt: string): Promise<string> {
+  async execute(prompt: string, sessionId?: string, workingDirectory?: string): Promise<OpenCodeExecuteResult> {
+    if (sessionId) {
+      const text = await this.runResume(prompt, sessionId, workingDirectory);
+      return { text, sessionId };
+    }
+    return this.runNew(prompt, workingDirectory);
+  }
+
+  private resolveWorkdir(override?: string): string {
+    return override || this.config.workdir || process.cwd();
+  }
+
+  // ── New session (first turn) ──────────────────────────────────────────
+
+  private async runNew(prompt: string, workingDirectory?: string): Promise<OpenCodeExecuteResult> {
     const cliPath = this.config.cliPath || 'opencode';
     const timeout = this.config.timeout ?? 600_000;
-    const MAX_PROMPT = 100_000; // safe below typical ARG_MAX
+    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 or use a provider with HTTP API transport.`);
+      throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}).`);
     }
 
-    // Only pass essential env vars
     const env: Record<string, string> = {
       PATH: process.env.PATH ?? '',
       HOME: process.env.HOME ?? '',
@@ -68,13 +93,110 @@ export class OpenCodeClient {
     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];
     }
-    // Forward auth env vars if present
     for (const key of ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'OPENCODE_SERVER_PASSWORD', 'OPENCODE_SERVER_USERNAME']) {
       if (process.env[key]) env[key] = process.env[key];
     }
 
-    const args: string[] = ['run', prompt];
+    const args: string[] = ['run', '--format', 'json'];
+    if (this.config.model) {
+      args.push('--model', this.config.model);
+    }
+    if (this.config.agent) {
+      args.push('--agent', this.config.agent);
+    }
+    if (this.config.attachUrl) {
+      args.push('--attach', this.config.attachUrl);
+    }
+    args.push('--dangerously-skip-permissions', prompt);
+
+    const workdir = this.resolveWorkdir(workingDirectory);
+    log.info('Spawning opencode (new session, json)', { cliPath, workdir });
+
+    return new Promise<OpenCodeExecuteResult>((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(`OpenCode 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('OpenCode stderr', { text: chunk.toString().trim() });
+      });
+
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        this.currentChild = null;
+
+        if (code !== 0) {
+          const errMsg = stderr.trim() || stdout.trim() || `OpenCode exited with code ${code}`;
+          log.warn('OpenCode non-zero exit', { code, stderr: errMsg });
+          reject(new Error(errMsg));
+          return;
+        }
+
+        try {
+          const { text, sessionId } = this.parseJsonEvents(stdout);
+          resolve({ text, sessionId });
+        } catch (err) {
+          reject(new Error(`Failed to parse OpenCode JSON output: ${(err as Error).message}`));
+        }
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timer);
+        log.error('OpenCode spawn failed', { error: err.message });
+        reject(new Error(`Failed to start opencode: ${err.message}. Is it installed?`));
+      });
+    });
+  }
+
+  // ── Resume session ────────────────────────────────────────────────────
+
+  private async runResume(prompt: string, sessionId: string, workingDirectory?: string): Promise<string> {
+    const cliPath = this.config.cliPath || 'opencode';
+    const timeout = this.config.timeout ?? 600_000;
+    const MAX_PROMPT = 100_000;
+
+    if (prompt.length > MAX_PROMPT) {
+      throw new Error(`Prompt too large (${prompt.length} chars, max ${MAX_PROMPT}).`);
+    }
+
+    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];
+    }
+    for (const key of ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'OPENCODE_SERVER_PASSWORD', 'OPENCODE_SERVER_USERNAME']) {
+      if (process.env[key]) env[key] = process.env[key];
+    }
+
+    const args: string[] = ['run', '--session', sessionId];
     if (this.config.model) {
       args.push('--model', this.config.model);
     }
@@ -84,16 +206,14 @@ export class OpenCodeClient {
     if (this.config.attachUrl) {
       args.push('--attach', this.config.attachUrl);
     }
-    // Default format captures plain text output
-    args.push('--format', 'default');
-    // Never go interactive
-    args.push('--dangerously-skip-permissions');
+    args.push('--format', 'default', '--dangerously-skip-permissions', prompt);
 
-    log.info('Spawning opencode', { cliPath, workdir: this.config.workdir, model: this.config.model });
+    const workdir = this.resolveWorkdir(workingDirectory);
+    log.info('Spawning opencode (resume)', { sessionId, workdir });
 
     return new Promise<string>((resolve, reject) => {
       const child = spawn(cliPath, args, {
-        cwd: this.config.workdir || process.cwd(),
+        cwd: workdir,
         env,
         stdio: ['ignore', 'pipe', 'pipe'],
       });
@@ -102,7 +222,7 @@ export class OpenCodeClient {
 
       let stdout = '';
       let stderr = '';
-      const MAX_OUTPUT = 10_000_000; // 10MB
+      const MAX_OUTPUT = 10_000_000;
 
       const timer = setTimeout(() => {
         child.kill('SIGTERM');
@@ -146,4 +266,58 @@ export class OpenCodeClient {
       });
     });
   }
+
+  // ── Parser ────────────────────────────────────────────────────────────
+
+  /**
+   * Parse newline-delimited JSON events from OpenCode's `--format json` output.
+   * Extracts the sessionID from the first event that contains it, and
+   * accumulates text content from relevant events.
+   */
+  private parseJsonEvents(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;
+      }
+
+      // Capture sessionID from any event that has it
+      if (!sessionId && event.sessionID) {
+        sessionId = event.sessionID as string;
+      }
+
+      // Skip error events — they don't contain user-facing text
+      if (event.type === 'error') continue;
+
+      // Extract text from events that have content
+      // Common OpenCode event shapes: { type, text }, { type, content }, { message }
+      const text = event.text as string | undefined
+        || event.content as string | undefined
+        || event.message as string | undefined;
+
+      if (text) {
+        textParts.push(text);
+      }
+    }
+
+    if (!sessionId) {
+      // Fallback: if no sessionID in JSON, the output may be plain text from
+      // a non-JSON mode invocation. Return the raw text.
+      return {
+        text: textParts.join('\n').trim() || stdout.trim(),
+        sessionId: '',
+      };
+    }
+
+    return {
+      text: textParts.join('\n').trim() || 'No response from OpenCode.',
+      sessionId,
+    };
+  }
 }

package/src/executors/opencode/executor.ts

@@ -2,21 +2,23 @@
  * OpenCode A2A Executor
  *
  * Bridges the local OpenCode CLI to the A2A protocol. Spawns `opencode run`
- * as a child process for each request and captures stdout as the response.
- * Same spawn pattern as Codex and Claude Code executors.
+ * as a child process 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 { OpenCodeClient } from './client.js';
 import {
   publishTask,
   publishStatus,
   publishFinalArtifact,
+  extractText,
 } from '../events.js';
 
 const log = logger.child('opencode:executor');
@@ -27,9 +29,11 @@ export class OpenCodeExecutor implements A2AExecutor {
   private config: Required<AgentConfig>;
   private client: OpenCodeClient | 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> {
@@ -56,31 +60,70 @@ export class OpenCodeExecutor 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, 'opencode')
+      : 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 OpenCode', { taskId, len: promptText.length });
-
-      const response = await this.client!.execute(promptText);
-
-      const finalText = response || 'No response from OpenCode.';
-      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 OpenCode', {
+        taskId,
+        contextId,
+        sessionId: sessionId || '(new)',
+        len: promptText.length,
+        workingDirectory: workingDirectory || '(default)',
+      });
+
+      const result = await this.client!.execute(promptText, sessionId, workingDirectory);
+
+      this.sessionStore.set({
+        provider: 'opencode',
+        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 OpenCode.');
       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();
     }
@@ -92,21 +135,13 @@ export class OpenCodeExecutor implements A2AExecutor {
     publishStatus(bus, taskId, '', 'canceled', 'OpenCode 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 createOpenCodeExecutor(config: Required<AgentConfig>): A2AExecutor {
-  return new OpenCodeExecutor(config);
+export function createOpenCodeExecutor(
+  config: Required<AgentConfig>,
+  sessionStore: SessionBindingStore,
+): A2AExecutor {
+  return new OpenCodeExecutor(config, sessionStore);
 }

package/src/index.ts

@@ -52,3 +52,11 @@ export type { AgentExecutor, RequestContext, ExecutionEventBus } from './executo
 
 // Logger
 export { logger, LogLevel } from './logger.js';
+
+// Session Store
+export {
+  SessionBindingStore,
+  generateContextId,
+  resolveSessionStorePath,
+} from './session-store.js';
+export type { SessionBinding } from './session-store.js';