@yeaft/webchat-agent 0.1.463 → 0.1.465

package/package.json

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

package/unify/config-api.js

@@ -11,6 +11,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
+import { normalizeProviderModels, serializeModelForPersistence } from './models.js';
 
 /**
  * Read the LLM-relevant portion of config.json.
@@ -87,7 +88,17 @@ export function updateLlmConfig(update, dir) {
         return { error: `Provider "${p.name}" must have at least one model` };
       }
     }
-    existing.providers = update.providers;
+    // Normalize + re-serialize each provider's models so that:
+    //   - id-only entries are persisted as plain strings (back-compat)
+    //   - entries with ctx / maxOutput are persisted as objects
+    //   - empty / 0 / NaN values get stripped
+    existing.providers = update.providers.map(p => {
+      const normalized = normalizeProviderModels(p);
+      return {
+        ...p,
+        models: normalized.map(serializeModelForPersistence),
+      };
+    });
   }
 
   // Update model selections

package/unify/config.js

@@ -22,7 +22,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
-import { resolveModel, parseModelRef } from './models.js';
+import { resolveModel, parseModelRef, normalizeProviderModels } from './models.js';
 
 /** Default configuration values. */
 const DEFAULTS = {
@@ -260,19 +260,24 @@ export function loadConfig(overrides = {}) {
     adapter: null,
   };
 
-  // Aggregate all available models from providers
+  // Aggregate all available models from providers.
+  // Normalizes each provider's `models` into `{ id, contextWindow?, maxOutput? }`
+  // so consumers never have to deal with raw string / object ambiguity.
   config.availableModels = [];
   if (providers) {
     for (const p of providers) {
-      if (!Array.isArray(p.models)) continue;
-      for (const m of p.models) {
+      const normalized = normalizeProviderModels(p);
+      for (const m of normalized) {
         // Avoid duplicates (first provider wins)
-        if (!config.availableModels.some(am => am.id === m)) {
-          config.availableModels.push({
-            id: m,
+        if (!config.availableModels.some(am => am.id === m.id)) {
+          const entry = {
+            id: m.id,
             provider: p.name,
-            label: m,
-          });
+            label: m.id,
+          };
+          if (m.contextWindow !== undefined) entry.contextWindow = m.contextWindow;
+          if (m.maxOutput !== undefined) entry.maxOutput = m.maxOutput;
+          config.availableModels.push(entry);
         }
       }
     }

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,27 @@ export const MODEL_REGISTRY = new Map([
     maxOutputTokens: 16384,
     displayName: 'GPT-5',
   }],
+  // gpt-5-mini/-nano/-pro: keep id + family/protocol metadata so they appear
+  // as known models, but do NOT hardcode context/maxOutput — the real limits
+  // should come from provider config (user-supplied) instead of guesses.
+  ['gpt-5-mini', {
+    provider: 'openai',
+    adapter: 'chat-completions',
+    baseUrl: 'https://api.openai.com/v1',
+    displayName: 'GPT-5 Mini',
+  }],
+  ['gpt-5-nano', {
+    provider: 'openai',
+    adapter: 'chat-completions',
+    baseUrl: 'https://api.openai.com/v1',
+    displayName: 'GPT-5 Nano',
+  }],
+  ['gpt-5-pro', {
+    provider: 'openai',
+    adapter: 'chat-completions',
+    baseUrl: 'https://api.openai.com/v1',
+    displayName: 'GPT-5 Pro',
+  }],
   ['gpt-5.4', {
     provider: 'openai',
     adapter: 'chat-completions',
@@ -209,3 +230,108 @@ export function parseModelRef(ref) {
     modelId: ref.slice(slashIdx + 1),
   };
 }
+
+// ─── task-284: config-driven context / maxOutput ────────────────
+
+/**
+ * Coerce a possibly-stringy numeric value to a positive integer, or
+ * `undefined` if it's empty / zero / NaN / negative / non-finite.
+ *
+ * @param {*} v
+ * @returns {number | undefined}
+ */
+function coercePositiveInt(v) {
+  if (v === null || v === undefined || v === '') return undefined;
+  const n = typeof v === 'number' ? v : Number(v);
+  if (!Number.isFinite(n) || n <= 0) return undefined;
+  return Math.floor(n);
+}
+
+/**
+ * Normalize a provider's `models` field into an in-memory array of
+ * `{ id, contextWindow?, maxOutput? }` objects.
+ *
+ * Accepts legacy `string[]` and new object form `{id, contextWindow, maxOutput}`.
+ * Empty / 0 / NaN / negative context/max values are treated as unset (dropped).
+ *
+ * @param {{ models?: Array<string | object> } | null | undefined} provider
+ * @returns {Array<{ id: string, contextWindow?: number, maxOutput?: number }>}
+ */
+export function normalizeProviderModels(provider) {
+  if (!provider || !Array.isArray(provider.models)) return [];
+  const out = [];
+  for (const entry of provider.models) {
+    if (typeof entry === 'string') {
+      const id = entry.trim();
+      if (id) out.push({ id });
+      continue;
+    }
+    if (entry && typeof entry === 'object' && typeof entry.id === 'string' && entry.id.trim()) {
+      const norm = { id: entry.id.trim() };
+      const ctx = coercePositiveInt(entry.contextWindow);
+      const max = coercePositiveInt(entry.maxOutput);
+      if (ctx !== undefined) norm.contextWindow = ctx;
+      if (max !== undefined) norm.maxOutput = max;
+      out.push(norm);
+    }
+    // silently skip anything else (null / missing id / numbers)
+  }
+  return out;
+}
+
+/**
+ * Serialize a normalized model entry back for persistence.
+ * - id-only → plain string (back-compat with existing configs)
+ * - with ctx or max → object with only the fields that are set
+ *
+ * @param {{ id: string, contextWindow?: number, maxOutput?: number }} entry
+ * @returns {string | object}
+ */
+export function serializeModelForPersistence(entry) {
+  if (!entry || typeof entry !== 'object') return entry;
+  const ctx = coercePositiveInt(entry.contextWindow);
+  const max = coercePositiveInt(entry.maxOutput);
+  if (ctx === undefined && max === undefined) return entry.id;
+  const obj = { id: entry.id };
+  if (ctx !== undefined) obj.contextWindow = ctx;
+  if (max !== undefined) obj.maxOutput = max;
+  return obj;
+}
+
+/**
+ * Resolve model info with per-provider override.
+ *
+ * Lookup order:
+ *   1. provider-config fields (contextWindow / maxOutput) — highest priority
+ *   2. MODEL_REGISTRY entry (contextWindow / maxOutputTokens)
+ *   3. undefined if neither has any info
+ *
+ * Returns a normalized shape: `{ id, contextWindow?, maxOutput?, provider?, adapter?, baseUrl?, displayName? }`.
+ *
+ * @param {string} model
+ * @param {{ id?: string, contextWindow?: number, maxOutput?: number } | null} [providerConfig]
+ * @returns {object | undefined}
+ */
+export function getModelInfo(model, providerConfig) {
+  if (!model) return undefined;
+  const reg = MODEL_REGISTRY.get(model);
+  const overrideCtx = coercePositiveInt(providerConfig?.contextWindow);
+  const overrideMax = coercePositiveInt(providerConfig?.maxOutput);
+
+  const ctx = overrideCtx ?? reg?.contextWindow;
+  const max = overrideMax ?? reg?.maxOutputTokens;
+
+  // If we have literally no information, return undefined
+  if (!reg && ctx === undefined && max === undefined) return undefined;
+
+  const info = { id: model };
+  if (reg) {
+    if (reg.provider) info.provider = reg.provider;
+    if (reg.adapter) info.adapter = reg.adapter;
+    if (reg.baseUrl) info.baseUrl = reg.baseUrl;
+    if (reg.displayName) info.displayName = reg.displayName;
+  }
+  if (ctx !== undefined) info.contextWindow = ctx;
+  if (max !== undefined) info.maxOutput = max;
+  return info;
+}