openmates 0.11.0-alpha.18 → 0.11.0-alpha.19

package/dist/{chunk-IJXZKFPX.js → chunk-S6RDNSHY.js}

@@ -743,6 +743,15 @@ function isSyncCacheFresh(maxAgeMs = 3e5) {
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 var WebSocket = require2("ws");
+var SUB_CHAT_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "spawn_sub_chats",
+  "sub_chat_progress",
+  "sub_chat_confirmation_required",
+  "sub_chat_confirmation_resolved",
+  "awaiting_sub_chats_completion",
+  "sub_chat_completed",
+  "awaiting_user_input"
+]);
 var OpenMatesWsClient = class {
   socket;
   constructor(options) {
@@ -920,6 +929,8 @@ var OpenMatesWsClient = class {
       let category = null;
       let modelName = null;
       let followUpSuggestions = [];
+      const subChatEvents = [];
+      const pendingSubChatHandlers = /* @__PURE__ */ new Set();
       const embeds = /* @__PURE__ */ new Map();
       const processingEmbedIds = /* @__PURE__ */ new Set();
       let aiResponseDone = false;
@@ -957,6 +968,7 @@ var OpenMatesWsClient = class {
       };
       const maybeResolve = () => {
         if (!aiResponseDone || !postProcessingDone) return;
+        if (pendingSubChatHandlers.size > 0) return;
         if (processingEmbedIds.size > 0 && !asyncEmbedTimer) {
           asyncEmbedTimer = setTimeout(() => {
             cleanup();
@@ -967,7 +979,8 @@ var OpenMatesWsClient = class {
               category,
               modelName,
               followUpSuggestions,
-              embeds: [...embeds.values()]
+              embeds: [...embeds.values()],
+              subChatEvents
             });
           }, asyncEmbedWaitMs);
           return;
@@ -981,7 +994,25 @@ var OpenMatesWsClient = class {
           category,
           modelName,
           followUpSuggestions,
-          embeds: [...embeds.values()]
+          embeds: [...embeds.values()],
+          subChatEvents
+        });
+      };
+      const handleSubChatEvent = (type, p) => {
+        const eventChatId = typeof p.chat_id === "string" ? p.chat_id : typeof p.parent_id === "string" ? p.parent_id : null;
+        if (eventChatId && eventChatId !== chatId) return;
+        const event = { type, payload: p };
+        subChatEvents.push(event);
+        const handler = options?.onSubChatEvent;
+        if (!handler) return;
+        const pending = Promise.resolve(handler(event));
+        pendingSubChatHandlers.add(pending);
+        pending.catch((error) => {
+          cleanup();
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }).finally(() => {
+          pendingSubChatHandlers.delete(pending);
+          maybeResolve();
         });
       };
       const scheduleResolve = (content) => {
@@ -1004,6 +1035,10 @@ var OpenMatesWsClient = class {
             );
             return;
           }
+          if (SUB_CHAT_EVENT_TYPES.has(type)) {
+            handleSubChatEvent(type, p);
+            return;
+          }
           if (type === "send_embed_data") {
             const embedPayload = p.payload && typeof p.payload === "object" ? p.payload : p;
             if (typeof embedPayload.chat_id === "string" && embedPayload.chat_id !== chatId) {
@@ -1120,7 +1155,8 @@ var OpenMatesWsClient = class {
             category,
             modelName,
             followUpSuggestions,
-            embeds: [...embeds.values()]
+            embeds: [...embeds.values()],
+            subChatEvents
           });
           return;
         }
@@ -1698,6 +1734,42 @@ function normalizeUnixSeconds(value, fallback) {
   }
   return value > 1e10 ? Math.floor(value / 1e3) : Math.floor(value);
 }
+function buildSubChatConfirmationPayload(params) {
+  return {
+    chat_id: params.chatId,
+    task_id: params.taskId,
+    action: params.approved ? "approve" : "cancel",
+    approve_count: params.approved ? params.approveCount ?? null : null
+  };
+}
+async function buildSubChatEncryptedMetadataPayloads(params) {
+  const createdAt = params.createdAt ?? Math.floor(Date.now() / 1e3);
+  const payloads = [];
+  for (const subChat of params.subChats) {
+    const chatId = subChat.id || subChat.chat_id;
+    const messageId = subChat.user_message_id || subChat.message_id;
+    const prompt = subChat.prompt || "";
+    if (!chatId || !messageId) continue;
+    const title = prompt.substring(0, 30);
+    payloads.push({
+      chat_id: chatId,
+      parent_id: params.parentChatId,
+      is_sub_chat: true,
+      message_id: messageId,
+      encrypted_content: await encryptWithAesGcmCombined(prompt, params.parentChatKey),
+      encrypted_sender_name: await encryptWithAesGcmCombined("User", params.parentChatKey),
+      encrypted_title: await encryptWithAesGcmCombined(title, params.parentChatKey),
+      created_at: createdAt,
+      encrypted_chat_key: params.encryptedParentChatKey,
+      versions: {
+        messages_v: 1,
+        title_v: 0,
+        last_edited_overall_timestamp: createdAt
+      }
+    });
+  }
+  return payloads;
+}
 var MEMORY_TYPE_REGISTRY = {
   "ai/communication_style": {
     appId: "ai",
@@ -2070,8 +2142,8 @@ var OpenMatesClient = class _OpenMatesClient {
   session;
   http;
   constructor(options = {}) {
-    this.apiUrl = (options.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
     const diskSession = options.session ?? this.getValidSessionFromDisk();
+    this.apiUrl = (options.apiUrl ?? process.env.OPENMATES_API_URL ?? diskSession?.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
     this.session = diskSession;
     this.http = new OpenMatesHttpClient({
       apiUrl: this.apiUrl,
@@ -2173,6 +2245,11 @@ var OpenMatesClient = class _OpenMatesClient {
     if (!response.ok || !response.data.success) {
       throw new Error("Session is invalid. Please run `openmates login`.");
     }
+    if (response.data.ws_token) {
+      session.wsToken = response.data.ws_token;
+    }
+    session.cookies = this.http.getCookieMap();
+    saveSession(session);
     return response.data.user ?? {};
   }
   async logout() {
@@ -2745,7 +2822,71 @@ var OpenMatesClient = class _OpenMatesClient {
     let category = null;
     let modelName = null;
     let followUpSuggestions = [];
-    const streamOpts = { onStream: params.onStream };
+    let subChatEvents = [];
+    const numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+    const isApprovalWithinServerLimits = (request) => {
+      const count = request.subChats.length;
+      if (count === 0) return false;
+      if (request.remainingSubChats !== null && count > request.remainingSubChats) {
+        return false;
+      }
+      if (request.maxDirectSubChats !== null && request.existingSubChats !== null && request.existingSubChats + count > request.maxDirectSubChats) {
+        return false;
+      }
+      return true;
+    };
+    const isAutoApprovalWithinServerLimits = (request) => {
+      if (!isApprovalWithinServerLimits(request)) return false;
+      return request.maxAutoSubChats === null || request.subChats.length <= request.maxAutoSubChats;
+    };
+    const handleSubChatEvent = async (event) => {
+      params.onSubChatEvent?.(event);
+      if (event.type === "spawn_sub_chats") {
+        if (params.incognito || !chatKeyBytes) return;
+        const rawSubChats = event.payload.sub_chats;
+        if (!Array.isArray(rawSubChats)) return;
+        const metadataPayloads = await buildSubChatEncryptedMetadataPayloads({
+          parentChatId: chatId,
+          parentChatKey: chatKeyBytes,
+          encryptedParentChatKey: encryptedChatKey,
+          subChats: rawSubChats
+        });
+        for (const metadataPayload of metadataPayloads) {
+          await ws.sendAsync("encrypted_chat_metadata", metadataPayload);
+        }
+        return;
+      }
+      if (event.type !== "sub_chat_confirmation_required") return;
+      const payload = event.payload;
+      const confirmationChatId = typeof payload.chat_id === "string" ? payload.chat_id : chatId;
+      const taskId = typeof payload.task_id === "string" ? payload.task_id : null;
+      const subChats = Array.isArray(payload.sub_chats) ? payload.sub_chats : [];
+      if (!taskId) return;
+      const request = {
+        chatId: confirmationChatId,
+        taskId,
+        subChats,
+        maxAutoSubChats: numberOrNull(payload.max_auto_sub_chats),
+        maxDirectSubChats: numberOrNull(payload.max_direct_sub_chats),
+        existingSubChats: numberOrNull(payload.existing_sub_chats),
+        remainingSubChats: numberOrNull(payload.remaining_sub_chats)
+      };
+      const withinLimits = isApprovalWithinServerLimits(request);
+      const approved = params.autoApproveSubChats ? isAutoApprovalWithinServerLimits(request) : withinLimits && params.onSubChatApprovalRequest ? await params.onSubChatApprovalRequest(request) : false;
+      await ws.sendAsync(
+        "sub_chat_confirmation",
+        buildSubChatConfirmationPayload({
+          chatId: request.chatId,
+          taskId: request.taskId,
+          approved,
+          approveCount: approved ? request.subChats.length : void 0
+        })
+      );
+    };
+    const streamOpts = {
+      onStream: params.onStream,
+      onSubChatEvent: handleSubChatEvent
+    };
     if (params.incognito) {
       try {
         const resp = await ws.collectAiResponse(messageId, chatId, streamOpts);
@@ -2753,6 +2894,7 @@ var OpenMatesClient = class _OpenMatesClient {
         assistant = resp.content;
         category = resp.category;
         modelName = resp.modelName;
+        subChatEvents = resp.subChatEvents;
       } finally {
         ws.close();
       }
@@ -2764,6 +2906,7 @@ var OpenMatesClient = class _OpenMatesClient {
         category = resp.category;
         modelName = resp.modelName;
         followUpSuggestions = resp.followUpSuggestions;
+        subChatEvents = resp.subChatEvents;
         if (chatKeyBytes && assistant) {
           const completedAt = Math.floor(Date.now() / 1e3);
           const encryptedAssistantContent = await encryptWithAesGcmCombined(
@@ -2819,7 +2962,8 @@ var OpenMatesClient = class _OpenMatesClient {
       category,
       modelName,
       mateName,
-      followUpSuggestions
+      followUpSuggestions,
+      subChatEvents
     };
   }
   async persistStreamedEmbeds(params) {
@@ -4343,6 +4487,9 @@ function printLogo() {
   stdout.write(lines.join("\n") + "\n");
 }
 
+// src/cli.ts
+import { createInterface as createInterface3 } from "readline/promises";
+
 // ../secret-scanner/src/registry.ts
 import { createRequire as createRequire2 } from "module";
 
@@ -7596,7 +7743,8 @@ async function handleChats(client, subcommand, rest, flags, redactor) {
         message,
         chatId: void 0,
         incognito: false,
-        json: flags.json === true
+        json: flags.json === true,
+        autoApproveSubChats: flags["auto-approve"] === true
       },
       redactor
     );
@@ -7667,7 +7815,8 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
         message,
         chatId,
         incognito: flags.incognito === true,
-        json: flags.json === true
+        json: flags.json === true,
+        autoApproveSubChats: flags["auto-approve"] === true
       },
       redactor
     );
@@ -7685,7 +7834,8 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
       {
         message,
         incognito: true,
-        json: flags.json === true
+        json: flags.json === true,
+        autoApproveSubChats: flags["auto-approve"] === true
       },
       redactor
     );
@@ -9562,6 +9712,56 @@ async function sendMessageStreaming(client, params, redactor) {
       processedRawLength = raw.length;
     }
   };
+  const onSubChatEvent = (event) => {
+    if (params.json) return;
+    clearTyping();
+    const payload = event.payload;
+    if (event.type === "spawn_sub_chats") {
+      const count = Array.isArray(payload.sub_chats) ? payload.sub_chats.length : 0;
+      process.stderr.write(
+        `\x1B[2mStarting ${count} sub-chat${count === 1 ? "" : "s"} for parallel research...\x1B[0m
+`
+      );
+      return;
+    }
+    if (event.type === "sub_chat_progress") {
+      const completed = typeof payload.completed === "number" ? payload.completed : null;
+      const total = typeof payload.total === "number" ? payload.total : null;
+      const status = typeof payload.status === "string" ? payload.status : "running";
+      const progress = completed !== null && total !== null ? `${completed}/${total}` : status;
+      process.stderr.write(`\x1B[2mSub-chats: ${progress} ${status}\x1B[0m
+`);
+      return;
+    }
+    if (event.type === "sub_chat_confirmation_resolved") {
+      const status = typeof payload.status === "string" ? payload.status : "resolved";
+      process.stderr.write(`\x1B[2mSub-chat approval ${status}.\x1B[0m
+`);
+      return;
+    }
+    if (event.type === "awaiting_user_input") {
+      process.stderr.write(
+        "\x1B[33mA sub-chat needs additional user input. Continue this chat in the web app if the parent cannot finish.\x1B[0m\n"
+      );
+    }
+  };
+  const onSubChatApprovalRequest = async (request) => {
+    if (params.autoApproveSubChats) return true;
+    clearTyping();
+    const count = request.subChats.length;
+    const remaining = request.remainingSubChats === null ? "" : ` (${request.remainingSubChats} remaining for this parent chat)`;
+    process.stderr.write(
+      `\x1B[33mDeep research wants to start ${count} additional sub-chat${count === 1 ? "" : "s"}${remaining}.\x1B[0m
+`
+    );
+    const rl = createInterface3({ input: process.stdin, output: process.stderr });
+    try {
+      const answer = await rl.question("Approve? [y/N] ");
+      return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+    } finally {
+      rl.close();
+    }
+  };
   const preparedEmbeds = [];
   let finalMessage = params.message;
   if (params.message.includes("@")) {
@@ -9733,6 +9933,9 @@ async function sendMessageStreaming(client, params, redactor) {
     chatId: params.chatId,
     incognito: params.incognito,
     onStream,
+    onSubChatEvent,
+    onSubChatApprovalRequest,
+    autoApproveSubChats: params.autoApproveSubChats,
     preparedEmbeds: preparedEmbeds.length > 0 ? preparedEmbeds : void 0
   });
   clearTyping();
@@ -10958,9 +11161,9 @@ function printChatsHelp() {
   openmates chats show <chat-id> [--raw] [--json]
   openmates chats open [<n>] [--json]
   openmates chats search <query> [--json]
-  openmates chats new <message> [--json]
-  openmates chats send [--chat <id>] [--incognito] <message> [--json]
-  openmates chats send --chat <id> --followup <n> [--json]
+  openmates chats new <message> [--json] [--auto-approve]
+  openmates chats send [--chat <id>] [--incognito] <message> [--json] [--auto-approve]
+  openmates chats send --chat <id> --followup <n> [--json] [--auto-approve]
   openmates chats download <chat-id> [--output <path>] [--zip] [--json]
   openmates chats delete <id1> [id2] [id3] ... [--yes]
   openmates chats share [<chat-id>] [--expires <seconds>] [--password <pwd>] [--json]
@@ -10987,6 +11190,10 @@ Options for 'send':
                    typing the full message (requires --chat)
   --incognito      Send without saving to chat history
 
+Options for 'new', 'send', and 'incognito':
+  --auto-approve   Automatically approve server-requested sub-chat batches.
+                   Without this, the CLI prompts in the terminal like the web app.
+
 Options for 'download':
   --output <path>  Target directory (default: current directory)
   --zip            Create a .zip archive instead of a folder

package/dist/cli.js

@@ -2,7 +2,7 @@
 import {
   getExtForLang,
   serializeToYaml
-} from "./chunk-IJXZKFPX.js";
+} from "./chunk-S6RDNSHY.js";
 import "./chunk-AXNRPVLE.js";
 export {
   getExtForLang,

package/dist/index.d.ts

@@ -66,6 +66,11 @@ interface StreamEvent {
     /** Human-readable model name. */
     modelName: string | null;
 }
+type SubChatEventType = "spawn_sub_chats" | "sub_chat_progress" | "sub_chat_confirmation_required" | "sub_chat_confirmation_resolved" | "awaiting_sub_chats_completion" | "sub_chat_completed" | "awaiting_user_input";
+interface SubChatEvent {
+    type: SubChatEventType;
+    payload: Record<string, unknown>;
+}
 
 /** Minimal model info needed for mention resolution */
 interface ModelInfo {
@@ -182,6 +187,23 @@ interface EmbedKeyWrapper {
  */
 type ShareDuration = 0 | 60 | 3600 | 86400 | 604800 | 1209600 | 2592000 | 7776000;
 
+interface CliSubChatRequest {
+    id?: string;
+    chat_id?: string;
+    user_message_id?: string;
+    message_id?: string;
+    prompt?: string;
+    wait_for_completion?: boolean;
+}
+interface SubChatApprovalRequest {
+    chatId: string;
+    taskId: string;
+    subChats: CliSubChatRequest[];
+    maxAutoSubChats: number | null;
+    maxDirectSubChats: number | null;
+    existingSubChats: number | null;
+    remainingSubChats: number | null;
+}
 /** A single field definition within a memory type schema. */
 interface MemoryFieldDef {
     type: string;
@@ -451,6 +473,12 @@ declare class OpenMatesClient {
         incognito?: boolean;
         /** Streaming callback — fires for typing, chunk, and done events. */
         onStream?: (event: StreamEvent) => void;
+        /** Sub-chat lifecycle callback for progress/status output. */
+        onSubChatEvent?: (event: SubChatEvent) => void;
+        /** Approval callback used when the server asks before starting a large sub-chat batch. */
+        onSubChatApprovalRequest?: (request: SubChatApprovalRequest) => boolean | Promise<boolean>;
+        /** Explicit opt-in for automatic sub-chat approval in non-interactive runs. */
+        autoApproveSubChats?: boolean;
         /** Encrypted file embeds to attach to the message (code, images, PDFs). */
         encryptedEmbeds?: EncryptedEmbed[];
         /** Prepared embeds to encrypt after the real chat/message IDs are known. */
@@ -463,6 +491,8 @@ declare class OpenMatesClient {
         mateName: string | null;
         /** Follow-up suggestions from post-processing (may be empty for incognito chats). */
         followUpSuggestions: string[];
+        /** Sub-chat lifecycle frames observed while collecting the parent response. */
+        subChatEvents: SubChatEvent[];
     }>;
     private persistStreamedEmbeds;
     /**

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   getExtForLang,
   parseNewChatSuggestionText,
   serializeToYaml
-} from "./chunk-IJXZKFPX.js";
+} from "./chunk-S6RDNSHY.js";
 import "./chunk-AXNRPVLE.js";
 export {
   MATE_NAMES,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmates",
-  "version": "0.11.0-alpha.18",
+  "version": "0.11.0-alpha.19",
   "description": "OpenMates CLI and SDK",
   "type": "module",
   "main": "dist/index.js",