@cjhyy/code-shell-chat 0.9.2 → 0.9.4

package/dist/bound-session-chat.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Routes a conversation that has entered a Work Session, ahead of Mimi.
+ *
+ * This middleware sits between the deterministic remote commands and
+ * createMimiPetChat. When the host reports no binding for the conversation it
+ * calls next() and Mimi handles the message exactly as before; when there is a
+ * binding it terminates the chain, and the message goes to the Session instead
+ * of the manager.
+ *
+ * Two properties matter more than they look:
+ *
+ * - Leaving is decided here, not by the host and never by a model. /mimi has
+ *   to work when the worker is wedged or the bound Session is unreachable,
+ *   otherwise a user can be stuck inside a Session with no way out.
+ * - The reply for an accepted message is not this middleware's job. A Session
+ *   turn can take minutes, far longer than an inbound HTTP request should be
+ *   held open, so acceptance is acknowledged immediately and the real answer
+ *   comes back later through the durable outbox.
+ */
+import type { ChatMiddleware } from "./chat-gateway.js";
+import type { ChannelMessage } from "./channel.js";
+/** What the host decided to do with one inbound message. */
+export type BoundSessionDisposition = {
+    kind: "not-bound";
+} | {
+    kind: "accepted";
+    notice?: string;
+} | {
+    kind: "left";
+    text: string;
+} | {
+    kind: "status";
+    text: string;
+} | {
+    kind: "suspended";
+    text: string;
+};
+export interface BoundSessionControlClient {
+    /**
+     * Hand one inbound message to the host's bridge. Returns what happened so
+     * the middleware can decide whether to stop or fall through to Mimi.
+     */
+    routeBoundSessionMessage(input: {
+        channel: string;
+        target: string;
+        senderId: string;
+        messageId?: string;
+        text: string;
+        isDirectMessage: boolean;
+    }): Promise<BoundSessionDisposition>;
+}
+export interface BoundSessionChatOptions {
+    desktop: BoundSessionControlClient;
+    /**
+     * Whether this conversation is a private chat. Group chats cannot be bound
+     * in Phase 1, and the adapter is the only thing that knows which is which.
+     */
+    isDirectMessage?(message: ChannelMessage): boolean;
+}
+export declare function createBoundSessionChat(options: BoundSessionChatOptions): ChatMiddleware;

package/dist/bound-session-chat.js

@@ -0,0 +1,67 @@
+/**
+ * Routes a conversation that has entered a Work Session, ahead of Mimi.
+ *
+ * This middleware sits between the deterministic remote commands and
+ * createMimiPetChat. When the host reports no binding for the conversation it
+ * calls next() and Mimi handles the message exactly as before; when there is a
+ * binding it terminates the chain, and the message goes to the Session instead
+ * of the manager.
+ *
+ * Two properties matter more than they look:
+ *
+ * - Leaving is decided here, not by the host and never by a model. /mimi has
+ *   to work when the worker is wedged or the bound Session is unreachable,
+ *   otherwise a user can be stuck inside a Session with no way out.
+ * - The reply for an accepted message is not this middleware's job. A Session
+ *   turn can take minutes, far longer than an inbound HTTP request should be
+ *   held open, so acceptance is acknowledged immediately and the real answer
+ *   comes back later through the durable outbox.
+ */
+/**
+ * A conversation is only addressable when both target and sender are known.
+ * Without them two anonymous messages on one channel are indistinguishable,
+ * and a reply could reach the wrong person, so such a message is left to Mimi.
+ */
+function isAddressable(message) {
+    return Boolean(message.target?.trim() && message.senderId?.trim());
+}
+export function createBoundSessionChat(options) {
+    const isDirectMessage = options.isDirectMessage ?? (() => true);
+    return async ({ message, reply }, next) => {
+        if (!message.text.trim() && !message.attachments?.length)
+            return next();
+        if (!isAddressable(message))
+            return next();
+        let disposition;
+        try {
+            disposition = await options.desktop.routeBoundSessionMessage({
+                channel: message.channel,
+                target: message.target,
+                senderId: message.senderId,
+                ...(message.messageId ? { messageId: message.messageId } : {}),
+                text: message.text,
+                isDirectMessage: isDirectMessage(message),
+            });
+        }
+        catch {
+            // The bridge being unreachable must not swallow the message: fall
+            // through so Mimi still answers, which is the pre-binding behavior.
+            return next();
+        }
+        switch (disposition.kind) {
+            case "not-bound":
+                return next();
+            case "accepted":
+                // The Session's answer arrives later through the outbox. Only an
+                // explicit notice (the stale-binding reminder) is sent now.
+                if (disposition.notice)
+                    await reply({ text: disposition.notice });
+                return;
+            case "left":
+            case "status":
+            case "suspended":
+                await reply({ text: disposition.text });
+                return;
+        }
+    };
+}

