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

package/dist/models-catalog.js

@@ -3,25 +3,76 @@
  *
  * 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 list: the runtime's configured default model (the one
- * `resolveRuntimeModel` would pick), marked `isDefault`. This is intentionally
- * minimal — a fuller curated catalogue can be added here later without touching
- * any caller. claude already has its own static list ({@link listClaudeModels}).
+ * serve a config-derived Codex list and Traex's native `models --json` catalog.
+ * claude already has its own static list ({@link listClaudeModels}).
  */
-import { resolveRuntimeModel, } from "@rynx-ai/core";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { resolveRuntimeBinary, 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.
- * Returns `null` when the runtime exposes no resolvable model (e.g. traex with
- * no `TRAEX_MODEL`), matching the prior "unsupported" semantics of `listModels`.
+ * Falls back to the configured model if live Traex discovery is unavailable.
  */
-export function listRuntimeModels(config, runtime) {
+export async function listRuntimeModels(config, runtime, deps = {}) {
     if (runtime === "claude") {
         return listClaudeModels();
     }
+    if (runtime === "traex") {
+        try {
+            const value = await (deps.readTraexModels ?? readTraexModels)();
+            const models = normalizeTraexModels(value, resolveRuntimeModel(config, runtime).trim());
+            if (models.length > 0)
+                return { data: models };
+        }
+        catch {
+            // Keep the configured fallback usable when Traex is missing/logged out.
+        }
+    }
     const model = resolveRuntimeModel(config, runtime).trim();
     if (!model) {
         return null;
     }
     return { data: [{ id: model, model, isDefault: true }] };
 }
+async function readTraexModels() {
+    const { stdout } = await execFileAsync(resolveRuntimeBinary("traex"), ["models", "--json"], {
+        encoding: "utf8",
+        timeout: TRAEX_MODELS_TIMEOUT_MS,
+        maxBuffer: TRAEX_MODELS_MAX_BYTES,
+    });
+    return JSON.parse(stdout);
+}
+function normalizeTraexModels(value, configuredDefault) {
+    if (!Array.isArray(value))
+        return [];
+    const models = [];
+    const seen = new Set();
+    for (const item of value) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const record = item;
+        const id = typeof record.name === "string" ? record.name.trim() : "";
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        models.push({
+            id,
+            model: id,
+            ...(typeof record.description === "string" ? { description: record.description } : {}),
+            isDefault: configuredDefault ? id === configuredDefault : models.length === 0,
+            ...(typeof record.context_window === "number" ? { contextWindow: record.context_window } : {}),
+            ...(Array.isArray(record.supported_mime_types)
+                ? { supportedMimeTypes: record.supported_mime_types }
+                : {}),
+            ...(record._meta && typeof record._meta === "object" ? { _meta: record._meta } : {}),
+        });
+    }
+    if (configuredDefault && !seen.has(configuredDefault)) {
+        models.unshift({ id: configuredDefault, model: configuredDefault, isDefault: true });
+    }
+    return models;
+}

package/dist/runner/child.js

@@ -161,9 +161,11 @@ export class RunnerSession {
             if (!this.terminals.get(`${msg.localThreadId}-main`)?.isAlive()) {
                 await this.launchCodexPane(msg.localThreadId, msg.cols, msg.rows);
             }
-            const ready = provider.waitLiveReady
-                ? await provider.waitLiveReady(msg.localThreadId)
-                : true;
+            const ready = msg.waitForReady === false
+                ? true
+                : provider.waitLiveReady
+                    ? await provider.waitLiveReady(msg.localThreadId)
+                    : true;
             this.transport.send({
                 t: "live.ready",
                 reqId: msg.reqId,
@@ -185,7 +187,8 @@ export class RunnerSession {
     async inject(msg) {
         const provider = this.liveProvider;
         try {
-            const outcome = (await provider.injectMessage?.(msg.localThreadId, msg.text)) ?? "notLive";
+            const input = msg.input ?? msg.text;
+            const outcome = (await provider.injectMessage?.(msg.localThreadId, input)) ?? "notLive";
             this.transport.send({ t: "injected", reqId: msg.reqId, localThreadId: msg.localThreadId, outcome });
         }
         catch (error) {

package/dist/runner/manager.d.ts

@@ -16,7 +16,7 @@
  * channel.
  */
 import { spawn as nodeSpawn } from "node:child_process";
-import { type AgentCapabilities, type AgentRuntimeId, type AgentSpec, type AppConfig, type CapabilityResult, type ModelListResponse, type ReasoningEffort, type SessionInteractionResolution, type SessionEvent, type ThreadGoal } from "@rynx-ai/core";
+import { type AgentCapabilities, type AgentRuntimeId, type AgentSpec, type AppConfig, type CapabilityResult, type ModelListResponse, type ReasoningEffort, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type ThreadGoal } from "@rynx-ai/core";
 import { type CodexSessionStore } from "../host.js";
 import type { ResolveInteractionResult } from "../interactions.js";
 import { type InjectOutcome, type TerminalOpenErrorCode, type TerminalRole } from "./protocol.js";
@@ -49,6 +49,10 @@ export interface RunnerManagerOptions {
     shutdownGraceMs?: number;
     /** Final bounded wait for child exit after SIGKILL. */
     shutdownKillGraceMs?: number;
+    /** Max wait for a setup-pane launch acknowledgement. */
+    liveStartTimeoutMs?: number;
+    /** Max wait for a Provider-native thread to become ready. */
+    liveReadyTimeoutMs?: number;
     /** Injected for tests. */
     spawn?: typeof nodeSpawn;
     now?: () => number;
@@ -124,6 +128,8 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly reapTimer;
     private readonly shutdownGraceMs;
     private readonly shutdownKillGraceMs;
+    private readonly liveStartTimeoutMs;
+    private readonly liveReadyTimeoutMs;
     private stopping;
     private stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
@@ -176,6 +182,19 @@ export declare class RunnerManager implements AgentCapabilities {
         agentName?: string;
         agentSpec?: AgentSpec;
     }): Promise<boolean>;
+    /** Start the Provider pane without waiting for login/onboarding to create a
+     * native thread. This is the setup-terminal gate; callers may attach as soon
+     * as it resolves, while normal message delivery still uses ensureLiveSession. */
+    startLiveSession(localThreadId: string, opts?: {
+        cwd?: string;
+        cols?: number;
+        rows?: number;
+        runtime?: AgentRuntimeId;
+        reasoningEffort?: ReasoningEffort;
+        agentName?: string;
+        agentSpec?: AgentSpec;
+    }): Promise<boolean>;
+    private requestLiveSession;
     lastLiveSessionError(localThreadId: string): string | undefined;
     /**
      * Inject a user turn into a session's live codex thread — reference implementation's
@@ -183,7 +202,7 @@ export declare class RunnerManager implements AgentCapabilities {
      * all output. Resolves true when the app-server accepted the turn, false when
      * the session has no live forwarder (caller falls back to the run path).
      */
-    injectMessage(localThreadId: string, text: string): Promise<InjectOutcome>;
+    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
     /**
      * Interrupt a session's active live turn — the web Stop button (codex
      * `turn/interrupt`, claude Escape). Best-effort: resolves false with NO spawn

package/dist/runner/manager.js

@@ -32,6 +32,10 @@ const STDERR_TAIL_LINES = 40;
 const DEFAULT_SHUTDOWN_GRACE_MS = 5_000;
 /** Time allowed for exit after SIGKILL before shutdown reports failure. */
 const DEFAULT_SHUTDOWN_KILL_GRACE_MS = 5_000;
+/** Setup-pane launch should acknowledge quickly; never pin its HTTP request. */
+const DEFAULT_LIVE_START_TIMEOUT_MS = 10_000;
+/** Thread readiness may legitimately wait through Provider startup. */
+const DEFAULT_LIVE_READY_TIMEOUT_MS = 25_000;
 /** Keep per-Session spawn context small enough to remain an environment handoff,
  * not an unbounded transport. */
 const MAX_SESSION_CONTEXT_ENV_ENTRIES = 32;
@@ -144,6 +148,8 @@ export class RunnerManager {
     reapTimer;
     shutdownGraceMs;
     shutdownKillGraceMs;
+    liveStartTimeoutMs;
+    liveReadyTimeoutMs;
     stopping = false;
     stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
@@ -166,6 +172,8 @@ export class RunnerManager {
         this.defaultRuntime = opts.config.AGENT_RUNTIME ?? "codex";
         this.shutdownGraceMs = Math.max(0, opts.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS);
         this.shutdownKillGraceMs = Math.max(0, opts.shutdownKillGraceMs ?? DEFAULT_SHUTDOWN_KILL_GRACE_MS);
+        this.liveStartTimeoutMs = Math.max(1, opts.liveStartTimeoutMs ?? DEFAULT_LIVE_START_TIMEOUT_MS);
+        this.liveReadyTimeoutMs = Math.max(1, opts.liveReadyTimeoutMs ?? DEFAULT_LIVE_READY_TIMEOUT_MS);
         const reapIntervalMs = opts.reapIntervalMs ?? 60_000;
         if (reapIntervalMs > 0) {
             this.reapTimer = setInterval(() => this.reapIdle(), reapIntervalMs);
@@ -244,12 +252,37 @@ export class RunnerManager {
      * non-codex / non-live session (the caller then uses the normal run path).
      */
     ensureLiveSession(localThreadId, opts) {
+        return this.requestLiveSession(localThreadId, opts, true);
+    }
+    /** Start the Provider pane without waiting for login/onboarding to create a
+     * native thread. This is the setup-terminal gate; callers may attach as soon
+     * as it resolves, while normal message delivery still uses ensureLiveSession. */
+    startLiveSession(localThreadId, opts) {
+        return this.requestLiveSession(localThreadId, opts, false);
+    }
+    requestLiveSession(localThreadId, opts, waitForReady) {
         const handle = this.getOrSpawn(localThreadId);
         handle.lastUsedAt = this.now();
         this.liveSessionKeys.add(localThreadId);
         const reqId = randomUUID();
         return new Promise((resolve) => {
+            const timeoutMs = waitForReady ? this.liveReadyTimeoutMs : this.liveStartTimeoutMs;
+            const timeout = setTimeout(() => {
+                if (!handle.live.delete(reqId))
+                    return;
+                const reason = `runner did not acknowledge ${waitForReady ? "live readiness" : "terminal start"} within ${timeoutMs}ms`;
+                this.liveErrors.set(localThreadId, reason);
+                this.liveSessionKeys.delete(localThreadId);
+                resolve(false);
+                // A child that cannot answer a bounded control round-trip is unsafe to
+                // reuse. Reap it so the next click gets a fresh runner.
+                void this.terminateHandle(handle, reason).catch((error) => {
+                    logTerminationFailure(handle, error);
+                });
+            }, timeoutMs);
+            timeout.unref?.();
             handle.live.set(reqId, (res) => {
+                clearTimeout(timeout);
                 const ok = res.ok ?? false;
                 if (ok) {
                     this.liveErrors.delete(localThreadId);
@@ -270,6 +303,7 @@ export class RunnerManager {
                 ...(opts?.reasoningEffort ? { reasoningEffort: opts.reasoningEffort } : {}),
                 ...(opts?.agentName ? { agentName: opts.agentName } : {}),
                 ...(opts?.agentSpec ? { agentSpec: opts.agentSpec } : {}),
+                waitForReady,
             });
         });
     }
@@ -282,13 +316,15 @@ export class RunnerManager {
      * all output. Resolves true when the app-server accepted the turn, false when
      * the session has no live forwarder (caller falls back to the run path).
      */
-    injectMessage(localThreadId, text) {
+    injectMessage(localThreadId, input) {
         const handle = this.getOrSpawn(localThreadId);
         handle.lastUsedAt = this.now();
         const reqId = randomUUID();
         return new Promise((resolve) => {
             handle.live.set(reqId, (res) => resolve(res.outcome ?? "failed"));
-            handle.transport.send({ t: "inject", reqId, localThreadId, text });
+            handle.transport.send(typeof input === "string"
+                ? { t: "inject", reqId, localThreadId, text: input }
+                : { t: "inject", reqId, localThreadId, input });
         });
     }
     /**

package/dist/runner/protocol.d.ts

@@ -6,7 +6,7 @@
  * (`live.ensure` / `inject` / `live.interrupt`) plus per-thread capabilities and
  * terminal attachment; the reply channels mirror each request's `reqId`.
  */
-import { AgentRuntimeError, type AgentRuntimeId, type AgentSpec, type ReasoningEffort, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
+import { AgentRuntimeError, type AgentRuntimeId, type AgentSpec, type ReasoningEffort, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
 import type { ResolveInteractionResult } from "../interactions.js";
 /** A runtime error flattened for the wire; rebuilt parent-side as `AgentRuntimeError`. */
 export interface WireError {
@@ -92,16 +92,24 @@ export type ToChild = {
     /** An inline agent spec (console session created from an inline config
      *  rather than a preset id) — same purpose as `agentName`. */
     agentSpec?: AgentSpec;
+    /** Setup terminals only need the Provider pane to exist. Message delivery
+     *  keeps the default and waits until the native thread is actually bound. */
+    waitForReady?: boolean;
 }
 /** Inject a user turn into the session's live codex thread (`turn/start` or
  *  `turn/steer`). The forwarder mirrors the output — this is the single-writer
  *  web send path. The child replies `injected` (echoing `reqId`). */
- | {
+ | ({
     t: "inject";
     reqId: string;
     localThreadId: string;
+} & ({
+    input: RuntimeUserInput;
+    text?: never;
+} | {
     text: string;
-}
+    input?: never;
+}))
 /** Interrupt the session's active turn — the web Stop button. codex: app-server
  *  `turn/interrupt`; claude: an Escape keystroke to the pane. The child replies
  *  `interrupted` (echoing `reqId`). */
@@ -163,8 +171,8 @@ export type FromChild = {
     cwd?: string;
     parentSessionId?: string;
 }
-/** Result of a `live.ensure`: `ok` once the codex thread is bound (or a no-op
- *  for a non-codex / non-live session). Echoes the request `reqId`. */
+/** Result of a `live.ensure`: `ok` once the requested gate is reached (pane
+ *  started for setup, otherwise native thread bound). Echoes `reqId`. */
  | {
     t: "live.ready";
     reqId: string;

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.9",
+  "version": "0.1.10-beta.2",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rynx-ai/rynx.git",
+    "directory": "packages/runtime"
+  },
   "description": "Runtime host that drives local coding-agent CLIs (codex / traex / claude) behind one AgentExecutor + AgentCapabilities contract.",
   "type": "module",
   "publishConfig": {
@@ -21,7 +26,7 @@
   "dependencies": {
     "node-pty": "^1.0.0",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.9"
+    "@rynx-ai/core": "0.1.10-beta.2"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"