@rynx-ai/server 0.1.11-beta.1 → 0.1.11-beta.3

package/dist/session-browser-service.js

@@ -42,12 +42,14 @@ export class SessionBrowserService {
     observers = new Set();
     pageIdFactory;
     bootGenerationSeed;
+    admissionReserve;
     shuttingDown = false;
     closeAllPromise;
     constructor(ports, options = {}) {
         this.ports = ports;
         this.pageIdFactory = options.pageIdFactory ?? (() => `page_${randomUUID()}`);
         this.bootGenerationSeed = options.bootGenerationSeed ?? randomBootGenerationSeed();
+        this.admissionReserve = options.admissionReserve;
         if (!Number.isSafeInteger(this.bootGenerationSeed) ||
             this.bootGenerationSeed < 0 ||
             this.bootGenerationSeed >= Number.MAX_SAFE_INTEGER) {
@@ -224,29 +226,35 @@ export class SessionBrowserService {
         });
     }
     async open(input) {
-        const params = parseInput(() => parseRuntimeBrowserOpenParams(input), "Browser open request is invalid");
-        return this.exclusive(params.sessionId, async () => {
-            this.ensureRunning();
-            await this.ensureSessionExists(params.sessionId);
-            const existing = this.records.get(params.sessionId);
-            if (existing?.status === "opening") {
-                return this.project(existing);
-            }
-            if (existing?.status === "ready") {
-                try {
-                    await this.reconcileForRead(existing);
+        const admission = this.reserveOpenAdmission();
+        try {
+            const params = parseInput(() => parseRuntimeBrowserOpenParams(input), "Browser open request is invalid");
+            return await this.exclusive(params.sessionId, async () => {
+                this.ensureRunning();
+                await this.ensureSessionExists(params.sessionId);
+                const existing = this.records.get(params.sessionId);
+                if (existing?.status === "opening") {
                     return this.project(existing);
                 }
-                catch {
-                    // An App Host may have gone away immediately before this open. The
-                    // failed reconciliation marks the old generation unavailable, so an
-                    // idempotent open can recreate it on the current preferred Host.
+                if (existing?.status === "ready") {
+                    try {
+                        await this.reconcileForRead(existing);
+                        return this.project(existing);
+                    }
+                    catch {
+                        // An App Host may have gone away immediately before this open. The
+                        // failed reconciliation marks the old generation unavailable, so an
+                        // idempotent open can recreate it on the current preferred Host.
+                    }
                 }
-            }
-            if (existing)
-                await this.closeUnavailableForRecreate(existing);
-            return this.createBrowser(params);
-        });
+                if (existing)
+                    await this.closeUnavailableForRecreate(existing);
+                return this.createBrowser(params);
+            });
+        }
+        finally {
+            admission?.release();
+        }
     }
     async close(input) {
         const params = parseInput(() => parseRuntimeBrowserCloseParams(input), "Browser close request is invalid");
@@ -438,6 +446,15 @@ export class SessionBrowserService {
             throw new SessionBrowserServiceError("host_failure", "Browser Host state could not be initialized", { cause: error });
         }
     }
+    reserveOpenAdmission() {
+        if (!this.admissionReserve)
+            return undefined;
+        const admission = this.admissionReserve();
+        if (!admission) {
+            throw new SessionBrowserServiceError("shutting_down", "Browser service is shutting down");
+        }
+        return admission;
+    }
     async closeUnavailableForRecreate(record) {
         record.status = "closing";
         try {

package/dist/session-runtime-index.d.ts

@@ -13,6 +13,12 @@ export interface SessionRuntimeActivitySnapshot {
  */
 export declare class SessionRuntimeIndex {
     private readonly sessions;
+    /**
+     * Make an accepted Turn visible before the request admission reservation is
+     * released. The returned callback only abandons the pre-created handoff; once
+     * response.created arrives, the native response remains authoritative.
+     */
+    beginResponseHandoff(sessionId: string, responseId: string): () => void;
     observe(sessionId: string, event: SessionEvent): void;
     snapshot(sessionId: string): SessionRuntimeSnapshot;
     /** Aggregate only process-live work; durable Session history is not activity. */
@@ -20,4 +26,5 @@ export declare class SessionRuntimeIndex {
     remove(sessionId: string): void;
     private state;
     private removeResponseInteractions;
+    private hasRunningTurn;
 }

package/dist/session-runtime-index.js

@@ -6,47 +6,76 @@
  */
 export class SessionRuntimeIndex {
     sessions = new Map();
+    /**
+     * Make an accepted Turn visible before the request admission reservation is
+     * released. The returned callback only abandons the pre-created handoff; once
+     * response.created arrives, the native response remains authoritative.
+     */
+    beginResponseHandoff(sessionId, responseId) {
+        const state = this.state(sessionId);
+        state.pendingResponseIds.add(responseId);
+        state.status = "running";
+        state.statusKind = "startup";
+        let pending = true;
+        return () => {
+            if (!pending)
+                return;
+            pending = false;
+            state.pendingResponseIds.delete(responseId);
+        };
+    }
     observe(sessionId, event) {
         const state = this.state(sessionId);
         switch (event.type) {
             case "response.created":
+                state.pendingResponseIds.delete(event.responseId);
                 state.activeResponseIds.add(event.responseId);
                 state.status = "running";
+                state.statusKind = undefined;
                 return;
             case "response.completed":
+                state.pendingResponseIds.delete(event.responseId);
                 state.activeResponseIds.delete(event.responseId);
                 this.removeResponseInteractions(state, event.responseId);
-                state.status = state.activeResponseIds.size > 0 ? "running" : "idle";
+                state.status = this.hasRunningTurn(state) ? "running" : "idle";
+                state.statusKind = undefined;
                 return;
             case "response.failed":
+                state.pendingResponseIds.delete(event.responseId);
                 state.activeResponseIds.delete(event.responseId);
                 this.removeResponseInteractions(state, event.responseId);
                 // Response failure is Turn-local. It must not poison a reusable Session.
-                state.status = state.activeResponseIds.size > 0 ? "running" : "idle";
+                state.status = this.hasRunningTurn(state) ? "running" : "idle";
+                state.statusKind = undefined;
                 return;
             case "session.status":
                 state.status =
-                    state.pendingInteractions.size > 0 || state.activeResponseIds.size > 0
+                    state.pendingInteractions.size > 0 || this.hasRunningTurn(state)
                         ? "running"
                         : event.status;
+                state.statusKind = event.statusKind;
                 return;
             case "session.interaction.requested":
+                state.pendingResponseIds.delete(event.responseId);
                 state.pendingInteractions.set(event.interaction.interactionId, {
                     responseId: event.responseId,
                     interaction: event.interaction,
                 });
                 state.activeResponseIds.add(event.responseId);
                 state.status = "running";
+                state.statusKind = undefined;
                 return;
             case "session.interaction.resolved":
             case "session.interaction.cancelled":
                 state.pendingInteractions.delete(event.interactionId);
-                state.status = state.activeResponseIds.size > 0 ? "running" : state.status;
+                state.status = this.hasRunningTurn(state) ? "running" : state.status;
                 return;
             case "session.rotated":
+                state.pendingResponseIds.clear();
                 state.activeResponseIds.clear();
                 state.pendingInteractions.clear();
                 state.status = "idle";
+                state.statusKind = undefined;
                 return;
             default:
                 return;
@@ -57,7 +86,10 @@ export class SessionRuntimeIndex {
         if (!state)
             return { status: "idle", activeResponseIds: [], pendingInteractions: [] };
         return {
-            status: state.pendingInteractions.size > 0 ? "running" : state.status,
+            status: state.pendingInteractions.size > 0 || this.hasRunningTurn(state)
+                ? "running"
+                : state.status,
+            ...(state.statusKind === undefined ? {} : { statusKind: state.statusKind }),
             activeResponseIds: [...state.activeResponseIds],
             pendingInteractions: [...state.pendingInteractions.values()],
         };
@@ -67,7 +99,7 @@ export class SessionRuntimeIndex {
         let runningTurns = 0;
         let pendingInteractions = 0;
         for (const state of this.sessions.values()) {
-            runningTurns += state.activeResponseIds.size;
+            runningTurns += state.pendingResponseIds.size + state.activeResponseIds.size;
             pendingInteractions += state.pendingInteractions.size;
         }
         return { runningTurns, pendingInteractions };
@@ -80,6 +112,7 @@ export class SessionRuntimeIndex {
         if (!state) {
             state = {
                 status: "idle",
+                pendingResponseIds: new Set(),
                 activeResponseIds: new Set(),
                 pendingInteractions: new Map(),
             };
@@ -93,4 +126,7 @@ export class SessionRuntimeIndex {
                 state.pendingInteractions.delete(interactionId);
         }
     }
+    hasRunningTurn(state) {
+        return state.pendingResponseIds.size > 0 || state.activeResponseIds.size > 0;
+    }
 }

package/dist/session-terminal-host.d.ts

@@ -1,3 +1,4 @@
+import type { AdmissionReservation } from "@rynx-ai/core";
 import { type RunnerManager } from "@rynx-ai/runtime";
 export type SessionTerminalRole = "owner" | "read-only";
 export interface SessionTerminalOpenOptions {
@@ -46,6 +47,11 @@ export interface RunnerSessionTerminalHostOptions {
     } | undefined | Promise<{
         cwd: string;
     } | undefined>;
+    /**
+     * Synchronous daemon admission fence. A successful reservation is held until
+     * the attachment is registered and the runner confirms that it is ready.
+     */
+    admissionReserve?: () => AdmissionReservation | undefined;
 }
 /** Adapt the runner-child terminal protocol without exposing cwd or commands to clients. */
 export declare function createRunnerSessionTerminalHost(options: RunnerSessionTerminalHostOptions): RunnerSessionTerminalHost;

package/dist/session-terminal-host.js

@@ -24,56 +24,71 @@ export function createRunnerSessionTerminalHost(options) {
     return {
         activeTerminalCount: () => attachmentCounts.size,
         async open(sessionId, openOptions) {
-            validateOpen(sessionId, openOptions);
-            throwIfAborted(openOptions.signal);
-            const session = await options.resolveLiveSession(sessionId);
-            if (!session || typeof session.cwd !== "string" || session.cwd.trim().length === 0) {
-                throw new SessionTerminalOpenError("not_live", "Session terminal is not live");
-            }
-            throwIfAborted(openOptions.signal);
-            let parent;
+            const admission = reserveTerminalAdmission(options.admissionReserve);
             try {
-                parent = options.runnerManager.openLiveTerminal(sessionId, {
-                    role: openOptions.role,
-                    cwd: session.cwd,
-                    cols: openOptions.cols,
-                    rows: openOptions.rows,
-                });
-            }
-            catch (error) {
-                if (error instanceof TerminalOpenError && error.code === "terminal_not_live") {
-                    throw new SessionTerminalOpenError("not_live", "Session terminal is not live", {
-                        cause: error,
+                validateOpen(sessionId, openOptions);
+                throwIfAborted(openOptions.signal);
+                const session = await options.resolveLiveSession(sessionId);
+                if (!session || typeof session.cwd !== "string" || session.cwd.trim().length === 0) {
+                    throw new SessionTerminalOpenError("not_live", "Session terminal is not live");
+                }
+                throwIfAborted(openOptions.signal);
+                let parent;
+                try {
+                    parent = options.runnerManager.openLiveTerminal(sessionId, {
+                        role: openOptions.role,
+                        cwd: session.cwd,
+                        cols: openOptions.cols,
+                        rows: openOptions.rows,
                     });
                 }
-                throw new SessionTerminalOpenError("internal", "Session terminal could not be opened", { cause: error });
-            }
-            const attachment = new RunnerSessionTerminalAttachment(sessionId, parent, openOptions.signal);
-            const releaseActivity = trackTerminalAttachment(attachmentCounts, sessionId);
-            void attachment.closed.then(releaseActivity, releaseActivity);
-            try {
-                const opened = await waitFor(parent.ready, openOptions.signal);
-                attachment.opened(opened.role);
-                attachment.throwIfOpeningFailed();
-                return attachment;
-            }
-            catch (error) {
-                await attachment.close().catch(() => undefined);
-                if (isAbort(error)) {
-                    throw new SessionTerminalOpenError("invalid_request", "Session terminal open was cancelled", { cause: error });
+                catch (error) {
+                    if (error instanceof TerminalOpenError && error.code === "terminal_not_live") {
+                        throw new SessionTerminalOpenError("not_live", "Session terminal is not live", {
+                            cause: error,
+                        });
+                    }
+                    throw new SessionTerminalOpenError("internal", "Session terminal could not be opened", { cause: error });
                 }
-                if (error instanceof TerminalOpenError && error.code === "terminal_not_live") {
-                    throw new SessionTerminalOpenError("not_live", "Session terminal is not live", {
-                        cause: error,
-                    });
+                const attachment = new RunnerSessionTerminalAttachment(sessionId, parent, openOptions.signal);
+                const releaseActivity = trackTerminalAttachment(attachmentCounts, sessionId);
+                void attachment.closed.then(releaseActivity, releaseActivity);
+                try {
+                    const opened = await waitFor(parent.ready, openOptions.signal);
+                    attachment.opened(opened.role);
+                    attachment.throwIfOpeningFailed();
+                    return attachment;
+                }
+                catch (error) {
+                    await attachment.close().catch(() => undefined);
+                    if (isAbort(error)) {
+                        throw new SessionTerminalOpenError("invalid_request", "Session terminal open was cancelled", { cause: error });
+                    }
+                    if (error instanceof TerminalOpenError && error.code === "terminal_not_live") {
+                        throw new SessionTerminalOpenError("not_live", "Session terminal is not live", {
+                            cause: error,
+                        });
+                    }
+                    if (error instanceof SessionTerminalOpenError)
+                        throw error;
+                    throw new SessionTerminalOpenError("internal", "Session terminal could not be opened", { cause: error });
                 }
-                if (error instanceof SessionTerminalOpenError)
-                    throw error;
-                throw new SessionTerminalOpenError("internal", "Session terminal could not be opened", { cause: error });
+            }
+            finally {
+                admission?.release();
             }
         },
     };
 }
+function reserveTerminalAdmission(reserve) {
+    if (!reserve)
+        return undefined;
+    const admission = reserve();
+    if (!admission) {
+        throw new SessionTerminalOpenError("not_live", "Session terminal is unavailable during daemon maintenance");
+    }
+    return admission;
+}
 function trackTerminalAttachment(attachmentCounts, sessionId) {
     attachmentCounts.set(sessionId, (attachmentCounts.get(sessionId) ?? 0) + 1);
     let released = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/server",
-  "version": "0.1.11-beta.1",
+  "version": "0.1.11-beta.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -27,15 +27,15 @@
     "@koa/router": "^15.4.0",
     "koa": "^3.2.0",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.1",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.1",
-    "@rynx-ai/protocol": "0.1.11-beta.1",
-    "@rynx-ai/remote-runtime-e2ee": "0.1.11-beta.1",
-    "@rynx-ai/runtime": "0.1.11-beta.1"
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.3",
+    "@rynx-ai/protocol": "0.1.11-beta.3",
+    "@rynx-ai/core": "0.1.11-beta.3",
+    "@rynx-ai/remote-runtime-e2ee": "0.1.11-beta.3",
+    "@rynx-ai/runtime": "0.1.11-beta.3"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/control-web": "0.1.11-beta.1"
+    "@rynx-ai/control-web": "0.1.11-beta.3"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && mkdir -p dist/control-web && cp -R ../control-web/dist/. dist/control-web/",

package/dist/channel-manager.d.ts

@@ -1,60 +0,0 @@
-/**
- * Runtime manager for mounted channel instances in the single-process control
- * plane. Holds live channel handles keyed by instance id and can start / stop /
- * reload a single instance without restarting the daemon — the seam the web
- * control page drives.
- *
- * Shared pieces (host/conversationRuntime/codex session store) are injected once
- * and reused across instances; only the per-instance {@link ChannelContext}
- * fields (instanceId / options / defaultAgent) differ, so two Lark bots get
- * distinct credentials + state while sharing one agent runtime.
- */
-import type { AgentCapabilities, AgentSessionStore, AppConfig, ChannelInstanceDescriptor, ConversationRuntime, SessionBus, SessionLogStore, SessionRegistry } from "@rynx-ai/core";
-export interface ChannelInstanceStatus {
-    instanceId: string;
-    type: string;
-    running: boolean;
-    agent?: string;
-    /** Connection state from the channel, or null when it exposes no status. */
-    connected: boolean | null;
-    lastError?: string | null;
-    lastEventAt?: string | null;
-}
-export interface ChannelManagerOptions {
-    config: AppConfig;
-    conversationRuntime: ConversationRuntime;
-    capabilities: AgentCapabilities;
-    sessionStore: AgentSessionStore;
-    /** Durable canonical session log, shared across instances (absent ⇒ no
-     *  persistence). */
-    sessionLog?: SessionLogStore;
-    /** Shared canonical session event bus (one instance ⇒ cross-channel fan-out). */
-    sessionBus?: SessionBus;
-    /** Unified machine-session registry, shared across instances; channels register
-     *  their sessions' identity rows here so the control plane lists them. */
-    sessionRegistry?: SessionRegistry;
-    /** Source of truth for current instance descriptors (daemon reads config). */
-    loadInstances: () => Promise<ChannelInstanceDescriptor[]>;
-    log?: (line: string) => void;
-}
-export declare class ChannelManager {
-    private readonly opts;
-    private readonly mounted;
-    constructor(opts: ChannelManagerOptions);
-    /** Mount + start every enabled instance from `loadInstances`. */
-    startAll(): Promise<void>;
-    /** Stop every mounted instance (on server close). */
-    stopAll(): Promise<void>;
-    /** Live status of currently-mounted instances. */
-    list(): ChannelInstanceStatus[];
-    isRunning(instanceId: string): boolean;
-    /** Start one instance by id (re-reads descriptors). No-op if already running. */
-    startInstance(instanceId: string): Promise<void>;
-    /** Stop + unmount one instance. No-op if not running. */
-    stopInstance(instanceId: string): Promise<void>;
-    /** Stop then start, picking up edited options/agent. */
-    reloadInstance(instanceId: string): Promise<void>;
-    private mountAndStart;
-    private buildContext;
-    private log;
-}

package/dist/channel-manager.js

@@ -1,106 +0,0 @@
-export class ChannelManager {
-    opts;
-    mounted = new Map();
-    constructor(opts) {
-        this.opts = opts;
-    }
-    /** Mount + start every enabled instance from `loadInstances`. */
-    async startAll() {
-        const instances = await this.opts.loadInstances();
-        for (const descriptor of instances) {
-            await this.mountAndStart(descriptor);
-        }
-    }
-    /** Stop every mounted instance (on server close). */
-    async stopAll() {
-        const ids = [...this.mounted.keys()];
-        await Promise.all(ids.map((id) => this.stopInstance(id)));
-    }
-    /** Live status of currently-mounted instances. */
-    list() {
-        return [...this.mounted.values()].map(({ descriptor, channel }) => {
-            const status = channel.getStatus?.();
-            return {
-                instanceId: descriptor.instanceId,
-                type: descriptor.type,
-                running: true,
-                agent: descriptor.agent,
-                connected: status ? status.connected : null,
-                lastError: status?.lastError ?? null,
-                lastEventAt: status?.lastEventAt ?? null,
-            };
-        });
-    }
-    isRunning(instanceId) {
-        return this.mounted.has(instanceId);
-    }
-    /** Start one instance by id (re-reads descriptors). No-op if already running. */
-    async startInstance(instanceId) {
-        if (this.mounted.has(instanceId))
-            return;
-        const descriptor = (await this.opts.loadInstances()).find((instance) => instance.instanceId === instanceId);
-        if (!descriptor) {
-            throw new Error(`channel instance "${instanceId}" is not enabled/configured`);
-        }
-        await this.mountAndStart(descriptor);
-    }
-    /** Stop + unmount one instance. No-op if not running. */
-    async stopInstance(instanceId) {
-        const entry = this.mounted.get(instanceId);
-        if (!entry)
-            return;
-        this.mounted.delete(instanceId);
-        try {
-            await entry.channel.stop();
-        }
-        catch (error) {
-            this.log(`instance "${instanceId}" stop failed: ${messageOf(error)}`);
-        }
-    }
-    /** Stop then start, picking up edited options/agent. */
-    async reloadInstance(instanceId) {
-        await this.stopInstance(instanceId);
-        // Only restart if it's still enabled/configured (disable ⇒ stays stopped).
-        const descriptor = (await this.opts.loadInstances()).find((instance) => instance.instanceId === instanceId);
-        if (descriptor) {
-            await this.mountAndStart(descriptor);
-        }
-    }
-    async mountAndStart(descriptor) {
-        let channel;
-        try {
-            channel = descriptor.factory(this.buildContext(descriptor));
-        }
-        catch (error) {
-            this.log(`instance "${descriptor.instanceId}" construct failed: ${messageOf(error)}`);
-            return;
-        }
-        this.mounted.set(descriptor.instanceId, { descriptor, channel });
-        try {
-            await channel.start();
-        }
-        catch (error) {
-            this.log(`instance "${descriptor.instanceId}" start failed: ${messageOf(error)}`);
-        }
-    }
-    buildContext(descriptor) {
-        return {
-            config: this.opts.config,
-            conversationRuntime: this.opts.conversationRuntime,
-            capabilities: this.opts.capabilities,
-            sessionStore: this.opts.sessionStore,
-            sessionLog: this.opts.sessionLog,
-            sessionBus: this.opts.sessionBus,
-            sessionRegistry: this.opts.sessionRegistry,
-            instanceId: descriptor.instanceId,
-            options: descriptor.options,
-            defaultAgent: descriptor.agent,
-        };
-    }
-    log(line) {
-        (this.opts.log ?? ((message) => console.error(message)))(line);
-    }
-}
-function messageOf(error) {
-    return error instanceof Error ? error.message : String(error);
-}