@rynx-ai/runtime 0.1.0

package/dist/codex-app-server/mapping.js

@@ -0,0 +1,189 @@
+/** Map one thread item (`item/started` | `item/completed`) to events. */
+export function mapCodexItem(method, item) {
+    const events = [];
+    const isStart = method === "item/started";
+    const isEnd = method === "item/completed";
+    switch (item.type) {
+        case "commandExecution": {
+            const commandItem = item;
+            events.push({
+                type: "tool",
+                event: isStart ? "on_tool_start" : "on_tool_end",
+                name: "command_execution",
+                input: isStart
+                    ? { id: commandItem.id, command: commandItem.command, cwd: commandItem.cwd }
+                    : undefined,
+                output: isEnd
+                    ? {
+                        id: commandItem.id,
+                        command: commandItem.command,
+                        status: commandItem.status,
+                        aggregatedOutput: commandItem.aggregatedOutput ?? null,
+                        exitCode: commandItem.exitCode ?? null,
+                    }
+                    : undefined,
+                data: { method, item },
+            });
+            return { events };
+        }
+        case "fileChange": {
+            events.push({
+                type: "tool",
+                event: isStart ? "on_tool_start" : "on_tool_end",
+                name: "file_change",
+                input: isStart ? { id: item.id } : undefined,
+                output: isEnd
+                    ? {
+                        id: item.id,
+                        changes: item.changes,
+                        status: item.status,
+                    }
+                    : undefined,
+                data: { method, item },
+            });
+            return { events };
+        }
+        case "mcpToolCall": {
+            const mcp = item;
+            events.push({
+                type: "tool",
+                event: isStart ? "on_tool_start" : "on_tool_end",
+                name: `mcp:${mcp.server ?? "unknown"}:${mcp.tool ?? "unknown"}`,
+                input: isStart ? { id: mcp.id, arguments: mcp.arguments } : undefined,
+                output: isEnd ? { id: mcp.id, status: mcp.status, result: mcp.result } : undefined,
+                data: { method, item },
+            });
+            return { events };
+        }
+        case "dynamicToolCall": {
+            const dyn = item;
+            events.push({
+                type: "tool",
+                event: isStart ? "on_tool_start" : "on_tool_end",
+                name: `dynamic:${dyn.namespace ?? "default"}:${dyn.tool ?? "unknown"}`,
+                input: isStart ? { id: dyn.id, arguments: dyn.arguments } : undefined,
+                output: isEnd ? { id: dyn.id, status: dyn.status, success: dyn.success } : undefined,
+                data: { method, item },
+            });
+            return { events };
+        }
+        case "webSearch": {
+            events.push({
+                type: "tool",
+                event: isStart ? "on_tool_start" : "on_tool_end",
+                name: "web_search",
+                input: isStart
+                    ? { id: item.id, query: item.query }
+                    : undefined,
+                output: isEnd ? { id: item.id } : undefined,
+                data: { method, item },
+            });
+            return { events };
+        }
+        case "agentMessage": {
+            const text = item.text?.trim() ?? "";
+            if (isEnd && text) {
+                events.push({ type: "message_completed", itemId: item.id, text });
+                return { events, finalText: text };
+            }
+            return { events };
+        }
+        case "plan": {
+            events.push({ type: "runtime_debug", channel: "codexEvent", data: { method, item } });
+            return { events };
+        }
+        case "reasoning": {
+            events.push({
+                type: "reasoning_completed",
+                itemId: item.id,
+                summary: item.summary ?? [],
+            });
+            return { events };
+        }
+        default:
+            events.push({ type: "runtime_debug", channel: "codexEvent", data: { method, item } });
+            return { events };
+    }
+}
+/** Map one codex app-server notification to events (+ turn/usage/error signals). */
+export function mapCodexNotification(method, params) {
+    const events = [];
+    const typed = { method, params };
+    switch (typed.method) {
+        case "thread/started":
+            return { events };
+        case "turn/started":
+            return { events };
+        case "turn/completed": {
+            const turnPayload = typed.params?.turn;
+            if (turnPayload?.status === "failed" && turnPayload.error?.message) {
+                return { events, fatalError: new Error(turnPayload.error.message), turnCompleted: true };
+            }
+            return { events, turnCompleted: true };
+        }
+        case "turn/plan/updated": {
+            const planParams = typed.params;
+            events.push({ type: "plan", steps: planParams.plan ?? [] });
+            return { events };
+        }
+        case "turn/diff/updated": {
+            const diffParams = typed.params;
+            events.push({ type: "turn_diff", diff: diffParams.diff ?? diffParams.unifiedDiff ?? "" });
+            return { events };
+        }
+        case "item/started":
+        case "item/completed": {
+            const item = typed.params.item;
+            return item ? mapCodexItem(method, item) : { events };
+        }
+        case "item/agentMessage/delta": {
+            const delta = typed.params.delta ?? "";
+            if (delta) {
+                events.push({
+                    type: "token",
+                    text: delta,
+                    metadata: { source: "app_server", itemId: typed.params.itemId },
+                });
+            }
+            return { events };
+        }
+        case "item/reasoning/summaryTextDelta":
+        case "item/reasoning/textDelta": {
+            const p = typed.params;
+            events.push({
+                type: "reasoning_delta",
+                text: p.delta ?? "",
+                summaryIndex: p.summaryIndex ?? 0,
+                itemId: p.itemId,
+            });
+            return { events };
+        }
+        case "item/commandExecution/outputDelta": {
+            const p = typed.params;
+            const delta = p.delta ?? "";
+            if (delta && p.itemId)
+                events.push({ type: "tool_output_delta", callId: p.itemId, delta });
+            return { events };
+        }
+        case "item/fileChange/patchUpdated": {
+            const p = typed.params;
+            events.push({ type: "file_change", changes: p.changes ?? [] });
+            return { events };
+        }
+        case "thread/tokenUsage/updated": {
+            const p = typed.params;
+            return { events, usage: p.tokenUsage };
+        }
+        case "error": {
+            const p = typed.params;
+            if (p.willRetry) {
+                events.push({ type: "runtime_debug", channel: "codexEvent", data: { method, params } });
+                return { events };
+            }
+            return { events, fatalError: new Error(p.error?.message ?? "Codex emitted an error notification") };
+        }
+        default:
+            events.push({ type: "runtime_debug", channel: "codexEvent", data: { method, params } });
+            return { events };
+    }
+}

