axexec 1.0.0

package/dist/agents/codex/types.d.ts

@@ -0,0 +1,407 @@
+/**
+ * Raw event types from Codex CLI's JSONL stream.
+ *
+ * These types represent the raw output from:
+ * `codex exec --json "..."`
+ *
+ * The parser transforms these into normalized {@link AxexecEvent} types.
+ */
+import { z } from "zod";
+/** Thread started event - emitted when a new thread begins */
+declare const CodexThreadStartedEvent: z.ZodObject<{
+    type: z.ZodLiteral<"thread.started">;
+    thread_id: z.ZodString;
+}, z.core.$strip>;
+type CodexThreadStartedEvent = z.infer<typeof CodexThreadStartedEvent>;
+/** Turn completed event - emitted when a turn finishes successfully */
+declare const CodexTurnCompletedEvent: z.ZodObject<{
+    type: z.ZodLiteral<"turn.completed">;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        cached_input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type CodexTurnCompletedEvent = z.infer<typeof CodexTurnCompletedEvent>;
+/** Turn failed event - emitted when a turn fails */
+declare const CodexTurnFailedEvent: z.ZodObject<{
+    type: z.ZodLiteral<"turn.failed">;
+    error: z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type CodexTurnFailedEvent = z.infer<typeof CodexTurnFailedEvent>;
+/** Item started event - emitted when an item begins processing */
+declare const CodexItemStartedEvent: z.ZodObject<{
+    type: z.ZodLiteral<"item.started">;
+    item: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"command_execution">;
+        command: z.ZodString;
+        aggregated_output: z.ZodString;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"mcp_tool_call">;
+        server: z.ZodString;
+        tool: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"file_change">;
+        changes: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                add: "add";
+                delete: "delete";
+                update: "update";
+            }>;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"agent_message">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"reasoning">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"web_search">;
+        query: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"todo_list">;
+        items: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            completed: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+type CodexItemStartedEvent = z.infer<typeof CodexItemStartedEvent>;
+/** Item completed event - emitted when an item finishes */
+declare const CodexItemCompletedEvent: z.ZodObject<{
+    type: z.ZodLiteral<"item.completed">;
+    item: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"command_execution">;
+        command: z.ZodString;
+        aggregated_output: z.ZodString;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"mcp_tool_call">;
+        server: z.ZodString;
+        tool: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"file_change">;
+        changes: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                add: "add";
+                delete: "delete";
+                update: "update";
+            }>;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"agent_message">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"reasoning">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"web_search">;
+        query: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"todo_list">;
+        items: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            completed: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+type CodexItemCompletedEvent = z.infer<typeof CodexItemCompletedEvent>;
+/** Error event - top-level error */
+declare const CodexErrorEvent: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, z.core.$strip>;
+type CodexErrorEvent = z.infer<typeof CodexErrorEvent>;
+/** Union of all Codex CLI event types */
+declare const CodexEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"thread.started">;
+    thread_id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"turn.started">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"turn.completed">;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        cached_input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"turn.failed">;
+    error: z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"item.started">;
+    item: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"command_execution">;
+        command: z.ZodString;
+        aggregated_output: z.ZodString;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"mcp_tool_call">;
+        server: z.ZodString;
+        tool: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"file_change">;
+        changes: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                add: "add";
+                delete: "delete";
+                update: "update";
+            }>;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"agent_message">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"reasoning">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"web_search">;
+        query: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"todo_list">;
+        items: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            completed: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"item.updated">;
+    item: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"command_execution">;
+        command: z.ZodString;
+        aggregated_output: z.ZodString;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"mcp_tool_call">;
+        server: z.ZodString;
+        tool: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"file_change">;
+        changes: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                add: "add";
+                delete: "delete";
+                update: "update";
+            }>;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"agent_message">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"reasoning">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"web_search">;
+        query: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"todo_list">;
+        items: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            completed: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"item.completed">;
+    item: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"command_execution">;
+        command: z.ZodString;
+        aggregated_output: z.ZodString;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"mcp_tool_call">;
+        server: z.ZodString;
+        tool: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"file_change">;
+        changes: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                add: "add";
+                delete: "delete";
+                update: "update";
+            }>;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"agent_message">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"reasoning">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"web_search">;
+        query: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"todo_list">;
+        items: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            completed: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, z.core.$strip>], "type">;
+type CodexEvent = z.infer<typeof CodexEvent>;
+/** Type guard for thread.started events */
+declare function isThreadStartedEvent(event: CodexEvent): event is CodexThreadStartedEvent;
+/** Type guard for turn.completed events */
+declare function isTurnCompletedEvent(event: CodexEvent): event is CodexTurnCompletedEvent;
+/** Type guard for turn.failed events */
+declare function isTurnFailedEvent(event: CodexEvent): event is CodexTurnFailedEvent;
+/** Type guard for item.started events */
+declare function isItemStartedEvent(event: CodexEvent): event is CodexItemStartedEvent;
+/** Type guard for item.completed events */
+declare function isItemCompletedEvent(event: CodexEvent): event is CodexItemCompletedEvent;
+/** Type guard for error events */
+declare function isErrorEvent(event: CodexEvent): event is CodexErrorEvent;
+export { CodexEvent, isErrorEvent, isItemCompletedEvent, isItemStartedEvent, isThreadStartedEvent, isTurnCompletedEvent, isTurnFailedEvent, };
+export type { CodexErrorEvent, CodexItemCompletedEvent, CodexItemStartedEvent, CodexThreadStartedEvent, CodexTurnCompletedEvent, CodexTurnFailedEvent, };

