@ganglion/xacpx 0.22.1-beta.0 → 0.23.0-beta.0

package/dist/bridge/bridge-main.js

@@ -2071,6 +2071,30 @@ var init_prompt_output = __esm(() => {
   };
 });
 
+// src/transport/message-injection.ts
+function isMessageInjectionErrorCode(value) {
+  return typeof value === "string" && MESSAGE_INJECTION_ERROR_CODES.has(value);
+}
+var MESSAGE_INJECTION_ERROR_CODES, MessageInjectionError;
+var init_message_injection = __esm(() => {
+  MESSAGE_INJECTION_ERROR_CODES = new Set([
+    "TARGET_NOT_RUNNING",
+    "TARGET_NOT_STEERABLE",
+    "TARGET_NOT_INTERRUPTIBLE",
+    "DELIVERY_RACE",
+    "DELIVERY_TIMEOUT",
+    "DELIVERY_FAILED"
+  ]);
+  MessageInjectionError = class MessageInjectionError extends Error {
+    code;
+    name = "MessageInjectionError";
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+    }
+  };
+});
+
 // src/process/spawn-command.ts
 function resolveSpawnCommand(command, args) {
   if (SCRIPT_FILE_PATTERN.test(command)) {
@@ -9246,6 +9270,9 @@ function buildPromptArgs(input, tail) {
   ];
   return appendAgentAndTail(prefix, input, tail);
 }
+function buildQueueMessagePromptArgs(input, sessionName, text) {
+  return buildPromptArgs(input, ["prompt", "-s", sessionName, "--no-wait", text]);
+}
 function buildAgentQueryArgs(input, format, tail) {
   const prefix = ["--format", format, "--cwd", input.cwd, ...buildPermissionArgs(input.permission)];
   return appendAgentAndTail(prefix, input, tail);
@@ -9682,6 +9709,9 @@ class AcpxQueueOverflowError extends Error {
   }
 }
 
+// src/bridge/bridge-server.ts
+init_message_injection();
+
 // src/bridge/bridge-request-scheduler.ts
 class BridgeRequestScheduler {
   sessions = new Map;
@@ -9690,16 +9720,18 @@ class BridgeRequestScheduler {
       return Promise.resolve().then(task);
     }
     const state = this.sessions.get(sessionName) ?? this.createSessionState(sessionName);
-    state.pendingNormals += 1;
-    const result = state.tail.then(() => task());
-    state.tail = result.then(() => {
+    const tailName = lane === "message" ? "messageTail" : "normalTail";
+    const pendingName = lane === "message" ? "pendingMessages" : "pendingNormals";
+    state[pendingName] += 1;
+    const result = state[tailName].then(() => task());
+    state[tailName] = result.then(() => {
       return;
     }, () => {
       return;
     });
     return result.finally(() => {
-      state.pendingNormals -= 1;
-      if (state.pendingNormals === 0 && this.sessions.get(sessionName) === state) {
+      state[pendingName] -= 1;
+      if (state.pendingNormals === 0 && state.pendingMessages === 0 && this.sessions.get(sessionName) === state) {
         this.sessions.delete(sessionName);
       }
     });
@@ -9707,7 +9739,9 @@ class BridgeRequestScheduler {
   createSessionState(sessionName) {
     const state = {
       pendingNormals: 0,
-      tail: Promise.resolve()
+      pendingMessages: 0,
+      normalTail: Promise.resolve(),
+      messageTail: Promise.resolve()
     };
     this.sessions.set(sessionName, state);
     return state;
@@ -9753,6 +9787,7 @@ init_command_timeouts();
 init_command_timeouts();
 init_acpx_command_builder();
 init_session_effort();
+init_message_injection();
 class EnsureSessionFailedError extends Error {
   kind;
   data;
@@ -10037,6 +10072,35 @@ class BridgeRuntime {
       } catch {}
     }
   }
+  async injectMessage(input) {
+    if (input.mode === "steer") {
+      throw new MessageInjectionError("TARGET_NOT_STEERABLE", "The target does not support same-turn steering.");
+    }
+    if (input.mode === "interrupt") {
+      throw new MessageInjectionError("TARGET_NOT_INTERRUPTIBLE", "The target does not support interrupt delivery.");
+    }
+    await this.syncPersistedSessionEffort(input);
+    await this.launchMcpQueueOwnerIfNeeded(input);
+    const spawnSpec = resolveSpawnCommand(this.command, buildQueueMessagePromptArgs({
+      agent: input.agent,
+      agentCommand: input.agentCommand,
+      acpxAgent: input.acpxAgent,
+      rawCommand: input.rawCommand,
+      cwd: input.cwd,
+      model: input.model,
+      permission: this.permissionInput(),
+      queueOwnerTtlSeconds: this.options.queueOwnerTtlSeconds
+    }, input.name, input.text));
+    const result = await this.run(spawnSpec.command, spawnSpec.args, this.withSpawnEnvironment(input, {
+      timeoutMs: this.managementCommandTimeoutMs(),
+      stage: "inject-message"
+    }));
+    if (result.code !== 0) {
+      const detail = normalizeCommandError(result) ?? (result.stderr || result.stdout || `inject-message failed with exit code ${result.code}`);
+      throw new Error(detail);
+    }
+    return { status: "queued", modeUsed: "queue" };
+  }
   async cleanupOverflowedOwner(input) {
     const diagnostics = [];
     let cancelSucceeded = false;
@@ -10596,6 +10660,7 @@ var BRIDGE_METHODS = new Set([
   "listAgentSessions",
   "resumeAgentSession",
   "prompt",
+  "injectMessage",
   "setMode",
   "setModel",
   "getSessionModel",
@@ -10614,6 +10679,7 @@ var SESSION_SCOPED_METHODS = new Set([
   "tailSessionHistory",
   "resumeAgentSession",
   "prompt",
+  "injectMessage",
   "setMode",
   "setModel",
   "getSessionModel",
@@ -10670,7 +10736,7 @@ class BridgeServer {
           ...error.stderrTail ? { stderrTail: error.stderrTail } : {}
         }
       } : {};
-      const errorCode = error instanceof AcpxQueueOverflowError ? error.code : error instanceof BridgeInvalidRequestError ? "BRIDGE_INVALID_REQUEST" : "BRIDGE_INTERNAL_ERROR";
+      const errorCode = error instanceof AcpxQueueOverflowError ? error.code : error instanceof MessageInjectionError ? error.code : error instanceof BridgeInvalidRequestError ? "BRIDGE_INVALID_REQUEST" : "BRIDGE_INTERNAL_ERROR";
       return `${JSON.stringify({
         id: requestId,
         ok: false,
@@ -10763,7 +10829,7 @@ class BridgeServer {
     if (!sessionKey) {
       return await this.dispatch(requestId, method, params, writeLine);
     }
-    const lane = method === "cancel" || method === "isSessionWarm" ? "control" : "normal";
+    const lane = method === "cancel" || method === "isSessionWarm" ? "control" : method === "injectMessage" ? "message" : "normal";
     return await this.scheduler.run(sessionKey, lane, () => this.dispatch(requestId, method, params, writeLine));
   }
   async dispatch(requestId, method, params, writeLine) {
@@ -10897,6 +10963,23 @@ class BridgeServer {
             }));
           }
         });
+      case "injectMessage":
+        return await this.runtime.injectMessage({
+          agent: requireString(params, "agent"),
+          ...agentExecutionSettings(params),
+          agentCommand: asOptionalString(params.agentCommand),
+          ...agentLaunchSelection(params),
+          cwd: requireString(params, "cwd"),
+          name: requireString(params, "name"),
+          sessionKey: asOptionalString(params.sessionKey),
+          model: asOptionalString(params.model),
+          effort: asOptionalString(params.effort),
+          mcpCoordinatorSession: asOptionalString(params.mcpCoordinatorSession),
+          mcpSourceHandle: asOptionalString(params.mcpSourceHandle),
+          text: requireString(params, "text"),
+          mode: requireMessageMode(params, "mode"),
+          messageId: requireString(params, "messageId")
+        });
       case "resumeAgentSession":
         return await this.runtime.resumeAgentSession({
           agent: requireString(params, "agent"),
@@ -11119,6 +11202,13 @@ function requirePromptText(params, media) {
   }
   return value;
 }
+function requireMessageMode(params, key) {
+  const value = params[key];
+  if (value === "auto" || value === "steer" || value === "queue" || value === "interrupt") {
+    return value;
+  }
+  throw new BridgeInvalidRequestError(key + " must be auto, steer, queue, or interrupt");
+}
 function requirePermissionMode(params, key) {
   const value = params[key];
   if (value === "approve-all" || value === "approve-reads" || value === "deny-all") {

package/dist/channels/types.d.ts

@@ -157,6 +157,28 @@ export interface MessageChannelRuntime {
      * treated as "table".
      */
     nativeSessionListFormat?: "cards" | "table";
+    /** Relay-capable channels: route an Agent Message to a remote messaging node.
+     *  Optional — absent channels make the router report ROUTE_UNAVAILABLE. */
+    sendAgentMessageRoute?(payload: {
+        sourceNodeId: string;
+        sourceEndpointId: string;
+        targetNodeId: string;
+        targetEndpointId: string;
+        messageId: string;
+        content: string;
+        requestedMode: string;
+        replyTo?: string;
+    }): Promise<{
+        messageId: string;
+        status: "injected" | "queued" | "failed";
+        modeUsed?: "steer" | "queue" | "interrupt" | "prompt";
+        targetState?: "idle" | "running";
+        errorCode?: string;
+        deduplicated?: boolean;
+    }>;
+    /** Relay-capable channels: publish this instance's agent endpoint directory to
+     *  the hub. The FULL snapshot replaces the previous one (no delta protocol). */
+    syncAgentEndpoints?(endpoints: unknown[]): void;
 }
 export type ToolUseStatus = "running" | "success" | "error";
 export type ToolUseKind = "read" | "search" | "execute" | "edit" | "think" | "other";