@yeaft/webchat-agent 0.1.442 → 0.1.444

package/unify/tools/wait-agent.js

@@ -0,0 +1,84 @@
+/**
+ * wait-agent.js — Wait for a sub-agent to complete and get its result.
+ */
+
+import { defineTool } from './types.js';
+import { getAgentRegistry } from './agent.js';
+
+export default defineTool({
+  name: 'WaitAgent',
+  description: `Wait for a sub-agent to complete its task and retrieve the result.
+
+Returns the agent's final result or current status if still running.
+Use after sending a task to an agent via SendMessage.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      agent_id: {
+        type: 'string',
+        description: 'The sub-agent ID to wait for',
+      },
+      timeout_ms: {
+        type: 'number',
+        description: 'Maximum time to wait in milliseconds (default: 30000)',
+      },
+    },
+    required: ['agent_id'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { agent_id, timeout_ms = 30000 } = input;
+    if (!agent_id) return JSON.stringify({ error: 'agent_id is required' });
+
+    const agents = getAgentRegistry();
+    const agent = agents.get(agent_id);
+
+    if (!agent) {
+      return JSON.stringify({ error: `Agent not found: ${agent_id}` });
+    }
+
+    // If already completed, return result immediately
+    if (agent.status === 'completed' || agent.status === 'closed') {
+      return JSON.stringify({
+        agentId: agent_id,
+        name: agent.name,
+        status: agent.status,
+        result: agent.result,
+        messages: agent.messages.length,
+      });
+    }
+
+    // Wait for completion with timeout
+    const deadline = Date.now() + timeout_ms;
+    while (Date.now() < deadline) {
+      if (agent.status === 'completed' || agent.status === 'closed') {
+        return JSON.stringify({
+          agentId: agent_id,
+          name: agent.name,
+          status: agent.status,
+          result: agent.result,
+          messages: agent.messages.length,
+        });
+      }
+
+      // Check abort signal
+      if (ctx?.signal?.aborted) {
+        return JSON.stringify({ error: 'Wait cancelled', agentId: agent_id });
+      }
+
+      // Poll every 500ms
+      await new Promise(r => setTimeout(r, 500));
+    }
+
+    return JSON.stringify({
+      agentId: agent_id,
+      name: agent.name,
+      status: agent.status,
+      timedOut: true,
+      message: `Agent "${agent.name}" is still running after ${timeout_ms}ms`,
+      messages: agent.messages.length,
+    });
+  },
+});

package/unify/tools/web-fetch.js

@@ -0,0 +1,131 @@
+/**
+ * web-fetch.js — Fetch web page content.
+ *
+ * Retrieves the content of a URL, converts HTML to readable text,
+ * and returns it for the LLM to process.
+ */
+
+import { defineTool } from './types.js';
+
+/** Strip HTML tags and normalize whitespace for readability. */
+function htmlToText(html) {
+  return html
+    // Remove script/style blocks
+    .replace(/<script[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[\s\S]*?<\/style>/gi, '')
+    // Replace br/p/div/h tags with newlines
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/(p|div|h[1-6]|li|tr|blockquote)>/gi, '\n')
+    .replace(/<(p|div|h[1-6]|li|tr|blockquote)[^>]*>/gi, '\n')
+    // Strip remaining tags
+    .replace(/<[^>]+>/g, '')
+    // Decode common HTML entities
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, ' ')
+    // Normalize whitespace
+    .replace(/[ \t]+/g, ' ')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+export default defineTool({
+  name: 'WebFetch',
+  description: `Fetch and read the content of a web page.
+
+Retrieves the URL content, strips HTML tags, and returns readable text.
+Use this to read documentation, articles, or any web page.
+
+Guidelines:
+- Provide the full URL including protocol (https://)
+- Large pages will be truncated — use the offset parameter for pagination
+- For APIs, the raw response body is returned as-is
+- Respects the abort signal for cancellation`,
+  parameters: {
+    type: 'object',
+    properties: {
+      url: {
+        type: 'string',
+        description: 'The URL to fetch',
+      },
+      max_length: {
+        type: 'number',
+        description: 'Maximum content length in characters (default: 50000)',
+      },
+      raw: {
+        type: 'boolean',
+        description: 'If true, return raw response without HTML stripping (for APIs)',
+      },
+    },
+    required: ['url'],
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { url, max_length = 50000, raw = false } = input;
+    if (!url) return JSON.stringify({ error: 'url is required' });
+
+    try {
+      // Validate URL
+      let parsedUrl;
+      try {
+        parsedUrl = new URL(url);
+      } catch {
+        return JSON.stringify({ error: `Invalid URL: ${url}` });
+      }
+
+      // Only allow http(s)
+      if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+        return JSON.stringify({ error: `Unsupported protocol: ${parsedUrl.protocol}` });
+      }
+
+      const response = await fetch(url, {
+        signal: ctx?.signal,
+        headers: {
+          'User-Agent': 'Yeaft/1.0 (compatible; bot)',
+          'Accept': 'text/html, application/json, text/plain, */*',
+        },
+        redirect: 'follow',
+      });
+
+      if (!response.ok) {
+        return JSON.stringify({
+          error: `HTTP ${response.status}: ${response.statusText}`,
+          url,
+        });
+      }
+
+      const contentType = response.headers.get('content-type') || '';
+      const body = await response.text();
+
+      let content;
+      if (raw || contentType.includes('json') || contentType.includes('text/plain')) {
+        content = body;
+      } else {
+        content = htmlToText(body);
+      }
+
+      // Truncate if too long
+      const truncated = content.length > max_length;
+      if (truncated) {
+        content = content.slice(0, max_length);
+      }
+
+      return JSON.stringify({
+        url: response.url, // final URL after redirects
+        status: response.status,
+        contentType,
+        contentLength: content.length,
+        truncated,
+        content,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') return JSON.stringify({ error: 'Fetch cancelled' });
+      return JSON.stringify({ error: `Fetch failed: ${err.message}`, url });
+    }
+  },
+});

package/unify/tools/web-search.js

@@ -0,0 +1,80 @@
+/**
+ * web-search.js — Web search tool.
+ *
+ * Delegates to an external search API or LLM-based web search.
+ * Supports configurable search providers via Yeaft config.
+ */
+
+import { defineTool } from './types.js';
+
+export default defineTool({
+  name: 'WebSearch',
+  description: `Search the web for current information.
+
+Use this when you need up-to-date information that may not be in your training data.
+Returns search results with titles, URLs, and snippets.
+
+Guidelines:
+- Use specific, targeted search queries
+- Include the current year for time-sensitive queries
+- Combine with WebFetch to read full page content from results`,
+  parameters: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'The search query',
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum number of results (default: 5)',
+      },
+    },
+    required: ['query'],
+  },
+  modes: ['chat', 'work'],
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { query, limit = 5 } = input;
+    if (!query) return JSON.stringify({ error: 'query is required' });
+
+    try {
+      // Check if adapter supports web search natively (some LLM providers have built-in search)
+      const adapter = ctx?.adapter;
+      if (adapter && typeof adapter.webSearch === 'function') {
+        const results = await adapter.webSearch(query, limit);
+        return JSON.stringify(results, null, 2);
+      }
+
+      // Check config for search API endpoint
+      const searchUrl = ctx?.config?.searchApiUrl;
+      if (searchUrl) {
+        const url = new URL(searchUrl);
+        url.searchParams.set('q', query);
+        url.searchParams.set('limit', String(limit));
+
+        const response = await fetch(url.toString(), {
+          signal: ctx?.signal,
+          headers: { 'User-Agent': 'Yeaft/1.0' },
+        });
+
+        if (!response.ok) {
+          return JSON.stringify({ error: `Search API returned ${response.status}: ${response.statusText}` });
+        }
+
+        const data = await response.json();
+        return JSON.stringify(data, null, 2);
+      }
+
+      // Fallback: no search provider configured
+      return JSON.stringify({
+        error: 'No web search provider configured.',
+        hint: 'Configure searchApiUrl in ~/.yeaft/config.json or use an LLM provider with built-in search.',
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') return JSON.stringify({ error: 'Search cancelled' });
+      return JSON.stringify({ error: `Web search failed: ${err.message}` });
+    }
+  },
+});

package/unify/tools/write-stdin.js

@@ -0,0 +1,54 @@
+/**
+ * write-stdin.js — Write data to a running process's stdin.
+ *
+ * Used in conjunction with Bash for processes that need interactive input.
+ * Currently returns a guidance message since Bash tool uses 'ignore' for stdin.
+ */
+
+import { defineTool } from './types.js';
+
+export default defineTool({
+  name: 'WriteStdin',
+  description: `Write data to a running process's standard input.
+
+This tool is intended for sending input to interactive processes.
+Since the Bash tool runs commands non-interactively, this is primarily
+useful with the terminal system or long-running processes.
+
+Note: For most use cases, pipe input via Bash: echo "input" | command`,
+  parameters: {
+    type: 'object',
+    properties: {
+      process_id: {
+        type: 'string',
+        description: 'Process identifier or terminal ID',
+      },
+      data: {
+        type: 'string',
+        description: 'Data to write to stdin',
+      },
+      newline: {
+        type: 'boolean',
+        description: 'Append newline after data (default: true)',
+      },
+    },
+    required: ['data'],
+  },
+  modes: ['work'],
+  isConcurrencySafe: () => false,
+  isReadOnly: () => false,
+  async execute(input, ctx) {
+    const { process_id, data, newline = true } = input;
+    if (!data && data !== '') return JSON.stringify({ error: 'data is required' });
+
+    // The Bash tool uses 'ignore' for stdin, so direct stdin writing
+    // is only possible through the terminal system.
+    // For most interactive needs, recommend using pipe syntax.
+    return JSON.stringify({
+      hint: 'The Bash tool does not support interactive stdin. Use pipe syntax instead:',
+      example: `echo "${data}" | your_command`,
+      alternativeBash: `printf '%s\\n' '${data.replace(/'/g, "'\\''")}' | your_command`,
+      message: 'For interactive processes, use the terminal system (not the AI tool system).',
+    });
+  },
+});

