@rynx-ai/daemon 0.1.11-beta.21 → 0.1.11-beta.23

package/bundled-plugins/plugins/lark/dist/host-adapters.js

@@ -111,7 +111,11 @@ export class HostConversationRuntime {
         const unsteer = input.steer?.subscribe((text) => {
             if (!runId || terminal)
                 return;
-            void this.host.sessions.steer({ runId, text }).catch(() => undefined);
+            // `session.run` is the only message-input operation. The Host reuses
+            // `runId` while this Turn is active and lets the native runtime choose
+            // turn/steer; callers do not select a separate steering RPC.
+            void this.host.sessions.run({ sessionId: input.threadId, message: text })
+                .catch(() => undefined);
         });
         input.signal?.addEventListener("abort", interrupt, { once: true });
         const generator = (async function* () {

package/bundled-plugins/plugins/lark/dist/runtime.js

@@ -126958,7 +126958,7 @@ var HostConversationRuntime = class {
     }
     const unsteer = input.steer?.subscribe((text) => {
       if (!runId || terminal) return;
-      void this.host.sessions.steer({ runId, text }).catch(() => void 0);
+      void this.host.sessions.run({ sessionId: input.threadId, message: text }).catch(() => void 0);
     });
     input.signal?.addEventListener("abort", interrupt, { once: true });
     const generator = (async function* () {

package/bundled-plugins/plugins/lark/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/plugin-channel-lark",
-  "version": "0.1.11-beta.21",
+  "version": "0.1.11-beta.23",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",

package/dist/plugin-host-rpc.d.ts

@@ -1,5 +1,5 @@
 import { type AdmissionReservation, type AgentSpec, type AgentCapabilities, type AgentRuntimeId, type AgentSessionStore, type ConversationRuntime, type ResolvedExecutionSnapshot, type SessionRegistry, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
-import { type PluginAgentSummary, type PluginHostEvent, type PluginResolvedSessionExecution, type PluginSessionExecutionSnapshot, type PluginSessionInteractionResolveDisposition } from "@rynx-ai/plugin-sdk";
+import { type PluginAgentSummary, type PluginHostEvent, type PluginSessionActivitySnapshot, type PluginResolvedSessionExecution, type PluginSessionExecutionSnapshot, type PluginSessionInteractionResolveDisposition } from "@rynx-ai/plugin-sdk";
 import type { SessionInteractionResolution } from "@rynx-ai/protocol";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
 /** Leaves ample room for the RPC envelope below the runner's 1 MiB line cap. */
@@ -52,6 +52,7 @@ export interface PluginHostServices {
             reasoningEffort: string | null;
         }): Promise<void>;
     };
+    sessionActivity(sessionId: string): PluginSessionActivitySnapshot | Promise<PluginSessionActivitySnapshot>;
     interruptSession?(sessionId: string): Promise<boolean>;
     terminateSession?(sessionId: string): Promise<boolean>;
     resolveSessionInteraction?(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
@@ -124,10 +125,9 @@ export declare class PluginHostRpc {
     private runSessionAdmitted;
     private pumpRun;
     private releaseRun;
-    private steerSession;
     private interruptRun;
+    private sessionActivity;
     private interruptWon;
-    private activeRun;
     private activeRunByIdentity;
     private getBinding;
     private listBindings;

package/dist/plugin-host-rpc.js

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { realpath, stat } from "node:fs/promises";
 import path from "node:path";
-import { AgentRuntimeError, agentSpecSchema, resolvedExecutionSnapshotSchema, sessionWorkspaceSnapshotSchema, SteerController, } from "@rynx-ai/core";
+import { AgentRuntimeError, agentSpecSchema, resolvedExecutionSnapshotSchema, sessionWorkspaceSnapshotSchema, } from "@rynx-ai/core";
 import { PLUGIN_HOST_MAX_ACTIVE_RUNS, } from "@rynx-ai/plugin-sdk";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
 import { ensurePluginSessionLaunch, replayPluginSessionLaunch, SessionLaunchOperationConflictError, SessionLaunchOperationTargetDeletedError, } from "./session-launch-operations.js";
@@ -14,6 +14,57 @@ const MAX_PLUGIN_RUN_FINAL_RESPONSE_BYTES = 64 * 1024;
 const MAX_DELTA_CHUNK_CODE_UNITS = 64 * 1024;
 const SESSION_INTERACTION_RESOLUTION_MAX_BYTES = 128 * 1024;
 const AGENT_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+/**
+ * Buffers messages that arrive while the first `session.run` is still bringing
+ * up its native Turn. Once Core subscribes, later messages are delivered
+ * through the same input channel. After that subscription closes, this Run no
+ * longer accepts input; the caller waits for release and opens the next Run.
+ */
+class PluginRunInputController {
+    listener;
+    pending = new Map();
+    subscribed = false;
+    closed = false;
+    enqueue(text) {
+        if (this.closed || (this.subscribed && !this.listener)) {
+            return { accepted: false, cancel: () => undefined };
+        }
+        if (this.listener) {
+            this.listener(text);
+            return { accepted: true, cancel: () => undefined };
+        }
+        const token = Symbol("plugin-run-input");
+        this.pending.set(token, text);
+        return {
+            accepted: true,
+            cancel: () => {
+                this.pending.delete(token);
+            },
+        };
+    }
+    subscribe(listener) {
+        if (this.closed)
+            return () => undefined;
+        if (this.listener) {
+            throw new Error("plugin Run input already has a subscriber");
+        }
+        this.subscribed = true;
+        this.listener = listener;
+        const queued = [...this.pending.values()];
+        this.pending.clear();
+        for (const text of queued)
+            listener(text);
+        return () => {
+            if (this.listener === listener)
+                this.listener = undefined;
+        };
+    }
+    close() {
+        this.closed = true;
+        this.listener = undefined;
+        this.pending.clear();
+    }
+}
 /**
  * One authenticated plugin's Host RPC surface.
  *
@@ -90,8 +141,8 @@ export class PluginHostRpc {
                     return await this.ensureSession(params);
                 case "session.run":
                     return await this.runSession(params, signal);
-                case "session.steer":
-                    return this.steerSession(params);
+                case "session.activity.get":
+                    return await this.sessionActivity(params);
                 case "session.interrupt":
                     return await this.interruptRun(params);
                 case "session.interaction.resolve":
@@ -301,6 +352,46 @@ export class PluginHostRpc {
         const input = record(params);
         const sessionId = requiredSessionId(input);
         const operationId = optionalString(input.operationId, "operationId", 512);
+        const message = requiredText(input.message, "message", MAX_MESSAGE_LENGTH);
+        let session = this.ownedSession(sessionId);
+        if (operationId) {
+            const replayed = this.activeRunsByOperation.get(operationId);
+            if (replayed) {
+                if (replayed.sessionId !== sessionId) {
+                    throw new PluginHostCallError("RUN_ALREADY_ACTIVE", `operation already belongs to another active Session: ${operationId}`, true);
+                }
+                return await waitForHostPromise(replayed.started, signal);
+            }
+        }
+        const active = this.activeSessionRuns.get(sessionId);
+        if (active) {
+            const queued = active.input.enqueue(message);
+            if (!queued.accepted) {
+                // The response reached its terminal boundary before Host cleanup won
+                // the scheduling race. Wait for that old Run to leave the Session slot,
+                // then submit this message as a new Turn with a new response identity.
+                await waitForHostPromise(active.settled, signal);
+                throwIfHostCallAborted(signal);
+                return await this.runSessionAdmitted(params, signal);
+            }
+            if (operationId) {
+                active.operationIds.add(operationId);
+                this.activeRunsByOperation.set(operationId, active);
+            }
+            try {
+                // Reuse the current Run identity. Core already owns its response stream;
+                // the buffered input will become turn/steer once that stream subscribes.
+                return await waitForHostPromise(active.started, signal);
+            }
+            catch (error) {
+                queued.cancel();
+                if (operationId && this.activeRunsByOperation.get(operationId) === active) {
+                    this.activeRunsByOperation.delete(operationId);
+                    active.operationIds.delete(operationId);
+                }
+                throw error;
+            }
+        }
         const modelProvided = input.model !== undefined;
         const requestedModel = input.model === null || input.model === ""
             ? null
@@ -309,17 +400,9 @@ export class PluginHostRpc {
         const requestedReasoningEffort = input.reasoningEffort === null || input.reasoningEffort === ""
             ? null
             : optionalString(input.reasoningEffort, "reasoningEffort", 64);
-        let session = this.ownedSession(sessionId);
-        if (operationId && this.activeRunsByOperation.has(operationId)) {
-            throw new PluginHostCallError("RUN_ALREADY_ACTIVE", `operation already has an active run: ${operationId}`, true);
-        }
-        if (this.activeSessionRuns.has(sessionId)) {
-            throw new PluginHostCallError("RUN_ALREADY_ACTIVE", `session already has an active run: ${sessionId}`, true);
-        }
         if (this.activeRuns.size >= PLUGIN_HOST_MAX_ACTIVE_RUNS) {
             throw new PluginHostCallError("RUN_LIMIT", "plugin has too many active session runs", true);
         }
-        const message = requiredText(input.message, "message", MAX_MESSAGE_LENGTH);
         const nextModel = modelProvided ? requestedModel ?? null : session.execution.model;
         const nextReasoningEffort = reasoningEffortProvided
             ? requestedReasoningEffort ?? null
@@ -340,32 +423,54 @@ export class PluginHostRpc {
             throwIfHostCallAborted(signal);
         }
         signal?.addEventListener("abort", cancel, { once: true });
-        const steer = new SteerController();
+        const runInput = new PluginRunInputController();
         const runId = randomUUID();
+        let resolveStarted;
+        let rejectStarted;
+        const startedResult = new Promise((resolve, reject) => {
+            resolveStarted = resolve;
+            rejectStarted = reject;
+        });
+        // The initiating RPC observes startup directly below. This promise exists
+        // for concurrent/replayed calls, so retain its rejection without creating
+        // an unhandled-rejection when there are none.
+        void startedResult.catch(() => undefined);
+        let resolveSettled;
+        const settled = new Promise((resolve) => {
+            resolveSettled = resolve;
+        });
         const run = {
             runId,
             sessionId,
-            operationId,
+            operationIds: new Set(operationId ? [operationId] : []),
             interruptRequested: false,
             abort,
-            steer,
+            input: runInput,
+            started: startedResult,
+            startupSettled: false,
+            resolveStarted,
+            rejectStarted,
+            settled,
+            resolveSettled,
         };
         this.activeRuns.set(runId, run);
         this.activeSessionRuns.set(sessionId, run);
         if (operationId)
             this.activeRunsByOperation.set(operationId, run);
-        let started;
+        let startedExecution;
         try {
-            started = await this.services.conversationRuntime.runLive({
+            startedExecution = await this.services.conversationRuntime.runLive({
                 message,
                 threadId: sessionId,
                 workspace: session.workspace,
                 execution: session.execution,
                 signal: abort.signal,
-                steer,
+                steer: runInput,
             });
         }
         catch (error) {
+            run.startupSettled = true;
+            run.rejectStarted(error);
             this.releaseRun(run);
             throw error;
         }
@@ -374,20 +479,28 @@ export class PluginHostRpc {
         }
         if (signal?.aborted || this.disposed || this.activeRuns.get(runId) !== run) {
             abort.abort(signal?.reason);
+            const error = signal?.aborted
+                ? new PluginHostCallError("REQUEST_CANCELLED", "plugin host request was cancelled")
+                : new PluginHostCallError("HOST_CLOSED", "plugin host is closed");
+            run.startupSettled = true;
+            run.rejectStarted(error);
             this.releaseRun(run);
             throwIfHostCallAborted(signal);
-            throw new PluginHostCallError("HOST_CLOSED", "plugin host is closed");
+            throw error;
         }
-        // Let the RPC transport write the request response before stream events are
-        // emitted. `runLive` has already subscribed, so no agent event is lost.
-        setImmediate(() => void this.pumpRun(run, started.generator));
-        return {
+        const result = {
             runId,
             sessionId,
-            provider: started.provider,
-            model: started.model,
-            authSource: started.authSource,
+            provider: startedExecution.provider,
+            model: startedExecution.model,
+            authSource: startedExecution.authSource,
         };
+        run.startupSettled = true;
+        run.resolveStarted(result);
+        // Let the RPC transport write the request response before stream events are
+        // emitted. `runLive` has already subscribed, so no agent event is lost.
+        setImmediate(() => void this.pumpRun(run, startedExecution.generator));
+        return result;
     }
     async pumpRun(run, generator) {
         let terminalFailure;
@@ -469,28 +582,52 @@ export class PluginHostRpc {
         }
     }
     releaseRun(run) {
+        run.input.close();
+        if (!run.startupSettled) {
+            run.startupSettled = true;
+            run.rejectStarted(new PluginHostCallError("HOST_CLOSED", "plugin Host closed the active Run"));
+        }
         if (this.activeRuns.get(run.runId) === run)
             this.activeRuns.delete(run.runId);
         if (this.activeSessionRuns.get(run.sessionId) === run) {
             this.activeSessionRuns.delete(run.sessionId);
         }
-        if (run.operationId && this.activeRunsByOperation.get(run.operationId) === run) {
-            this.activeRunsByOperation.delete(run.operationId);
+        for (const operationId of run.operationIds) {
+            if (this.activeRunsByOperation.get(operationId) === run) {
+                this.activeRunsByOperation.delete(operationId);
+            }
         }
-    }
-    steerSession(params) {
-        const input = record(params);
-        const run = this.activeRun(input);
-        const text = requiredText(input.text, "text", MAX_MESSAGE_LENGTH);
-        return { delivered: run.steer.send(text) };
+        run.resolveSettled();
     }
     async interruptRun(params) {
         const input = record(params);
-        const run = this.activeRunByIdentity(input);
         const forceAfterMs = optionalPositiveNumber(input.forceAfterMs, "forceAfterMs");
         if (forceAfterMs !== undefined && forceAfterMs > 30_000) {
             throw new PluginHostCallError("INVALID_PARAMS", "forceAfterMs must not exceed 30000");
         }
+        const sessionId = optionalString(input.sessionId, "sessionId", 128);
+        const runId = optionalString(input.runId, "runId", 128);
+        const operationId = optionalString(input.operationId, "operationId", 512);
+        if ((sessionId ? 1 : 0) + (runId ? 1 : 0) + (operationId ? 1 : 0) !== 1) {
+            throw new PluginHostCallError("INVALID_PARAMS", "exactly one of sessionId, runId, or operationId is required");
+        }
+        let run;
+        if (sessionId) {
+            this.ownedSession(sessionId);
+            run = this.activeSessionRuns.get(sessionId);
+            if (!run) {
+                const graceful = this.services.interruptSession
+                    ? Promise.resolve().then(() => this.services.interruptSession(sessionId))
+                    : Promise.resolve(false);
+                const interrupted = forceAfterMs === undefined
+                    ? await graceful
+                    : await forceStoppedInterrupt(graceful, forceAfterMs, () => this.services.terminateSession?.(sessionId) ?? Promise.resolve(false));
+                return { interrupted };
+            }
+        }
+        else {
+            run = this.activeRunByIdentity(input);
+        }
         if (run.interruptResult) {
             return { interrupted: await run.interruptResult };
         }
@@ -529,6 +666,24 @@ export class PluginHostRpc {
             throw error;
         }
     }
+    async sessionActivity(params) {
+        const sessionId = requiredSessionId(params);
+        this.ownedSession(sessionId);
+        const snapshot = structuredClone(await this.services.sessionActivity(sessionId));
+        const activeRun = this.activeSessionRuns.get(sessionId);
+        const waiting = snapshot.pendingInteractions.length > 0;
+        const status = waiting
+            ? "waiting"
+            : activeRun
+                ? "running"
+                : snapshot.status;
+        const startup = Boolean(activeRun && snapshot.activeResponseIds.length === 0 && !waiting);
+        return {
+            ...snapshot,
+            status,
+            ...(startup ? { statusKind: "startup" } : {}),
+        };
+    }
     async interruptWon(run) {
         if (!run.interruptRequested)
             return false;
@@ -536,13 +691,6 @@ export class PluginHostRpc {
             return true;
         return run.interruptResult.catch(() => false);
     }
-    activeRun(input) {
-        const runId = requiredString(input.runId, "runId", 128);
-        const run = this.activeRuns.get(runId);
-        if (!run)
-            throw new PluginHostCallError("RUN_NOT_FOUND", `active run not found: ${runId}`);
-        return run;
-    }
     activeRunByIdentity(input) {
         const runId = optionalString(input.runId, "runId", 128);
         const operationId = optionalString(input.operationId, "operationId", 512);
@@ -692,6 +840,24 @@ function throwIfHostCallAborted(signal) {
         return;
     throw new PluginHostCallError("REQUEST_CANCELLED", "plugin host request was cancelled");
 }
+async function waitForHostPromise(promise, signal) {
+    throwIfHostCallAborted(signal);
+    if (!signal)
+        return await promise;
+    return await new Promise((resolve, reject) => {
+        const aborted = () => {
+            reject(new PluginHostCallError("REQUEST_CANCELLED", "plugin host request was cancelled"));
+        };
+        signal.addEventListener("abort", aborted, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener("abort", aborted);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", aborted);
+            reject(error);
+        });
+    });
+}
 export class PluginHostCallError extends PluginRunnerError {
     retryable;
     data;
@@ -714,6 +880,12 @@ function toHostCallError(error) {
         // not be brought up, so callers may fail without quarantining capacity.
         return new PluginHostCallError("LIVE_SESSION_UNAVAILABLE", error.message, false);
     }
+    if (error instanceof AgentRuntimeError) {
+        // Native lifecycle failures already carry a stable phase code. Preserve it
+        // across the plugin-host boundary instead of erasing it behind the generic
+        // HOST_CALL_FAILED wrapper.
+        return new PluginHostCallError(error.code, error.message, false);
+    }
     if (error instanceof SessionLaunchOperationConflictError) {
         return new PluginHostCallError(error.code, error.message, false);
     }

package/dist/remote-runtime-connection-manager.js

@@ -1465,7 +1465,7 @@ function nonNegativeInteger(value, fallback, field) {
     return value;
 }
 function parseCallTimeout(value) {
-    if (value === undefined)
+    if (value === undefined || value === null)
         return undefined;
     if (!Number.isSafeInteger(value) ||
         value < MIN_CALL_TIMEOUT_MS ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/daemon",
-  "version": "0.1.11-beta.21",
+  "version": "0.1.11-beta.23",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -50,17 +50,17 @@
     "pm2": "^6.0.0",
     "tar": "^7.5.19",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.21",
-    "@rynx-ai/emulator": "0.1.11-beta.21",
-    "@rynx-ai/plugin-runner": "0.1.11-beta.21",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.21",
-    "@rynx-ai/protocol": "0.1.11-beta.21",
-    "@rynx-ai/remote-runtime-client": "0.1.11-beta.21",
-    "@rynx-ai/server": "0.1.11-beta.21"
+    "@rynx-ai/plugin-runner": "0.1.11-beta.23",
+    "@rynx-ai/core": "0.1.11-beta.23",
+    "@rynx-ai/emulator": "0.1.11-beta.23",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.23",
+    "@rynx-ai/protocol": "0.1.11-beta.23",
+    "@rynx-ai/remote-runtime-client": "0.1.11-beta.23",
+    "@rynx-ai/server": "0.1.11-beta.23"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.21"
+    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.23"
   },
   "scripts": {
     "build": "rm -rf dist bundled-plugins && tsc -p tsconfig.json && chmod +x dist/index-daemon.js && node ../../scripts/stage-bundled-plugins.mjs",