@0xmaxma/claude-gateway 2.0.9 → 2.0.11

package/dist/agent/runner.js

@@ -134,20 +134,27 @@ exports.MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024;
 // the Opus 5 -> Opus 4.8 demotion above and the Fable 5.1 -> Fable 5 one.
 // Selection still stores the resolved id, so an agent already on Opus 5 stays
 // on claude-opus-5 — only `/model opus` from now on resolves to 5.5.
+//
+// Sonnet 5.5 (`claude-sonnet-5-5`) does the same on the Sonnet family: it takes
+// `sonnet` / `sonnet[1m]` and Sonnet 5 is demoted to `sonnet5` / `sonnet5[1m]`;
+// Sonnet 4.6 keeps `sonnet46`. An agent already on Sonnet 5 stays on
+// claude-sonnet-5.
 exports.DEFAULT_MODELS = [
     { id: 'claude-fable-5-1[1m]', label: 'Fable 5.1 (1M)', alias: 'fable[1m]', contextWindow: 1000000 },
     { id: 'claude-fable-5[1m]', label: 'Fable 5 (1M)', alias: 'fable5[1m]', contextWindow: 1000000 },
     { id: 'claude-opus-5-5[1m]', label: 'Opus 5.5 (1M)', alias: 'opus[1m]', contextWindow: 1000000 },
     { id: 'claude-opus-5[1m]', label: 'Opus 5 (1M)', alias: 'opus5[1m]', contextWindow: 1000000 },
     { id: 'claude-opus-4-8[1m]', label: 'Opus 4.8 (1M)', alias: 'opus48[1m]', contextWindow: 1000000 },
-    { id: 'claude-sonnet-5[1m]', label: 'Sonnet 5 (1M)', alias: 'sonnet[1m]', contextWindow: 1000000 },
+    { id: 'claude-sonnet-5-5[1m]', label: 'Sonnet 5.5 (1M)', alias: 'sonnet[1m]', contextWindow: 1000000 },
+    { id: 'claude-sonnet-5[1m]', label: 'Sonnet 5 (1M)', alias: 'sonnet5[1m]', contextWindow: 1000000 },
     { id: 'claude-fable-5-1', label: 'Fable 5.1', alias: 'fable', contextWindow: 200000 },
     { id: 'claude-fable-5', label: 'Fable 5', alias: 'fable5', contextWindow: 200000 },
     { id: 'claude-opus-5-5', label: 'Opus 5.5', alias: 'opus', contextWindow: 200000 },
     { id: 'claude-opus-5', label: 'Opus 5', alias: 'opus5', contextWindow: 200000 },
     { id: 'claude-opus-4-8', label: 'Opus 4.8', alias: 'opus48', contextWindow: 200000 },
     { id: 'claude-opus-4-6', label: 'Opus 4.6', alias: 'opus46', contextWindow: 200000 },
-    { id: 'claude-sonnet-5', label: 'Sonnet 5', alias: 'sonnet', contextWindow: 200000 },
+    { id: 'claude-sonnet-5-5', label: 'Sonnet 5.5', alias: 'sonnet', contextWindow: 200000 },
+    { id: 'claude-sonnet-5', label: 'Sonnet 5', alias: 'sonnet5', contextWindow: 200000 },
     { id: 'claude-sonnet-4-6', label: 'Sonnet 4.6', alias: 'sonnet46', contextWindow: 200000 },
     { id: 'claude-haiku-4-5-20251001', label: 'Haiku 4.5', alias: 'haiku', contextWindow: 200000 },
     { id: 'gpt-6-sol[1m]', label: 'GPT 6 Sol', alias: 'gpt6sol', contextWindow: 1050000 },
@@ -419,18 +426,28 @@ class AgentRunner extends events_1.EventEmitter {
     recordVoicePlayback(responseId, principalId, progress, state) {
         this.orchestration?.recordPlayback(responseId, principalId, progress, state);
     }
-    async submitVoiceUtterance(sessionId, chatId, principalId, text, utteranceId, allowTools, model) {
+    async submitVoiceUtterance(sessionId, chatId, principalId, text, utteranceId, allowTools, model, executionTaskId) {
         if (!this.agentConfig.orchestration?.enabled || !this.agentConfig.voice?.enabled)
             throw new Error('Voice is disabled');
         if (!(await this.apiSessionExists(chatId, sessionId)))
             throw new Error('Session not found');
         const orchestration = await this.getOrchestration();
         const accepted = orchestration.submitInput({ scope: { agentId: this.agentConfig.id, agentSessionId: sessionId, source: 'api', accountId: principalId,
-                chatId, threadKey: '', principalId }, text, model, modality: 'live_voice', ingressKey: `utterance:${utteranceId}` }, { execute: allowTools, writeMemory: false });
+                chatId, threadKey: '', principalId }, text, model, metadata: { executionTaskId }, modality: 'live_voice', ingressKey: `utterance:${utteranceId}` }, { execute: allowTools, writeMemory: false });
         // The browser refreshes history on utterance.accepted, before inference finishes.
         await orchestration.flushHistory();
         return { ...accepted, responseId: () => orchestration.responseIdForInput(accepted.inputId) };
     }
