@plannotator/pi-extension 0.15.0 → 0.15.2

package/generated/ai/providers/codex-sdk.ts

@@ -0,0 +1,430 @@
+// @generated — DO NOT EDIT. Source: packages/ai/providers/codex-sdk.ts
+/**
+ * Codex SDK provider — bridges Plannotator's AI layer with OpenAI's Codex agent.
+ *
+ * Uses @openai/codex-sdk to create sessions that can:
+ * - Start fresh with Plannotator context as the system prompt
+ * - Fake-fork from a parent session (fresh thread + preamble, no real history)
+ * - Resume a previous thread by ID
+ * - Stream text deltas back to the UI in real time
+ *
+ * Sessions default to read-only sandbox mode for safety in inline chat.
+ */
+
+import { buildSystemPrompt, buildEffectivePrompt } from "../context.ts";
+import { BaseSession } from "../base-session.ts";
+import type {
+  AIProvider,
+  AIProviderCapabilities,
+  AISession,
+  AIMessage,
+  CreateSessionOptions,
+  CodexSDKConfig,
+} from "../types.ts";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const PROVIDER_NAME = "codex-sdk";
+const DEFAULT_MODEL = "gpt-5.4";
+
+// ---------------------------------------------------------------------------
+// Provider
+// ---------------------------------------------------------------------------
+
+export class CodexSDKProvider implements AIProvider {
+  readonly name = PROVIDER_NAME;
+  readonly capabilities: AIProviderCapabilities = {
+    fork: false, // No real fork — faked with fresh thread + preamble
+    resume: true,
+    streaming: true,
+    tools: true,
+  };
+  readonly models = [
+    { id: 'gpt-5.4', label: 'GPT-5.4', default: true },
+    { id: 'gpt-5.4-mini', label: 'GPT-5.4 Mini' },
+    { id: 'gpt-5.3-codex', label: 'GPT-5.3 Codex' },
+    { id: 'gpt-5.3-codex-spark', label: 'GPT-5.3 Codex Spark' },
+    { id: 'gpt-5.2-codex', label: 'GPT-5.2 Codex' },
+    { id: 'gpt-5.2', label: 'GPT-5.2' },
+  ] as const;
+
+  private config: CodexSDKConfig;
+
+  constructor(config: CodexSDKConfig) {
+    this.config = config;
+  }
+
+  async createSession(options: CreateSessionOptions): Promise<AISession> {
+    return new CodexSDKSession({
+      ...this.baseConfig(options),
+      systemPrompt: buildSystemPrompt(options.context),
+      cwd: options.cwd ?? this.config.cwd ?? process.cwd(),
+      parentSessionId: null,
+    });
+  }
+
+  async forkSession(_options: CreateSessionOptions): Promise<AISession> {
+    throw new Error(
+      "Codex does not support session forking. " +
+        "The endpoint layer should fall back to createSession()."
+    );
+  }
+
+  async resumeSession(sessionId: string): Promise<AISession> {
+    return new CodexSDKSession({
+      ...this.baseConfig(),
+      systemPrompt: null,
+      cwd: this.config.cwd ?? process.cwd(),
+      parentSessionId: null,
+      resumeThreadId: sessionId,
+    });
+  }
+
+  dispose(): void {
+    // No persistent resources to clean up
+  }
+
+  private baseConfig(options?: CreateSessionOptions) {
+    return {
+      model: options?.model ?? this.config.model ?? DEFAULT_MODEL,
+      maxTurns: options?.maxTurns ?? 99,
+      sandboxMode: this.config.sandboxMode ?? "read-only" as const,
+      codexExecutablePath: this.config.codexExecutablePath,
+      reasoningEffort: options?.reasoningEffort,
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// SDK import cache — resolve once, reuse across all sessions
+// ---------------------------------------------------------------------------
+
+// biome-ignore lint/suspicious/noExplicitAny: SDK type not available at compile time
+let CodexClass: any = null;
+
+async function getCodexClass() {
+  if (!CodexClass) {
+    // biome-ignore lint/suspicious/noExplicitAny: SDK exports vary between versions
+    const mod = await import("@openai/codex-sdk") as any;
+    CodexClass = mod.default ?? mod.Codex;
+  }
+  return CodexClass;
+}
+
+// ---------------------------------------------------------------------------
+// Session
+// ---------------------------------------------------------------------------
+
+interface SessionConfig {
+  systemPrompt: string | null;
+  model: string;
+  maxTurns: number;
+  sandboxMode: "read-only" | "workspace-write" | "danger-full-access";
+  cwd: string;
+  parentSessionId: string | null;
+  resumeThreadId?: string;
+  codexExecutablePath?: string;
+  reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+}
+
+class CodexSDKSession extends BaseSession {
+  private config: SessionConfig;
+  // biome-ignore lint/suspicious/noExplicitAny: SDK types not available at compile time
+  private _codexInstance: any = null;
+  // biome-ignore lint/suspicious/noExplicitAny: SDK types not available at compile time
+  private _thread: any = null;
+  /** Tracks cumulative text length per item for delta extraction. */
+  private _itemTextOffsets = new Map<string, number>();
+
+  constructor(config: SessionConfig) {
+    super({
+      parentSessionId: config.parentSessionId,
+      initialId: config.resumeThreadId,
+    });
+    this.config = config;
+    // If resuming, treat the thread ID as already resolved
+    if (config.resumeThreadId) {
+      this._resolvedId = config.resumeThreadId;
+    }
+  }
+
+  async *query(prompt: string): AsyncIterable<AIMessage> {
+    const started = this.startQuery();
+    if (!started) { yield BaseSession.BUSY_ERROR; return; }
+    const { gen, signal } = started;
+
+    this._itemTextOffsets.clear();
+
+    try {
+      const Codex = await getCodexClass();
+
+      // Lazy-create the Codex instance
+      if (!this._codexInstance) {
+        this._codexInstance = new Codex({
+          ...(this.config.codexExecutablePath && { codexPathOverride: this.config.codexExecutablePath }),
+        });
+      }
+
+      // Lazy-create or resume the thread
+      if (!this._thread) {
+        if (this.config.resumeThreadId) {
+          this._thread = this._codexInstance.resumeThread(this.config.resumeThreadId, {
+            model: this.config.model,
+            workingDirectory: this.config.cwd,
+            sandboxMode: this.config.sandboxMode,
+            ...(this.config.reasoningEffort && { modelReasoningEffort: this.config.reasoningEffort }),
+          });
+        } else {
+          this._thread = this._codexInstance.startThread({
+            model: this.config.model,
+            workingDirectory: this.config.cwd,
+            sandboxMode: this.config.sandboxMode,
+            ...(this.config.reasoningEffort && { modelReasoningEffort: this.config.reasoningEffort }),
+          });
+        }
+      }
+
+      const effectivePrompt = buildEffectivePrompt(
+        prompt,
+        this.config.systemPrompt,
+        this._firstQuerySent,
+      );
+      const streamed = await this._thread.runStreamed(effectivePrompt, {
+        signal,
+      });
+
+      this._firstQuerySent = true;
+      let turnFailed = false;
+
+      for await (const event of streamed.events) {
+        // ID resolution from thread.started
+        if (
+          !this._resolvedId &&
+          event.type === "thread.started" &&
+          typeof event.thread_id === "string"
+        ) {
+          this.resolveId(event.thread_id);
+        }
+
+        if (event.type === "turn.failed") {
+          turnFailed = true;
+        }
+
+        const mapped = mapCodexEvent(event, this._itemTextOffsets);
+        for (const msg of mapped) {
+          yield msg;
+        }
+      }
+
+      // Emit synthetic result after stream ends
+      if (!turnFailed) {
+        yield {
+          type: "result",
+          sessionId: this.id,
+          success: true,
+        };
+      }
+    } catch (err) {
+      yield {
+        type: "error",
+        error: err instanceof Error ? err.message : String(err),
+        code: "provider_error",
+      };
+    } finally {
+      this.endQuery(gen);
+    }
+  }
+
+}
+
+// ---------------------------------------------------------------------------
+// Event mapping
+// ---------------------------------------------------------------------------
+
+/**
+ * Map a Codex SDK ThreadEvent to one or more AIMessages.
+ *
+ * The itemTextOffsets map tracks cumulative text length per item ID
+ * so we can extract true deltas from the cumulative text in item.updated events.
+ */
+function mapCodexEvent(
+  event: Record<string, unknown>,
+  itemTextOffsets: Map<string, number>,
+): AIMessage[] {
+  const eventType = event.type as string;
+
+  switch (eventType) {
+    case "thread.started":
+    case "turn.started":
+      return [];
+
+    case "turn.completed":
+      return [];
+
+    case "turn.failed": {
+      const error = event.error as Record<string, unknown> | undefined;
+      return [{
+        type: "error",
+        error: (error?.message as string) ?? "Turn failed",
+        code: "turn_failed",
+      }];
+    }
+
+    case "error":
+      return [{
+        type: "error",
+        error: (event.message as string) ?? "Unknown error",
+        code: "codex_error",
+      }];
+
+    case "item.started":
+    case "item.updated":
+    case "item.completed":
+      return mapCodexItem(event, itemTextOffsets);
+
+    default:
+      return [{ type: "unknown", raw: event }];
+  }
+}
+
+/**
+ * Map item-level events to AIMessages.
+ */
+function mapCodexItem(
+  event: Record<string, unknown>,
+  itemTextOffsets: Map<string, number>,
+): AIMessage[] {
+  const item = event.item as Record<string, unknown>;
+  if (!item) return [{ type: "unknown", raw: event }];
+
+  const eventType = event.type as string;
+  const itemType = item.type as string;
+  const itemId = (item.id as string) ?? "";
+  const isStarted = eventType === "item.started";
+  const isCompleted = eventType === "item.completed";
+
+  switch (itemType) {
+    case "agent_message": {
+      const text = (item.text as string) ?? "";
+
+      if (isStarted) {
+        // Reset offset tracking for this item
+        itemTextOffsets.set(itemId, 0);
+        return [];
+      }
+
+      if (isCompleted) {
+        // Emit final complete text
+        itemTextOffsets.delete(itemId);
+        return text ? [{ type: "text", text }] : [];
+      }
+
+      // item.updated — extract delta from cumulative text
+      const prevOffset = itemTextOffsets.get(itemId) ?? 0;
+      if (text.length > prevOffset) {
+        const delta = text.slice(prevOffset);
+        itemTextOffsets.set(itemId, text.length);
+        return [{ type: "text_delta", delta }];
+      }
+      return [];
+    }
+
+    case "command_execution": {
+      const messages: AIMessage[] = [];
+      if (isStarted) {
+        messages.push({
+          type: "tool_use",
+          toolName: "Bash",
+          toolInput: { command: item.command as string },
+          toolUseId: itemId,
+        });
+      }
+      if (isCompleted) {
+        const output = (item.aggregated_output as string) ?? "";
+        const exitCode = item.exit_code as number | undefined;
+        messages.push({
+          type: "tool_result",
+          toolUseId: itemId,
+          result: exitCode != null ? `${output}\n[exit code: ${exitCode}]` : output,
+        });
+      }
+      return messages;
+    }
+
+    case "file_change": {
+      const changes = item.changes as Array<{ path: string; kind: string }> | undefined;
+      if (isStarted || isCompleted) {
+        return [{
+          type: "tool_use",
+          toolName: "FileChange",
+          toolInput: { changes: changes ?? [] },
+          toolUseId: itemId,
+        }];
+      }
+      return [];
+    }
+
+    case "mcp_tool_call": {
+      const messages: AIMessage[] = [];
+      if (isStarted) {
+        messages.push({
+          type: "tool_use",
+          toolName: `${item.server as string}/${item.tool as string}`,
+          toolInput: (item.arguments as Record<string, unknown>) ?? {},
+          toolUseId: itemId,
+        });
+      }
+      if (isCompleted) {
+        if (item.result != null) {
+          messages.push({
+            type: "tool_result",
+            toolUseId: itemId,
+            result: typeof item.result === "string" ? item.result : JSON.stringify(item.result),
+          });
+        }
+        if (item.error) {
+          const err = item.error as Record<string, unknown>;
+          messages.push({
+            type: "error",
+            error: (err.message as string) ?? "MCP tool call failed",
+            code: "mcp_error",
+          });
+        }
+      }
+      return messages;
+    }
+
+    case "error":
+      return [{
+        type: "error",
+        error: (item.message as string) ?? "Unknown error",
+      }];
+
+    case "reasoning":
+    case "web_search":
+    case "todo_list":
+      return [{ type: "unknown", raw: { eventType, item } }];
+
+    default:
+      return [{ type: "unknown", raw: { eventType, item } }];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Exported for testing
+// ---------------------------------------------------------------------------
+
+export { mapCodexEvent, mapCodexItem };
+
+// ---------------------------------------------------------------------------
+// Factory registration
+// ---------------------------------------------------------------------------
+
+import { registerProviderFactory } from "../provider.ts";
+
+registerProviderFactory(
+  PROVIDER_NAME,
+  async (config) => new CodexSDKProvider(config as CodexSDKConfig)
+);