package/dist/agents/codex/types.js

@@ -0,0 +1,188 @@
+/**
+ * Raw event types from Codex CLI's JSONL stream.
+ *
+ * These types represent the raw output from:
+ * `codex exec --json "..."`
+ *
+ * The parser transforms these into normalized {@link AxexecEvent} types.
+ */
+import { z } from "zod";
+// =============================================================================
+// Thread Item Types (discriminated union)
+// =============================================================================
+/** Status for items that can be in progress */
+const CodexItemStatus = z.enum(["in_progress", "completed", "failed"]);
+/** Command execution item - shell command being executed */
+const CodexCommandExecutionItem = z.object({
+    id: z.string(),
+    type: z.literal("command_execution"),
+    command: z.string(),
+    aggregated_output: z.string(),
+    exit_code: z.number().nullish(),
+    status: CodexItemStatus,
+});
+/** MCP tool call item - MCP server tool invocation */
+const CodexMcpToolCallItem = z.object({
+    id: z.string(),
+    type: z.literal("mcp_tool_call"),
+    server: z.string(),
+    tool: z.string(),
+    arguments: z.record(z.string(), z.unknown()),
+    result: z.unknown().optional(),
+    error: z.string().optional(),
+    status: CodexItemStatus,
+});
+/** File change kind */
+const CodexFileChangeKind = z.enum(["add", "delete", "update"]);
+/** Individual file change entry */
+const CodexFileChangeEntry = z.object({
+    path: z.string(),
+    kind: CodexFileChangeKind,
+});
+/** File change item - file modifications */
+const CodexFileChangeItem = z.object({
+    id: z.string(),
+    type: z.literal("file_change"),
+    changes: z.array(CodexFileChangeEntry),
+    status: z.enum(["completed", "failed"]),
+});
+/** Agent message item - text output from the agent */
+const CodexAgentMessageItem = z.object({
+    id: z.string(),
+    type: z.literal("agent_message"),
+    text: z.string(),
+});
+/** Reasoning item - agent's reasoning process */
+const CodexReasoningItem = z.object({
+    id: z.string(),
+    type: z.literal("reasoning"),
+    text: z.string(),
+});
+/** Web search item - web search query */
+const CodexWebSearchItem = z.object({
+    id: z.string(),
+    type: z.literal("web_search"),
+    query: z.string(),
+});
+/** Todo item entry */
+const CodexTodoEntry = z.object({
+    text: z.string(),
+    completed: z.boolean(),
+});
+/** Todo list item - task list */
+const CodexTodoListItem = z.object({
+    id: z.string(),
+    type: z.literal("todo_list"),
+    items: z.array(CodexTodoEntry),
+});
+/** Error item - error within thread */
+const CodexErrorItem = z.object({
+    id: z.string(),
+    type: z.literal("error"),
+    message: z.string(),
+});
+/** Union of all thread item types */
+const CodexThreadItem = z.discriminatedUnion("type", [
+    CodexCommandExecutionItem,
+    CodexMcpToolCallItem,
+    CodexFileChangeItem,
+    CodexAgentMessageItem,
+    CodexReasoningItem,
+    CodexWebSearchItem,
+    CodexTodoListItem,
+    CodexErrorItem,
+]);
+// =============================================================================
+// Event Types
+// =============================================================================
+/** Thread started event - emitted when a new thread begins */
+const CodexThreadStartedEvent = z.object({
+    type: z.literal("thread.started"),
+    thread_id: z.string(),
+});
+/** Turn started event - emitted when a new turn begins */
+const CodexTurnStartedEvent = z.object({
+    type: z.literal("turn.started"),
+});
+/** Usage statistics for a completed turn */
+const CodexUsage = z.object({
+    input_tokens: z.number(),
+    cached_input_tokens: z.number(),
+    output_tokens: z.number(),
+});
+/** Turn completed event - emitted when a turn finishes successfully */
+const CodexTurnCompletedEvent = z.object({
+    type: z.literal("turn.completed"),
+    usage: CodexUsage,
+});
+/** Error info for failed turns */
+const CodexTurnError = z.object({
+    message: z.string(),
+});
+/** Turn failed event - emitted when a turn fails */
+const CodexTurnFailedEvent = z.object({
+    type: z.literal("turn.failed"),
+    error: CodexTurnError,
+});
+/** Item started event - emitted when an item begins processing */
+const CodexItemStartedEvent = z.object({
+    type: z.literal("item.started"),
+    item: CodexThreadItem,
+});
+/** Item updated event - emitted when an item is updated */
+const CodexItemUpdatedEvent = z.object({
+    type: z.literal("item.updated"),
+    item: CodexThreadItem,
+});
+/** Item completed event - emitted when an item finishes */
+const CodexItemCompletedEvent = z.object({
+    type: z.literal("item.completed"),
+    item: CodexThreadItem,
+});
+/** Error event - top-level error */
+const CodexErrorEvent = z.object({
+    type: z.literal("error"),
+    message: z.string(),
+});
+/** Union of all Codex CLI event types */
+const CodexEvent = z.discriminatedUnion("type", [
+    CodexThreadStartedEvent,
+    CodexTurnStartedEvent,
+    CodexTurnCompletedEvent,
+    CodexTurnFailedEvent,
+    CodexItemStartedEvent,
+    CodexItemUpdatedEvent,
+    CodexItemCompletedEvent,
+    CodexErrorEvent,
+]);
+// =============================================================================
+// Type Guards
+// =============================================================================
+/** Type guard for thread.started events */
+function isThreadStartedEvent(event) {
+    return event.type === "thread.started";
+}
+/** Type guard for turn.completed events */
+function isTurnCompletedEvent(event) {
+    return event.type === "turn.completed";
+}
+/** Type guard for turn.failed events */
+function isTurnFailedEvent(event) {
+    return event.type === "turn.failed";
+}
+/** Type guard for item.started events */
+function isItemStartedEvent(event) {
+    return event.type === "item.started";
+}
+/** Type guard for item.completed events */
+function isItemCompletedEvent(event) {
+    return event.type === "item.completed";
+}
+/** Type guard for error events */
+function isErrorEvent(event) {
+    return event.type === "error";
+}
+// =============================================================================
+// Exports
+// =============================================================================
+export { CodexEvent, isErrorEvent, isItemCompletedEvent, isItemStartedEvent, isThreadStartedEvent, isTurnCompletedEvent, isTurnFailedEvent, };