+    async browserSessionScope(sessionId, principalId) {
+        if (!this.agentConfig.orchestration?.enabled)
+            throw new Error('ORCHESTRATION_DISABLED');
+        return (await this.getOrchestration()).browserSessionScope(sessionId, principalId);
+    }
+    async browserEvidence(sessionId, principalId, taskId, refresh = false) {
+        if (!this.agentConfig.orchestration?.enabled)
+            throw new Error('ORCHESTRATION_DISABLED');
+        return (await this.getOrchestration()).browserEvidence(sessionId, principalId, taskId, refresh);
+    }
     async listApiTasks(sessionId, principalId, page = 0, pageSize = 10, includeFinished = false) {
         if (!this.agentConfig.orchestration?.enabled)
             throw new Error('ORCHESTRATION_DISABLED');
@@ -447,6 +464,35 @@ class AgentRunner extends events_1.EventEmitter {
         // Full retained result, with worker-only skill context removed by status().
         return { ...runtime.tasks.status(task.conversationId, principalId, taskId)[0], ...detail };
     }
+    /** Provisional: returns the pause id so releaseVoicePause can undo it if the speech yields no command. */
+    async pauseVoiceExecution(sessionId, principalId, taskId) {
+        const runtime = await this.getOrchestration();
+        const detail = runtime.taskControls.detail(sessionId, principalId, taskId);
+        const task = runtime.store.task(taskId);
+        if (task.executionControl?.action === 'pause' && ['pending', 'paused'].includes(task.executionControl.phase))
+            return;
+        if (!['queued', 'starting', 'running', 'interrupting'].includes(task.state))
+            return;
+        if (!runtime.tasks.voicePauseApplies(detail.taskId))
+            return;
+        const id = (0, crypto_1.randomUUID)();
+        runtime.controlTask(sessionId, principalId, detail.taskId, { id, action: 'pause', expectedRevision: task.revision });
+        return id;
+    }
+    /** Speech that produced no command (empty, muted or lost) resumes the task,
+     * but only if this voice pause is still the latest control. */
+    async releaseVoicePause(sessionId, principalId, taskId, pauseId) {
+        const runtime = await this.getOrchestration();
+        const task = runtime.store.task(taskId);
+        if (task?.executionControl?.id !== pauseId || task.executionControl.action !== 'pause')
+            return;
+        runtime.controlTask(sessionId, principalId, taskId, { id: (0, crypto_1.randomUUID)(), action: 'resume', expectedRevision: task.revision });
+    }
+    async controlApiTask(sessionId, principalId, taskId, command) {
+        if (!this.agentConfig.orchestration?.enabled)
+            throw new Error('ORCHESTRATION_DISABLED');
+        return (await this.getOrchestration()).controlTask(sessionId, principalId, taskId, command);
+    }
     async cancelApiTask(sessionId, principalId, taskId) {
         if (!this.agentConfig.orchestration?.enabled)
             throw new Error('ORCHESTRATION_DISABLED');
@@ -474,12 +520,12 @@ class AgentRunner extends events_1.EventEmitter {
     }
     async sendOrchestratedApi(sessionId, chatId, message, opts, onText, onTool) {
         const semantic = this.agentConfig.orchestration?.conversation?.semanticIntake === true;
-        if (!semantic && !opts.acceptOnly && this.pendingApiSessions.has(sessionId))
+        if (!opts.executionTaskId && !semantic && !opts.acceptOnly && this.pendingApiSessions.has(sessionId))
             throw Object.assign(new Error('Session already has a pending request'), { code: 'CONFLICT' });
         if (!opts.principalId)
             throw new Error('Authenticated principal required for conversation orchestration');
         const deadline = Date.now() + opts.timeoutMs;
-        if (!semantic && !opts.acceptOnly)
+        if (!opts.executionTaskId && !semantic && !opts.acceptOnly)
             this.pendingApiSessions.add(sessionId); // reserve before the first await
         const preparationDir = opts.acceptOnly ? `api-${sessionId}/admission-${(0, crypto_1.randomUUID)()}` : undefined;
         let keepPreparedMedia = false;
@@ -490,7 +536,7 @@ class AgentRunner extends events_1.EventEmitter {
                 source: 'api', accountId: opts.principalId, chatId, threadKey: '', principalId: opts.principalId };
             const ingressKey = opts.clientMessageId ? `web:${sessionId}:${opts.clientMessageId}` : undefined;
             const requestFingerprint = opts.clientMessageId ? (0, store_1.payloadHash)({ scope, message,
-                mediaFiles: opts.mediaFiles ?? [], model: opts.model, imageParams: opts.imageParams,
+                executionTaskId: opts.executionTaskId, mediaFiles: opts.mediaFiles ?? [], model: opts.model, imageParams: opts.imageParams,
                 videoParams: opts.videoParams, storeUserMessage: !opts.skipUserMessage, allowTools: opts.allowTools ?? false }) : undefined;
             if (opts.acceptOnly && requestFingerprint) {
                 const prior = orchestration.store.apiReceipt(scope, ingressKey, requestFingerprint);
@@ -517,7 +563,7 @@ class AgentRunner extends events_1.EventEmitter {
             const requestId = opts.requestId ?? (0, crypto_1.randomUUID)();
             const scopedInput = { scope, text: message || '[Attachment inspection requested]', attachmentIds: media,
                 requestId, ingressKey, requestFingerprint, storeUserMessage: !opts.skipUserMessage,
-                metadata: { clientMessageId: opts.clientMessageId, promptContext: (imageParams ? AgentRunner.buildImageParamsNote(imageParams) : '') + (videoParams ? AgentRunner.buildVideoParamsNote(videoParams) : ''), imageRefs: imageParams?.image_refs } };
+                metadata: { executionTaskId: opts.executionTaskId, clientMessageId: opts.clientMessageId, promptContext: (imageParams ? AgentRunner.buildImageParamsNote(imageParams) : '') + (videoParams ? AgentRunner.buildVideoParamsNote(videoParams) : ''), imageRefs: imageParams?.image_refs } };
             if (opts.acceptOnly) {
                 const accepted = orchestration.submitInput({ ...scopedInput, model: opts.model }, { execute: opts.allowTools ?? false, writeMemory: false });
                 // Concurrent retries can prepare separate copies; only the winning
@@ -531,7 +577,7 @@ class AgentRunner extends events_1.EventEmitter {
                 return { text: '', attachments: [], inputId: accepted.inputId };
             }
             let text;
-            if (semantic) {
+            if (semantic || opts.executionTaskId) {
                 const accepted = orchestration.submitInput({ ...scopedInput, model: opts.model }, { execute: opts.allowTools ?? false, writeMemory: false }, onTool);
                 const lengths = new Map();
                 const unsubscribe = orchestration.subscribeText(sessionId, opts.principalId, event => {
@@ -565,7 +611,7 @@ class AgentRunner extends events_1.EventEmitter {
                     this.logger.warn('Unused admission media cleanup failed', { error: String(error) });
                 }
             }
-            if (!semantic && !opts.acceptOnly)
+            if (!opts.executionTaskId && !semantic && !opts.acceptOnly)
                 this.pendingApiSessions.delete(sessionId);
         }
     }
@@ -3603,6 +3649,15 @@ class AgentRunner extends events_1.EventEmitter {
         }
         this.pendingRestarts.add(chatId);
     }
+    /**
+     * Format the web→channel echo. Attribute it to the sender when known so
+     * multi-user web messages are distinguishable in the channel; fall back to the
+     * bare prefix when no sender name is available (senderName is persisted to
+     * history on the adjacent line either way).
+     */
+    webEchoText(message, senderName) {
+        return senderName ? `📱 Web (${senderName}): ${message}` : '📱 Web: ' + message;
+    }
     writeAutoForward(chatId, text, format = 'text', forceDeliver = false) {
         // LINE has no .forward consumer — route through LineReplyManager's push path.
         if (this.channelFor(chatId) === 'line') {
@@ -4758,6 +4813,17 @@ class AgentRunner extends events_1.EventEmitter {
      */
     async sendApiMessageStream(sessionId, chatId, message, callbacks, opts) {
         if (this.orchestrationForApi(sessionId)) {
+            if (opts.executionTaskId) {
+                // A task control applies immediately, then its scoped agent reply streams independently.
+                let detached = false;
+                void this.sendOrchestratedApi(sessionId, chatId, message, opts, text => { if (!detached)
+                    callbacks.onChunk({ type: 'text_delta', text }); })
+                    .then(result => { if (!detached)
+                    callbacks.onDone(result.text, result.attachments); })
+                    .catch(error => { if (!detached)
+                    callbacks.onError((0, response_errors_1.presentedResponseError)(error)); });
+                return () => { detached = true; };
+            }
             if (this.pendingApiSessions.has(sessionId))
                 throw Object.assign(new Error('Session already has a pending request'), { code: 'CONFLICT' });
             const turn = this.turnStreams.start((0, turn_stream_1.turnStreamKey)('api', sessionId), opts.requestId ?? (0, crypto_1.randomUUID)());
@@ -5585,6 +5651,23 @@ class AgentRunner extends events_1.EventEmitter {
                 source: channel, accountId: String(rows[0]?.account_id ?? this.agentConfig.id), chatId: rawChatId,
                 threadKey: String(rows[0]?.thread_key ?? ''), principalId: opts.principalId },
             text: message, requestId, trustedChannelMember: true, metadata: { senderName, senderId: opts.principalId } }, { execute: opts.allowTools ?? false, writeMemory: false });
+        // Echo the web-UI message back to the originating channel so its users see
+        // what was typed from the web (fixes the one-sided conversation on every
+        // channel the endpoint serves, not just Telegram). Placed after the
+        // validation above AND after submitInput has accepted the input into the
+        // store, so a rejected request — whether from validation (Authenticated
+        // principal, Ambiguous/mismatched session, Session not found) or from
+        // admission (QUEUE_FULL, ORCHESTRATION_CLOSING thrown by submitInput) —
+        // sends no phantom echo. channelSourceMap is set first so writeAutoForward
+        // routes to the right channel receiver — the orchestrated path never
+        // reaches the legacy set. forceDeliver=true (null turnId) because the echo
+        // is standalone text no `.replied` marker covers: without it the entry
+        // carries readCurrentTurnId(), which a concurrent channel turn's marker (or
+        // a stale one) with the same turn id would dedup-swallow — defeating the
+        // one-sided-conversation fix. Same convention as the socket-drop notice
+        // (2706) and the reply-failure fallback (3738-3742).
+        this.channelSourceMap.set(rawChatId, channel);
+        this.writeAutoForward(rawChatId, this.webEchoText(message, senderName), 'text', true);
         const turn = this.turnStreams.start((0, turn_stream_1.turnStreamKey)(channel, sessionId), requestId);
         const sink = (0, turn_stream_1.callbackSink)(callbacks);
         turn.attach(sink, 0);
@@ -5678,6 +5761,15 @@ class AgentRunner extends events_1.EventEmitter {
         this.channelSourceMap.set(rawChatId, channel);
         // Channel sessions use agent-level model (not per-session)
         const session = await this.getOrSpawnSession(rawChatId, channel, sessionId);
+        // Echo the web-UI message back to the originating channel so its users see
+        // what was typed from the web (fixes the one-sided conversation on every
+        // channel the endpoint serves, not just Telegram). Placed after
+        // getOrSpawnSession so a rejected request or a failed spawn sends no phantom
+        // echo. channelSourceMap was set just above, so writeAutoForward routes to
+        // the right channel receiver. forceDeliver=true (null turnId): see the
+        // orchestrated path above — the echo is standalone text no `.replied` marker
+        // covers, so a same-turn-id marker must not dedup it away.
+        this.writeAutoForward(rawChatId, this.webEchoText(message, senderName), 'text', true);
         // Persist user message (Layer 1 session JSON + Layer 2 history DB)
         const uiUserTs = Date.now();
         await this.sessionStore.appendTelegramMessage(this.agentConfig.id, rawChatId, sessionId, {