axexec 1.0.0

package/dist/agents/copilot/watch-session.js

@@ -0,0 +1,186 @@
+/**
+ * Session file watcher for Copilot CLI.
+ *
+ * Watches ~/.copilot/session-state/ for new session files.
+ *
+ * Copilot CLI has two session file formats:
+ * - Old: ~/.copilot/session-state/<uuid>.jsonl
+ * - New (0.0.380+): ~/.copilot/session-state/<uuid>/events.jsonl
+ *
+ * This module supports both formats for compatibility.
+ */
+import { existsSync, readdirSync, statSync, watch, } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+/** Copilot session state directory */
+const SESSION_STATE_DIR = path.join(homedir(), ".copilot", "session-state");
+/** Session events filename inside session directories (new format) */
+const SESSION_EVENTS_FILE = "events.jsonl";
+/**
+ * Get all existing session entries (both old .jsonl files and new directories).
+ * Returns entry names (not full paths) for comparison.
+ */
+export function getExistingSessionFiles() {
+    try {
+        const entries = readdirSync(SESSION_STATE_DIR);
+        // Include both .jsonl files (old format) and directories (new format)
+        return new Set(entries.filter((entry) => {
+            if (entry.endsWith(".jsonl")) {
+                return true;
+            }
+            // Check if it's a directory (new format)
+            try {
+                const entryPath = path.join(SESSION_STATE_DIR, entry);
+                return statSync(entryPath).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        }));
+    }
+    catch {
+        // Directory might not exist yet
+        return new Set();
+    }
+}
+/**
+ * Find a new session file that wasn't in the existing set.
+ * Supports both old format (.jsonl files) and new format (directories with events.jsonl).
+ */
+function findNewSessionFile(existing) {
+    try {
+        const entries = readdirSync(SESSION_STATE_DIR);
+        for (const entry of entries) {
+            if (existing.has(entry)) {
+                continue;
+            }
+            const entryPath = path.join(SESSION_STATE_DIR, entry);
+            // Old format: direct .jsonl file
+            if (entry.endsWith(".jsonl")) {
+                return entryPath;
+            }
+            // New format: directory with events.jsonl inside
+            try {
+                if (statSync(entryPath).isDirectory()) {
+                    const eventsFile = path.join(entryPath, SESSION_EVENTS_FILE);
+                    if (existsSync(eventsFile)) {
+                        return eventsFile;
+                    }
+                }
+            }
+            catch {
+                // Entry might have been deleted, continue
+            }
+        }
+    }
+    catch {
+        // Directory might not exist
+    }
+    return undefined;
+}
+/**
+ * Wait for a new session file to appear.
+ *
+ * Uses both file watching and polling to detect new session files.
+ * Returns a promise that resolves with the new session file path.
+ */
+export function waitForSessionFile(existingFiles, timeoutMs = 10_000) {
+    let watcher;
+    let pollInterval;
+    let timeoutId;
+    let eventsCheckInterval;
+    let resolved = false;
+    const cleanup = () => {
+        if (watcher) {
+            watcher.close();
+            watcher = undefined;
+        }
+        if (pollInterval) {
+            clearInterval(pollInterval);
+            pollInterval = undefined;
+        }
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+        if (eventsCheckInterval) {
+            clearInterval(eventsCheckInterval);
+            eventsCheckInterval = undefined;
+        }
+    };
+    const promise = new Promise((resolve, reject) => {
+        // Check immediately
+        const existing = findNewSessionFile(existingFiles);
+        if (existing) {
+            resolved = true;
+            resolve(existing);
+            return;
+        }
+        // Set up watcher (gracefully degrade to polling if directory doesn't exist)
+        try {
+            watcher = watch(SESSION_STATE_DIR, (eventType, filename) => {
+                if (resolved)
+                    return;
+                if (eventType === "rename" &&
+                    filename &&
+                    !existingFiles.has(filename)) {
+                    // Old format: direct .jsonl file
+                    if (filename.endsWith(".jsonl")) {
+                        resolved = true;
+                        cleanup();
+                        resolve(path.join(SESSION_STATE_DIR, filename));
+                        return;
+                    }
+                    // New format: directory - check for events.jsonl inside
+                    // Use polling to detect when events.jsonl appears (directory may be created first)
+                    const eventsFile = path.join(SESSION_STATE_DIR, filename, SESSION_EVENTS_FILE);
+                    const checkForEventsFile = () => {
+                        if (resolved)
+                            return;
+                        if (existsSync(eventsFile)) {
+                            resolved = true;
+                            cleanup();
+                            resolve(eventsFile);
+                        }
+                    };
+                    // Check immediately and set up short polling for the events file
+                    checkForEventsFile();
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- resolved may be set by checkForEventsFile
+                    if (!resolved) {
+                        eventsCheckInterval = setInterval(checkForEventsFile, 50);
+                    }
+                }
+            });
+            watcher.on("error", () => {
+                // Watcher failed, continue with polling only
+                if (watcher) {
+                    watcher.close();
+                    watcher = undefined;
+                }
+            });
+        }
+        catch {
+            // Directory doesn't exist yet (ENOENT), continue with polling only
+            // Polling will detect the file once Copilot creates the directory
+        }
+        // Also poll periodically in case we miss the event
+        pollInterval = setInterval(() => {
+            if (resolved)
+                return;
+            const newFile = findNewSessionFile(existingFiles);
+            if (newFile) {
+                resolved = true;
+                cleanup();
+                resolve(newFile);
+            }
+        }, 100);
+        // Timeout
+        timeoutId = setTimeout(() => {
+            if (!resolved) {
+                cleanup();
+                reject(new Error("Timeout waiting for session file"));
+            }
+        }, timeoutMs);
+    });
+    return { promise, cleanup };
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Gemini adapter implementation.
+ *
+ * Implements the {@link AgentAdapter} interface for Gemini CLI.
+ */
+export {};

package/dist/agents/gemini/adapter.js

@@ -0,0 +1,78 @@
+/**
+ * Gemini adapter implementation.
+ *
+ * Implements the {@link AgentAdapter} interface for Gemini CLI.
+ */
+import { determineSessionSuccess } from "../../determine-session-success.js";
+import { resolveBinary } from "../../resolve-binary.js";
+import { registerAdapter } from "../registry.js";
+import { createGeminiParser } from "./parse-event.js";
+const GEMINI_INFO = {
+    id: "gemini",
+    name: "Gemini",
+    package: "@google/gemini-cli",
+};
+/**
+ * Environment variables to exclude by default.
+ *
+ * Gemini CLI has strict environment variable sanitization that blocks
+ * GH_TOKEN from reaching shell commands when GITHUB_SHA is set.
+ */
+const GITHUB_SHA_EXCLUSION = ["GITHUB_SHA"];
+/**
+ * Prepares the command to spawn Gemini CLI.
+ */
+function prepareCommand(options) {
+    const cliArguments = [
+        "--output-format",
+        "stream-json",
+        // Required for non-interactive mode - stdin is not connected for approval prompts
+        "--yolo",
+    ];
+    // Add model flag if specified
+    // Gemini accepts: gemini-2.5-pro, gemini-2.5-flash, auto, pro, flash aliases
+    if (options.model) {
+        cliArguments.push("--model", options.model);
+    }
+    // Prompt must be last argument
+    cliArguments.push(options.prompt);
+    const environment = {};
+    // Pass through authentication environment variables.
+    // If none are set, Gemini CLI will handle auth errors on its own.
+    if (process.env["GEMINI_API_KEY"]) {
+        environment["GEMINI_API_KEY"] = process.env["GEMINI_API_KEY"];
+    }
+    if (process.env["GOOGLE_API_KEY"]) {
+        environment["GOOGLE_API_KEY"] = process.env["GOOGLE_API_KEY"];
+    }
+    if (process.env["GOOGLE_APPLICATION_CREDENTIALS"]) {
+        environment["GOOGLE_APPLICATION_CREDENTIALS"] =
+            process.env["GOOGLE_APPLICATION_CREDENTIALS"];
+    }
+    if (process.env["GOOGLE_CLOUD_PROJECT"]) {
+        environment["GOOGLE_CLOUD_PROJECT"] = process.env["GOOGLE_CLOUD_PROJECT"];
+    }
+    const bin = resolveBinary({
+        name: "gemini",
+        command: "gemini",
+        environmentVariable: "AXEXEC_GEMINI_PATH",
+        installHint: "npm install -g @google/gemini-cli",
+    });
+    return {
+        bin,
+        args: cliArguments,
+        env: environment,
+        // By default, exclude GITHUB_SHA to work around Gemini CLI's strict env sanitization.
+        // Use --preserve-github-sha to keep it.
+        envExclusions: options.preserveGithubSha ? undefined : GITHUB_SHA_EXCLUSION,
+    };
+}
+/** Gemini adapter */
+const geminiAdapter = {
+    info: () => GEMINI_INFO,
+    prepareCommand,
+    createParser: createGeminiParser,
+    isSuccess: determineSessionSuccess,
+};
+// Self-register on import
+registerAdapter(geminiAdapter);

package/dist/agents/gemini/parse-event.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Event parser for Gemini CLI.
+ *
+ * Transforms raw Gemini CLI JSONL events into normalized {@link AxexecEvent} types.
+ * Uses stateful correlation to resolve tool names in tool.result events.
+ */
+import type { EventParser } from "../../types/adapter.js";
+/**
+ * Creates a parser for Gemini CLI events.
+ *
+ * Gemini CLI's tool_result events only include tool_id, not tool_name.
+ * This parser maintains a mapping from callId to toolName to resolve
+ * the tool name when parsing tool.result events.
+ * Uses a stateful timestamp parser to preserve event ordering when
+ * timestamps are missing.
+ */
+declare function createGeminiParser(): EventParser;
+export { createGeminiParser };

package/dist/agents/gemini/parse-event.js

@@ -0,0 +1,144 @@
+/**
+ * Event parser for Gemini CLI.
+ *
+ * Transforms raw Gemini CLI JSONL events into normalized {@link AxexecEvent} types.
+ * Uses stateful correlation to resolve tool names in tool.result events.
+ */
+import { createTimestampParser } from "../../parse-iso-timestamp.js";
+import { GeminiEvent, isErrorEvent, isInitEvent, isMessageEvent, isResultEvent, isToolResultEvent, isToolUseEvent, } from "./types.js";
+/**
+ * Creates a parser for Gemini CLI events.
+ *
+ * Gemini CLI's tool_result events only include tool_id, not tool_name.
+ * This parser maintains a mapping from callId to toolName to resolve
+ * the tool name when parsing tool.result events.
+ * Uses a stateful timestamp parser to preserve event ordering when
+ * timestamps are missing.
+ */
+function createGeminiParser() {
+    // Map from callId (tool_id) to tool name for correlation
+    const toolNames = new Map();
+    // Stateful timestamp parser - falls back to previous timestamp when missing
+    const parseTimestamp = createTimestampParser();
+    return (line) => {
+        const trimmed = line.trim();
+        if (trimmed === "") {
+            return undefined;
+        }
+        let json;
+        try {
+            json = JSON.parse(trimmed);
+        }
+        catch {
+            return undefined;
+        }
+        const result = GeminiEvent.safeParse(json);
+        if (!result.success) {
+            return undefined;
+        }
+        const raw = result.data;
+        if (isInitEvent(raw)) {
+            return parseInitEvent(raw, parseTimestamp);
+        }
+        if (isMessageEvent(raw)) {
+            return parseMessageEvent(raw, parseTimestamp);
+        }
+        if (isToolUseEvent(raw)) {
+            return parseToolUseEvent(raw, toolNames, parseTimestamp);
+        }
+        if (isToolResultEvent(raw)) {
+            return parseToolResultEvent(raw, toolNames, parseTimestamp);
+        }
+        if (isErrorEvent(raw)) {
+            return parseErrorEvent(raw, parseTimestamp);
+        }
+        if (isResultEvent(raw)) {
+            return parseResultEvent(raw, parseTimestamp);
+        }
+        return undefined;
+    };
+}
+/** Parses an init event (task start) */
+function parseInitEvent(event, parseTimestamp) {
+    return {
+        type: "session.start",
+        sessionId: event.session_id,
+        agent: "gemini",
+        model: event.model ?? "unknown",
+        provider: "google",
+        timestamp: parseTimestamp(event.timestamp),
+    };
+}
+/** Parses a message event (progress or skip) */
+function parseMessageEvent(event, parseTimestamp) {
+    if (event.role === "user") {
+        return undefined;
+    }
+    return {
+        type: "agent.message",
+        content: event.content,
+        timestamp: parseTimestamp(event.timestamp),
+    };
+}
+/** Parses a tool use event and stores the callId -> toolName mapping */
+function parseToolUseEvent(event, toolNames, parseTimestamp) {
+    // Store mapping for later correlation with tool.result
+    toolNames.set(event.tool_id, event.tool_name);
+    return {
+        type: "tool.call",
+        callId: event.tool_id,
+        tool: event.tool_name,
+        input: event.parameters,
+        timestamp: parseTimestamp(event.timestamp),
+    };
+}
+/** Parses a tool result event, resolving the tool name from stored mapping */
+function parseToolResultEvent(event, toolNames, parseTimestamp) {
+    // Look up tool name from previous tool.call event
+    const toolName = toolNames.get(event.tool_id) ?? "unknown";
+    // Clean up the mapping to prevent memory leaks in long-running sessions
+    toolNames.delete(event.tool_id);
+    return {
+        type: "tool.result",
+        callId: event.tool_id,
+        tool: toolName,
+        output: event.output ?? event.error?.message,
+        success: event.status === "success",
+        timestamp: parseTimestamp(event.timestamp),
+    };
+}
+/** Parses an error event (task error or skip) */
+function parseErrorEvent(event, parseTimestamp) {
+    if (event.severity === "warning") {
+        return undefined;
+    }
+    return {
+        type: "session.error",
+        code: "AGENT_ERROR",
+        message: event.message,
+        timestamp: parseTimestamp(event.timestamp),
+    };
+}
+/** Parses a result event (task completion or error) */
+function parseResultEvent(event, parseTimestamp) {
+    const timestamp = parseTimestamp(event.timestamp);
+    if (event.status === "success") {
+        return {
+            type: "session.complete",
+            stats: {
+                durationMs: event.stats?.duration_ms ?? 0,
+                inputTokens: event.stats?.input_tokens,
+                outputTokens: event.stats?.output_tokens,
+            },
+            timestamp,
+        };
+    }
+    // Error or unknown status - treat as error
+    return {
+        type: "session.error",
+        code: "AGENT_ERROR",
+        message: event.error?.message ?? "Unknown error",
+        timestamp,
+    };
+}
+export { createGeminiParser };

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

@@ -0,0 +1,162 @@
+/**
+ * Raw event types from Gemini CLI's JSONL stream.
+ *
+ * These types represent the raw output from:
+ * `gemini --output-format stream-json "..."`
+ *
+ * The parser transforms these into normalized {@link AxexecEvent} types.
+ */
+import { z } from "zod";
+/** Init event - emitted at startup with session info */
+declare const GeminiInitEvent: z.ZodObject<{
+    type: z.ZodLiteral<"init">;
+    timestamp: z.ZodString;
+    session_id: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GeminiInitEvent = z.infer<typeof GeminiInitEvent>;
+/** Message event - user or assistant messages */
+declare const GeminiMessageEvent: z.ZodObject<{
+    type: z.ZodLiteral<"message">;
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        user: "user";
+    }>;
+    content: z.ZodString;
+    delta: z.ZodOptional<z.ZodBoolean>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+type GeminiMessageEvent = z.infer<typeof GeminiMessageEvent>;
+/** Tool use event - when the model invokes a tool */
+declare const GeminiToolUseEvent: z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    tool_name: z.ZodString;
+    tool_id: z.ZodString;
+    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+type GeminiToolUseEvent = z.infer<typeof GeminiToolUseEvent>;
+/** Tool result event - result from a tool execution */
+declare const GeminiToolResultEvent: z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    tool_id: z.ZodString;
+    status: z.ZodEnum<{
+        success: "success";
+        error: "error";
+    }>;
+    output: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+type GeminiToolResultEvent = z.infer<typeof GeminiToolResultEvent>;
+/** Error event - warnings or errors during execution */
+declare const GeminiErrorEvent: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+    message: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+type GeminiErrorEvent = z.infer<typeof GeminiErrorEvent>;
+/** Result event - emitted when task completes */
+declare const GeminiResultEvent: z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    status: z.ZodEnum<{
+        success: "success";
+        error: "error";
+    }>;
+    error: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    stats: z.ZodOptional<z.ZodObject<{
+        total_tokens: z.ZodNumber;
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        duration_ms: z.ZodNumber;
+        tool_calls: z.ZodNumber;
+    }, z.core.$strip>>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+type GeminiResultEvent = z.infer<typeof GeminiResultEvent>;
+/** Union of all Gemini CLI event types */
+declare const GeminiEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"init">;
+    timestamp: z.ZodString;
+    session_id: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"message">;
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        user: "user";
+    }>;
+    content: z.ZodString;
+    delta: z.ZodOptional<z.ZodBoolean>;
+    timestamp: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    tool_name: z.ZodString;
+    tool_id: z.ZodString;
+    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    timestamp: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    tool_id: z.ZodString;
+    status: z.ZodEnum<{
+        success: "success";
+        error: "error";
+    }>;
+    output: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    timestamp: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+    message: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    status: z.ZodEnum<{
+        success: "success";
+        error: "error";
+    }>;
+    error: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    stats: z.ZodOptional<z.ZodObject<{
+        total_tokens: z.ZodNumber;
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        duration_ms: z.ZodNumber;
+        tool_calls: z.ZodNumber;
+    }, z.core.$strip>>;
+    timestamp: z.ZodString;
+}, z.core.$strip>], "type">;
+type GeminiEvent = z.infer<typeof GeminiEvent>;
+/** Type guard for init events */
+declare function isInitEvent(event: GeminiEvent): event is GeminiInitEvent;
+/** Type guard for message events */
+declare function isMessageEvent(event: GeminiEvent): event is GeminiMessageEvent;
+/** Type guard for tool use events */
+declare function isToolUseEvent(event: GeminiEvent): event is GeminiToolUseEvent;
+/** Type guard for tool result events */
+declare function isToolResultEvent(event: GeminiEvent): event is GeminiToolResultEvent;
+/** Type guard for error events */
+declare function isErrorEvent(event: GeminiEvent): event is GeminiErrorEvent;
+/** Type guard for result events */
+declare function isResultEvent(event: GeminiEvent): event is GeminiResultEvent;
+export { GeminiEvent, isErrorEvent, isInitEvent, isMessageEvent, isResultEvent, isToolResultEvent, isToolUseEvent, };
+export type { GeminiErrorEvent, GeminiInitEvent, GeminiMessageEvent, GeminiResultEvent, GeminiToolResultEvent, GeminiToolUseEvent, };

