newmark-agent 0.5.14 → 0.6.0

package/dist/providers/responses.adapter.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponsesAdapter = void 0;
 const provider_events_1 = require("./provider-events");
 const provider_headers_1 = require("./provider-headers");
+const provider_request_compat_1 = require("./provider-request-compat");
 const chat_messages_1 = require("./chat-messages");
 /**
  * OpenAI Responses adapter. Serializes a normalized request to `/responses`
@@ -80,13 +81,9 @@ class ResponsesAdapter {
             body.tool_choice = 'auto';
             body.parallel_tool_calls = true;
         }
-        const base = request.baseUrl.replace(/\/+$/, '');
         return {
-            url: `${base}/responses`,
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${request.apiKey}`,
-            },
+            url: (0, provider_request_compat_1.providerEndpoint)(request.baseUrl, '/responses'),
+            headers: (0, provider_request_compat_1.providerRequestHeaders)('openai', request.apiKey),
             body,
         };
     }
@@ -116,7 +113,7 @@ class ResponsesAdapter {
         const contentType = response.headers.get('content-type') || '';
         if (!/text\/event-stream/i.test(contentType)) {
             const json = (0, provider_events_1.normalizeResponsesPayload)(await response.json());
-            yield* this.emitNonStreaming(json);
+            yield* this.emitNonStreaming(json, response.headers);
             return;
         }
         const reader = response.body?.getReader();
@@ -125,132 +122,165 @@ class ResponsesAdapter {
             return;
         }
         const decoder = new TextDecoder();
-        let buffer = '';
+        const sse = new provider_events_1.ProviderSseDecoder();
         const calls = new Map();
+        const callAliases = new Map();
+        const resolveCall = (payload, item = {}) => {
+            const aliases = [];
+            const itemId = item.id ?? payload.item_id;
+            const callId = item.call_id ?? payload.call_id;
+            if (itemId)
+                aliases.push(`item:${itemId}`);
+            if (callId)
+                aliases.push(`call:${callId}`);
+            if (payload.output_index !== undefined)
+                aliases.push(`index:${payload.output_index}`);
+            const key = aliases.map(alias => callAliases.get(alias)).find(value => value !== undefined) ?? `call_${calls.size}`;
+            const call = calls.get(key) || { id: String(callId || itemId || ''), name: '', argumentParts: [] };
+            if (callId)
+                call.id = String(callId);
+            if (item.name || payload.name)
+                call.name = String(item.name || payload.name);
+            calls.set(key, call);
+            for (const alias of aliases)
+                callAliases.set(alias, key);
+            return call;
+        };
         const reasoningSummaries = new Map();
         let emittedContent = false;
         let completed = false;
         let streamError = '';
+        let completedResponse;
+        let emittedText = '';
         try {
-            while (true) {
+            stream: while (true) {
                 const { done, value } = await (0, provider_events_1.readProviderStreamChunk)(reader, signal);
                 if (done)
                     break;
-                buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, '\n');
-                const blocks = buffer.split(/\n\n+/);
-                buffer = blocks.pop() || '';
-                for (const block of blocks) {
-                    for (const event of (0, provider_events_1.parseProviderSse)(block + '\n\n')) {
-                        if (event.data === '[DONE]')
-                            continue;
-                        let payload;
-                        try {
-                            payload = JSON.parse(event.data);
-                        }
-                        catch {
-                            continue;
-                        }
-                        const eventType = String(event.event || payload.type || '');
-                        if (eventType === 'response.reasoning_summary_text.delta') {
-                            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 };
-                            }
-                            continue;
-                        }
-                        if (eventType === 'response.reasoning_summary_text.done') {
-                            const key = `${String(payload.item_id || '')}:${String(payload.summary_index || 0)}`;
-                            const summary = this.extractText(payload.text) || reasoningSummaries.get(key) || '';
-                            reasoningSummaries.delete(key);
-                            if (summary) {
-                                emittedContent = true;
-                                yield { type: 'reasoning.summary.done', summary };
-                            }
-                            continue;
-                        }
-                        if (eventType === 'response.output_text.delta') {
-                            const delta = this.extractText(payload.delta);
-                            if (delta) {
-                                emittedContent = true;
-                                yield { type: 'text.delta', delta };
-                            }
-                            continue;
-                        }
-                        if (eventType === 'response.output_item.added') {
-                            const item = payload.item;
-                            if (item?.type === 'function_call') {
-                                const key = String(item.id || item.call_id || calls.size);
-                                calls.set(key, {
-                                    id: String(item.call_id || item.id || key),
-                                    name: String(item.name || ''),
-                                    argumentParts: item.arguments ? [String(item.arguments)] : [],
-                                    emitted: false,
-                                });
-                            }
-                            continue;
+                for (const event of sse.push(decoder.decode(value, { stream: true }))) {
+                    if (event.data === '[DONE]')
+                        continue;
+                    let payload;
+                    try {
+                        payload = JSON.parse(event.data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const eventType = String(event.event || payload.type || '');
+                    if (eventType === 'response.reasoning_summary_text.delta') {
+                        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 };
                         }
-                        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 || ''), argumentParts: [], emitted: false };
-                            const delta = String(payload.delta || '');
-                            if (delta)
-                                call.argumentParts.push(delta);
-                            calls.set(key, call);
-                            yield { type: 'tool_call.arguments.delta', id: call.id, delta };
-                            continue;
+                        continue;
+                    }
+                    if (eventType === 'response.reasoning_summary_text.done') {
+                        const key = `${String(payload.item_id || '')}:${String(payload.summary_index || 0)}`;
+                        const summary = this.extractText(payload.text) || reasoningSummaries.get(key) || '';
+                        reasoningSummaries.delete(key);
+                        if (summary) {
+                            emittedContent = true;
+                            yield { type: 'reasoning.summary.done', summary };
                         }
-                        if (eventType === 'response.output_item.done') {
-                            const item = payload.item;
-                            if (item?.type === 'function_call') {
-                                const key = String(item.id || item.call_id || payload.output_index || '');
-                                const call = calls.get(key) || {
-                                    id: String(item.call_id || item.id || key),
-                                    name: String(item.name || ''),
-                                    argumentParts: item.arguments ? [String(item.arguments)] : [],
-                                    emitted: false,
-                                };
-                                call.id = String(item.call_id || call.id);
-                                call.name = String(item.name || call.name);
-                                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 (argumentsJson !== '{}') {
-                                        yield { type: 'tool_call.arguments.delta', id: call.id, delta: argumentsJson };
-                                    }
-                                    yield { type: 'tool_call.completed', id: call.id, name: call.name, arguments: argumentsJson };
-                                }
-                                calls.set(key, call);
-                            }
-                            continue;
+                        continue;
+                    }
+                    if (eventType === 'response.output_text.delta') {
+                        const delta = this.extractText(payload.delta);
+                        if (delta) {
+                            emittedContent = true;
+                            emittedText += delta;
+                            yield { type: 'text.delta', delta };
                         }
-                        if (eventType === 'response.completed') {
-                            completed = true;
-                            const usage = this.normalizeUsage(payload.response ?? payload);
-                            if (usage)
-                                yield { type: 'usage.updated', usage };
-                            continue;
+                        continue;
+                    }
+                    if (eventType === 'response.output_item.added') {
+                        const item = payload.item;
+                        if (item?.type === 'function_call') {
+                            const call = resolveCall(payload, item);
+                            if (item.arguments)
+                                call.argumentParts.push(String(item.arguments));
+                            call.status = String(item.status || '');
                         }
-                        if (eventType === 'response.failed' || eventType === 'response.incomplete' || eventType === 'error') {
-                            const errorPayload = payload.error || {};
-                            const responseObj = payload.response && typeof payload.response === 'object'
-                                ? payload.response.error
-                                : undefined;
-                            streamError = this.extractText(errorPayload.message)
-                                || this.extractText(responseObj?.message)
-                                || this.extractText(payload.message)
-                                || eventType;
+                        continue;
+                    }
+                    if (eventType === 'response.function_call_arguments.delta') {
+                        const call = resolveCall(payload);
+                        const delta = String(payload.delta || '');
+                        if (delta)
+                            call.argumentParts.push(delta);
+                        yield { type: 'tool_call.arguments.delta', id: call.id, delta };
+                        continue;
+                    }
+                    if (eventType === 'response.function_call_arguments.done') {
+                        const call = resolveCall(payload);
+                        if (payload.name)
+                            call.name = String(payload.name);
+                        if (typeof payload.arguments === 'string')
+                            call.finalArguments = payload.arguments;
+                        continue;
+                    }
+                    if (eventType === 'response.output_item.done') {
+                        const item = payload.item;
+                        if (item?.type === 'function_call') {
+                            const call = resolveCall(payload, item);
+                            call.id = String(item.call_id || call.id);
+                            call.name = String(item.name || call.name);
+                            if (typeof item.arguments === 'string')
+                                call.finalArguments = item.arguments;
+                            call.status = String(item.status || '');
                         }
+                        continue;
                     }
+                    if (eventType === 'response.completed') {
+                        completedResponse = (0, provider_events_1.normalizeResponsesPayload)(payload.response ?? payload);
+                        streamError = this.completionError(completedResponse, response.headers);
+                        completed = !streamError;
+                        const usage = this.normalizeUsage(completedResponse);
+                        if (usage)
+                            yield { type: 'usage.updated', usage };
+                        break stream;
+                    }
+                    if (eventType === 'response.failed' || eventType === 'response.incomplete' || eventType === 'error') {
+                        const usage = this.normalizeUsage(payload.response ?? payload);
+                        if (usage)
+                            yield { type: 'usage.updated', usage };
+                        const errorPayload = payload.error || {};
+                        const responseObj = payload.response && typeof payload.response === 'object'
+                            ? payload.response.error
+                            : undefined;
+                        streamError = (0, provider_events_1.providerSemanticErrorText)(payload.error || responseObj || payload, this.extractText(errorPayload.message)
+                            || this.extractText(responseObj?.message)
+                            || this.extractText(payload.message)
+                            || eventType, response.headers);
+                        break stream;
+                    }
+                }
+            }
+            if (completedResponse && completed) {
+                const snapshotText = this.extractResponsesText(completedResponse);
+                if (snapshotText && snapshotText.startsWith(emittedText) && snapshotText.length > emittedText.length) {
+                    yield { type: 'text.delta', delta: snapshotText.slice(emittedText.length) };
+                    emittedText = snapshotText;
+                    emittedContent = true;
+                }
+                for (const raw of Array.isArray(completedResponse.output) ? completedResponse.output : []) {
+                    const item = raw;
+                    if (item.type !== 'function_call')
+                        continue;
+                    const call = resolveCall({}, item);
+                    call.id = String(item.call_id || call.id);
+                    call.name = String(item.name || call.name);
+                    if (typeof item.arguments === 'string')
+                        call.finalArguments = item.arguments;
+                    call.status = String(item.status || '');
                 }
             }
             if (streamError) {
-                yield { type: 'response.failed', error: `[LLM Error] ${streamError}` };
+                yield { type: 'response.failed', error: streamError.startsWith('[LLM Error]') ? streamError : `[LLM Error] ${streamError}` };
             }
             else if (!completed) {
                 yield { type: 'response.failed', error: '[LLM Error] Responses stream ended before response.completed.' };
@@ -262,21 +292,30 @@ class ResponsesAdapter {
                 // 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);
+                const completeCalls = [...calls.values()].map(call => ({ ...call,
+                    argumentsJson: call.finalArguments ?? (0, provider_events_1.assembleCompatibleToolArguments)(call.argumentParts, true) }));
+                if (completeCalls.some(call => !call.id || !call.name || call.status === 'incomplete' || !this.validToolArguments(call.argumentsJson))) {
+                    yield { type: 'response.failed', error: '[LLM Error] Provider returned incomplete or invalid tool-call arguments.' };
+                    return;
+                }
+                for (const call of completeCalls) {
                     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: 'tool_call.completed', id: call.id, name: call.name, arguments: call.argumentsJson };
                 }
                 yield { type: 'response.completed' };
             }
         }
         finally {
+            // Completion and consumer return are terminal even if a gateway keeps
+            // the HTTP body open. Release the socket as well as the reader lock.
+            try {
+                await reader.cancel();
+            }
+            catch { }
             reader.releaseLock();
         }
     }
-    async *emitNonStreaming(json) {
+    async *emitNonStreaming(json, headers) {
         const usage = this.normalizeUsage(json.usage ?? json.response ?? json);
         if (usage)
             yield { type: 'usage.updated', usage };
@@ -289,15 +328,25 @@ class ResponsesAdapter {
             emitted = true;
             yield { type: 'text.delta', delta: text };
         }
-        for (const itemRaw of Array.isArray(json.output) ? json.output : []) {
+        const error = this.completionError(json, headers);
+        if (error) {
+            yield { type: 'response.failed', error };
+            return;
+        }
+        const completeCalls = (Array.isArray(json.output) ? json.output : []).filter(item => item?.type === 'function_call').map(itemRaw => {
             const item = itemRaw;
-            if (item.type !== 'function_call')
-                continue;
-            emitted = true;
             const id = String(item.call_id || item.id || '');
             const name = String(item.name || '');
+            const args = typeof item.arguments === 'string' ? item.arguments : item.arguments ? JSON.stringify(item.arguments) : '';
+            return { id, name, args, status: String(item.status || '') };
+        });
+        if (completeCalls.some(call => !call.id || !call.name || call.status === 'incomplete' || !this.validToolArguments(call.args))) {
+            yield { type: 'response.failed', error: '[LLM Error] Provider returned incomplete or invalid tool-call arguments.' };
+            return;
+        }
+        for (const { id, name, args } of completeCalls) {
+            emitted = true;
             yield { type: 'tool_call.started', id, name };
-            const args = typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments || {});
             if (args && args !== '{}')
                 yield { type: 'tool_call.arguments.delta', id, delta: args };
             yield { type: 'tool_call.completed', id, name, arguments: args };
@@ -311,6 +360,23 @@ class ResponsesAdapter {
     normalizeUsage(value) {
         return (0, provider_events_1.normalizeProviderUsage)(value);
     }
+    completionError(json, headers) {
+        const status = String(json.status || '');
+        if (!json.error && (!status || status === 'completed'))
+            return '';
+        const error = json.error && typeof json.error === 'object' ? json.error : {};
+        const incomplete = json.incomplete_details && typeof json.incomplete_details === 'object' ? json.incomplete_details : {};
+        return (0, provider_events_1.providerSemanticErrorText)(error, this.extractText(error.message || json.error) || `Responses response was ${status || 'unsuccessful'}${incomplete.reason ? ': ' + String(incomplete.reason) : '.'}`, headers);
+    }
+    validToolArguments(value) {
+        try {
+            const parsed = JSON.parse(value);
+            return !!parsed && typeof parsed === 'object' && !Array.isArray(parsed);
+        }
+        catch {
+            return false;
+        }
+    }
     normalizeHeaders(headers) {
         return (0, provider_headers_1.normalizeProviderHeaders)(headers);
     }

package/dist/server.d.ts

@@ -1,5 +1,6 @@
 import { Agent, AgentWorkEvent } from './core/agent';
 import { AutomationManager } from './core/automation';
+import type { AgentPromptMessage } from './core/conversationKernel';
 export interface HostedMobileServerOptions {
     agent?: Agent;
     automation?: AutomationManager | null;
@@ -11,20 +12,26 @@ export interface HostedMobileServerOptions {
     conversationUiState?: (target: {
         workspaceId: string;
         conversationId: string;
+    }, options?: {
+        window?: number;
+        before?: number;
     }) => Promise<Record<string, unknown>>;
     /** Mutate Goal/Flow state owned by the GUI runtime pool for one exact target. */
     conversationUiAction?: (target: {
         workspaceId: string;
         conversationId: string;
-    }, action: 'goal_update' | 'goal_guide' | 'conversation_guide' | 'goal_toggle_pause' | 'goal_clear' | 'flow_pause' | 'flow_resume' | 'flow_guide' | 'conversation_stop' | 'input_mode' | 'queue_enqueue' | 'queue_update' | 'queue_delete' | 'queue_reorder' | 'queue_toggle_pause' | 'queue_guide', value?: string, input?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    }, action: 'goal_update' | 'goal_guide' | 'conversation_guide' | 'goal_toggle_pause' | 'goal_clear' | 'flow_pause' | 'flow_resume' | 'flow_guide' | 'conversation_stop' | 'mode' | 'input_mode' | 'queue_enqueue' | 'queue_update' | 'queue_delete' | 'queue_reorder' | 'queue_toggle_pause' | 'queue_set_pause' | 'queue_guide' | 'conversation_branch_inspect' | 'conversation_branch_activate' | 'conversation_branch_create' | 'conversation_archive', value?: string, input?: Record<string, unknown>) => Promise<Record<string, unknown>>;
     /** Send through the same GUI runtime pool used by the desktop renderer. */
     conversationPrompt?: (target: {
         workspaceId: string;
         conversationId: string;
-    }, message: string, options?: {
+    }, message: string | AgentPromptMessage, options?: {
         requestedMode?: string;
         goalObjective?: string;
         inputMode?: string;
+        clientMessageId?: string;
+        flowName?: string;
+        flowStart?: number;
     }) => Promise<Record<string, unknown>>;
 }
 export interface HostedMobileServerStatus {