newmark-agent 0.5.7 → 0.5.9

package/dist/core/agent.d.ts

@@ -464,7 +464,7 @@ export declare class Agent {
     markRouteToolExecuted(name: string, rawArgs?: string): void;
     routeTransitionKind(): PlannedRouteAttempt['kind'] | '';
     beginRouteAttempt(): void;
-    waitForPlannedRouteRetry(): Promise<void>;
+    waitForPlannedRouteRetry(explicitDelayMs?: number): Promise<void>;
     recordRouteSuccess(latencyMs?: number, throughput?: number): void;
     recordRouteToolOutcome(valid: boolean): void;
     updateProviders(value: unknown): void;

package/dist/core/agent.js

@@ -355,7 +355,7 @@ class Agent {
             this.config.set('skills', 'auto_download', 'disabled');
         }
         const modeStr = this.config.getStr('agent', 'default_mode');
-        this.mode = (['plan', 'goal', 'flow'].includes(modeStr) ? modeStr : 'build');
+        this.mode = (['plan', 'chat', 'goal', 'flow'].includes(modeStr) ? modeStr : 'build');
         const inputStr = this.config.getStr('general', 'default_input');
         this.inputMode = inputStr === 'next' ? 'next' : 'guide';
         const configuredModel = this.config.getStr('models', 'default_model');
@@ -399,6 +399,8 @@ class Agent {
         }
     }
     setMode(m) {
+        if (!['build', 'plan', 'chat', 'goal', 'flow'].includes(m))
+            m = 'build';
         if (m === 'goal' && !this.goal) {
             this.goal = new GoalStateImpl('Set your objective');
         }
@@ -1016,7 +1018,13 @@ class Agent {
     beginRouteAttempt() {
         this.routeAttemptStartedAt = Date.now();
     }
-    async waitForPlannedRouteRetry() {
+    async waitForPlannedRouteRetry(explicitDelayMs) {
+        if (explicitDelayMs !== undefined) {
+            if (explicitDelayMs <= 0)
+                return;
+            await new Promise(resolve => setTimeout(resolve, explicitDelayMs));
+            return;
+        }
         const waitBudgetMs = Math.max(0, Math.min(15_000, this.lastRouteDecision?.retryBudgetMs ?? 5_000));
         const delay = Math.max(0, Math.min(waitBudgetMs, this.lastRouteRetryDelayMs));
         this.lastRouteRetryDelayMs = 0;
@@ -5356,7 +5364,24 @@ class Agent {
             if (action !== 'update')
                 return JSON.stringify({ ok: false, error: `Unknown linked_plan action: ${action}` });
             const expectedRevision = Number(input.expected_revision ?? input.expectedRevision);
-            return JSON.stringify({ ok: true, linkedPlan: this.updateLinkedPlan(String(input.markdown || ''), expectedRevision) }, null, 2);
+            const current = this.getLinkedPlan();
+            let markdown = input.markdown === undefined ? current.markdown : String(input.markdown);
+            if (input.append !== undefined)
+                markdown = `${current.markdown}${String(input.append)}`;
+            if (input.old_text !== undefined || input.oldText !== undefined) {
+                const oldText = String(input.old_text ?? input.oldText ?? '');
+                if (!oldText)
+                    throw new Error('linked_plan old_text must not be empty.');
+                const matches = current.markdown.split(oldText).length - 1;
+                if (!matches)
+                    throw new Error('linked_plan old_text was not found.');
+                const replaceAll = input.replace_all === true || input.replaceAll === true;
+                if (matches > 1 && !replaceAll)
+                    throw new Error(`linked_plan old_text matched ${matches} places; pass replace_all=true or a unique fragment.`);
+                const newText = String(input.new_text ?? input.newText ?? '');
+                markdown = replaceAll ? current.markdown.split(oldText).join(newText) : current.markdown.replace(oldText, newText);
+            }
+            return JSON.stringify({ ok: true, linkedPlan: this.updateLinkedPlan(markdown, expectedRevision) }, null, 2);
         }
         catch (error) {
             return JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) });
@@ -7959,7 +7984,24 @@ class Agent {
                     }));
                 }
                 case 'memory_lab_update': {
-                    const result = await this.updateMemoryLab({
+                    const selector = String(params.component || params.slug || '').trim();
+                    const prepared = selector ? this.memoryLab.preparePatch({
+                        component: selector,
+                        name: params.name === undefined ? undefined : String(params.name),
+                        description: params.description === undefined ? undefined : String(params.description),
+                        tags: params.tags === undefined ? undefined : (Array.isArray(params.tags) ? params.tags.map(String) : String(params.tags).split(/[,，\n]+/)),
+                        tagPaths: params.tagPaths === undefined ? undefined : (Array.isArray(params.tagPaths) ? params.tagPaths.filter(Array.isArray).map(pathValue => pathValue.map(String)) : []),
+                        content: params.content === undefined ? undefined : String(params.content),
+                        contentAppend: params.contentAppend === undefined && params.content_append === undefined ? undefined : String(params.contentAppend ?? params.content_append),
+                        oldText: params.oldText === undefined && params.old_text === undefined ? undefined : String(params.oldText ?? params.old_text),
+                        newText: String(params.newText ?? params.new_text ?? ''),
+                        replaceAll: params.replaceAll === true || params.replace_all === true,
+                        kind: params.kind === undefined ? undefined : (params.kind === 'folder' ? 'folder' : 'file'),
+                        expectedUpdatedAt: String(params.expectedUpdatedAt || params.expected_updated_at || ''),
+                        reason: String(params.reason || ''),
+                        source: String(params.source || ''),
+                    }) : undefined;
+                    const result = await this.updateMemoryLab(prepared || {
                         name: String(params.name || ''),
                         description: String(params.description || ''),
                         tags: Array.isArray(params.tags) ? params.tags.map(String) : String(params.tags || '').split(/[,，\n]+/),
@@ -9121,6 +9163,8 @@ class Agent {
         parts.push(this.buildFeatureDisclosurePrompt());
         if (this.mode === 'plan')
             parts.push(`[Plan Tool Policy]\n${(0, toolPolicy_1.planModePolicyPrompt)()}`);
+        if (this.mode === 'chat')
+            parts.push(`[Chat Tool Policy]\n${(0, toolPolicy_1.chatModePolicyPrompt)()}`);
         const pm = this.config.getStr('workspace', 'prompt_mode') || 'both';
         const injectedPrompts = new Set();
         if ((pm === 'global_only' || pm === 'both') && globalPrompt) {
@@ -9241,7 +9285,7 @@ class Agent {
             `- Language policy: general.language=${language}; the UI can switch this at runtime and each turn must obey the current value. auto follows the user's dominant input language, en replies in English, zh replies in Simplified Chinese. Keep code, commands, file paths, JSON keys, model/provider names, tool names, quoted source text, and user-provided literals exactly as required by their source language.`,
             `- Workspace permissions: access_permission=${permission}; file tools are checked before execution and blocked when they exceed the configured workspace boundary.`,
             `- Remote repository safety: when the active workspace or any target path is inside a GitHub/remote-backed repository, proactively use repo_security_audit and file_audit before git_push, gh_pr_create, release packaging, public reporting, or cloud-side audit. Treat public remotes as public disclosure surfaces and keep private URLs, secrets, privacy addresses (credential URLs, private network addresses, local user paths), local runtime state, archives, Memory Lab, Work, config, and release outputs out of commits and summaries. git_push/gh_pr_create hard-block on detected high-risk findings until a second review resolves them and the action is retried with security_review_confirmed=true.`,
-            `- Mode engine: current mode=${this.modeName()}; Build works autonomously, Plan is fully read-only with no file modifications, Goal continues until completion unless paused, Flow follows saved workflow components.`,
+            `- Mode engine: current mode=${this.modeName()}; Build works autonomously, Plan is fully read-only, Chat only performs web search/fetch evidence gathering and prompt synthesis, Goal continues until completion unless paused, Flow follows saved workflow components.`,
             `- Input mode: ${input}; Guide injects immediately, Next queues user intent for the following build turn.`,
             `- Option feedback: ${this.buildQuestionPolicyPrompt(optionFeedback)}`,
             `- Model policy: current model=${this.model || '(unset)'}, intelligence=${this.intelligence}, auto-switch=${modelSwitch}.`,
@@ -9312,6 +9356,14 @@ class Agent {
                     'Only after the durable linked plan has actually been updated and the plan is complete, expose the fixed mode handoff asking whether execution should begin. Offer exactly these two choices in the user language: "是，执行此计划" / "否，请补充____" (or "Yes, execute this plan" / "No, please supplement _____"). This fixed handoff remains required when discretionary questions are disabled.',
                     'A positive choice starts a new Build-mode input. A negative choice remains in Plan mode so the user can supply the missing details.',
                 ]).join('\n');
+            case 'chat':
+                return withLanguage([
+                    'CHAT MODE.',
+                    'Use only web_search and web_fetch. You have no workspace, host, application, memory, task, browser-control, or write permissions.',
+                    'Perform an online search to gather evidence before answering. Fetch primary or authoritative pages when the search snippets are insufficient.',
+                    'After sufficient evidence is collected, summarize and answer the user as soon as possible. Stay concise and do not turn the request into a long-running Build, Plan, Goal, or Flow task.',
+                    'Distinguish sourced facts from uncertainty and include useful source links in the final answer.',
+                ]).join('\n');
             case 'goal': {
                 const g = this.goal?.history() || '';
                 const paused = this.goal?.paused ? '\n[GOAL PAUSED by user. Wait for resume.]' : '\n[Continue working until the goal is achieved.]';

package/dist/core/agentKernelRunner.js

@@ -46,6 +46,7 @@ const toolPolicy_1 = require("./toolPolicy");
 const performanceDiagnostics_1 = require("./performanceDiagnostics");
 const agentKernelDiagnostics_1 = require("./agentKernelDiagnostics");
 const toolchain_1 = require("../toolchain");
+const emptyResponseRetry_1 = require("./emptyResponseRetry");
 const publicStreamFilters = new WeakMap();
 const brokerOnlyAssistantBuffers = new WeakMap();
 const BROKER_PREFACE_BUFFER_CHARS = 96;
@@ -206,7 +207,7 @@ function kernelTurnFailed(agent, turn) {
     return turn.stopReason === 'error' || agent.isLlmErrorText(turn.text);
 }
 function providerTurnIsEmpty(turn) {
-    return /provider returned an empty response/i.test(`${turn.errorMessage}\n${turn.text}`);
+    return !turn.activity && /provider returned an empty response/i.test(`${turn.errorMessage}\n${turn.text}`);
 }
 function removeTrailingFailedAssistant(agent, messages) {
     const last = messages[messages.length - 1];
@@ -216,6 +217,14 @@ function removeTrailingFailedAssistant(agent, messages) {
     if (last.stopReason === 'error' || agent.isLlmErrorText(text))
         messages.pop();
 }
+function removeTrailingThoughtOnlyAssistant(messages) {
+    const last = messages[messages.length - 1];
+    if (last?.role !== 'assistant')
+        return;
+    const hasToolCall = last.content.some(content => content.type === 'toolCall');
+    if (!KernelMessageText(last).trim() && !hasToolCall)
+        messages.pop();
+}
 function normalizePublicProviderError(error, secrets = []) {
     let raw = '';
     if (error instanceof Error) {
@@ -369,8 +378,22 @@ async function runAgentKernel(agent) {
     const tokens = [];
     const runOnce = async (promptMessages, appendPromptToAgentHistory) => {
         let lastAssistant = null;
+        let observedActivity = false;
+        let observedThought = false;
         const unsubscribe = kernel.subscribe(async (event) => {
             await handleKernelEvent(agent, event, tokens);
+            if (event.type === 'message_update') {
+                const delta = event.assistantMessageEvent;
+                const deltaText = typeof delta.delta === 'string'
+                    ? delta.delta
+                    : '';
+                const thoughtDelta = delta.type === 'thinking_delta' && !!deltaText.trim();
+                observedThought = observedThought || thoughtDelta;
+                observedActivity = observedActivity ||
+                    thoughtDelta ||
+                    (delta.type === 'text_delta' && !!deltaText.trim()) ||
+                    (delta.type === 'toolcall_end');
+            }
             if (event.type === 'message_end' && event.message.role === 'assistant') {
                 lastAssistant = event.message;
             }
@@ -390,11 +413,14 @@ async function runAgentKernel(agent) {
             const text = assistant ? KernelMessageText(assistant) : '';
             const hasToolCall = !!assistant?.content?.some(content => content.type === 'toolCall');
             const emptyResponse = !assistant
-                || (!text.trim() && !hasToolCall && String(assistant?.stopReason || '') !== 'aborted');
+                || (!text.trim() && !hasToolCall && !observedActivity && String(assistant?.stopReason || '') !== 'aborted');
             return {
                 text: emptyResponse ? '[Error] Provider returned an empty response.' : text,
                 stopReason: String(assistant?.stopReason || ''),
                 errorMessage: String(assistant?.errorMessage || (emptyResponse ? 'Provider returned an empty response.' : '')),
+                activity: observedActivity || !!text.trim() || hasToolCall,
+                thoughtOnly: observedThought && !text.trim() && !hasToolCall
+                    && !['error', 'aborted'].includes(String(assistant?.stopReason || '')),
             };
         }
         finally {
@@ -448,14 +474,23 @@ async function runAgentKernel(agent) {
                 fallback: { from: modelBeforeKernelRun, to: agent.model, providerId: agent.activeDeployment()?.providerId },
             });
         }
-        let emptyResponseRetries = 0;
-        while (providerTurnIsEmpty(lastTurn) && emptyResponseRetries < 2) {
+        let consecutiveEmptyResponses = 0;
+        for (;;) {
+            const emptyResponseState = (0, emptyResponseRetry_1.observeEmptyResponseOutcome)(consecutiveEmptyResponses, providerTurnIsEmpty(lastTurn));
+            consecutiveEmptyResponses = emptyResponseState.consecutiveEmptyResponses;
+            if (lastTurn.thoughtOnly) {
+                removeTrailingThoughtOnlyAssistant(kernel.state.messages);
+                lastTurn = await runWithCompressionResume([], false);
+                continue;
+            }
+            if (!emptyResponseState.retry)
+                break;
             removeTrailingFailedAssistant(agent, kernel.state.messages);
-            emptyResponseRetries += 1;
-            const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${emptyResponseRetries}/2).`;
+            const retryNumber = consecutiveEmptyResponses;
+            const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${retryNumber}/${emptyResponseRetry_1.MAX_EMPTY_RESPONSE_RETRIES}) after ${(0, emptyResponseRetry_1.emptyResponseRetryDelayMs)(consecutiveEmptyResponses)}ms.`;
             tokens.push({ type: 'text', text: notice });
             agent.recordWorkStatus(notice);
-            await agent.waitForPlannedRouteRetry();
+            await agent.waitForPlannedRouteRetry((0, emptyResponseRetry_1.emptyResponseRetryDelayMs)(consecutiveEmptyResponses));
             lastTurn = await runWithCompressionResume([], false);
         }
         let routeRetries = 0;
@@ -667,7 +702,7 @@ async function runAgentKernel(agent) {
                     }
                     if (textStarted)
                         finalContent.push({ type: 'text', text });
-                    if (!finalContent.length) {
+                    if (!finalContent.length && !thinking.trim()) {
                         text = '[Error] Provider returned an empty response.';
                         finalContent.push({ type: 'text', text });
                     }

package/dist/core/emptyResponseRetry.d.ts

@@ -0,0 +1,16 @@
+export declare const EMPTY_RESPONSE_RETRY_DELAYS_MS: readonly [200, 800, 2000, 10000, 60000];
+/**
+ * A retry is scheduled only after an explicit provider empty-response
+ * failure. The initial failed request is not called a retry, so five retries
+ * means six consecutive explicit failures before termination.
+ */
+export declare const MAX_EMPTY_RESPONSE_RETRIES: 5;
+export declare const MAX_CONSECUTIVE_EMPTY_RESPONSES: number;
+export declare function emptyResponseRetryDelayMs(consecutiveEmptyResponses: number): number;
+export interface EmptyResponseRetryState {
+    consecutiveEmptyResponses: number;
+    retry: boolean;
+    terminate: boolean;
+}
+export declare function observeEmptyResponseOutcome(consecutiveEmptyResponses: number, emptyResponse: boolean): EmptyResponseRetryState;
+//# sourceMappingURL=emptyResponseRetry.d.ts.map

package/dist/core/emptyResponseRetry.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONSECUTIVE_EMPTY_RESPONSES = exports.MAX_EMPTY_RESPONSE_RETRIES = exports.EMPTY_RESPONSE_RETRY_DELAYS_MS = void 0;
+exports.emptyResponseRetryDelayMs = emptyResponseRetryDelayMs;
+exports.observeEmptyResponseOutcome = observeEmptyResponseOutcome;
+exports.EMPTY_RESPONSE_RETRY_DELAYS_MS = [200, 800, 2_000, 10_000, 60_000];
+/**
+ * A retry is scheduled only after an explicit provider empty-response
+ * failure. The initial failed request is not called a retry, so five retries
+ * means six consecutive explicit failures before termination.
+ */
+exports.MAX_EMPTY_RESPONSE_RETRIES = exports.EMPTY_RESPONSE_RETRY_DELAYS_MS.length;
+exports.MAX_CONSECUTIVE_EMPTY_RESPONSES = exports.MAX_EMPTY_RESPONSE_RETRIES + 1;
+function emptyResponseRetryDelayMs(consecutiveEmptyResponses) {
+    return exports.EMPTY_RESPONSE_RETRY_DELAYS_MS[Math.max(0, consecutiveEmptyResponses - 1)] ?? 0;
+}
+function observeEmptyResponseOutcome(consecutiveEmptyResponses, emptyResponse) {
+    const nextCount = emptyResponse ? consecutiveEmptyResponses + 1 : 0;
+    return {
+        consecutiveEmptyResponses: nextCount,
+        retry: emptyResponse && nextCount <= exports.MAX_EMPTY_RESPONSE_RETRIES,
+        terminate: emptyResponse && nextCount > exports.MAX_EMPTY_RESPONSE_RETRIES,
+    };
+}
+//# sourceMappingURL=emptyResponseRetry.js.map

package/dist/core/memoryLab.d.ts

@@ -35,6 +35,22 @@ export interface MemoryLabUpdateInput {
     reason?: string;
     source?: string;
 }
+export interface MemoryLabPatchInput {
+    component: string;
+    name?: string;
+    description?: string;
+    tags?: string[];
+    tagPaths?: string[][];
+    content?: string;
+    contentAppend?: string;
+    oldText?: string;
+    newText?: string;
+    replaceAll?: boolean;
+    kind?: MemoryLabComponentKind;
+    expectedUpdatedAt?: string;
+    reason?: string;
+    source?: string;
+}
 export interface MemoryLabPreparedUpdate extends MemoryLabUpdateInput {
     slug: string;
     description: string;
@@ -120,6 +136,7 @@ export declare class MemoryLabManager {
     read(componentSelector?: string): MemoryLabReadResult;
     visualizationSnapshot(): MemoryLabVisualizationResult;
     prepareUpdate(input: MemoryLabUpdateInput): MemoryLabPreparedUpdate;
+    preparePatch(input: MemoryLabPatchInput): MemoryLabPreparedUpdate;
     update(prepared: MemoryLabPreparedUpdate): MemoryLabWriteResult;
     query(input: {
         query: string;

package/dist/core/memoryLab.js

@@ -91,7 +91,8 @@ class MemoryLabManager {
             'Use memory_lab_read to inspect index.json before deciding what memory is relevant.',
             'Use memory_lab_query for bounded task-relevant retrieval; do not inject the complete index when a focused query is sufficient.',
             'Use memory_lab_read with component/name/slug to read a component core markdown file.',
-            'Use memory_lab_update only when the user asks to create or update durable memory, passing name, description, tags, optional tagPaths, content, and optional kind=file|folder.',
+            'Use memory_lab_update only when the user asks to create or update durable memory. Create with name, tags, and content; patch an existing component with component plus only changed fields.',
+            'For small body edits prefer contentAppend or oldText/newText over resending the complete content.',
             'For an existing component, pass expectedUpdatedAt from the latest read/query result. A stale update is rejected instead of overwriting newer memory.',
             'Use memory_lab_delete only when the user explicitly asks to forget/remove durable memory. Delete moves the prior revision to Memory Lab/archive and records a policy event.',
             'Every mutation should include a concise reason and source. ADD, UPDATE, and DELETE decisions are append-only in policy.jsonl and are recoverable from archive.',
@@ -206,6 +207,47 @@ class MemoryLabManager {
             source: String(input.source || '').trim(),
         };
     }
+    preparePatch(input) {
+        const selector = String(input.component || '').trim();
+        if (!selector)
+            throw new Error('Memory component is required for a patch.');
+        const current = this.read(selector);
+        if (!current.ok || !current.component)
+            throw new Error(current.error || `Memory component not found: ${selector}`);
+        const existing = current.component.meta;
+        const oldContent = current.component.content;
+        let content = input.content !== undefined ? String(input.content) : oldContent;
+        if (input.contentAppend !== undefined)
+            content = `${oldContent}${String(input.contentAppend)}`;
+        if (input.oldText !== undefined) {
+            const oldText = String(input.oldText);
+            if (!oldText)
+                throw new Error('oldText must not be empty.');
+            const matches = oldContent.split(oldText).length - 1;
+            if (!matches)
+                throw new Error('oldText was not found in the Memory Lab component.');
+            if (matches > 1 && input.replaceAll !== true)
+                throw new Error(`oldText matched ${matches} places; pass replaceAll=true or a unique fragment.`);
+            content = input.replaceAll === true
+                ? oldContent.split(oldText).join(String(input.newText || ''))
+                : oldContent.replace(oldText, String(input.newText || ''));
+        }
+        const name = input.name === undefined ? existing.name : String(input.name);
+        if (this.slugify(name) !== current.component.slug) {
+            throw new Error('Renaming a Memory Lab component is not supported by incremental patch; create the new component then delete the old one.');
+        }
+        return this.prepareUpdate({
+            name,
+            description: input.description === undefined ? existing.description : String(input.description),
+            tags: input.tags === undefined ? existing.tags : input.tags,
+            tagPaths: input.tagPaths === undefined ? existing.tagPaths : input.tagPaths,
+            content,
+            kind: input.kind === undefined ? existing.kind : input.kind,
+            expectedUpdatedAt: String(input.expectedUpdatedAt || existing.updatedAt),
+            reason: input.reason,
+            source: input.source,
+        });
+    }
     update(prepared) {
         this.ensure();
         const index = this.loadIndex();

package/dist/core/terminalOutputBuffer.d.ts

@@ -0,0 +1,24 @@
+export declare const TERMINAL_HISTORY_LIMIT: number;
+export interface TerminalOutputBufferOptions {
+    flushIntervalMs?: number;
+    historyLimit?: number;
+}
+export declare class TerminalOutputBuffer {
+    private readonly send;
+    private readonly sessions;
+    private timer;
+    private readonly flushIntervalMs;
+    private readonly historyLimit;
+    constructor(send: (sessionId: string, text: string) => void, options?: TerminalOutputBufferOptions);
+    push(sessionId: string, text: string): void;
+    flush(sessionId: string): void;
+    flushAll(): void;
+    close(sessionId: string): string;
+    history(sessionId: string): string;
+    pendingChunkCount(): number;
+    hasScheduledFlush(): boolean;
+    private bound;
+    private schedule;
+    private clearTimerWhenIdle;
+}
+//# sourceMappingURL=terminalOutputBuffer.d.ts.map

package/dist/core/terminalOutputBuffer.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalOutputBuffer = exports.TERMINAL_HISTORY_LIMIT = void 0;
+exports.TERMINAL_HISTORY_LIMIT = 256 * 1024;
+class TerminalOutputBuffer {
+    send;
+    sessions = new Map();
+    timer = null;
+    flushIntervalMs;
+    historyLimit;
+    constructor(send, options = {}) {
+        this.send = send;
+        this.flushIntervalMs = Math.max(1, options.flushIntervalMs ?? 20);
+        this.historyLimit = Math.max(1, options.historyLimit ?? exports.TERMINAL_HISTORY_LIMIT);
+    }
+    push(sessionId, text) {
+        if (!text)
+            return;
+        let state = this.sessions.get(sessionId);
+        if (!state) {
+            state = { chunks: [], length: 0, history: '' };
+            this.sessions.set(sessionId, state);
+        }
+        state.chunks.push(text);
+        state.length += text.length;
+        this.schedule();
+    }
+    flush(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state?.length)
+            return;
+        const text = state.chunks.length === 1 ? state.chunks[0] : state.chunks.join('');
+        state.chunks = [];
+        state.length = 0;
+        state.history = this.bound(`${state.history}${text}`);
+        this.send(sessionId, text);
+        this.clearTimerWhenIdle();
+    }
+    flushAll() {
+        for (const sessionId of this.sessions.keys())
+            this.flush(sessionId);
+        this.clearTimerWhenIdle(true);
+    }
+    close(sessionId) {
+        this.flush(sessionId);
+        const history = this.sessions.get(sessionId)?.history ?? '';
+        this.sessions.delete(sessionId);
+        this.clearTimerWhenIdle();
+        return history;
+    }
+    history(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state)
+            return '';
+        if (!state.length)
+            return state.history;
+        const pending = state.chunks.length === 1 ? state.chunks[0] : state.chunks.join('');
+        return this.bound(`${state.history}${pending}`);
+    }
+    pendingChunkCount() {
+        let count = 0;
+        for (const state of this.sessions.values())
+            count += state.chunks.length;
+        return count;
+    }
+    hasScheduledFlush() {
+        return this.timer !== null;
+    }
+    bound(text) {
+        return text.length > this.historyLimit ? text.slice(-this.historyLimit) : text;
+    }
+    schedule() {
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.flushAll();
+        }, this.flushIntervalMs);
+        this.timer.unref?.();
+    }
+    clearTimerWhenIdle(force = false) {
+        if (!this.timer)
+            return;
+        const hasPending = !force && Array.from(this.sessions.values()).some(state => state.length > 0);
+        if (hasPending)
+            return;
+        clearTimeout(this.timer);
+        this.timer = null;
+    }
+}
+exports.TerminalOutputBuffer = TerminalOutputBuffer;
+//# sourceMappingURL=terminalOutputBuffer.js.map

package/dist/core/toolPolicy.d.ts

@@ -25,6 +25,7 @@ export declare function toolAvailability(name: string): ToolAvailability;
 export declare function evaluateToolPolicy(request: ToolPolicyRequest): ToolPolicyDecision;
 export declare function filterToolDefinitions<T>(definitions: T[], request: Omit<ToolPolicyRequest, 'name' | 'args'>): T[];
 export declare function planModePolicyPrompt(): string;
+export declare function chatModePolicyPrompt(): string;
 export interface DeletionGuardDecision {
     blocked: boolean;
     reason?: string;

package/dist/core/toolPolicy.js

@@ -7,6 +7,7 @@ exports.toolAvailability = toolAvailability;
 exports.evaluateToolPolicy = evaluateToolPolicy;
 exports.filterToolDefinitions = filterToolDefinitions;
 exports.planModePolicyPrompt = planModePolicyPrompt;
+exports.chatModePolicyPrompt = chatModePolicyPrompt;
 exports.evaluateDeletionGuard = evaluateDeletionGuard;
 const REQUIRED_TOOLS = new Set(['pwd', 'read', 'glob', 'grep']);
 const MODE_SCOPED_TOOLS = new Set([
@@ -81,6 +82,7 @@ exports.PLAN_COMPUTER_USE_ACTIONS = ['observe', 'app_list', 'app_observe'];
 exports.PLAN_BROWSER_USE_ACTIONS = ['observe', 'navigate', 'wait', 'extract'];
 const PLAN_COMPUTER_USE_ACTION_SET = new Set(exports.PLAN_COMPUTER_USE_ACTIONS);
 const PLAN_BROWSER_USE_ACTION_SET = new Set(exports.PLAN_BROWSER_USE_ACTIONS);
+const CHAT_WEB_TOOLS = new Set(['web_search', 'web_fetch']);
 /**
  * 并发安全工具集合（DSH isConcurrencySafe 语义的 Newmark 落地）。
  *
@@ -140,6 +142,13 @@ function evaluateToolPolicy(request) {
     const base = { availability, settingsVisible: availability === 'configurable' };
     if (!name)
         return { ...base, allowed: false, reason: '[permission] Tool name is required.' };
+    if (request.mode === 'chat' && !CHAT_WEB_TOOLS.has(name)) {
+        return {
+            ...base,
+            allowed: false,
+            reason: `[permission] Chat mode only allows web_search and web_fetch. It has no workspace, host, application, memory, task, or other write access. Blocked: ${name}`,
+        };
+    }
     if (request.mode === 'plan') {
         if (name === 'computer_use') {
             const action = String(request.args?.action || '').trim();
@@ -182,6 +191,13 @@ function planModePolicyPrompt() {
         'Runtime policy rejects stale or hidden mutating tool calls even if a prompt asks for them.',
     ].join(' ');
 }
+function chatModePolicyPrompt() {
+    return [
+        'Chat mode is a narrow web-evidence mode.',
+        'Only web_search and web_fetch are available; every workspace, host, application, memory, task, browser-control, and write capability is denied at runtime.',
+        'Search the web for relevant evidence, fetch primary or authoritative sources when useful, then summarize and answer promptly instead of expanding into a long-running task.',
+    ].join(' ');
+}
 /** 删除命令动词（跨 POSIX / PowerShell / cmd）。注意：不含单独 "remove"（避免匹配普通英文）。 */
 const DELETE_VERB_SOURCE = '(?:remove-item|rmdir|unlink|erase|del|rm|rd|ri)';
 const DELETE_VERB_BOUNDARY = new RegExp(`(?:^|[\\s;&|()\\n])${DELETE_VERB_SOURCE}(?:\\s|$)`, 'i');

package/dist/core/types.d.ts

@@ -1,4 +1,4 @@
-export type AgentMode = 'build' | 'plan' | 'goal' | 'flow';
+export type AgentMode = 'build' | 'plan' | 'chat' | 'goal' | 'flow';
 export type InputMode = 'guide' | 'next';
 export type AgentStatus = 'idle' | 'working' | 'error' | 'goal_paused';
 /** Public routing identity used by renderer/main/runtime envelopes. */

package/dist/llm/provider.d.ts

@@ -96,7 +96,7 @@ export declare class LLMProvider {
      * `provider_adapters_v2` context flag. Request serialization and SSE
      * normalization are delegated to the shared provider adapters while the
      * transport orchestration (loopback node-http, fetch -> node-http fallback,
-     * 120s/30s timeouts) and the 4xx Chat -> Responses downgrade stay here.
+     * cancellation-only streaming and the 4xx Chat -> Responses downgrade) stay here.
      * The emitted request body and StreamToken stream are byte-equivalent to
      * the legacy inlined path.
      */
@@ -106,9 +106,9 @@ export declare class LLMProvider {
     private shouldDowngradeToResponses;
     /**
      * Loopback-aware transport injected into adapter `execute`. Streaming
-     * requests retain the fetch-to-node fallback for transport failures, while
-     * a local deadline is returned directly so one request cannot become a
-     * second Windows fallback request.
+     * requests retain the fetch-to-node fallback for transport failures. They
+     * have no response deadline; only caller cancellation or a concrete
+     * transport/provider failure may end the request.
      */
     private buildProviderAdapterTransport;
     private toTransportResponse;