@rynx-ai/runtime 0.1.11-beta.4 → 0.1.11-beta.6

package/dist/host.js

@@ -1536,6 +1536,9 @@ export class LocalAgentHost {
             // Explicit rynx hooks and selected-skill plugin dirs remain enabled.
             settingSources: "",
             model: live.execution.model,
+            ...(live.execution.reasoningEffort
+                ? { reasoningEffort: live.execution.reasoningEffort }
+                : {}),
             ...(live.execution.instructions
                 ? { appendSystemPrompt: live.execution.instructions }
                 : {}),

package/dist/models-catalog.d.ts

@@ -1,11 +1,12 @@
 import { type AgentRuntimeId, type AppConfig } from "@rynx-ai/core";
 import type { ModelListResponse } from "./codex-app-server/protocol.js";
 export interface RuntimeModelCatalogDeps {
+    readCodexModels?: () => Promise<unknown>;
     readTraexModels?: () => Promise<unknown>;
     readTraexDebugModels?: () => Promise<unknown>;
 }
 /**
  * The model list for a runtime, without an execution backend.
- * Falls back to the configured model if live Traex discovery is unavailable.
+ * Falls back to the configured model if local/native discovery is unavailable.
  */
 export declare function listRuntimeModels(config: AppConfig, runtime: AgentRuntimeId, deps?: RuntimeModelCatalogDeps): Promise<ModelListResponse | null>;

package/dist/models-catalog.js

@@ -3,24 +3,37 @@
  *
  * The parent control plane no longer holds an app-server, so `/models` can't be
  * a live `model/list` RPC anymore. Following reference implementation's static-catalog model, we
- * serve a config-derived Codex list and Traex's native `models --json` catalog.
+ * serve Codex's local model cache and Traex's native `models --json` catalog.
  * claude already has its own static list ({@link listClaudeModels}).
  */
 import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
 import { promisify } from "node:util";
-import { resolveRuntimeBinary, resolveRuntimeModel, } from "@rynx-ai/core";
+import { getRuntimeProfile, resolveRuntimeBinary, resolveRuntimeHome, resolveRuntimeModel, } from "@rynx-ai/core";
 import { listClaudeModels } from "./claude/models.js";
 const execFileAsync = promisify(execFile);
 const TRAEX_MODELS_TIMEOUT_MS = 8_000;
 const TRAEX_MODELS_MAX_BYTES = 2 * 1024 * 1024;
 /**
  * The model list for a runtime, without an execution backend.
- * Falls back to the configured model if live Traex discovery is unavailable.
+ * Falls back to the configured model if local/native discovery is unavailable.
  */
 export async function listRuntimeModels(config, runtime, deps = {}) {
     if (runtime === "claude") {
         return listClaudeModels();
     }
+    if (runtime === "codex") {
+        try {
+            const configuredDefault = resolveRuntimeModel(config, runtime).trim();
+            const models = normalizeCodexModels(await (deps.readCodexModels ?? readCodexModels)(), configuredDefault);
+            if (models.length > 0)
+                return { data: models };
+        }
+        catch {
+            // Keep the configured fallback usable before Codex has populated its cache.
+        }
+    }
     if (runtime === "traex") {
         try {
             const value = await (deps.readTraexModels ?? readTraexModels)();
@@ -48,6 +61,72 @@ export async function listRuntimeModels(config, runtime, deps = {}) {
     }
     return { data: [{ id: model, model, isDefault: true }] };
 }
+async function readCodexModels() {
+    const cachePath = join(resolveRuntimeHome(getRuntimeProfile("codex")), "models_cache.json");
+    return JSON.parse(await readFile(cachePath, "utf8"));
+}
+function normalizeCodexModels(value, configuredDefault) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    const entries = value.models;
+    if (!Array.isArray(entries))
+        return [];
+    const models = [];
+    const seen = new Set();
+    for (const item of entries) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const record = item;
+        const id = typeof record.slug === "string" ? record.slug.trim() : "";
+        if (!id || seen.has(id) || record.visibility === "hide")
+            continue;
+        seen.add(id);
+        const supportedReasoningEfforts = Array.isArray(record.supported_reasoning_levels)
+            ? record.supported_reasoning_levels.flatMap((raw) => {
+                if (!raw || typeof raw !== "object" || Array.isArray(raw))
+                    return [];
+                const effort = typeof raw.effort === "string"
+                    ? raw.effort.trim()
+                    : "";
+                if (!effort)
+                    return [];
+                const description = raw.description;
+                return [{
+                        reasoningEffort: effort,
+                        ...(typeof description === "string" && description.trim()
+                            ? { description: description.trim() }
+                            : {}),
+                    }];
+            })
+            : [];
+        const displayName = typeof record.display_name === "string"
+            ? record.display_name.trim()
+            : "";
+        const description = typeof record.description === "string"
+            ? record.description.trim()
+            : "";
+        const defaultReasoningEffort = typeof record.default_reasoning_level === "string"
+            ? record.default_reasoning_level.trim()
+            : "";
+        models.push({
+            id,
+            model: id,
+            ...(displayName ? { displayName } : {}),
+            ...(description ? { description } : {}),
+            isDefault: id === configuredDefault,
+            ...(supportedReasoningEfforts.length > 0 ? { supportedReasoningEfforts } : {}),
+            ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+        });
+    }
+    if (configuredDefault && !seen.has(configuredDefault)) {
+        models.unshift({
+            id: configuredDefault,
+            model: configuredDefault,
+            isDefault: true,
+        });
+    }
+    return models;
+}
 async function readTraexModels() {
     const { stdout } = await execFileAsync(resolveRuntimeBinary("traex"), ["models", "--json"], {
         encoding: "utf8",

package/dist/runner/child.js

@@ -1,5 +1,14 @@
 import { TerminalRegistry } from "../terminal/registry.js";
 import { toWireError } from "./protocol.js";
+const TRAEX_STARTUP_WATCH_MS = 20_000;
+const TRAEX_STARTUP_POLL_MS = 100;
+const TRAEX_PROMPT_RETRY_MS = 500;
+function normalizeTraexPane(pane) {
+    return pane.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function isTerminalProtocolResponse(input) {
+    return /^(?:\x1b\[(?:(?:\?|>)[0-9;]*c|[0-9;]*(?:n|R|t)|[IO]))+$/.test(input);
+}
 export class RunnerSession {
     transport;
     executor;
@@ -48,8 +57,17 @@ export class RunnerSession {
                 });
                 return;
             case "term.input":
-                this.cancelTraexStartupWatcher(this.attachmentThreadIds.get(msg.attachId));
-                this.attachments.get(msg.attachId)?.write(Buffer.from(msg.dataB64, "base64").toString("utf8"));
+                {
+                    const localThreadId = this.attachmentThreadIds.get(msg.attachId);
+                    const input = Buffer.from(msg.dataB64, "base64").toString("utf8");
+                    // xterm sends device/focus reports through the same onData channel as
+                    // keystrokes. They must reach the TUI without pretending the user has
+                    // taken over startup prompt handling.
+                    if (!isTerminalProtocolResponse(input)) {
+                        this.cancelTraexStartupWatcher(localThreadId);
+                    }
+                    this.attachments.get(msg.attachId)?.write(input);
+                }
                 return;
             case "term.resize":
                 this.attachments.get(msg.attachId)?.resize(msg.cols, msg.rows);
@@ -215,8 +233,8 @@ export class RunnerSession {
         try {
             const input = msg.input ?? msg.text;
             const outcome = (await provider.injectMessage?.(msg.localThreadId, input)) ?? "notLive";
-            if (outcome === "injected")
-                this.cancelTraexStartupWatcher(msg.localThreadId);
+            // App-server injection is independent of the Terminal TUI startup, so it
+            // must not cancel prompt handling for the pane that is still starting.
             this.transport.send({ t: "injected", reqId: msg.reqId, localThreadId: msg.localThreadId, outcome });
         }
         catch (error) {
@@ -255,7 +273,6 @@ export class RunnerSession {
         if (!spec)
             return;
         const terminalId = `${localThreadId}-main`;
-        const coldStart = !this.terminals.has(terminalId);
         const term = this.terminals.getOrCreate(terminalId, {
             cwd: spec.cwd,
             command: spec.command,
@@ -264,7 +281,7 @@ export class RunnerSession {
             rows: rows ?? 40,
             ...(spec.env ? { env: spec.env } : {}),
         });
-        if (coldStart && spec.skipTraexStartupPrompts) {
+        if (spec.skipTraexStartupPrompts) {
             const watcher = Symbol(localThreadId);
             this.traexStartupWatchers.set(localThreadId, watcher);
             void this.skipTraexStartupPrompts(localThreadId, term, watcher);
@@ -279,46 +296,48 @@ export class RunnerSession {
         const prompts = [
             {
                 id: "welcome",
-                matches: (pane) => pane.includes("Welcome to TRAE CLI") && pane.includes("Press enter to continue"),
+                matches: (pane) => pane.includes("welcome to trae cli") && pane.includes("press enter to continue"),
                 dismiss: () => terminal.sendEnter(),
             },
             {
                 id: "migration",
-                matches: (pane) => pane.includes("Legacy TRAE CLI data detected") &&
-                    pane.includes("Would you like to migrate detected data to the new TRAE CLI storage?") &&
-                    pane.includes("Select what to import:"),
+                matches: (pane) => pane.includes("legacy trae cli data detected") &&
+                    pane.includes("select what to import") &&
+                    (pane.includes("skip for now") || pane.includes("don't ask again")),
                 dismiss: () => terminal.interrupt(),
             },
             {
                 id: "hooks",
-                matches: (pane) => pane.includes("Hooks need review") &&
-                    pane.includes("hooks are new or changed.") &&
-                    pane.includes("Trust all and continue") &&
-                    pane.includes("Continue without trusting"),
+                matches: (pane) => pane.includes("hooks need review") &&
+                    pane.includes("trust all and continue") &&
+                    pane.includes("continue without trusting"),
                 dismiss: () => terminal.interrupt(),
             },
         ];
-        const dismissed = new Set();
-        const deadline = Date.now() + 20_000;
+        let activePromptId;
+        let lastDismissedAt = 0;
+        const deadline = Date.now() + TRAEX_STARTUP_WATCH_MS;
         const terminalId = `${localThreadId}-main`;
         while (!this.shuttingDown &&
             Date.now() < deadline &&
             this.traexStartupWatchers.get(localThreadId) === watcher &&
             this.terminals.get(terminalId) === terminal) {
-            const pane = terminal.capturePane();
-            // Once the normal composer is visible, startup is complete and there is
-            // no reason to keep polling the tmux pane for the remainder of the window.
-            if (pane.includes("TRAE CLI Next"))
-                break;
+            // Do not treat a composer frame as completion: Traex can render it before
+            // the startup modals arrive. The bounded deadline stops this watcher.
+            const pane = normalizeTraexPane(terminal.capturePane());
             const prompt = prompts.find((candidate) => candidate.matches(pane));
-            if (prompt && !dismissed.has(prompt.id)) {
+            const now = Date.now();
+            if (!prompt) {
+                activePromptId = undefined;
+            }
+            else if (prompt.id !== activePromptId ||
+                now - lastDismissedAt >= TRAEX_PROMPT_RETRY_MS) {
                 prompt.dismiss();
-                dismissed.add(prompt.id);
-                if (dismissed.size === prompts.length)
-                    break;
+                activePromptId = prompt.id;
+                lastDismissedAt = now;
             }
             await new Promise((resolve) => {
-                const timer = setTimeout(resolve, 100);
+                const timer = setTimeout(resolve, TRAEX_STARTUP_POLL_MS);
                 timer.unref();
             });
         }

package/dist/terminal/claude-tui.d.ts

@@ -18,6 +18,8 @@ export interface ClaudeTuiArgs {
     settingSources?: string;
     /** Launch model (`--model`); omit to use claude's default. */
     model?: string;
+    /** Native Claude Code effort (`--effort`); omit to use its default. */
+    reasoningEffort?: string;
     /** Agent instructions appended to Claude Code's native system prompt. */
     appendSystemPrompt?: string;
     /** Resume a specific prior claude session (`--resume <id>`). */
@@ -36,4 +38,4 @@ export interface ClaudeTuiArgs {
  * Build the `claude` argv for an interactive, co-drivable TUI:
  * `[..extra] [--resume <id>] [--model <m>] [--append-system-prompt <text>] --settings <json>`.
  */
-export declare function buildClaudeTuiArgs({ settingsJson, settingSources, model, appendSystemPrompt, resume, forkSession, sessionId, additionalDirs, extraArgs, }: ClaudeTuiArgs): string[];
+export declare function buildClaudeTuiArgs({ settingsJson, settingSources, model, reasoningEffort, appendSystemPrompt, resume, forkSession, sessionId, additionalDirs, extraArgs, }: ClaudeTuiArgs): string[];

package/dist/terminal/claude-tui.js

@@ -2,7 +2,7 @@
  * Build the `claude` argv for an interactive, co-drivable TUI:
  * `[..extra] [--resume <id>] [--model <m>] [--append-system-prompt <text>] --settings <json>`.
  */
-export function buildClaudeTuiArgs({ settingsJson, settingSources, model, appendSystemPrompt, resume, forkSession = false, sessionId, additionalDirs = [], extraArgs = [], }) {
+export function buildClaudeTuiArgs({ settingsJson, settingSources, model, reasoningEffort, appendSystemPrompt, resume, forkSession = false, sessionId, additionalDirs = [], extraArgs = [], }) {
     const args = [...extraArgs];
     if (additionalDirs.length > 0)
         args.push("--add-dir", ...additionalDirs);
@@ -16,6 +16,8 @@ export function buildClaudeTuiArgs({ settingsJson, settingSources, model, append
         args.push("--session-id", sessionId);
     if (model)
         args.push("--model", model);
+    if (reasoningEffort)
+        args.push("--effort", reasoningEffort);
     if (appendSystemPrompt)
         args.push("--append-system-prompt", appendSystemPrompt);
     args.push("--settings", settingsJson);

package/dist/terminal/tmux.d.ts

@@ -146,7 +146,9 @@ export declare class TmuxTerminal {
     paste(text: string, bufferName?: string): void;
     /**
      * Attach a client. `role: "read-only"` passes tmux `-r` so the viewer cannot
-     * type (defense-in-depth on top of the WS bridge dropping input frames).
+     * type and `ignore-size` so even its initial PTY dimensions cannot resize the
+     * owner's pane (defense-in-depth on top of the WS bridge dropping input and
+     * resize frames).
      */
     attach(role: "owner" | "read-only", dims?: {
         cols?: number;

package/dist/terminal/tmux.js

@@ -319,14 +319,17 @@ export class TmuxTerminal {
     }
     /**
      * Attach a client. `role: "read-only"` passes tmux `-r` so the viewer cannot
-     * type (defense-in-depth on top of the WS bridge dropping input frames).
+     * type and `ignore-size` so even its initial PTY dimensions cannot resize the
+     * owner's pane (defense-in-depth on top of the WS bridge dropping input and
+     * resize frames).
      */
     async attach(role, dims) {
         this.start();
         const spawn = this.injectedSpawn ?? (await loadPtySpawn());
-        const args = [...this.base(), "attach-session", "-t", TMUX_TARGET];
+        const args = [...this.base(), "attach-session"];
         if (role === "read-only")
-            args.push("-r");
+            args.push("-r", "-f", "ignore-size");
+        args.push("-t", TMUX_TARGET);
         const proc = spawn(this.tmuxBin, args, {
             name: "xterm-256color",
             cols: dims?.cols ?? this.cols,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.4",
+  "version": "0.1.11-beta.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -26,7 +26,7 @@
   "dependencies": {
     "node-pty": "^1.0.0",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.4"
+    "@rynx-ai/core": "0.1.11-beta.6"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"