@yeaft/webchat-agent 0.1.463 → 0.1.464

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.463",
+  "version": "0.1.464",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/llm/openai-responses.js

@@ -0,0 +1,438 @@
+/**
+ * openai-responses.js — OpenAI Responses API adapter (/v1/responses)
+ *
+ * Next-gen OpenAI API recommended for GPT-5+. Differences from Chat Completions:
+ *   - Endpoint: /v1/responses instead of /v1/chat/completions
+ *   - Input: `input[]` array of typed items (message / function_call / function_call_output)
+ *     instead of `messages[]` with role/content
+ *   - System prompt: passed as `instructions` field (not as a message)
+ *   - Content parts: `input_text` / `input_image` (image_url string) / `output_text`
+ *   - Tool definitions: flat `{type:"function", name, description, parameters}`
+ *     (no nested `function` object)
+ *   - Tool call id: uses `call_id` (separate from the internal item `id`)
+ *   - Stream: semantic SSE events
+ *     - response.created
+ *     - response.output_item.added
+ *     - response.output_text.delta
+ *     - response.function_call_arguments.delta / .done
+ *     - response.completed  (contains final response.usage)
+ *     - response.incomplete (e.g. max_output_tokens)
+ *     - response.error
+ *   - Usage: only in terminal completed/incomplete events
+ *
+ * Id contract (agreed with PM):
+ *   - Responses `function_call.call_id` ← → internal UnifiedToolCall.id (direct passthrough)
+ *   - tool_result.toolCallId ← → function_call_output.call_id (direct passthrough)
+ */
+
+import {
+  LLMAdapter,
+  LLMRateLimitError,
+  LLMAuthError,
+  LLMContextError,
+  LLMServerError,
+  LLMAbortError,
+} from './adapter.js';
+
+const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
+
+export class OpenAIResponsesAdapter extends LLMAdapter {
+  #apiKey;
+  #baseUrl;
+
+  /**
+   * @param {{ apiKey: string, baseUrl?: string }} config
+   */
+  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL }) {
+    super({ apiKey, baseUrl });
+    this.#apiKey = apiKey;
+    this.#baseUrl = (baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+  }
+
+  /** Expose baseUrl for testing. */
+  get baseUrl() { return this.#baseUrl; }
+
+  // ─── Request translation ────────────────────────────────
+
+  /**
+   * Translate unified tool defs → Responses API tool format (flat).
+   * @param {import('./adapter.js').UnifiedToolDef[]} tools
+   */
+  #translateTools(tools) {
+    if (!tools || tools.length === 0) return undefined;
+    return tools.map(t => ({
+      type: 'function',
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+    }));
+  }
+
+  /**
+   * Translate a user message's content into Responses API content parts.
+   * Accepts either a string or an array of parts (text / image).
+   */
+  #translateUserContent(content) {
+    if (typeof content === 'string') {
+      return [{ type: 'input_text', text: content }];
+    }
+    if (Array.isArray(content)) {
+      return content.map(part => {
+        if (!part || typeof part !== 'object') {
+          return { type: 'input_text', text: String(part ?? '') };
+        }
+        if (part.type === 'text') {
+          return { type: 'input_text', text: part.text || '' };
+        }
+        if (part.type === 'image') {
+          // part.source may be { url } or { data, mediaType } (base64)
+          const src = part.source || {};
+          let imageUrl;
+          if (src.url) {
+            imageUrl = src.url;
+          } else if (src.data) {
+            const mt = src.mediaType || 'image/png';
+            imageUrl = `data:${mt};base64,${src.data}`;
+          } else {
+            imageUrl = '';
+          }
+          return { type: 'input_image', image_url: imageUrl };
+        }
+        // Passthrough for already-shaped parts
+        if (part.type === 'input_text' || part.type === 'input_image') return part;
+        return { type: 'input_text', text: String(part.text || '') };
+      });
+    }
+    return [{ type: 'input_text', text: String(content ?? '') }];
+  }
+
+  /**
+   * Translate UnifiedMessage[] → Responses API `input[]` array.
+   *
+   * Message → { type:'message', role, content: parts[] }
+   * Assistant tool_calls → separate { type:'function_call', call_id, name, arguments } items
+   * Tool message → { type:'function_call_output', call_id, output }
+   */
+  #translateInput(messages) {
+    const input = [];
+    for (const msg of messages) {
+      if (msg.role === 'system') {
+        // System is handled as `instructions` at the top-level; skip here.
+        continue;
+      }
+      if (msg.role === 'user') {
+        input.push({
+          type: 'message',
+          role: 'user',
+          content: this.#translateUserContent(msg.content),
+        });
+      } else if (msg.role === 'assistant') {
+        // Emit a message item if there is text content
+        if (msg.content && typeof msg.content === 'string' && msg.content.trim()) {
+          input.push({
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: msg.content }],
+          });
+        }
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+          for (const tc of msg.toolCalls) {
+            input.push({
+              type: 'function_call',
+              call_id: tc.id,
+              name: tc.name,
+              arguments: JSON.stringify(tc.input ?? {}),
+            });
+          }
+        }
+      } else if (msg.role === 'tool') {
+        input.push({
+          type: 'function_call_output',
+          call_id: msg.toolCallId,
+          output: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+        });
+      }
+    }
+    return input;
+  }
+
+  // ─── Error classification ───────────────────────────────
+
+  #classifyError(status, body) {
+    if (status === 401 || status === 403) {
+      return new LLMAuthError(`Auth error: ${body}`, status);
+    }
+    if (status === 429) {
+      return new LLMRateLimitError(`Rate limit: ${body}`, status);
+    }
+    if (status === 529) {
+      return new LLMRateLimitError(`Overloaded: ${body}`, status);
+    }
+    if (status === 413 || body.includes('context_length_exceeded') || body.includes('maximum context length')) {
+      return new LLMContextError(`Context too long: ${body}`);
+    }
+    if (status >= 500) {
+      return new LLMServerError(`Server error: ${body}`, status);
+    }
+    return new Error(`API error ${status}: ${body}`);
+  }
+
+  // ─── Stop reason mapping ────────────────────────────────
+
+  /**
+   * Map a terminal response object to a unified stop reason.
+   * @param {object} response — response.completed or response.incomplete payload
+   * @param {boolean} sawToolCall
+   */
+  #mapStopReason(response, sawToolCall) {
+    if (response?.status === 'incomplete') {
+      const r = response.incomplete_details?.reason;
+      if (r === 'max_output_tokens') return 'max_tokens';
+      return 'end_turn';
+    }
+    if (sawToolCall) return 'tool_use';
+    // Inspect the final output: if the last item is a function_call, it's tool_use
+    const out = Array.isArray(response?.output) ? response.output : [];
+    if (out.some(item => item?.type === 'function_call')) return 'tool_use';
+    return 'end_turn';
+  }
+
+  // ─── Streaming ──────────────────────────────────────────
+
+  /**
+   * @param {{ model: string, system: string, messages: import('./adapter.js').UnifiedMessage[], tools?: import('./adapter.js').UnifiedToolDef[], maxTokens?: number, extraBody?: object, signal?: AbortSignal }} params
+   */
+  async *stream({ model, system, messages, tools, maxTokens = 16384, extraBody, signal }) {
+    if (signal?.aborted) throw new LLMAbortError();
+
+    const body = {
+      model,
+      input: this.#translateInput(messages),
+      stream: true,
+      max_output_tokens: maxTokens,
+    };
+    if (system) body.instructions = system;
+    const translatedTools = this.#translateTools(tools);
+    if (translatedTools) body.tools = translatedTools;
+    if (extraBody) Object.assign(body, extraBody);
+
+    let response;
+    try {
+      response = await fetch(`${this.#baseUrl}/responses`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.#apiKey}`,
+        },
+        body: JSON.stringify(body),
+        signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') throw new LLMAbortError();
+      throw err;
+    }
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw this.#classifyError(response.status, errorBody);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    /** Accumulate tool call arguments by output_index.
+     *  Value: { callId, name, arguments } */
+    const toolCallAccum = new Map();
+    /** call_ids already emitted as tool_call events (to avoid duplicating on completed fallback). */
+    const emittedToolCallIds = new Set();
+    let sawToolCall = false;
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+
+        // SSE events are separated by blank lines; split on \n
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const rawLine of lines) {
+          const line = rawLine.trimEnd();
+          if (!line.startsWith('data:')) continue;
+          const data = line.slice(5).trim();
+          if (!data || data === '[DONE]') continue;
+
+          let event;
+          try {
+            event = JSON.parse(data);
+          } catch {
+            continue;
+          }
+
+          const type = event.type;
+
+          if (type === 'response.output_item.added') {
+            const item = event.item;
+            const idx = event.output_index;
+            if (item?.type === 'function_call') {
+              toolCallAccum.set(idx, {
+                callId: item.call_id || item.id || '',
+                name: item.name || '',
+                arguments: '',
+              });
+            }
+          } else if (type === 'response.output_text.delta') {
+            if (typeof event.delta === 'string' && event.delta.length > 0) {
+              yield { type: 'text_delta', text: event.delta };
+            }
+          } else if (type === 'response.function_call_arguments.delta') {
+            const idx = event.output_index;
+            const accum = toolCallAccum.get(idx);
+            if (accum) {
+              accum.arguments += event.delta || '';
+            }
+          } else if (type === 'response.function_call_arguments.done') {
+            const idx = event.output_index;
+            const accum = toolCallAccum.get(idx);
+            if (accum) {
+              // Prefer the .done event's authoritative arguments string if present
+              const argsStr = typeof event.arguments === 'string' ? event.arguments : accum.arguments;
+              let parsed = {};
+              try {
+                parsed = argsStr ? JSON.parse(argsStr) : {};
+              } catch {
+                parsed = {};
+              }
+              if (accum.callId && !emittedToolCallIds.has(accum.callId)) {
+                emittedToolCallIds.add(accum.callId);
+                sawToolCall = true;
+                yield {
+                  type: 'tool_call',
+                  id: accum.callId,
+                  name: accum.name,
+                  input: parsed,
+                };
+              }
+              toolCallAccum.delete(idx);
+            }
+          } else if (type === 'response.completed' || type === 'response.incomplete') {
+            const respObj = event.response || {};
+
+            // Fallback: flush any function_call items in the final output that we
+            // didn't see a .done event for (defensive against partial streams).
+            const outputArr = Array.isArray(respObj.output) ? respObj.output : [];
+            for (const item of outputArr) {
+              if (item?.type !== 'function_call') continue;
+              const cid = item.call_id || item.id || '';
+              if (!cid || emittedToolCallIds.has(cid)) continue;
+              let parsed = {};
+              try {
+                parsed = item.arguments ? JSON.parse(item.arguments) : {};
+              } catch {
+                parsed = {};
+              }
+              emittedToolCallIds.add(cid);
+              sawToolCall = true;
+              yield {
+                type: 'tool_call',
+                id: cid,
+                name: item.name || '',
+                input: parsed,
+              };
+            }
+
+            // Usage
+            const usage = respObj.usage || {};
+            yield {
+              type: 'usage',
+              inputTokens: usage.input_tokens || 0,
+              outputTokens: usage.output_tokens || 0,
+              cacheReadTokens: usage.input_tokens_details?.cached_tokens || 0,
+              cacheWriteTokens: 0,
+            };
+
+            yield {
+              type: 'stop',
+              stopReason: this.#mapStopReason(respObj, sawToolCall),
+            };
+          } else if (type === 'response.error') {
+            // Let the engine decide; emit error event
+            const message = event.error?.message || event.message || 'response.error';
+            yield { type: 'error', error: new Error(message), retryable: false };
+          }
+          // Other semantic events (output_item.done, content_part.added, etc.) are ignored.
+        }
+      }
+    } catch (err) {
+      if (err?.name === 'AbortError') throw new LLMAbortError();
+      throw err;
+    } finally {
+      try { reader.releaseLock(); } catch { /* noop */ }
+    }
+  }
+
+  // ─── Non-streaming call() ───────────────────────────────
+
+  async call({ model, system, messages, maxTokens = 4096, extraBody, signal }) {
+    if (signal?.aborted) throw new LLMAbortError();
+
+    const body = {
+      model,
+      input: this.#translateInput(messages),
+      max_output_tokens: maxTokens,
+    };
+    if (system) body.instructions = system;
+    if (extraBody) Object.assign(body, extraBody);
+
+    let response;
+    try {
+      response = await fetch(`${this.#baseUrl}/responses`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.#apiKey}`,
+        },
+        body: JSON.stringify(body),
+        signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') throw new LLMAbortError();
+      throw err;
+    }
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw this.#classifyError(response.status, errorBody);
+    }
+
+    const result = await response.json();
+
+    // Prefer the `output_text` convenience field; fall back to output[].content[].text
+    let text = '';
+    if (typeof result.output_text === 'string' && result.output_text.length > 0) {
+      text = result.output_text;
+    } else {
+      const out = Array.isArray(result.output) ? result.output : [];
+      for (const item of out) {
+        if (item?.type === 'message' && Array.isArray(item.content)) {
+          for (const part of item.content) {
+            if (part?.type === 'output_text' && typeof part.text === 'string') {
+              text += part.text;
+            }
+          }
+        }
+      }
+    }
+
+    const usage = result.usage || {};
+    return {
+      text,
+      usage: {
+        inputTokens: usage.input_tokens || 0,
+        outputTokens: usage.output_tokens || 0,
+      },
+    };
+  }
+}

