lark-to-codex 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,134 @@
+type AgentEvent = {
+    type: 'system';
+    sessionId?: string;
+    cwd?: string;
+    model?: string;
+} | {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'thinking';
+    delta: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    id: string;
+    output: string;
+    isError: boolean;
+} | {
+    type: 'usage';
+    inputTokens?: number;
+    outputTokens?: number;
+    costUsd?: number;
+} | {
+    type: 'done';
+    sessionId?: string;
+} | {
+    type: 'error';
+    message: string;
+};
+interface AgentRunOptions {
+    prompt: string;
+    cwd?: string;
+    sessionId?: string;
+    model?: string;
+    permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan';
+    /**
+     * Grace period (ms) between SIGTERM and SIGKILL when stop() is called on
+     * the returned run. Lets the agent (and any subprocess it spawned, e.g.
+     * lark-cli mid-OAuth) clean up before the kernel reaps the tree.
+     * Adapters that don't kill via signals are free to ignore this. Defaults
+     * are adapter-specific.
+     */
+    stopGraceMs?: number;
+}
+interface AgentRun {
+    readonly events: AsyncIterable<AgentEvent>;
+    stop(): Promise<void>;
+    /**
+     * Wait up to `timeoutMs` for the agent process to exit on its own.
+     * Resolves true if it exited within the window, false if the timer
+     * fired first (caller usually wants to fall back to stop()).
+     *
+     * Use this after a terminal stream event (`done` / `error`): the
+     * stream-json `result` line arrives before codex has actually closed
+     * stdout — there's a brief telemetry/cleanup tail in between. Calling
+     * stop() in that window forces a SIGTERM and the run exits with code
+     * 143 instead of 0; waiting it out lets it exit cleanly.
+     */
+    waitForExit(timeoutMs: number): Promise<boolean>;
+}
+interface AgentAdapter {
+    readonly id: string;
+    readonly displayName: string;
+    isAvailable(): Promise<boolean>;
+    run(opts: AgentRunOptions): AgentRun;
+}
+
+type ToolStatus = 'running' | 'done' | 'error';
+interface ToolEntry {
+    id: string;
+    name: string;
+    input: unknown;
+    status: ToolStatus;
+    output?: string;
+}
+type Block = {
+    kind: 'text';
+    content: string;
+    streaming: boolean;
+} | {
+    kind: 'tool';
+    tool: ToolEntry;
+};
+type FooterStatus = 'thinking' | 'tool_running' | 'streaming' | null;
+type Terminal = 'running' | 'done' | 'interrupted' | 'error' | 'idle_timeout';
+interface RunState {
+    blocks: Block[];
+    reasoning: {
+        content: string;
+        active: boolean;
+    };
+    footer: FooterStatus;
+    terminal: Terminal;
+    errorMsg?: string;
+    /** Set when terminal === 'idle_timeout' — how long codex was idle before
+     * the watchdog gave up (so the message can say "N 分钟无响应"). */
+    idleTimeoutMinutes?: number;
+}
+declare const initialState: RunState;
+declare function reduce(state: RunState, evt: AgentEvent): RunState;
+declare function markInterrupted(state: RunState): RunState;
+declare function finalizeIfRunning(state: RunState): RunState;
+
+declare function renderCard(state: RunState): object;
+
+/**
+ * Render `RunState` as plain markdown text — used in `messageReply: 'text'`
+ * mode where we stream a markdown message instead of a card.
+ *
+ * Differences vs `renderCard`:
+ *   - No collapsible panels, no buttons (markdown messages have neither)
+ *   - Tool calls collapse to a single short line each (no body)
+ *   - No reasoning / thinking output (no place to fold it; would be noise)
+ *   - Footer is appended inline at the bottom while running
+ */
+declare function renderText(state: RunState): string;
+
+interface CodexAdapterOptions {
+    binary?: string;
+}
+declare class CodexAdapter implements AgentAdapter {
+    readonly id = "codex";
+    readonly displayName = "Codex";
+    private readonly binary;
+    constructor(opts?: CodexAdapterOptions);
+    isAvailable(): Promise<boolean>;
+    run(opts: AgentRunOptions): AgentRun;
+}
+
+export { type Block, CodexAdapter, type FooterStatus, type RunState, type Terminal, type ToolEntry, type ToolStatus, finalizeIfRunning, initialState, markInterrupted, reduce, renderCard, renderText };