@rynx-ai/server 0.1.11-beta.22 → 0.1.11-beta.24

package/dist/control-web/index.html

@@ -7,7 +7,7 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="icon" type="image/png" href="/favicon.png" />
     <title>rynx · control</title>
-    <script type="module" crossorigin src="/assets/index-BQFR9W8k.js"></script>
+    <script type="module" crossorigin src="/assets/index-D-5t2eCT.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-0noHpRXD.css">
   </head>
   <body>

package/dist/machine-session-service.d.ts

@@ -3,10 +3,9 @@ import type { SequencedSessionEvent, SessionEvent, SessionInteractionResolution,
 import type { RemoteRuntimeSessionResourceDeleteParams, RemoteRuntimeSessionResourceDeleteResult, RemoteRuntimeSessionResourceGetParams, RemoteRuntimeSessionResourceGetResult, RemoteRuntimeSessionResourcePolicyResult, RemoteRuntimeSessionResourceReadParams, RemoteRuntimeSessionResourceReadResult, RemoteRuntimeSessionResourceUploadBeginParams, RemoteRuntimeSessionResourceUploadBeginResult, RemoteRuntimeSessionResourceUploadChunkParams, RemoteRuntimeSessionResourceUploadChunkResult, RemoteRuntimeSessionResourceUploadCommitParams, RemoteRuntimeSessionResourceUploadCommitResult } from "@rynx-ai/protocol/remote-runtime-rpc";
 import type { ControlAgentModelOption, ControlAgentSummary, ControlSessionInteractionResolveDisposition, ControlSessionRuntimeSnapshot, SessionPermissionPreset } from "@rynx-ai/protocol/control";
 import { type RemoteRuntimeSessionInterruptResult, type RemoteRuntimeSessionExecutionGetResult, type RemoteRuntimeSessionExecutionUpdateParams, type RemoteRuntimeSessionExecutionUpdateResult, type RemoteRuntimeSessionLaunchOptionsListResult, type RemoteRuntimeSessionListParams, type RemoteRuntimeSessionListResult, type RemoteRuntimeSessionSnapshotParams } from "@rynx-ai/protocol/remote-runtime-rpc";
-import type { CodexRuntimeStatus, InjectOutcome } from "@rynx-ai/runtime";
+import type { CodexRuntimeStatus, InjectResult } from "@rynx-ai/runtime";
 export interface MachineSessionRuntimeStatePort {
     snapshot(sessionId: string): ControlSessionRuntimeSnapshot;
-    beginResponseHandoff?(sessionId: string, responseId: string): () => void;
     remove?(sessionId: string): void;
 }
 export interface MachineSessionInterruptPort {
@@ -69,7 +68,7 @@ export interface MachineSessionRunnerPort {
     }): Promise<boolean>;
     lastLiveSessionError?(sessionId: string): string | undefined;
     lastLiveSessionFailure?(sessionId: string): LiveSessionFailure | undefined;
-    injectMessage(sessionId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    injectMessage(sessionId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
     stopRunner(sessionId: string): void;
     resolveInteraction(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
         disposition: ControlSessionInteractionResolveDisposition;
@@ -313,10 +312,11 @@ export declare class MachineSessionService {
     launchOptions(): Promise<RemoteRuntimeSessionLaunchOptionsListResult>;
     /** Read the effective model defaults used for the next turn. */
     executionSettings(sessionIdInput: string): Promise<RemoteRuntimeSessionExecutionGetResult>;
-    /** Replace the Turn defaults of an idle Session. Execution settings are
-     * passed through to the Provider CLI, which owns availability validation.
-     * The runner is closed so every Provider resumes its native context with
-     * the new settings on the next turn. */
+    /** Replace the defaults for the next new Turn. Codex-lineage Providers keep
+     * their live runner: the host applies changed native thread settings under
+     * its injection lock immediately before the next `turn/start`. Claude still
+     * needs an idle cold resume because its live CLI has no confirmed settings
+     * update boundary. Provider CLIs own model availability validation. */
     updateExecutionSettings(input: RemoteRuntimeSessionExecutionUpdateParams): Promise<RemoteRuntimeSessionExecutionUpdateResult>;
     /** Create target-owned Session identity from one Agent preset or direct Provider. */
     create(input: MachineSessionCreateInput): Promise<MachineSessionCreateResult>;

package/dist/machine-session-service.js

@@ -7,8 +7,8 @@
  * Direct adapters can therefore expose the same behavior without copying state
  * into a Control Plane database.
  */
-import { createHash, randomUUID } from "node:crypto";
-import { SESSION_PROVIDER_IDS, getRuntimeProfile, isSessionProviderId, newSessionItemId, newSessionId, normalizeSessionTitle, } from "@rynx-ai/core";
+import { createHash } from "node:crypto";
+import { SESSION_PROVIDER_IDS, getRuntimeProfile, isSessionProviderId, newSessionId, normalizeSessionTitle, } from "@rynx-ai/core";
 import { REMOTE_RUNTIME_SESSION_DEFAULT_PAGE_SIZE, REMOTE_RUNTIME_SESSION_MAX_CURSOR_CHARS, REMOTE_RUNTIME_SESSION_MAX_ID_CHARS, REMOTE_RUNTIME_SESSION_MAX_PAGE_SIZE, } from "@rynx-ai/protocol/remote-runtime-rpc";
 const DEFAULT_LIST_LIMIT = REMOTE_RUNTIME_SESSION_DEFAULT_PAGE_SIZE;
 const MAX_LIST_LIMIT = REMOTE_RUNTIME_SESSION_MAX_PAGE_SIZE;
@@ -210,10 +210,11 @@ export class MachineSessionService {
         }
         return executionSettingsResult(meta.execution);
     }
-    /** Replace the Turn defaults of an idle Session. Execution settings are
-     * passed through to the Provider CLI, which owns availability validation.
-     * The runner is closed so every Provider resumes its native context with
-     * the new settings on the next turn. */
+    /** Replace the defaults for the next new Turn. Codex-lineage Providers keep
+     * their live runner: the host applies changed native thread settings under
+     * its injection lock immediately before the next `turn/start`. Claude still
+     * needs an idle cold resume because its live CLI has no confirmed settings
+     * update boundary. Provider CLIs own model availability validation. */
     async updateExecutionSettings(input) {
         const sessionId = validOpaqueToken(input.sessionId, "sessionId", MAX_SESSION_ID_CHARS);
         const modelId = input.model === null ? null : validRequiredText(input.model, "model");
@@ -222,13 +223,15 @@ export class MachineSessionService {
             throw new MachineSessionServiceFailure("not_found", "session not found");
         }
         await this.assertNotForkReserved(sessionId);
-        const runtime = this.ports.runtimeState.snapshot(sessionId);
-        const pendingMessage = await this.ports.pendingMessages?.get(sessionId);
-        if (runtime.status !== "idle" ||
-            runtime.activeResponseIds.length > 0 ||
-            runtime.pendingInteractions.length > 0 ||
-            pendingMessage) {
-            throw new MachineSessionServiceFailure("failed_precondition", "Session must be idle before changing model settings");
+        if (meta.execution.provider === "claude") {
+            const runtime = this.ports.runtimeState.snapshot(sessionId);
+            const pendingMessage = await this.ports.pendingMessages?.get(sessionId);
+            if (runtime.status !== "idle" ||
+                runtime.activeResponseIds.length > 0 ||
+                runtime.pendingInteractions.length > 0 ||
+                pendingMessage) {
+                throw new MachineSessionServiceFailure("failed_precondition", "Claude Session must be idle before changing model settings");
+            }
         }
         const executionPort = this.requireExecution();
         const reasoningEffort = input.reasoningEffort === null
@@ -240,7 +243,9 @@ export class MachineSessionService {
             reasoningEffort,
         };
         this.ports.registry.setExecution(sessionId, nextExecution);
-        executionPort.runner.stopRunner(sessionId);
+        if (nextExecution.provider === "claude") {
+            executionPort.runner.stopRunner(sessionId);
+        }
         return executionSettingsResult(nextExecution);
     }
     /** Create target-owned Session identity from one Agent preset or direct Provider. */
@@ -508,69 +513,21 @@ export class MachineSessionService {
         if (request.clientMessageId) {
             await resources?.markMessageInjecting(sessionId, request.clientMessageId);
         }
-        const responseId = this.ports.publishEvent ? `resp_${randomUUID()}` : undefined;
-        if (responseId) {
-            await this.ports.publishEvent(sessionId, {
-                type: "session.input.consumed",
-                item: {
-                    id: newSessionItemId("message"),
-                    sessionId,
-                    position: 0,
-                    responseId,
-                    status: "completed",
-                    createdAt: Date.now(),
-                    type: "message",
-                    data: {
-                        role: "user",
-                        content: prepared.input.content.map((part) => part.type === "text"
-                            ? { type: "input_text", text: part.text }
-                            : { ...part.resource }),
-                    },
-                },
-            });
-            await this.ports.publishEvent(sessionId, {
-                type: "session.status",
-                sessionId,
-                responseId,
-                status: "running",
-                statusKind: "startup",
-            });
-        }
-        const abandonResponseHandoff = responseId
-            ? this.ports.runtimeState.beginResponseHandoff?.(sessionId, responseId)
-            : undefined;
-        const clearStartup = async (status) => {
-            if (!responseId)
-                return;
-            await this.ports.publishEvent(sessionId, {
-                type: "session.status",
-                sessionId,
-                responseId,
-                status,
-            });
-        };
         let execution;
         try {
             execution = await this.ensureLiveSession(sessionId, meta);
         }
         catch (error) {
-            abandonResponseHandoff?.();
-            await clearStartup("idle");
             if (request.clientMessageId) {
                 await resources?.markMessageFailedNotStarted(sessionId, request.clientMessageId, error instanceof Error ? error.message : String(error));
             }
             throw error;
         }
-        let outcome;
+        let result;
         try {
-            const runtimeInput = responseId
-                ? { ...prepared.input, responseId }
-                : prepared.input;
-            outcome = await execution.runner.injectMessage(sessionId, responseId || needsPreparedOperation ? runtimeInput : request.message);
+            result = await execution.runner.injectMessage(sessionId, needsPreparedOperation ? prepared.input : request.message);
         }
         catch (error) {
-            abandonResponseHandoff?.();
-            await clearStartup("idle");
             const failure = execution.runner.lastLiveSessionFailure?.(sessionId)
                 ?? liveSessionFailureFrom(error);
             const reason = failure?.message
@@ -580,9 +537,8 @@ export class MachineSessionService {
             }
             throw new MachineSessionServiceFailure("outcome_unknown", "live injection outcome is unknown", reason, failure);
         }
+        const outcome = result.outcome;
         if (outcome === "failed") {
-            abandonResponseHandoff?.();
-            await clearStartup("idle");
             const failure = execution.runner.lastLiveSessionFailure?.(sessionId);
             const reason = failure?.message
                 ?? execution.runner.lastLiveSessionError?.(sessionId)
@@ -593,8 +549,6 @@ export class MachineSessionService {
             throw new MachineSessionServiceFailure("outcome_unknown", `live injection ${outcome}`, reason, failure);
         }
         if (outcome !== "injected" && outcome !== "steered") {
-            abandonResponseHandoff?.();
-            await clearStartup("idle");
             const failure = execution.runner.lastLiveSessionFailure?.(sessionId);
             const reason = failure?.message
                 ?? execution.runner.lastLiveSessionError?.(sessionId)
@@ -604,9 +558,6 @@ export class MachineSessionService {
             }
             throw new MachineSessionServiceFailure("failed_precondition", `live injection ${outcome}`, reason, failure);
         }
-        if (outcome === "steered")
-            abandonResponseHandoff?.();
-        await clearStartup("running");
         if (request.clientMessageId) {
             try {
                 await resources?.markMessageInjected(sessionId, request.clientMessageId);
@@ -838,7 +789,7 @@ export class MachineSessionService {
                     current.message !== pending.message)
                     return;
                 injectionAttempted = true;
-                const outcome = await execution.runner.injectMessage(sessionId, pending.message);
+                const { outcome } = await execution.runner.injectMessage(sessionId, pending.message);
                 if (outcome === "injected" || outcome === "steered") {
                     await Promise.resolve(pendingStore.delete(sessionId)).catch(async () => {
                         await Promise.resolve(pendingStore.markOutcomeUnknown(sessionId)).catch(() => undefined);

package/dist/remote-runtime-session-projection.js

@@ -534,6 +534,7 @@ function assertEventScope(event, expectedSessionId) {
         case "session.interaction.requested":
         case "session.interaction.resolved":
         case "session.interaction.cancelled":
+        case "session.interrupted":
         case "session.todos":
         case "session.rotated":
             actual = event.sessionId;

package/dist/server.d.ts

@@ -4,7 +4,7 @@ import { ConversationRuntime, type AdmissionReservation, type AgentCapabilities,
 import type { SessionInteractionResolution } from "@rynx-ai/protocol";
 import type { ControlRuntimeShareAddress, DaemonBrowserArtifactCleanResult, DaemonBrowserArtifactInstallInput, DaemonBrowserArtifactInstallResult, DaemonBrowserArtifactUpdateInput, DaemonBrowserArtifactVersionResult, DaemonCleanupSessionsInput, DaemonCleanupSessionsResult, DaemonChromeInspectionConfigureInput, DaemonChromeInspectionStatus, DaemonShutdownIfIdleResult } from "@rynx-ai/protocol/control";
 import type { PluginInstallCommitInput, PluginInstallCommitResult, PluginInstallPreparation, PluginInstallPrepareInput, PluginManagementItem, PluginMarketplaceAddInput, PluginMarketplaceItem } from "@rynx-ai/protocol/plugin-management";
-import type { PluginJsonValue } from "@rynx-ai/plugin-sdk";
+import type { PluginAgentSummary, PluginJsonValue, PluginResolvedSessionExecution, PluginSessionActivitySnapshot, PluginSessionExecutionSnapshot } from "@rynx-ai/plugin-sdk";
 import type { PairingOffer } from "@rynx-ai/protocol/direct-runtime";
 import type { DaemonStatus } from "@rynx-ai/protocol/remote-runtime";
 import type { RuntimeBrowserBootstrapCredential, RuntimeBrowserEndpointDescriptor } from "@rynx-ai/protocol/runtime-browser-bootstrap";
@@ -12,7 +12,6 @@ import type { RuntimeBrowserInspectMessage, RuntimeBrowserInspectTarget } from "
 import type { RuntimeBrowserSurfaceClientFrame, RuntimeBrowserSurfaceImageFrame, RuntimeBrowserSurfaceOpenFrame, RuntimeBrowserSurfaceReadyFrame, RuntimeBrowserSurfaceServerFrame } from "@rynx-ai/protocol/runtime-browser-surface";
 import type { RuntimeEmulatorSurfaceImageFrame, RuntimeEmulatorSurfaceReadyFrame } from "@rynx-ai/protocol/runtime-emulator-surface";
 import type { RemoteRuntimeRpcMethod, RemoteRuntimeRpcParams, RemoteRuntimeRpcResultFor, RemoteRuntimeSequencedSessionEvent } from "@rynx-ai/protocol/remote-runtime-rpc";
-import type { PluginAgentSummary, PluginResolvedSessionExecution, PluginSessionExecutionSnapshot } from "@rynx-ai/plugin-sdk";
 import { RunnerManager, type CodexSessionStore, type RunnerSessionContextProvider } from "@rynx-ai/runtime";
 import { type ControlPlaneDeps, type LocalSessionResourceHost, type SessionResourceLifecycle } from "./control-api.js";
 import type { MachineSessionService } from "./machine-session-service.js";
@@ -160,6 +159,7 @@ export interface PluginRuntimeHostServices {
             session: PluginSessionExecutionSnapshot;
         }): Promise<PluginResolvedSessionExecution>;
     };
+    sessionActivity(sessionId: string): PluginSessionActivitySnapshot;
     interruptSession(sessionId: string): Promise<boolean>;
     terminateSession?(sessionId: string): Promise<boolean>;
     resolveSessionInteraction(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{

package/dist/server.js

@@ -75,7 +75,6 @@ export function createSessionRuntimeServices(input) {
         config: input.config,
         executor: runnerManager,
         sessionBus,
-        sessionEventSink: mirrorSessionEvent,
     });
     runnerManager.onMirror((sessionId, event) => {
         void mirrorSessionEvent(sessionId, event).catch((error) => {
@@ -222,6 +221,15 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                     session: input.session,
                 }),
             },
+            sessionActivity: (sessionId) => {
+                const snapshot = sessionRuntimeIndex.snapshot(sessionId);
+                return {
+                    ...snapshot,
+                    status: snapshot.pendingInteractions.length > 0
+                        ? "waiting"
+                        : snapshot.status,
+                };
+            },
             interruptSession: (sessionId) => runnerManager.interruptLiveSession(sessionId),
             terminateSession: (sessionId) => runnerManager.terminateLiveSession(sessionId),
             resolveSessionInteraction: (sessionId, interactionId, resolution) => runnerManager.resolveInteraction(sessionId, interactionId, resolution),

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

@@ -13,12 +13,6 @@ 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. */
@@ -27,4 +21,6 @@ export declare class SessionRuntimeIndex {
     private state;
     private removeResponseInteractions;
     private hasRunningTurn;
+    private statusAfterResponseTerminal;
+    private retireStatusResponses;
 }

package/dist/session-runtime-index.js

@@ -6,57 +6,63 @@
  */
 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 = this.hasRunningTurn(state) ? "running" : "idle";
+                state.status = this.statusAfterResponseTerminal(state);
                 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 = this.hasRunningTurn(state) ? "running" : "idle";
+                state.status = this.statusAfterResponseTerminal(state);
                 state.statusKind = undefined;
                 return;
-            case "session.status":
-                state.status =
-                    state.pendingInteractions.size > 0 || this.hasRunningTurn(state)
-                        ? "running"
-                        : event.status;
-                state.statusKind = event.statusKind;
+            case "session.interrupted":
+                state.activeResponseIds.delete(event.responseId);
+                this.removeResponseInteractions(state, event.responseId);
+                state.status = this.statusAfterResponseTerminal(state);
+                state.statusKind = undefined;
+                return;
+            case "session.status": {
+                if (event.status === "running") {
+                    if (event.responseId)
+                        state.activeResponseIds.add(event.responseId);
+                    state.status = "running";
+                    state.statusKind = event.statusKind;
+                    return;
+                }
+                // A provider interaction is a stronger in-flight fact than a quiet-pane
+                // idle observation. Claude's status-file path reports waiting as running;
+                // this guard preserves the same truth on its legacy PTY fallback.
+                if (event.status === "idle" && state.pendingInteractions.size > 0) {
+                    state.status = "running";
+                    state.statusKind = undefined;
+                    return;
+                }
+                this.retireStatusResponses(state);
+                if (event.status === "failed") {
+                    state.status = "failed";
+                }
+                else if (state.status !== "failed") {
+                    // Provider idle is authoritative even when final transcript records
+                    // arrive later. Response identity remains on those events themselves;
+                    // it must not keep Session activity/loading alive.
+                    state.status = this.hasRunningTurn(state) ? "running" : "idle";
+                }
+                state.statusKind = undefined;
                 return;
+            }
             case "session.interaction.requested":
-                state.pendingResponseIds.delete(event.responseId);
                 state.pendingInteractions.set(event.interaction.interactionId, {
                     responseId: event.responseId,
                     interaction: event.interaction,
@@ -68,10 +74,10 @@ export class SessionRuntimeIndex {
             case "session.interaction.resolved":
             case "session.interaction.cancelled":
                 state.pendingInteractions.delete(event.interactionId);
-                state.status = this.hasRunningTurn(state) ? "running" : state.status;
+                if (this.hasRunningTurn(state))
+                    state.status = "running";
                 return;
             case "session.rotated":
-                state.pendingResponseIds.clear();
                 state.activeResponseIds.clear();
                 state.pendingInteractions.clear();
                 state.status = "idle";
@@ -86,9 +92,7 @@ export class SessionRuntimeIndex {
         if (!state)
             return { status: "idle", activeResponseIds: [], pendingInteractions: [] };
         return {
-            status: state.pendingInteractions.size > 0 || this.hasRunningTurn(state)
-                ? "running"
-                : state.status,
+            status: state.pendingInteractions.size > 0 ? "running" : state.status,
             ...(state.statusKind === undefined ? {} : { statusKind: state.statusKind }),
             activeResponseIds: [...state.activeResponseIds],
             pendingInteractions: [...state.pendingInteractions.values()],
@@ -99,7 +103,9 @@ export class SessionRuntimeIndex {
         let runningTurns = 0;
         let pendingInteractions = 0;
         for (const state of this.sessions.values()) {
-            runningTurns += state.pendingResponseIds.size + state.activeResponseIds.size;
+            if (state.status === "running" || state.pendingInteractions.size > 0) {
+                runningTurns += Math.max(1, state.activeResponseIds.size);
+            }
             pendingInteractions += state.pendingInteractions.size;
         }
         return { runningTurns, pendingInteractions };
@@ -112,7 +118,6 @@ export class SessionRuntimeIndex {
         if (!state) {
             state = {
                 status: "idle",
-                pendingResponseIds: new Set(),
                 activeResponseIds: new Set(),
                 pendingInteractions: new Map(),
             };
@@ -127,6 +132,20 @@ export class SessionRuntimeIndex {
         }
     }
     hasRunningTurn(state) {
-        return state.pendingResponseIds.size > 0 || state.activeResponseIds.size > 0;
+        return state.activeResponseIds.size > 0;
+    }
+    statusAfterResponseTerminal(state) {
+        if (state.pendingInteractions.size > 0 || this.hasRunningTurn(state))
+            return "running";
+        return state.status === "failed" ? "failed" : "idle";
+    }
+    retireStatusResponses(state) {
+        // session.status is Session-wide. Match Omnigent's
+        // _session_active_response_cache: every idle/failed edge closes the one
+        // in-flight native response projection, even when the edge happens to be
+        // stamped with that response id. A late transcript event may still carry
+        // the old id for grouping, but it cannot keep activity alive.
+        state.activeResponseIds.clear();
+        state.pendingInteractions.clear();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/server",
-  "version": "0.1.11-beta.22",
+  "version": "0.1.11-beta.24",
   "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.22",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.22",
-    "@rynx-ai/protocol": "0.1.11-beta.22",
-    "@rynx-ai/runtime": "0.1.11-beta.22",
-    "@rynx-ai/remote-runtime-e2ee": "0.1.11-beta.22"
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.24",
+    "@rynx-ai/protocol": "0.1.11-beta.24",
+    "@rynx-ai/remote-runtime-e2ee": "0.1.11-beta.24",
+    "@rynx-ai/core": "0.1.11-beta.24",
+    "@rynx-ai/runtime": "0.1.11-beta.24"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/control-web": "0.1.11-beta.22"
+    "@rynx-ai/control-web": "0.1.11-beta.24"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && mkdir -p dist/control-web && cp -R ../control-web/dist/. dist/control-web/",