package/dist/agents/gemini/types.js

@@ -0,0 +1,103 @@
+/**
+ * Raw event types from Gemini CLI's JSONL stream.
+ *
+ * These types represent the raw output from:
+ * `gemini --output-format stream-json "..."`
+ *
+ * The parser transforms these into normalized {@link AxexecEvent} types.
+ */
+import { z } from "zod";
+/** Init event - emitted at startup with session info */
+const GeminiInitEvent = z.object({
+    type: z.literal("init"),
+    timestamp: z.string(),
+    session_id: z.string(),
+    model: z.string().optional(),
+});
+/** Message event - user or assistant messages */
+const GeminiMessageEvent = z.object({
+    type: z.literal("message"),
+    role: z.enum(["user", "assistant"]),
+    content: z.string(),
+    delta: z.boolean().optional(),
+    timestamp: z.string(),
+});
+/** Tool use event - when the model invokes a tool */
+const GeminiToolUseEvent = z.object({
+    type: z.literal("tool_use"),
+    tool_name: z.string(),
+    tool_id: z.string(),
+    parameters: z.record(z.string(), z.unknown()),
+    timestamp: z.string(),
+});
+/** Error info schema - used in tool_result and result events */
+const GeminiErrorInfo = z.object({
+    type: z.string(),
+    message: z.string(),
+});
+/** Tool result event - result from a tool execution */
+const GeminiToolResultEvent = z.object({
+    type: z.literal("tool_result"),
+    tool_id: z.string(),
+    status: z.enum(["success", "error"]),
+    output: z.string().optional(),
+    error: GeminiErrorInfo.optional(),
+    timestamp: z.string(),
+});
+/** Error event - warnings or errors during execution */
+const GeminiErrorEvent = z.object({
+    type: z.literal("error"),
+    severity: z.enum(["warning", "error"]),
+    message: z.string(),
+    timestamp: z.string(),
+});
+/** Stats schema - used in result events */
+const GeminiStats = z.object({
+    total_tokens: z.number(),
+    input_tokens: z.number(),
+    output_tokens: z.number(),
+    duration_ms: z.number(),
+    tool_calls: z.number(),
+});
+/** Result event - emitted when task completes */
+const GeminiResultEvent = z.object({
+    type: z.literal("result"),
+    status: z.enum(["success", "error"]),
+    error: GeminiErrorInfo.optional(),
+    stats: GeminiStats.optional(),
+    timestamp: z.string(),
+});
+/** Union of all Gemini CLI event types */
+const GeminiEvent = z.discriminatedUnion("type", [
+    GeminiInitEvent,
+    GeminiMessageEvent,
+    GeminiToolUseEvent,
+    GeminiToolResultEvent,
+    GeminiErrorEvent,
+    GeminiResultEvent,
+]);
+/** Type guard for init events */
+function isInitEvent(event) {
+    return event.type === "init";
+}
+/** Type guard for message events */
+function isMessageEvent(event) {
+    return event.type === "message";
+}
+/** Type guard for tool use events */
+function isToolUseEvent(event) {
+    return event.type === "tool_use";
+}
+/** Type guard for tool result events */
+function isToolResultEvent(event) {
+    return event.type === "tool_result";
+}
+/** Type guard for error events */
+function isErrorEvent(event) {
+    return event.type === "error";
+}
+/** Type guard for result events */
+function isResultEvent(event) {
+    return event.type === "result";
+}
+export { GeminiEvent, isErrorEvent, isInitEvent, isMessageEvent, isResultEvent, isToolResultEvent, isToolUseEvent, };