package/unify/llm/router.js

@@ -79,6 +79,13 @@ export class AdapterRouter extends LLMAdapter {
         apiKey: provider.apiKey,
         baseUrl: provider.baseUrl,
       });
+    } else if (protocol === 'openai-responses') {
+      // OpenAI Responses API (/v1/responses) — next-gen, recommended for GPT-5+
+      const { OpenAIResponsesAdapter } = await import('./openai-responses.js');
+      adapter = new OpenAIResponsesAdapter({
+        apiKey: provider.apiKey,
+        baseUrl: provider.baseUrl,
+      });
     } else {
       // Default: openai (Chat Completions API) — covers proxy, OpenAI, DeepSeek, Gemini, etc.
       const { ChatCompletionsAdapter } = await import('./chat-completions.js');

package/unify/models.js

@@ -59,6 +59,33 @@ export const MODEL_REGISTRY = new Map([
     maxOutputTokens: 16384,
     displayName: 'GPT-5',
   }],
+  ['gpt-5-mini', {
+    provider: 'openai',
+    adapter: 'chat-completions',
+    baseUrl: 'https://api.openai.com/v1',
+    // TODO: verify exact limits against OpenAI docs on first real call
+    contextWindow: 400000,
+    maxOutputTokens: 128000,
+    displayName: 'GPT-5 Mini',
+  }],
+  ['gpt-5-nano', {
+    provider: 'openai',
+    adapter: 'chat-completions',
+    baseUrl: 'https://api.openai.com/v1',
+    // TODO: verify exact limits against OpenAI docs on first real call
+    contextWindow: 400000,
+    maxOutputTokens: 128000,
+    displayName: 'GPT-5 Nano',
+  }],
+  ['gpt-5-pro', {
+    provider: 'openai',
+    adapter: 'chat-completions',
+    baseUrl: 'https://api.openai.com/v1',
+    // TODO: verify exact limits against OpenAI docs on first real call
+    contextWindow: 400000,
+    maxOutputTokens: 128000,
+    displayName: 'GPT-5 Pro',
+  }],
   ['gpt-5.4', {
     provider: 'openai',
     adapter: 'chat-completions',