package/dist/cli.js

@@ -7,7 +7,7 @@ import { createChannelAdapterAsync } from "./adapter-factory.js";
 import { ChatGateway, createAllowlistMiddleware, createRateLimitMiddleware, } from "./chat-gateway.js";
 import { defaultGatewayConfigPath, loadGatewayConfig } from "./config.js";
 import { DesktopControlClient } from "./desktop-control-client.js";
-import { CODE_SHELL_REMOTE_COMMANDS, createCodeShellRemoteCommands, createMimiPetChat, } from "./gateway.js";
+import { CODE_SHELL_REMOTE_COMMANDS, createCodeShellRemoteCommands, createMimiPetChat, MIMI_MIN_CONCURRENT_MESSAGES_PER_TARGET, } from "./gateway.js";
 import { loginCodeShellWechat } from "./wechat-login.js";
 import { defaultWechatDataDirectory } from "./wechat-storage.js";
 import { acquireGatewayInstanceLock } from "./instance-lock.js";
@@ -63,7 +63,7 @@ async function main(args = process.argv.slice(2)) {
                 path: config.runtime.inboxPath,
                 maxPending: config.runtime.maxPending,
                 maxConcurrent: config.runtime.maxConcurrent,
-                maxPerTarget: config.runtime.maxPerTarget,
+                maxPerTarget: Math.max(config.runtime.maxPerTarget, MIMI_MIN_CONCURRENT_MESSAGES_PER_TARGET),
             },
             adapterRestart: {
                 baseMs: config.runtime.adapterRestartBaseMs,

package/dist/codeshell.d.ts

@@ -1,6 +1,7 @@
 export * from "./config.js";
 export * from "./desktop-control-client.js";
 export * from "./gateway.js";
+export * from "./bound-session-chat.js";
 export * from "./protocol.js";
 export * from "./wechat-login.js";
 export { hasWechatStoredContextToken } from "./wechat-storage.js";

package/dist/codeshell.js

@@ -1,6 +1,7 @@
 export * from "./config.js";
 export * from "./desktop-control-client.js";
 export * from "./gateway.js";
+export * from "./bound-session-chat.js";
 export * from "./protocol.js";
 export * from "./wechat-login.js";
 export { hasWechatStoredContextToken } from "./wechat-storage.js";

package/dist/desktop-control-client.d.ts

@@ -1,4 +1,5 @@
 import { type ChildProcess } from "node:child_process";
+import type { BoundSessionDisposition } from "./bound-session-chat.js";
 import type { DesktopGatewayConfig } from "./config.js";
 import { type DesktopControlDescriptor, type DesktopControlEvent, type DesktopControlEventPage, type MobileRemoteOpenResult, type MobileRemoteStatus, type PetChatRequest, type PetChatResult } from "./protocol.js";
 type SpawnFn = (command: string, args: readonly string[], options: {
@@ -42,6 +43,19 @@ export declare class DesktopControlClient {
         expiresAt: number;
     }>;
     petChat(input: PetChatRequest): Promise<PetChatResult>;
+    /**
+     * Ask the host where one inbound message should go. Short timeout on
+     * purpose: this only records the routing decision, and the Session's answer
+     * returns later through the durable outbox.
+     */
+    routeBoundSessionMessage(input: {
+        channel: string;
+        target: string;
+        senderId: string;
+        messageId?: string;
+        text: string;
+        isDirectMessage: boolean;
+    }): Promise<BoundSessionDisposition>;
     events(after?: number, waitMs?: number, signal?: AbortSignal): Promise<DesktopControlEventPage>;
     watchEvents(signal: AbortSignal, handle: (event: DesktopControlEvent, context: DesktopEventContext) => Promise<void>, options?: DesktopEventWatchOptions): Promise<void>;
     private ensureDesktopAvailable;

package/dist/desktop-control-client.js

@@ -49,6 +49,15 @@ export class DesktopControlClient {
         await this.ensureDesktopAvailable();
         return this.request("POST", "/v1/pet/chat", 150_000, input);
     }
+    /**
+     * Ask the host where one inbound message should go. Short timeout on
+     * purpose: this only records the routing decision, and the Session's answer
+     * returns later through the durable outbox.
+     */
+    async routeBoundSessionMessage(input) {
+        await this.ensureDesktopAvailable();
+        return this.request("POST", "/v1/session/route", 20_000, input);
+    }
     events(after = 0, waitMs = 25_000, signal) {
         if (!Number.isSafeInteger(after) || after < 0 || waitMs < 0 || waitMs > 25_000) {
             throw new Error("invalid desktop event cursor");

package/dist/gateway.d.ts

@@ -9,6 +9,12 @@ export interface MimiPetChatOptions {
     /** Enabled adapters whose declared capabilities back first-level Gateway discovery. */
     channels?: readonly ChannelAdapter[];
 }
+/**
+ * Mimi can accept several messages from one conversation while one model turn
+ * is running. The host folds same-route followers into that turn via steer;
+ * ordinary adapter replies remain bounded by the Gateway's global concurrency.
+ */
+export declare const MIMI_MIN_CONCURRENT_MESSAGES_PER_TARGET = 4;
 export declare const CODE_SHELL_REMOTE_COMMANDS: readonly [{
     readonly name: "open";
     readonly description: "打开 CodeShell 手机遥控隧道";

package/dist/gateway.js

@@ -3,6 +3,12 @@ import { materializeChatAttachments } from "./attachments.js";
 import { DesktopControlOperationError, DesktopControlUnavailableError, } from "./desktop-control-client.js";
 import { materializeOutgoingAttachments, splitNotificationTextForChannel, } from "./notification-relay.js";
 const MIMI_REPLY_CACHE_MAX_ENTRIES = 2_048;
+/**
+ * Mimi can accept several messages from one conversation while one model turn
+ * is running. The host folds same-route followers into that turn via steer;
+ * ordinary adapter replies remain bounded by the Gateway's global concurrency.
+ */
+export const MIMI_MIN_CONCURRENT_MESSAGES_PER_TARGET = 4;
 export const CODE_SHELL_REMOTE_COMMANDS = [
     { name: "open", description: "打开 CodeShell 手机遥控隧道" },
     { name: "close", description: "关闭 CodeShell 手机遥控隧道" },
@@ -193,6 +199,8 @@ async function buildMimiOutgoingReplies(options, message, capabilities, configur
             channels: gatewayChannelCatalog(message.channel, capabilities, configuredChannels),
         },
     });
+    if (result.suppressReply)
+        return [];
     const chunks = splitNotificationTextForChannel(result.text || "Mimi Pet 已处理，但没有返回文字内容。", message.channel, capabilities);
     const outgoing = chunks.map((text) => ({ text }));
     const last = outgoing.at(-1);

package/dist/protocol.d.ts

@@ -15,7 +15,7 @@ export interface DesktopControlEvent {
      * stable when Desktop republishes one durable event after a process restart.
      */
     deliveryKey?: string;
-    type: "tunnel.connected" | "tunnel.disconnected" | "tunnel.error" | "pet.task.completed" | "pet.task.failed" | "pet.task.cancelled" | "pet.task.reported" | "automation.completed" | "automation.failed" | "automation.stopped" | "automation.cancelled" | "automation.missed";
+    type: "tunnel.connected" | "tunnel.disconnected" | "tunnel.error" | "pet.task.completed" | "pet.task.failed" | "pet.task.cancelled" | "pet.task.reported" | "session.reply" | "automation.completed" | "automation.failed" | "automation.stopped" | "automation.cancelled" | "automation.missed";
     text: string;
     title?: string;
     button?: {
@@ -92,6 +92,8 @@ export interface PetChatResult {
     text: string;
     petSessionId: string;
     reason?: string;
+    /** This input joined an in-flight Mimi turn; the earlier request owns the combined reply. */
+    suppressReply?: boolean;
     /** GatewayReply URL action; rendered natively or as a labelled link by the adapter. */
     button?: {
         text: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-chat",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "A standalone, transport-agnostic multi-channel chat gateway for Node.js and Bun.",
   "type": "module",
   "main": "./dist/index.js",