package/dist/agents/copilot/adapter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copilot CLI adapter implementation.
+ *
+ * Implements the {@link AgentAdapter} interface for Copilot CLI.
+ *
+ * Unlike other agents that stream JSONL to stdout, Copilot CLI writes
+ * session events to JSONL files in ~/.copilot/session-state/. This adapter
+ * uses a wrapper script that tails the session file and streams events
+ * to stdout.
+ */
+export {};

package/dist/agents/copilot/adapter.js

@@ -0,0 +1,81 @@
+/**
+ * Copilot CLI adapter implementation.
+ *
+ * Implements the {@link AgentAdapter} interface for Copilot CLI.
+ *
+ * Unlike other agents that stream JSONL to stdout, Copilot CLI writes
+ * session events to JSONL files in ~/.copilot/session-state/. This adapter
+ * uses a wrapper script that tails the session file and streams events
+ * to stdout.
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { determineSessionSuccess } from "../../determine-session-success.js";
+import { resolveBinary } from "../../resolve-binary.js";
+import { registerAdapter } from "../registry.js";
+import { createCopilotParser } from "./parse-event.js";
+const COPILOT_INFO = {
+    id: "copilot",
+    name: "Copilot CLI",
+    package: "@github/copilot",
+};
+/** Get the path to the stream-session.js script */
+function getWrapperScriptPath() {
+    const currentDirectory = path.dirname(fileURLToPath(import.meta.url));
+    return path.join(currentDirectory, "stream-session.js");
+}
+/**
+ * Prepares the command to spawn the Copilot session streamer.
+ *
+ * Uses a wrapper script that:
+ * 1. Watches ~/.copilot/session-state/ for new session files
+ * 2. Spawns Copilot CLI with the given prompt
+ * 3. Tails the session JSONL file and streams events to stdout
+ */
+function prepareCommand(options) {
+    const wrapperScript = getWrapperScriptPath();
+    // The wrapper script takes the prompt as the first argument,
+    // followed by any extra arguments to pass to copilot
+    const cliArguments = [wrapperScript, options.prompt];
+    // Add model flag if specified
+    // Copilot accepts: claude-sonnet-4.5, gpt-5, gemini-3-pro-preview, etc.
+    if (options.model) {
+        cliArguments.push("--model", options.model);
+    }
+    const environment = {};
+    // Pass through GitHub authentication environment variables.
+    // Copilot CLI checks these in priority order (highest to lowest):
+    // COPILOT_GITHUB_TOKEN > GH_TOKEN > GITHUB_TOKEN > GITHUB_ASKPASS
+    // See: copilot-cli-decompiled/copilot-source/index.js lines 216991-217011
+    // If not set, Copilot CLI will handle auth errors on its own.
+    if (process.env["COPILOT_GITHUB_TOKEN"]) {
+        environment["COPILOT_GITHUB_TOKEN"] = process.env["COPILOT_GITHUB_TOKEN"];
+    }
+    if (process.env["GH_TOKEN"]) {
+        environment["GH_TOKEN"] = process.env["GH_TOKEN"];
+    }
+    if (process.env["GITHUB_TOKEN"]) {
+        environment["GITHUB_TOKEN"] = process.env["GITHUB_TOKEN"];
+    }
+    const copilotBin = resolveBinary({
+        name: "copilot",
+        command: "copilot",
+        environmentVariable: "AXEXEC_COPILOT_PATH",
+        installHint: "npm install -g @github/copilot",
+    });
+    environment["AXEXEC_COPILOT_PATH"] = copilotBin;
+    return {
+        bin: process.execPath,
+        args: cliArguments,
+        env: environment,
+    };
+}
+/** Copilot CLI adapter */
+const copilotAdapter = {
+    info: () => COPILOT_INFO,
+    prepareCommand,
+    createParser: createCopilotParser,
+    isSuccess: determineSessionSuccess,
+};
+// Self-register on import
+registerAdapter(copilotAdapter);