newmark-agent 0.5.7 → 0.5.8

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/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;

package/dist/llm/provider.js

@@ -43,9 +43,6 @@ const child_process_1 = require("child_process");
 const agentKernelDiagnostics_1 = require("../core/agentKernelDiagnostics");
 const chat_messages_1 = require("../providers/chat-messages");
 const providers_1 = require("../providers");
-// Keep provider requests below the release-harness/user-visible command
-// deadline. A provider that does not answer must produce one bounded error;
-// it must not restart the same request through every Windows transport.
 // Provider responses are intentionally unbounded. User cancellation, transport
 // errors, and tool-specific limits remain the only automatic stop conditions.
 const DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 0;
@@ -939,7 +936,7 @@ 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.
      */
@@ -1082,9 +1079,9 @@ class LLMProvider {
     }
     /**
      * 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.
      */
     buildProviderAdapterTransport() {
         return async (request, signal) => {
@@ -1096,7 +1093,9 @@ class LLMProvider {
                     forwardAbort();
                 else
                     signal?.addEventListener('abort', forwardAbort, { once: true });
-                const effectiveTimeout = this.effectiveRequestTimeout(120000);
+                // Streaming provider responses are intentionally unbounded. Only
+                // caller cancellation or an explicit provider failure may end them.
+                const effectiveTimeout = 0;
                 const timer = effectiveTimeout > 0
                     ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout)
                     : undefined;
@@ -1247,7 +1246,9 @@ class LLMProvider {
             forwardAbort();
         else
             signal?.addEventListener('abort', forwardAbort, { once: true });
-        const effectiveTimeout = this.effectiveRequestTimeout(120000);
+        // Streaming provider responses are intentionally unbounded. Do not turn
+        // silence into an empty-response failure.
+        const effectiveTimeout = 0;
         const timeout = effectiveTimeout > 0
             ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout)
             : undefined;
@@ -1285,10 +1286,14 @@ class LLMProvider {
             }
             const decoder = new TextDecoder();
             let buffer = '';
-            let currentToolCall = null;
+            const toolCalls = new Map();
+            const toolCallOrder = [];
+            let syntheticToolIndex = 0;
+            let lastToolIndex = 0;
             let currentReasoningContent = '';
             let contentPolicyBlocked = false;
             let emittedContent = false;
+            let explicitCompletion = false;
             const streamSignal = signal || new AbortController().signal;
             while (true) {
                 const { done, value } = await (0, providers_1.readProviderStreamChunk)(reader, streamSignal);
@@ -1302,8 +1307,10 @@ class LLMProvider {
                     if (!trimmed.startsWith('data: '))
                         continue;
                     const data = trimmed.slice(6);
-                    if (data === '[DONE]')
+                    if (data === '[DONE]') {
+                        explicitCompletion = true;
                         continue;
+                    }
                     try {
                         const json = JSON.parse(data);
                         if (json.usage)
@@ -1324,27 +1331,54 @@ class LLMProvider {
                         }
                         if (delta.tool_calls) {
                             for (const tc of delta.tool_calls) {
-                                if (tc.id) {
-                                    if (currentToolCall) {
-                                        yield { type: 'tool_call', text: '', toolCall: currentToolCall, reasoningContent: currentReasoningContent || undefined };
-                                    }
-                                    currentToolCall = { id: tc.id, name: tc.function?.name || '', arguments: tc.function?.arguments || '' };
-                                }
-                                else if (tc.function?.arguments && currentToolCall) {
-                                    currentToolCall.arguments += tc.function.arguments;
+                                const rawIndex = Number(tc.index);
+                                const index = Number.isInteger(rawIndex) && rawIndex >= 0
+                                    ? rawIndex
+                                    : (tc.id ? syntheticToolIndex++ : lastToolIndex);
+                                lastToolIndex = index;
+                                let call = toolCalls.get(index);
+                                if (!call && (tc.id || tc.function?.name)) {
+                                    call = { id: tc.id || '', name: tc.function?.name || '', argumentParts: [] };
+                                    toolCalls.set(index, call);
+                                    toolCallOrder.push(index);
                                 }
+                                if (!call)
+                                    continue;
+                                if (tc.id && !call.id)
+                                    call.id = tc.id;
+                                if (tc.function?.name && !call.name)
+                                    call.name = tc.function.name;
+                                if (tc.function?.arguments)
+                                    call.argumentParts.push(tc.function.arguments);
                             }
                         }
                     }
                     catch { /* skip malformed JSON */ }
                 }
             }
-            if (currentToolCall && currentToolCall.arguments) {
-                yield { type: 'tool_call', text: '', toolCall: currentToolCall, reasoningContent: currentReasoningContent || undefined };
+            if (toolCallOrder.length) {
+                for (const index of toolCallOrder) {
+                    const call = toolCalls.get(index);
+                    if (!call)
+                        continue;
+                    yield {
+                        type: 'tool_call',
+                        text: '',
+                        toolCall: {
+                            id: call.id,
+                            name: call.name,
+                            arguments: (0, providers_1.assembleCompatibleToolArguments)(call.argumentParts),
+                        },
+                        reasoningContent: currentReasoningContent || undefined,
+                    };
+                }
             }
             else if (!emittedContent && contentPolicyBlocked) {
                 yield { type: 'text', text: '[Error] Content policy refusal (content_filter).' };
             }
+            else if (!explicitCompletion && !emittedContent && !currentReasoningContent) {
+                yield { type: 'text', text: '[LLM Error] GitHub Models stream ended before an explicit completion.' };
+            }
         }
         finally {
             reader?.releaseLock();

package/dist/main.js

@@ -77,6 +77,7 @@ const compat_1 = require("./core/compat");
 const dshCompatibility_1 = require("./core/dshCompatibility");
 const mcpManager_1 = require("./core/mcpManager");
 const workEventCoalescer_1 = require("./core/workEventCoalescer");
+const terminalOutputBuffer_1 = require("./core/terminalOutputBuffer");
 const cli_help_1 = require("./cli-help");
 const APP_NAME = 'Newmark Agent';
 const APP_ID = 'ai.newmark.agent';
@@ -4451,10 +4452,16 @@ else {
                 }
             });
             const ptySessions = new Map();
-            const sendTerminalData = (sessionId, session, text) => {
-                session.buffer = `${session.buffer}${text}`.slice(-256 * 1024);
+            const terminalOutput = new terminalOutputBuffer_1.TerminalOutputBuffer((sessionId, text) => {
+                const session = ptySessions.get(sessionId);
+                if (session)
+                    session.buffer = terminalOutput.history(sessionId);
                 if (mainWindow && !mainWindow.isDestroyed())
                     mainWindow.webContents.send('pty:data', sessionId, text);
+            });
+            const sendTerminalData = (sessionId, session, text) => {
+                terminalOutput.push(sessionId, text);
+                session.buffer = terminalOutput.history(sessionId);
             };
             electron_1.ipcMain.handle('pty:spawn', async (_event, shellId) => {
                 const sessionId = (0, crypto_1.randomUUID)().slice(0, 8);
@@ -4476,7 +4483,9 @@ else {
                 ptySessions.set(sessionId, session);
                 proc.onData(text => sendTerminalData(sessionId, session, text));
                 proc.onExit(event => {
+                    terminalOutput.flush(sessionId);
                     ptySessions.delete(sessionId);
+                    terminalOutput.close(sessionId);
                     if (mainWindow && !mainWindow.isDestroyed()) {
                         mainWindow.webContents.send('pty:exit', sessionId, event.exitCode);
                     }
@@ -4534,7 +4543,7 @@ else {
                 const session = ptySessions.get(sessionId);
                 if (!session)
                     return { buffer: '' };
-                return { buffer: session.buffer };
+                return { buffer: terminalOutput.history(sessionId) || session.buffer };
             });
             const terminalOwnerFor = (conversationId, actorId) => (0, terminalTakeover_1.normalizeTerminalTakeoverOwner)({
                 backend: wslBackendEnabled() ? 'wsl' : (process.platform === 'win32' ? 'windows' : process.platform),

package/dist/providers/chat-completions.adapter.js

@@ -105,6 +105,8 @@ class ChatCompletionsAdapter {
         let contentPolicyBlocked = false;
         let emittedContent = false;
         let emittedTool = false;
+        let emittedReasoning = false;
+        let explicitCompletion = false;
         try {
             while (true) {
                 const { done, value } = await (0, provider_events_1.readProviderStreamChunk)(reader, signal);
@@ -118,8 +120,10 @@ class ChatCompletionsAdapter {
                     if (!trimmed.startsWith('data: '))
                         continue;
                     const data = trimmed.slice(6);
-                    if (data === '[DONE]')
+                    if (data === '[DONE]') {
+                        explicitCompletion = true;
                         continue;
+                    }
                     let json;
                     try {
                         json = JSON.parse(data);
@@ -135,13 +139,18 @@ class ChatCompletionsAdapter {
                     if ((0, provider_events_1.isContentPolicyBlocked)(json))
                         contentPolicyBlocked = true;
                     const choices = Array.isArray(json.choices) ? json.choices : [];
-                    const delta = choices[0]?.delta;
+                    const choice = choices[0];
+                    if (choice?.finish_reason !== undefined && choice.finish_reason !== null)
+                        explicitCompletion = true;
+                    const delta = choice?.delta;
                     if (!delta)
                         continue;
                     if (delta.reasoning_content) {
                         const reasoning = this.extractText(delta.reasoning_content);
-                        if (reasoning)
+                        if (reasoning) {
+                            emittedReasoning = true;
                             yield { type: 'reasoning.summary.delta', delta: reasoning };
+                        }
                     }
                     const textDelta = this.extractText(delta.content);
                     if (textDelta) {
@@ -190,7 +199,7 @@ class ChatCompletionsAdapter {
                         type: 'tool_call.completed',
                         id: currentToolCall.id,
                         name: currentToolCall.name,
-                        arguments: currentToolCall.argumentParts.join(''),
+                        arguments: (0, provider_events_1.assembleCompatibleToolArguments)(currentToolCall.argumentParts),
                     };
                 }
             }
@@ -198,6 +207,10 @@ class ChatCompletionsAdapter {
                 yield { type: 'response.failed', error: '[Error] Content policy refusal (content_filter).' };
                 return;
             }
+            if (!explicitCompletion && !emittedContent && !emittedTool && !emittedReasoning) {
+                yield { type: 'response.failed', error: '[LLM Error] Chat stream ended before an explicit completion.' };
+                return;
+            }
             yield { type: 'response.completed' };
         }
         finally {

package/dist/providers/provider-events.d.ts

@@ -29,6 +29,13 @@ export declare function parseProviderSse(raw: string): Array<{
     event?: string;
     data: string;
 }>;
+/**
+ * Compatible gateways may stream function arguments as JSON deltas or repeat
+ * a cumulative snapshot on every SSE frame. Keep the normal incremental form
+ * when it parses, then fall back to snapshot folding. Returning malformed
+ * concatenated snapshots would erase the model's correction at tool parsing.
+ */
+export declare function assembleCompatibleToolArguments(parts: string[]): string;
 /**
  * Detect content-policy refusals across the provider failure shapes.
  * Mirrors `LLMProvider.contentPolicyBlocked` semantics exactly so the

package/dist/providers/provider-events.js

@@ -5,6 +5,7 @@ exports.providerAbortError = providerAbortError;
 exports.providerStreamTimeoutError = providerStreamTimeoutError;
 exports.readProviderStreamChunk = readProviderStreamChunk;
 exports.parseProviderSse = parseProviderSse;
+exports.assembleCompatibleToolArguments = assembleCompatibleToolArguments;
 exports.isContentPolicyBlocked = isContentPolicyBlocked;
 exports.normalizeProviderUsage = normalizeProviderUsage;
 exports.estimateRequestTokens = estimateRequestTokens;
@@ -105,6 +106,45 @@ function parseProviderSse(raw) {
     }
     return events;
 }
+/**
+ * Compatible gateways may stream function arguments as JSON deltas or repeat
+ * a cumulative snapshot on every SSE frame. Keep the normal incremental form
+ * when it parses, then fall back to snapshot folding. Returning malformed
+ * concatenated snapshots would erase the model's correction at tool parsing.
+ */
+function assembleCompatibleToolArguments(parts) {
+    const nonEmpty = (parts || []).map(String).filter(part => part && part !== 'null');
+    if (!nonEmpty.length)
+        return '{}';
+    const isJsonObject = (value) => {
+        try {
+            const parsed = JSON.parse(value);
+            return !!parsed && typeof parsed === 'object' && !Array.isArray(parsed);
+        }
+        catch {
+            return false;
+        }
+    };
+    const incremental = nonEmpty.join('');
+    if (isJsonObject(incremental))
+        return incremental;
+    let compatible = '';
+    for (const incoming of nonEmpty) {
+        if (!compatible)
+            compatible = incoming;
+        else if (incoming === compatible)
+            continue;
+        else if (incoming.startsWith(compatible))
+            compatible = incoming;
+        else if (compatible.startsWith(incoming))
+            continue;
+        else
+            compatible += incoming;
+    }
+    if (isJsonObject(compatible))
+        return compatible;
+    return [...nonEmpty].reverse().find(isJsonObject) || compatible;
+}
 /**
  * Detect content-policy refusals across the provider failure shapes.
  * Mirrors `LLMProvider.contentPolicyBlocked` semantics exactly so the

package/dist/providers/responses.adapter.js

@@ -155,6 +155,7 @@ class ResponsesAdapter {
                             const key = `${String(payload.item_id || '')}:${String(payload.summary_index || 0)}`;
                             const delta = this.extractText(payload.delta);
                             if (delta) {
+                                emittedContent = true;
                                 reasoningSummaries.set(key, (reasoningSummaries.get(key) || '') + delta);
                                 yield { type: 'reasoning.summary.delta', delta };
                             }
@@ -185,7 +186,7 @@ class ResponsesAdapter {
                                 calls.set(key, {
                                     id: String(item.call_id || item.id || key),
                                     name: String(item.name || ''),
-                                    arguments: String(item.arguments || ''),
+                                    argumentParts: item.arguments ? [String(item.arguments)] : [],
                                     emitted: false,
                                 });
                             }
@@ -193,9 +194,10 @@ class ResponsesAdapter {
                         }
                         if (eventType === 'response.function_call_arguments.delta') {
                             const key = String(payload.item_id || payload.call_id || payload.output_index || '');
-                            const call = calls.get(key) || { id: String(payload.call_id || key), name: String(payload.name || ''), arguments: '', emitted: false };
+                            const call = calls.get(key) || { id: String(payload.call_id || key), name: String(payload.name || ''), argumentParts: [], emitted: false };
                             const delta = String(payload.delta || '');
-                            call.arguments += delta;
+                            if (delta)
+                                call.argumentParts.push(delta);
                             calls.set(key, call);
                             yield { type: 'tool_call.arguments.delta', id: call.id, delta };
                             continue;
@@ -207,19 +209,21 @@ class ResponsesAdapter {
                                 const call = calls.get(key) || {
                                     id: String(item.call_id || item.id || key),
                                     name: String(item.name || ''),
-                                    arguments: String(item.arguments || ''),
+                                    argumentParts: item.arguments ? [String(item.arguments)] : [],
                                     emitted: false,
                                 };
                                 call.id = String(item.call_id || call.id);
                                 call.name = String(item.name || call.name);
-                                call.arguments = typeof item.arguments === 'string' ? item.arguments : call.arguments;
+                                if (typeof item.arguments === 'string' && item.arguments)
+                                    call.argumentParts.push(item.arguments);
                                 if (!call.emitted) {
                                     call.emitted = true;
+                                    const argumentsJson = (0, provider_events_1.assembleCompatibleToolArguments)(call.argumentParts);
                                     yield { type: 'tool_call.started', id: call.id, name: call.name };
-                                    if (call.arguments && call.arguments !== '{}') {
-                                        yield { type: 'tool_call.arguments.delta', id: call.id, delta: call.arguments };
+                                    if (argumentsJson !== '{}') {
+                                        yield { type: 'tool_call.arguments.delta', id: call.id, delta: argumentsJson };
                                     }
-                                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: call.arguments };
+                                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: argumentsJson };
                                 }
                                 calls.set(key, call);
                             }
@@ -252,9 +256,19 @@ class ResponsesAdapter {
                 yield { type: 'response.failed', error: '[LLM Error] Responses stream ended before response.completed.' };
             }
             else if (!emittedContent && calls.size === 0) {
-                yield { type: 'response.failed', error: '[Error] Empty Responses stream.' };
+                yield { type: 'response.failed', error: '[Error] Provider returned an empty response.' };
             }
             else {
+                // Some compatible Responses providers omit output_item.done but still
+                // complete the response. Preserve that valid tool activity and fold
+                // cumulative argument snapshots before handing it to the kernel.
+                for (const call of calls.values()) {
+                    if (call.emitted)
+                        continue;
+                    const argumentsJson = (0, provider_events_1.assembleCompatibleToolArguments)(call.argumentParts);
+                    yield { type: 'tool_call.started', id: call.id, name: call.name };
+                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: argumentsJson };
+                }
                 yield { type: 'response.completed' };
             }
         }