@rynx-ai/runtime 0.1.0 → 0.1.9

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

@@ -1,5 +1,5 @@
 /**
- * Persistent codex session forwarder — the heart of omnigent's codex-native
+ * Persistent codex session forwarder — the heart of reference implementation's codex-native
  * model, ported to rynx. It subscribes to a session's app-server for the whole
  * session lifetime (not just one turn) and maps every thread notification to a
  * typed {@link AgentEvent}, so turns started by ANY client — the web composer OR
@@ -10,9 +10,9 @@
  * (or a fatal error) closes it. The turn's codex `turnId` is surfaced on
  * {@link CodexForwarderSink.onTurnStart} so the normalizer's `responseId` is
  * DETERMINISTIC (`resp_codex_<turnId>`) — the same turn always maps to the same
- * response id across snapshot/live, so items converge (omnigent's `codex_{turnId}`).
+ * response id across snapshot/live, so items converge (reference implementation's `codex_{turnId}`).
  *
- * omnigent's subscribe-then-mirror model (verified against real codex 0.142.5):
+ * reference implementation's subscribe-then-mirror model (verified against real codex 0.142.5):
  * the app-server delivers a thread's item/turn notifications to a connection that
  * has `thread/resume`d it. A fresh TUI-created thread has no rollout until its
  * first turn, so resume is parked until {@link CodexForwarderSink.onThreadActive}
@@ -41,7 +41,7 @@ export interface CodexForwarderSink {
      *  or a resume). The host persists the id + starts the subscribe loop. */
     onThreadStarted?(threadId: string): void;
     /** The thread showed activity (a turn/item began, so its rollout now exists).
-     *  Fired once; lets a parked `thread/resume` retry (omnigent's ready signal). */
+     *  Fired once; lets a parked `thread/resume` retry (reference implementation's ready signal). */
     onThreadActive?(): void;
 }
 export declare class CodexSessionForwarder {
@@ -54,10 +54,10 @@ export declare class CodexSessionForwarder {
     private activeSignaled;
     /** Completed-item dedup keys already mirrored (live vs resume backfill). Key =
      *  `threadId:turnId:item.id`; anonymous items use a per-(thread,turn) position
-     *  counter. Mirrors omnigent `_completed_item_key` + `synced_item_keys`. */
+     *  counter. Mirrors reference implementation `_completed_item_key` + `synced_item_keys`. */
     private readonly seenCompletedItems;
     /** Per-(thread,turn) position counter for items lacking a stable codex id
-     *  (peek-then-advance; advanced only on a successful claim). omnigent anon path. */
+     *  (peek-then-advance; advanced only on a successful claim). reference implementation anon path. */
     private readonly anonCounters;
     constructor(client: CodexAppServerClient, sink: CodexForwarderSink);
     /** Begin mirroring. Idempotent. */
@@ -85,7 +85,7 @@ export declare class CodexSessionForwarder {
      *  `threadId:turnId:item.id` — identical across replay + live, so the second
      *  delivery is dropped. Items without a codex id fall back to a per-(thread,turn)
      *  position counter (peeked here; advanced only on a successful claim, via
-     *  {@link advanceAnonCounter}). Mirrors omnigent `_completed_item_key`. */
+     *  {@link advanceAnonCounter}). Mirrors reference implementation `_completed_item_key`. */
     private completedItemKey;
     private advanceAnonCounter;
     private ensureTurn;

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

@@ -19,7 +19,7 @@ function userMessageText(item) {
     return text || undefined;
 }
 /** Whether a notification implies the thread is now active (its first turn has
- *  begun, so the rollout exists). Mirrors omnigent's `_event_indicates_thread_active`. */
+ *  begun, so the rollout exists). Mirrors reference implementation's `_event_indicates_thread_active`. */
 function indicatesActive(method, params) {
     if (method.startsWith("turn/") || method.startsWith("item/"))
         return true;
@@ -39,10 +39,10 @@ export class CodexSessionForwarder {
     activeSignaled = false;
     /** Completed-item dedup keys already mirrored (live vs resume backfill). Key =
      *  `threadId:turnId:item.id`; anonymous items use a per-(thread,turn) position
-     *  counter. Mirrors omnigent `_completed_item_key` + `synced_item_keys`. */
+     *  counter. Mirrors reference implementation `_completed_item_key` + `synced_item_keys`. */
     seenCompletedItems = new Set();
     /** Per-(thread,turn) position counter for items lacking a stable codex id
-     *  (peek-then-advance; advanced only on a successful claim). omnigent anon path. */
+     *  (peek-then-advance; advanced only on a successful claim). reference implementation anon path. */
     anonCounters = new Map();
     constructor(client, sink) {
         this.client = client;
@@ -91,8 +91,14 @@ export class CodexSessionForwarder {
             this.ensureTurn();
             for (const item of turn.items ?? [])
                 this.processCompletedItem(item);
+            if (turn.status === "inProgress")
+                continue;
+            const mapped = mapCodexNotification("turn/completed", { turn });
             this.turnOpen = false;
-            this.sink.onTurnEnd();
+            if (mapped.fatalError)
+                this.sink.onTurnError(mapped.fatalError);
+            else
+                this.sink.onTurnEnd(mapped.usage);
         }
     }
     handle(method, params) {
@@ -166,7 +172,7 @@ export class CodexSessionForwarder {
      *  `threadId:turnId:item.id` — identical across replay + live, so the second
      *  delivery is dropped. Items without a codex id fall back to a per-(thread,turn)
      *  position counter (peeked here; advanced only on a successful claim, via
-     *  {@link advanceAnonCounter}). Mirrors omnigent `_completed_item_key`. */
+     *  {@link advanceAnonCounter}). Mirrors reference implementation `_completed_item_key`. */
     completedItemKey(item) {
         const threadId = this.currentThreadIdValue ?? "thread";
         const turnId = this.currentTurnIdValue ?? "turn";

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

@@ -2,7 +2,7 @@
  * Pure codex app-server notification → {@link AgentEvent} mapping. Extracted from
  * the executor so BOTH the per-turn executor and the persistent session
  * forwarder (which mirrors every thread turn — web- AND TUI-initiated — into the
- * canonical log, omnigent's codex-native model) share one mapping.
+ * canonical log, reference implementation's codex-native model) share one mapping.
  */
 import type { AgentEvent } from "@rynx-ai/core";
 import type { ThreadItem } from "./protocol.js";

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

@@ -1,3 +1,13 @@
+function turnError(error, fallback) {
+    if (typeof error === "string" && error.trim())
+        return new Error(error);
+    if (error && typeof error === "object" && "message" in error) {
+        const message = error.message;
+        if (typeof message === "string" && message.trim())
+            return new Error(message);
+    }
+    return new Error(fallback);
+}
 /** Map one thread item (`item/started` | `item/completed`) to events. */
 export function mapCodexItem(method, item) {
     const events = [];
@@ -112,12 +122,27 @@ export function mapCodexNotification(method, params) {
     switch (typed.method) {
         case "thread/started":
             return { events };
+        case "serverRequest/resolved":
+            // Interaction lifecycle is handled by CodexAppServerClient. It is not
+            // model output and must never open or close a Turn in the forwarder.
+            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 };
+            if (turnPayload?.status === "failed") {
+                return {
+                    events,
+                    fatalError: turnError(turnPayload.error, "Codex turn failed"),
+                    turnCompleted: true,
+                };
+            }
+            if (turnPayload?.status === "interrupted") {
+                return {
+                    events,
+                    fatalError: turnError(turnPayload.error, "Codex turn was interrupted"),
+                    turnCompleted: true,
+                };
             }
             return { events, turnCompleted: true };
         }

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

@@ -58,7 +58,8 @@ export interface GetAuthStatusResponse {
 }
 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";
+/** Open since Codex App Server 0.144; values are advertised by `model/list`. */
+export type ReasoningEffort = string;
 export interface ThreadStartParams {
     model?: string | null;
     modelProvider?: string | null;
@@ -75,13 +76,15 @@ export interface ThreadResumeParams extends ThreadStartParams {
     /** 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`). */
+     *  fresh thread's first turn (reference implementation's `_replay_resume_response`). */
     excludeTurns?: boolean;
 }
 /** One turn in a resumed thread's backlog (`thread/resume` response). */
 export interface ResumedTurn {
     id?: string;
     turnId?: string;
+    status: TurnStatus;
+    error?: unknown;
     items?: ThreadItem[];
 }
 /** The `thread` object a `thread/resume` response carries (id + optional backlog). */
@@ -256,6 +259,11 @@ export interface ModelInfo {
     hidden?: boolean;
     isDefault?: boolean;
     supportsPersonality?: boolean;
+    supportedReasoningEfforts?: Array<{
+        reasoningEffort: ReasoningEffort;
+        description?: string;
+    }>;
+    defaultReasoningEffort?: ReasoningEffort;
     [key: string]: unknown;
 }
 export interface ModelListResponse {
@@ -450,11 +458,26 @@ export interface CommandExecutionRequestApprovalParams {
     itemId: string;
     startedAtMs: number;
     approvalId?: string | null;
+    environmentId: string | null;
     reason?: string | null;
+    networkApprovalContext?: NetworkApprovalContext | null;
     command?: string | null;
     cwd?: string | null;
-}
-export type CommandExecutionApprovalDecision = "accept" | "acceptForSession" | "decline" | "cancel";
+    commandActions?: Array<Record<string, unknown>> | null;
+    additionalPermissions?: AdditionalPermissionProfile | null;
+    proposedExecpolicyAmendment?: string[] | null;
+    proposedNetworkPolicyAmendments?: NetworkPolicyAmendment[] | null;
+    availableDecisions?: CommandExecutionApprovalDecision[] | null;
+}
+export type CommandExecutionApprovalDecision = "accept" | "acceptForSession" | {
+    acceptWithExecpolicyAmendment: {
+        execpolicy_amendment: string[];
+    };
+} | {
+    applyNetworkPolicyAmendment: {
+        network_policy_amendment: NetworkPolicyAmendment;
+    };
+} | "decline" | "cancel";
 export interface CommandExecutionRequestApprovalResponse {
     decision: CommandExecutionApprovalDecision;
 }
@@ -470,3 +493,214 @@ export type FileChangeApprovalDecision = "accept" | "acceptForSession" | "declin
 export interface FileChangeRequestApprovalResponse {
     decision: FileChangeApprovalDecision;
 }
+/** Legacy/experimental app-server approval methods still emitted by current
+ * Codex builds alongside the v2 item approval methods. */
+export interface ExecCommandApprovalParams {
+    conversationId: string;
+    callId: string;
+    approvalId: string | null;
+    command: string[];
+    cwd: string;
+    reason: string | null;
+}
+export interface ApplyPatchApprovalParams {
+    conversationId: string;
+    callId: string;
+    fileChanges: Record<string, {
+        type: "add" | "delete";
+        content: string;
+    } | {
+        type: "update";
+        unified_diff: string;
+        move_path: string | null;
+    }>;
+    reason: string | null;
+    grantRoot: string | null;
+}
+export type LegacyReviewDecision = "approved" | "approved_for_session" | "denied" | "timed_out" | "abort";
+export interface LegacyApprovalResponse {
+    decision: LegacyReviewDecision;
+}
+/** EXPERIMENTAL request_user_input question advertised by Codex app-server. */
+export interface ToolRequestUserInputQuestion {
+    id: string;
+    header: string;
+    question: string;
+    isOther: boolean;
+    isSecret: boolean;
+    options: Array<{
+        label: string;
+        description: string;
+    }> | null;
+}
+export interface ToolRequestUserInputParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    questions: ToolRequestUserInputQuestion[];
+    autoResolutionMs: number | null;
+}
+export interface ToolRequestUserInputResponse {
+    answers: Record<string, {
+        answers: string[];
+    }>;
+}
+export interface McpElicitationConstOption {
+    const: string;
+    title: string;
+}
+export type McpElicitationPrimitiveSchema = {
+    type: "string";
+    title?: string;
+    description?: string;
+    minLength?: number;
+    maxLength?: number;
+    format?: "email" | "uri" | "date" | "date-time";
+    default?: string;
+} | {
+    type: "string";
+    title?: string;
+    description?: string;
+    enum: string[];
+    enumNames?: string[];
+    default?: string;
+} | {
+    type: "string";
+    title?: string;
+    description?: string;
+    oneOf: McpElicitationConstOption[];
+    default?: string;
+} | {
+    type: "array";
+    title?: string;
+    description?: string;
+    minItems?: number;
+    maxItems?: number;
+    items: {
+        type: "string";
+        enum: string[];
+    } | {
+        anyOf: McpElicitationConstOption[];
+    };
+    default?: string[];
+} | {
+    type: "number" | "integer";
+    title?: string;
+    description?: string;
+    minimum?: number;
+    maximum?: number;
+    default?: number;
+} | {
+    type: "boolean";
+    title?: string;
+    description?: string;
+    default?: boolean;
+};
+export interface McpElicitationSchema {
+    $schema?: string;
+    type: "object";
+    properties: Record<string, McpElicitationPrimitiveSchema>;
+    required?: string[];
+}
+/** MCP elicitation request. `openai/form` deliberately keeps its schema open. */
+export type McpServerElicitationRequestParams = {
+    threadId: string;
+    turnId: string | null;
+    serverName: string;
+} & ({
+    mode: "form";
+    message: string;
+    requestedSchema: McpElicitationSchema;
+    _meta: unknown;
+} | {
+    mode: "openai/form";
+    message: string;
+    requestedSchema: Record<string, unknown>;
+    _meta: unknown;
+} | {
+    mode: "url";
+    message: string;
+    url: string;
+    elicitationId: string;
+    _meta: unknown;
+});
+export interface McpServerElicitationRequestResponse {
+    action: "accept" | "decline" | "cancel";
+    content: unknown | null;
+    _meta: unknown | null;
+}
+export interface AdditionalNetworkPermissions {
+    enabled: boolean | null;
+}
+export type FileSystemSpecialPath = {
+    kind: "root";
+} | {
+    kind: "minimal";
+} | {
+    kind: "project_roots";
+    subpath: string | null;
+} | {
+    kind: "tmpdir";
+} | {
+    kind: "slash_tmp";
+} | {
+    kind: "unknown";
+    path: string;
+    subpath: string | null;
+};
+export type FileSystemPath = {
+    type: "path";
+    path: string;
+} | {
+    type: "glob_pattern";
+    pattern: string;
+} | {
+    type: "special";
+    value: FileSystemSpecialPath;
+};
+export interface FileSystemSandboxEntry {
+    path: FileSystemPath;
+    access: "read" | "write" | "deny";
+}
+export interface AdditionalFileSystemPermissions {
+    read: string[] | null;
+    write: string[] | null;
+    globScanMaxDepth?: number;
+    entries?: FileSystemSandboxEntry[];
+}
+export interface AdditionalPermissionProfile {
+    network: AdditionalNetworkPermissions | null;
+    fileSystem: AdditionalFileSystemPermissions | null;
+}
+export interface NetworkApprovalContext {
+    host: string;
+    protocol: "http" | "https" | "socks5Tcp" | "socks5Udp";
+}
+export interface NetworkPolicyAmendment {
+    host: string;
+    action: "allow" | "deny";
+}
+export type RequestPermissionProfile = AdditionalPermissionProfile;
+export interface PermissionsRequestApprovalParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    environmentId: string | null;
+    startedAtMs: number;
+    cwd: string;
+    reason: string | null;
+    permissions: RequestPermissionProfile;
+}
+export interface PermissionsRequestApprovalResponse {
+    permissions: {
+        network?: AdditionalNetworkPermissions;
+        fileSystem?: AdditionalFileSystemPermissions;
+    };
+    scope: "turn" | "session";
+    strictAutoReview?: boolean;
+}
+/** A different app-server client (usually the native TUI) answered first. */
+export interface ServerRequestResolvedNotificationParams {
+    threadId?: string;
+    requestId: RequestId;
+}

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

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import type { SandboxMode } from "./protocol.js";
+import type { RequestId, SandboxMode } from "./protocol.js";
 export declare function buildAppServerSpawnArgs(sandboxMode: SandboxMode, listen?: string): string[];
 /** app-server args WITHOUT `--listen` — for a channel that appends its own
  *  transport endpoint (e.g. {@link import("./ws-channel.js").WsRpcChannel}). */
@@ -29,7 +29,7 @@ export interface RpcChannel {
     /** Establish the channel (connect / await readiness). */
     start(): Promise<void>;
     /** Write one framed message (already newline-terminated). */
-    send(line: string): void;
+    send(line: string): void | Promise<void>;
     /** Register the inbound-line handler (one framed message per call). */
     onLine(cb: (line: string) => void): void;
     /** Register the close/error handler. */
@@ -64,8 +64,17 @@ export declare class CodexTransportError extends Error {
     readonly data?: unknown;
     constructor(message: string, code?: number, data?: unknown);
 }
-export type ServerRequestHandler = (method: string, params: unknown) => Promise<unknown> | unknown;
+export type ServerRequestHandler = (method: string, params: unknown, requestId: RequestId) => Promise<unknown | typeof NO_SERVER_RESPONSE> | unknown | typeof NO_SERVER_RESPONSE;
+/** A server request was resolved by another app-server client. In that case the
+ * local handler must settle without sending a second JSON-RPC response. */
+export declare const NO_SERVER_RESPONSE: unique symbol;
 export type ServerNotificationHandler = (method: string, params: unknown) => void;
+export type ServerRequestResponseDeliveryHandler = (requestId: RequestId, result: {
+    delivered: true;
+} | {
+    delivered: false;
+    error: Error;
+}) => void;
 export interface CodexAppServerTransportOptions {
     /** Default stdio transport: spawns `app-server --listen stdio://`. Mutually
      *  exclusive with {@link channel}; provide exactly one. */
@@ -83,6 +92,10 @@ export interface CodexAppServerTransportOptions {
      * propagated back to the server.
      */
     onNotification?: ServerNotificationHandler;
+    /** Reports whether a server-request response was actually handed to the
+     * transport. Provider acknowledgement still arrives separately as
+     * `serverRequest/resolved`. */
+    onServerRequestResponseDelivery?: ServerRequestResponseDeliveryHandler;
 }
 interface TransportEvents {
     exit: [code: number | null, signal: NodeJS.Signals | null];
@@ -109,6 +122,7 @@ export declare class CodexAppServerTransport extends EventEmitter {
     private readonly logger;
     private readonly onServerRequest?;
     private readonly onNotification?;
+    private readonly onServerRequestResponseDelivery?;
     private child;
     private rl;
     private stderrRl;
@@ -116,14 +130,14 @@ export declare class CodexAppServerTransport extends EventEmitter {
     private readonly pending;
     private startPromise;
     private exited;
-    constructor({ spawner, channel, logger, onServerRequest, onNotification, }: CodexAppServerTransportOptions);
+    constructor({ spawner, channel, logger, onServerRequest, onNotification, onServerRequestResponseDelivery, }: CodexAppServerTransportOptions);
     emit<K extends keyof TransportEvents>(event: K, ...args: TransportEvents[K]): boolean;
     on<K extends keyof TransportEvents>(event: K, listener: (...args: TransportEvents[K]) => void): this;
     off<K extends keyof TransportEvents>(event: K, listener: (...args: TransportEvents[K]) => void): this;
     isRunning(): boolean;
     ensureStarted(): Promise<void>;
     sendRequest<TResult = unknown>(method: string, params?: unknown): Promise<TResult>;
-    sendNotification(method: string, params?: unknown): void;
+    sendNotification(method: string, params?: unknown): Promise<void>;
     stop(signal?: NodeJS.Signals): Promise<void>;
     private startTransport;
     private startChild;
@@ -134,6 +148,7 @@ export declare class CodexAppServerTransport extends EventEmitter {
     private handleErrorEnvelope;
     private handleServerRequest;
     private respondToServerRequest;
+    private notifyServerRequestResponseDelivery;
     private handleNotification;
 }
 export {};