@rynx-ai/runtime 0.1.0 → 0.1.10-beta.2

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). */
@@ -197,6 +200,20 @@ export interface DynamicToolCallItem extends ThreadItemBase {
 export interface WebSearchItem extends ThreadItemBase {
     type: "webSearch";
     query: string;
+    action?: {
+        type: "search";
+        query: string | null;
+        queries: string[] | null;
+    } | {
+        type: "openPage";
+        url: string | null;
+    } | {
+        type: "findInPage";
+        url: string | null;
+        pattern: string | null;
+    } | {
+        type: "other";
+    } | null;
 }
 export type ThreadItem = UserMessageItem | AgentMessageItem | ReasoningItem | PlanItem | CommandExecutionItem | FileChangeItem | McpToolCallItem | DynamicToolCallItem | WebSearchItem | (ThreadItemBase & Record<string, unknown>);
 export interface ThreadSummary {
@@ -256,6 +273,11 @@ export interface ModelInfo {
     hidden?: boolean;
     isDefault?: boolean;
     supportsPersonality?: boolean;
+    supportedReasoningEfforts?: Array<{
+        reasoningEffort: ReasoningEffort;
+        description?: string;
+    }>;
+    defaultReasoningEffort?: ReasoningEffort;
     [key: string]: unknown;
 }
 export interface ModelListResponse {
@@ -398,6 +420,15 @@ export interface ErrorNotificationParams {
     threadId: string;
     turnId: string;
 }
+/** Traex backend-capacity queue update. */
+export interface QueueStatusNotificationParams {
+    threadId: string;
+    turnId: string;
+    /** `queued` | `waiting` | `ready`. */
+    state: string;
+    position: number | null;
+    message: string | null;
+}
 export type ServerNotification = {
     method: "thread/started";
     params: ThreadStartedNotificationParams;
@@ -437,6 +468,9 @@ export type ServerNotification = {
 } | {
     method: "thread/tokenUsage/updated";
     params: ThreadTokenUsageUpdatedNotificationParams;
+} | {
+    method: "queue/status";
+    params: QueueStatusNotificationParams;
 } | {
     method: "error";
     params: ErrorNotificationParams;
@@ -450,11 +484,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 +519,219 @@ 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;
+    /** Traex extension; absent in Codex 0.144. */
+    multiSelect?: boolean;
+    options: Array<{
+        label: string;
+        description: string;
+    }> | null;
+}
+export interface ToolRequestUserInputParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    questions: ToolRequestUserInputQuestion[];
+    /** Codex supplies an optional auto-resolution deadline. */
+    autoResolutionMs?: number | null;
+    /** Traex 0.200 supplies blocking semantics instead of a deadline. */
+    isBlocking?: boolean;
+}
+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 {};

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

@@ -67,6 +67,9 @@ export class CodexTransportError extends Error {
         this.data = data;
     }
 }
+/** 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 const NO_SERVER_RESPONSE = Symbol("NO_SERVER_RESPONSE");
 /**
  * Wraps the Codex `app-server` subprocess and exposes a typed JSON-RPC API
  * over its stdio. Frames are line-delimited NDJSON (no Content-Length
@@ -88,6 +91,7 @@ export class CodexAppServerTransport extends EventEmitter {
     logger;
     onServerRequest;
     onNotification;
+    onServerRequestResponseDelivery;
     child = null;
     rl = null;
     stderrRl = null;
@@ -95,7 +99,7 @@ export class CodexAppServerTransport extends EventEmitter {
     pending = new Map();
     startPromise = null;
     exited = false;
-    constructor({ spawner, channel, logger = defaultLogger, onServerRequest, onNotification, }) {
+    constructor({ spawner, channel, logger = defaultLogger, onServerRequest, onNotification, onServerRequestResponseDelivery, }) {
         super();
         if (!spawner && !channel) {
             throw new Error("CodexAppServerTransport requires a spawner or a channel");
@@ -105,6 +109,7 @@ export class CodexAppServerTransport extends EventEmitter {
         this.logger = logger;
         this.onServerRequest = onServerRequest;
         this.onNotification = onNotification;
+        this.onServerRequestResponseDelivery = onServerRequestResponseDelivery;
     }
     emit(event, ...args) {
         return super.emit(event, ...args);
@@ -145,39 +150,46 @@ export class CodexAppServerTransport extends EventEmitter {
     async sendRequest(method, params) {
         await this.ensureStarted();
         const id = this.nextId++;
-        return await new Promise((resolve, reject) => {
+        const envelope = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            ...(params === undefined ? {} : { params }),
+        };
+        let rejectResponse;
+        const response = new Promise((resolve, reject) => {
+            rejectResponse = reject;
             this.pending.set(id, {
                 resolve: resolve,
                 reject,
                 method,
             });
-            const envelope = {
-                jsonrpc: "2.0",
-                id,
-                method,
-                ...(params === undefined ? {} : { params }),
-            };
-            try {
-                this.writeLine(envelope);
-            }
-            catch (error) {
-                this.pending.delete(id);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
         });
+        try {
+            await this.writeLine(envelope);
+        }
+        catch (error) {
+            this.pending.delete(id);
+            rejectResponse(error instanceof Error ? error : new Error(String(error)));
+        }
+        return await response;
     }
-    sendNotification(method, params) {
+    async sendNotification(method, params) {
         const envelope = {
             jsonrpc: "2.0",
             method,
             ...(params === undefined ? {} : { params }),
         };
-        this.writeLine(envelope);
+        await this.writeLine(envelope);
     }
     async stop(signal = "SIGTERM") {
         if (this.channel) {
-            this.exited = true;
             await this.channel.stop(signal);
+            // Channel implementations may report close asynchronously (or not at all).
+            // Run the same exit path synchronously so pending RPCs reject and clients
+            // clear pending native interactions before stop() resolves.
+            if (!this.exited)
+                this.handleExit(null, signal, null);
             return;
         }
         const child = this.child;
@@ -268,25 +280,29 @@ export class CodexAppServerTransport extends EventEmitter {
         });
         this.emit("exit", code, signal);
     }
-    writeLine(envelope) {
+    async writeLine(envelope) {
         const line = `${JSON.stringify(envelope)}\n`;
         if (this.channel) {
             if (this.exited) {
                 throw new CodexTransportError("Codex app-server is not running");
             }
-            this.channel.send(line);
+            await this.channel.send(line);
             return;
         }
         const child = this.child;
         if (!child || this.exited) {
             throw new CodexTransportError("Codex app-server is not running");
         }
-        const ok = child.stdin.write(line);
-        if (!ok) {
-            // Don't block — back-pressure on stdin is unlikely with line-sized
-            // messages, but we surface it as a log entry if it ever shows up.
-            this.logger.log({ event: "transport.stdin_backpressure" });
-        }
+        await new Promise((resolve, reject) => {
+            const ok = child.stdin.write(line, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+            if (!ok)
+                this.logger.log({ event: "transport.stdin_backpressure" });
+        });
     }
     handleLine(line) {
         if (!line.trim()) {
@@ -352,34 +368,71 @@ export class CodexAppServerTransport extends EventEmitter {
     }
     async handleServerRequest(envelope) {
         if (!this.onServerRequest) {
-            this.respondToServerRequest(envelope.id, undefined, {
-                code: -32601,
-                message: `No handler registered for ${envelope.method}`,
-            });
+            try {
+                await this.respondToServerRequest(envelope.id, undefined, {
+                    code: -32601,
+                    message: `No handler registered for ${envelope.method}`,
+                });
+            }
+            catch (error) {
+                this.logger.log({
+                    event: "transport.server_request_error_write_failed",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
             return;
         }
+        let result;
         try {
-            const result = await this.onServerRequest(envelope.method, envelope.params);
-            this.respondToServerRequest(envelope.id, result, null);
+            result = await this.onServerRequest(envelope.method, envelope.params, envelope.id);
         }
         catch (error) {
-            this.respondToServerRequest(envelope.id, undefined, {
-                code: -32000,
-                message: error instanceof Error ? error.message : String(error),
+            try {
+                await this.respondToServerRequest(envelope.id, undefined, {
+                    code: -32000,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+            catch (writeError) {
+                this.logger.log({
+                    event: "transport.server_request_error_write_failed",
+                    error: writeError instanceof Error ? writeError.message : String(writeError),
+                });
+            }
+            return;
+        }
+        if (result === NO_SERVER_RESPONSE)
+            return;
+        try {
+            await this.respondToServerRequest(envelope.id, result, null);
+            this.notifyServerRequestResponseDelivery(envelope.id, { delivered: true });
+        }
+        catch (writeError) {
+            const error = writeError instanceof Error ? writeError : new Error(String(writeError));
+            this.logger.log({
+                event: "transport.server_request_write_failed",
+                error: error.message,
+            });
+            this.notifyServerRequestResponseDelivery(envelope.id, {
+                delivered: false,
+                error,
             });
         }
     }
-    respondToServerRequest(id, result, error) {
+    async respondToServerRequest(id, result, error) {
         const envelope = error
             ? { jsonrpc: "2.0", id, error }
             : { jsonrpc: "2.0", id, result };
+        await this.writeLine(envelope);
+    }
+    notifyServerRequestResponseDelivery(requestId, result) {
         try {
-            this.writeLine(envelope);
+            this.onServerRequestResponseDelivery?.(requestId, result);
         }
-        catch (writeError) {
+        catch (error) {
             this.logger.log({
-                event: "transport.server_request_write_failed",
-                error: writeError instanceof Error ? writeError.message : String(writeError),
+                event: "transport.server_request_delivery_handler_failed",
+                error: error instanceof Error ? error.message : String(error),
             });
         }
     }

package/dist/codex-app-server/ws-channel.d.ts

@@ -28,7 +28,7 @@ export declare class WsRpcChannel implements RpcChannel {
     }) => void): void;
     isOpen(): boolean;
     start(): Promise<void>;
-    send(line: string): void;
+    send(line: string): Promise<void>;
     stop(signal?: NodeJS.Signals): Promise<void>;
     private emitClose;
     private connectWithRetry;
@@ -37,7 +37,7 @@ export declare class WsRpcChannel implements RpcChannel {
 /**
  * Connect-only {@link RpcChannel}: attaches an ADDITIONAL client to an app-server
  * someone else already started (a {@link WsRpcChannel}'s `url`) — no spawn. This
- * is how rynx runs omnigent's multi-connection codex-native model: the backend
+ * is how rynx runs reference implementation's multi-connection codex-native model: the backend
  * client owns the app-server + drives injection, while a SEPARATE forwarder
  * connection `thread/resume`s the same thread to subscribe to its item/turn
  * notifications (verified: codex delivers a thread's items to every connection
@@ -65,7 +65,7 @@ export declare class ExternalWsChannel implements RpcChannel {
     }) => void): void;
     isOpen(): boolean;
     start(): Promise<void>;
-    send(line: string): void;
+    send(line: string): Promise<void>;
     stop(): Promise<void>;
     private emitClose;
     private connect;