package/dist/codex-app-server/protocol.d.ts

@@ -0,0 +1,472 @@
+/**
+ * Hand-curated subset of the Codex App Server JSON-RPC protocol.
+ *
+ * Source of truth: `codex app-server generate-ts --out <dir>` produces the
+ * full TypeScript bindings (~150 files). This file only mirrors the shapes
+ * the bridge consumes today. Unused notification / request payloads are
+ * captured with a permissive `Record<string, unknown>` so future Codex
+ * releases keep parsing without code changes here.
+ *
+ * Re-generate the upstream bindings periodically to spot field renames.
+ */
+export type RequestId = string | number;
+export interface JsonRpcRequestEnvelope<TParams = unknown> {
+    jsonrpc?: "2.0";
+    id: RequestId;
+    method: string;
+    params?: TParams;
+}
+export interface JsonRpcSuccessEnvelope<TResult = unknown> {
+    jsonrpc?: "2.0";
+    id: RequestId;
+    result: TResult;
+}
+export interface JsonRpcErrorEnvelope {
+    jsonrpc?: "2.0";
+    id: RequestId;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface JsonRpcNotificationEnvelope<TParams = unknown> {
+    jsonrpc?: "2.0";
+    method: string;
+    params?: TParams;
+}
+export type JsonRpcIncoming = JsonRpcSuccessEnvelope | JsonRpcErrorEnvelope | JsonRpcRequestEnvelope | JsonRpcNotificationEnvelope;
+export interface ClientInfo {
+    name: string;
+    title?: string | null;
+    version: string;
+}
+export interface InitializeResponse {
+    userAgent: string;
+    codexHome: string;
+    platformFamily: string;
+    platformOs: string;
+}
+export interface GetAuthStatusParams {
+    includeToken?: boolean;
+    refreshToken?: boolean;
+}
+export interface GetAuthStatusResponse {
+    authMethod: "chatgpt" | "apikey" | string;
+    authToken: string | null;
+    requiresOpenaiAuth: boolean;
+}
+export type AskForApproval = "untrusted" | "on-failure" | "on-request" | "never";
+export type SandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export interface ThreadStartParams {
+    model?: string | null;
+    modelProvider?: string | null;
+    cwd?: string | null;
+    approvalPolicy?: AskForApproval | null;
+    sandbox?: SandboxMode | null;
+    config?: Record<string, unknown> | null;
+    baseInstructions?: string | null;
+    developerInstructions?: string | null;
+    ephemeral?: boolean | null;
+}
+export interface ThreadResumeParams extends ThreadStartParams {
+    threadId: string;
+    /** When true, the resume response omits the thread's `turns` backlog (used to
+     *  SUBSCRIBE without re-replaying history). When false/absent, the response
+     *  carries `thread.turns[].items[]` — the backfill the forwarder replays for a
+     *  fresh thread's first turn (omnigent's `_replay_resume_response`). */
+    excludeTurns?: boolean;
+}
+/** One turn in a resumed thread's backlog (`thread/resume` response). */
+export interface ResumedTurn {
+    id?: string;
+    turnId?: string;
+    items?: ThreadItem[];
+}
+/** The `thread` object a `thread/resume` response carries (id + optional backlog). */
+export interface ResumedThread {
+    id: string;
+    turns?: ResumedTurn[];
+    [key: string]: unknown;
+}
+export interface ThreadDescriptor {
+    id: string;
+    cwd: string;
+    modelProvider?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+export type UserInput = {
+    type: "text";
+    text: string;
+    text_elements?: unknown[];
+} | {
+    type: "image";
+    url: string;
+} | {
+    type: "localImage";
+    path: string;
+};
+export interface TurnStartParams {
+    threadId: string;
+    input: UserInput[];
+    cwd?: string | null;
+    approvalPolicy?: AskForApproval | null;
+    model?: string | null;
+    effort?: ReasoningEffort | null;
+}
+export interface TurnInterruptParams {
+    threadId: string;
+    turnId: string;
+}
+export interface TurnSteerParams {
+    threadId: string;
+    /**
+     * Active turn id precondition. `turn/steer` fails if it does not match the
+     * currently running turn (e.g. the turn already finished).
+     */
+    expectedTurnId: string;
+    input: UserInput[];
+}
+export type TurnStatus = "completed" | "interrupted" | "failed" | "inProgress";
+export interface TurnPlanStep {
+    step: string;
+    status: "pending" | "inProgress" | "completed";
+}
+export type CommandExecutionStatus = "inProgress" | "completed" | "failed" | "declined";
+export type PatchApplyStatus = "inProgress" | "completed" | "failed" | "declined";
+export interface ThreadItemBase {
+    id: string;
+    type: string;
+}
+export interface UserMessageItem extends ThreadItemBase {
+    type: "userMessage";
+    content: UserInput[];
+}
+export interface AgentMessageItem extends ThreadItemBase {
+    type: "agentMessage";
+    text: string;
+    phase?: string | null;
+}
+export interface ReasoningItem extends ThreadItemBase {
+    type: "reasoning";
+    summary: string[];
+    content: string[];
+}
+export interface PlanItem extends ThreadItemBase {
+    type: "plan";
+    text: string;
+}
+export interface CommandExecutionItem extends ThreadItemBase {
+    type: "commandExecution";
+    command: string;
+    cwd: string;
+    status: CommandExecutionStatus;
+    aggregatedOutput: string | null;
+    exitCode: number | null;
+    durationMs: number | null;
+}
+export interface FileChangeItem extends ThreadItemBase {
+    type: "fileChange";
+    changes: Array<{
+        path: string;
+        kind: string;
+        diff: string;
+    }>;
+    status: PatchApplyStatus;
+}
+export interface McpToolCallItem extends ThreadItemBase {
+    type: "mcpToolCall";
+    server: string;
+    tool: string;
+    status: "inProgress" | "completed" | "failed";
+    arguments: unknown;
+    result?: unknown;
+    error?: unknown;
+    durationMs?: number | null;
+}
+export interface DynamicToolCallItem extends ThreadItemBase {
+    type: "dynamicToolCall";
+    namespace: string | null;
+    tool: string;
+    arguments: unknown;
+    status: "inProgress" | "completed" | "failed";
+    success?: boolean | null;
+}
+export interface WebSearchItem extends ThreadItemBase {
+    type: "webSearch";
+    query: string;
+}
+export type ThreadItem = UserMessageItem | AgentMessageItem | ReasoningItem | PlanItem | CommandExecutionItem | FileChangeItem | McpToolCallItem | DynamicToolCallItem | WebSearchItem | (ThreadItemBase & Record<string, unknown>);
+export interface ThreadSummary {
+    id?: string;
+    threadId?: string;
+    name?: string | null;
+    preview?: string | null;
+    cwd?: string | null;
+    createdAt?: string | number | null;
+    updatedAt?: string | number | null;
+    [key: string]: unknown;
+}
+export interface ThreadListParams {
+    cursor?: string | null;
+    limit?: number | null;
+    sortKey?: string | null;
+    sortDirection?: string | null;
+    archived?: boolean | null;
+}
+export interface ThreadListResponse {
+    data: ThreadSummary[];
+    nextCursor?: string | null;
+    [key: string]: unknown;
+}
+export interface ThreadForkParams {
+    threadId: string;
+    path?: string | null;
+    model?: string | null;
+    modelProvider?: string | null;
+    cwd?: string | null;
+    approvalPolicy?: AskForApproval | null;
+    sandbox?: SandboxMode | null;
+}
+export interface ThreadSettingsUpdateParams {
+    threadId: string;
+    cwd?: string | null;
+    approvalPolicy?: AskForApproval | null;
+    sandboxPolicy?: Record<string, unknown> | null;
+    /** Named permissions profile id; cannot be combined with `sandboxPolicy`. */
+    permissions?: string | null;
+    model?: string | null;
+    serviceTier?: string | null;
+    effort?: ReasoningEffort | null;
+    summary?: string | null;
+    collaborationMode?: Record<string, unknown> | null;
+    personality?: string | null;
+}
+export interface ModelListParams {
+    cursor?: string | null;
+    limit?: number | null;
+}
+export interface ModelInfo {
+    id: string;
+    model: string;
+    displayName?: string;
+    description?: string;
+    hidden?: boolean;
+    isDefault?: boolean;
+    supportsPersonality?: boolean;
+    [key: string]: unknown;
+}
+export interface ModelListResponse {
+    data: ModelInfo[];
+    nextCursor?: string | null;
+}
+export type CollaborationModeMask = Record<string, unknown>;
+export interface CollaborationModeListResponse {
+    data: CollaborationModeMask[];
+}
+export type ThreadGoalStatus = "active" | "paused" | "completed" | string;
+export interface ThreadGoalSetParams {
+    threadId: string;
+    objective?: string | null;
+    status?: ThreadGoalStatus | null;
+    tokenBudget?: number | null;
+}
+export interface ThreadGoalGetParams {
+    threadId: string;
+}
+export interface ThreadGoalClearParams {
+    threadId: string;
+}
+export interface ThreadGoal {
+    objective?: string | null;
+    status?: ThreadGoalStatus | null;
+    [key: string]: unknown;
+}
+export interface ThreadGoalGetResponse {
+    goal?: ThreadGoal | null;
+    [key: string]: unknown;
+}
+export type ReviewTarget = {
+    type: "uncommittedChanges";
+} | {
+    type: "baseBranch";
+    branch: string;
+} | {
+    type: "commit";
+    sha: string;
+    title?: string | null;
+} | {
+    type: "custom";
+    instructions: string;
+};
+export interface ReviewStartParams {
+    threadId: string;
+    target: ReviewTarget;
+    delivery?: Record<string, unknown> | null;
+}
+export interface ReviewStartResponse {
+    reviewThreadId?: string | null;
+    [key: string]: unknown;
+}
+export interface ThreadStartedNotificationParams {
+    thread: ThreadDescriptor;
+}
+export interface TurnStartedNotificationParams {
+    threadId: string;
+    turn: {
+        id: string;
+    } & Record<string, unknown>;
+}
+export interface TurnCompletedNotificationParams {
+    threadId: string;
+    turn: {
+        id: string;
+        status: TurnStatus;
+        error?: unknown;
+    } & Record<string, unknown>;
+}
+export interface TurnPlanUpdatedNotificationParams {
+    threadId: string;
+    turnId: string;
+    explanation?: string | null;
+    plan: TurnPlanStep[];
+}
+export interface TurnDiffUpdatedNotificationParams {
+    threadId: string;
+    turnId: string;
+    /** Aggregated turn-level unified diff (generated binding field name). */
+    diff?: string;
+    /** @deprecated older hand-written field name; prefer `diff`. */
+    unifiedDiff?: string;
+    [key: string]: unknown;
+}
+export interface ItemStartedNotificationParams {
+    item: ThreadItem;
+    threadId: string;
+    turnId: string;
+    startedAtMs: number;
+}
+export interface ItemCompletedNotificationParams {
+    item: ThreadItem;
+    threadId: string;
+    turnId: string;
+    completedAtMs: number;
+}
+export interface AgentMessageDeltaNotificationParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    delta: string;
+}
+export interface ReasoningSummaryTextDeltaNotificationParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    delta: string;
+    summaryIndex: number;
+}
+export interface CommandExecutionOutputDeltaNotificationParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    delta: string;
+}
+export interface FileChangePatchUpdatedNotificationParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    changes?: Array<{
+        path: string;
+        kind: string;
+        diff: string;
+    }>;
+    [key: string]: unknown;
+}
+export interface ThreadTokenUsageUpdatedNotificationParams {
+    threadId: string;
+    turnId: string;
+    tokenUsage: Record<string, unknown>;
+}
+export interface ErrorNotificationParams {
+    error: {
+        message: string;
+        additionalDetails?: string | null;
+    };
+    willRetry: boolean;
+    threadId: string;
+    turnId: string;
+}
+export type ServerNotification = {
+    method: "thread/started";
+    params: ThreadStartedNotificationParams;
+} | {
+    method: "turn/started";
+    params: TurnStartedNotificationParams;
+} | {
+    method: "turn/completed";
+    params: TurnCompletedNotificationParams;
+} | {
+    method: "turn/plan/updated";
+    params: TurnPlanUpdatedNotificationParams;
+} | {
+    method: "turn/diff/updated";
+    params: TurnDiffUpdatedNotificationParams;
+} | {
+    method: "item/started";
+    params: ItemStartedNotificationParams;
+} | {
+    method: "item/completed";
+    params: ItemCompletedNotificationParams;
+} | {
+    method: "item/agentMessage/delta";
+    params: AgentMessageDeltaNotificationParams;
+} | {
+    method: "item/reasoning/summaryTextDelta";
+    params: ReasoningSummaryTextDeltaNotificationParams;
+} | {
+    method: "item/reasoning/textDelta";
+    params: ReasoningSummaryTextDeltaNotificationParams;
+} | {
+    method: "item/commandExecution/outputDelta";
+    params: CommandExecutionOutputDeltaNotificationParams;
+} | {
+    method: "item/fileChange/patchUpdated";
+    params: FileChangePatchUpdatedNotificationParams;
+} | {
+    method: "thread/tokenUsage/updated";
+    params: ThreadTokenUsageUpdatedNotificationParams;
+} | {
+    method: "error";
+    params: ErrorNotificationParams;
+} | {
+    method: string;
+    params?: Record<string, unknown>;
+};
+export interface CommandExecutionRequestApprovalParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    startedAtMs: number;
+    approvalId?: string | null;
+    reason?: string | null;
+    command?: string | null;
+    cwd?: string | null;
+}
+export type CommandExecutionApprovalDecision = "accept" | "acceptForSession" | "decline" | "cancel";
+export interface CommandExecutionRequestApprovalResponse {
+    decision: CommandExecutionApprovalDecision;
+}
+export interface FileChangeRequestApprovalParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    startedAtMs: number;
+    reason?: string | null;
+    grantRoot?: string | null;
+}
+export type FileChangeApprovalDecision = "accept" | "acceptForSession" | "decline" | "cancel";
+export interface FileChangeRequestApprovalResponse {
+    decision: FileChangeApprovalDecision;
+}

package/dist/codex-app-server/protocol.js

@@ -0,0 +1,12 @@
+/**
+ * Hand-curated subset of the Codex App Server JSON-RPC protocol.
+ *
+ * Source of truth: `codex app-server generate-ts --out <dir>` produces the
+ * full TypeScript bindings (~150 files). This file only mirrors the shapes
+ * the bridge consumes today. Unused notification / request payloads are
+ * captured with a permissive `Record<string, unknown>` so future Codex
+ * releases keep parsing without code changes here.
+ *
+ * Re-generate the upstream bindings periodically to spot field renames.
+ */
+export {};