package/unify/web-bridge.js

@@ -103,6 +103,7 @@ export async function handleUnifyChat(msg) {
         type: 'session_ready',
         conversationId: unifyConversationId,
         model: session.config.model,
+        availableModels: session.config.availableModels || [],
         skills: session.status.skills,
         mcpServers: session.status.mcpServers,
         tools: session.status.tools,
@@ -385,6 +386,32 @@ export function handleUnifyModeSwitch(msg) {
   }
 }
 
+/**
+ * Handle model switch from the web UI.
+ * Updates Engine's config so the next query uses the new model.
+ * @param {{ model: string }} msg
+ */
+export function handleUnifyModelSwitch(msg) {
+  if (!session || !msg.model) return;
+
+  // Validate: model must be in availableModels list
+  const available = session.config.availableModels || [];
+  const found = available.some(m => m.id === msg.model);
+  if (!found) {
+    console.warn(`[Unify] model switch rejected — "${msg.model}" not in availableModels`);
+    return;
+  }
+
+  // Update Engine's model for subsequent queries
+  session.config.model = msg.model;
+
+  // Confirm switch to frontend
+  sendUnifyEvent({
+    type: 'model_switched',
+    model: msg.model,
+  });
+}
+
 /**
  * Reset Unify session (for clear messages).
  */