@aion0/forge 0.9.13 → 0.9.14

package/RELEASE_NOTES.md

@@ -1,19 +1,15 @@
-# Forge v0.9.13
+# Forge v0.9.14
 
 Released: 2026-05-27
 
-## Changes since v0.9.12
+## Changes since v0.9.13
 
 ### Other
-- refactor(schedules): drop skill + connector_tool body kinds (web)
-- fix(schedules): prompt mode end-to-end — MCP config + zombie reconciler
-- fix(schedules-modal): normalize 'scratch' → '' on edit-mode load
-- feat(projects): synthetic 'scratch' project as default workspace
-- feat(schedules): natural-language quick create — extractor + Confirm Card
-- feat(schedules-ui): prompt mode in ScheduleCreateModal + SchedulesView
-- feat(schedules): body_kind='prompt' dispatch + task-backed run settle
-- feat(prompts): store + CRUD API for V3 schedule body_kind='prompt'
-- feat(mcp): list_connectors + call_connector tools for ai-orchestration
+- fix(pipeline): apply workflow.input defaults for missing fields
+- feat(chat): trigger_pipeline schema validation + self-evolving rules
+- feat(chat): pipeline input schemas + Forge context tools
+- refactor(chat): LLM layer on Vercel AI SDK (provider-agnostic streaming)
+- feat(chat): trigger_pipeline + dispatch_task builtin tools
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.9.12...v0.9.13
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.9.13...v0.9.14

package/lib/chat/agent-loop.ts

@@ -164,6 +164,18 @@ function resolveProvider(sessionProvider: string | null, sessionModel: string |
 
 function buildSystemPrompt(connectorTools: LlmTool[], builtinDefs: typeof BUILTIN_TOOL_DEFS, sessionSystemPrompt: string | null): string {
   const now = new Date().toISOString();
+
+  // Inject a brief Forge context block (project names only) so the LLM can
+  // validate names the user mentions ("FortiNAC" → real project? → yes) and
+  // pass them to trigger_pipeline / dispatch_task without guessing. Full
+  // details (paths, agents, skills) are behind list_forge_context — only
+  // names are cheap enough to ship every turn.
+  let projectNames: string[] = [];
+  try {
+    const { scanProjects } = require('../projects') as typeof import('../projects');
+    projectNames = scanProjects().map((p) => p.name);
+  } catch { /* projects roots not configured / read failed — omit */ }
+
   const lines: string[] = [
     "You are Forge, the user's personal AI assistant.",
     '',
@@ -174,6 +186,14 @@ function buildSystemPrompt(connectorTools: LlmTool[], builtinDefs: typeof BUILTI
     '  Don\'t explain how to do something manually before trying the tool. The tools below run inside the user\'s actual logged-in browser session — they CAN do things you might think only the user can do manually.',
     '- For Teams in particular: send_message can target any chat by name; if the chat doesn\'t exist yet, the tool will return a specific error and THEN you can advise. Don\'t pre-judge.',
     '- If a tool call fails, read its error carefully — it usually tells you what to fix (wrong arg, missing setting, login required). Retry with the fix. Only give up after the tool explicitly says it cannot do the task.',
+    '- For trigger_pipeline / dispatch_task: when the user names a "project" (e.g. "FortiNAC"), pass it as input.project verbatim. The names in the "Forge projects" list below ARE the valid values. Call list_forge_context only if you need paths / agents / skills.',
+    '',
+    'trigger_pipeline specifics — these are easy to get wrong, READ CAREFULLY:',
+    '- FIRST call this session: call trigger_pipeline() with NO arguments. The response lists every workflow + which input fields are required (*) vs have defaults. Field names are EXACT, snake_case (e.g. bug_id), declared by the workflow yaml. They are NOT the same as bash variable names inside pipeline scripts (BUG_ID / BASE / PROJECT_PATH are wrong). DO NOT pass uppercase / made-up names.',
+    '- For optional fields with defaults (mr_body_template / user_prompt / teams_message_template / etc.), OMIT them — let the default apply. NEVER pass empty strings or invented placeholder values.',
+    '- If the response says "Unknown input fields", "Missing required", or "0 iterations" — the pipeline did NOT do what the user asked. Fix the input and retry. Optionally save a pinned memory rule via memory_remember_block({pinned: true, ...}) so the lesson sticks for future sessions.',
+    '- DO NOT trust earlier assistant messages in this conversation that claim a pipeline "already ran" — those may be wrong. If the user re-asks, fire fresh; verify only by re-checking the actual target system (e.g. mantis.get_bug for status).',
+    '',
     '- Reply without tools ONLY when no system + no time question is involved.',
     '',
     'Other:',
@@ -181,6 +201,10 @@ function buildSystemPrompt(connectorTools: LlmTool[], builtinDefs: typeof BUILTI
     'Keep replies short and direct.',
   ];
 
+  if (projectNames.length > 0) {
+    lines.push('', `Forge projects (valid input.project values): ${projectNames.join(', ')}`);
+  }
+
   if (connectorTools.length > 0) {
     lines.push('', 'Connector tools available:');
     for (const t of connectorTools) {

package/lib/chat/llm/anthropic.ts

@@ -1,64 +1,36 @@
 /**
- * Anthropic adapter — ported from the extension. Server-side variant
- * (no dangerouslyAllowBrowser). OAuth tokens (sk-ant-oat-*) get the
- * special beta header + authToken handling.
+ * Anthropic adapter — uses Vercel AI SDK (@ai-sdk/anthropic + ai).
+ * Public contract (streamLlm interface) is unchanged from the hand-rolled
+ * version this replaced; agent-loop.ts callers see no difference.
+ *
+ * Forge-specific bits we keep:
+ *  - OAuth token (sk-ant-oat-*) → Authorization: Bearer + oauth beta header
+ *  - Connector tool names (dotted, e.g. "gitlab.list_my_mrs") encoded as
+ *    "__" to satisfy Anthropic's name regex; decoded on tool_use events
  */
 
 import Anthropic from '@anthropic-ai/sdk';
-import type { Message } from '../types';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { jsonSchema, streamText, type ModelMessage } from 'ai';
+import type { ContentBlock, Message } from '../types';
 import type { LlmAdapter, LlmCallbacks, LlmRequest, LlmTurnResult, StopReason } from './types';
 
-function historyToApi(history: Message[]): Anthropic.MessageParam[] {
-  const out: Anthropic.MessageParam[] = [];
-  for (const m of history) {
-    const content: Anthropic.ContentBlockParam[] = [];
-    for (const b of m.blocks) {
-      if (b.type === 'text') {
-        if (b.text.length > 0) content.push({ type: 'text', text: b.text });
-      } else if (b.type === 'tool_use') {
-        // Same encoding as tool definitions — names with `.` must
-        // round-trip through Anthropic as `__` to satisfy its tool name
-        // regex when this turn's history is re-sent next turn.
-        content.push({
-          type: 'tool_use',
-          id: b.id,
-          name: b.name.replace(/\./g, '__'),
-          input: (b.input ?? {}) as Record<string, unknown>,
-        });
-      } else if (b.type === 'tool_result') {
-        content.push({
-          type: 'tool_result',
-          tool_use_id: b.tool_use_id,
-          content: b.content,
-          is_error: b.is_error,
-        });
-      }
-    }
-    if (content.length === 0) continue;
-    out.push({ role: m.role, content });
-  }
-  return out;
-}
-
-function mapStop(r: Anthropic.Message['stop_reason']): StopReason {
-  switch (r) {
-    case 'end_turn': return 'end_turn';
-    case 'tool_use': return 'tool_use';
-    case 'max_tokens': return 'max_tokens';
-    case 'refusal': return 'refusal';
-    default: return 'other';
-  }
-}
-
 function isOauthToken(key: string): boolean {
   return key.startsWith('sk-ant-oat');
 }
 
+/**
+ * Raw Anthropic SDK client (one-shot calls, non-streaming). Used by
+ * /api/schedules/extract for structured JSON extraction. Kept here so OAuth
+ * + baseURL handling matches the streaming adapter; callers wanting tool
+ * calls / streaming should use streamLlm via the Vercel AI SDK adapter below.
+ */
 export function makeAnthropicClient(apiKey: string, baseUrl: string): Anthropic {
+  const oauth = isOauthToken(apiKey);
   const opts: ConstructorParameters<typeof Anthropic>[0] = {
     baseURL: baseUrl || undefined,
   };
-  if (isOauthToken(apiKey)) {
+  if (oauth) {
     opts.authToken = apiKey;
     opts.defaultHeaders = { 'anthropic-beta': 'oauth-2025-04-20' };
   } else {
@@ -69,49 +41,127 @@ export function makeAnthropicClient(apiKey: string, baseUrl: string): Anthropic
 
 /**
  * Anthropic restricts tool names to `^[a-zA-Z0-9_-]{1,128}$`. Forge's
- * connector tools use a `connector.tool` namespace (e.g.
- * `gitlab.list_my_mrs`), so we encode the dot as `__` on the way out and
- * decode it back when Anthropic returns a tool_use. Internal dispatcher
- * still sees the canonical dotted form.
+ * connector tools use a `connector.tool` namespace, so we encode the
+ * dot as `__` on the way out and decode it back on tool_use. Internal
+ * dispatcher still sees the canonical dotted form.
  */
-function encodeToolName(name: string): string {
-  return name.replace(/\./g, '__');
+function encodeToolName(name: string): string { return name.replace(/\./g, '__'); }
+function decodeToolName(name: string): string { return name.replace(/__/g, '.'); }
+
+function makeClient(apiKey: string, baseUrl: string) {
+  const oauth = isOauthToken(apiKey);
+  return createAnthropic({
+    apiKey: oauth ? '' : apiKey,
+    baseURL: baseUrl || undefined,
+    headers: oauth
+      ? {
+          authorization: `Bearer ${apiKey}`,
+          'anthropic-beta': 'oauth-2025-04-20',
+        }
+      : undefined,
+  });
 }
-function decodeToolName(name: string): string {
-  return name.replace(/__/g, '.');
+
+/** Convert Forge Message[] → AI SDK ModelMessage[]. */
+function historyToModelMessages(history: Message[]): ModelMessage[] {
+  const out: ModelMessage[] = [];
+  for (const m of history) {
+    if (m.role === 'user') {
+      // User message may carry plain text OR tool_result blocks.
+      const toolResults = m.blocks.filter((b): b is Extract<ContentBlock, { type: 'tool_result' }> => b.type === 'tool_result');
+      if (toolResults.length > 0) {
+        out.push({
+          role: 'tool',
+          content: toolResults.map((r) => ({
+            type: 'tool-result' as const,
+            toolCallId: r.tool_use_id,
+            toolName: '', // tool name not tracked in our model; SDK ignores when matching by toolCallId
+            output: { type: 'text', value: r.content },
+          })),
+        });
+        continue;
+      }
+      const text = m.blocks
+        .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
+        .map((b) => b.text).join('\n');
+      if (text.length > 0) out.push({ role: 'user', content: text });
+    } else {
+      // Assistant: text + tool_use blocks
+      const parts: any[] = [];
+      for (const b of m.blocks) {
+        if (b.type === 'text' && b.text.length > 0) {
+          parts.push({ type: 'text', text: b.text });
+        } else if (b.type === 'tool_use') {
+          parts.push({
+            type: 'tool-call',
+            toolCallId: b.id,
+            toolName: encodeToolName(b.name),
+            input: b.input ?? {},
+          });
+        }
+      }
+      if (parts.length > 0) out.push({ role: 'assistant', content: parts });
+    }
+  }
+  return out;
+}
+
+function mapStop(r: string | undefined): StopReason {
+  switch (r) {
+    case 'stop': return 'end_turn';
+    case 'tool-calls': return 'tool_use';
+    case 'length': return 'max_tokens';
+    case 'content-filter': return 'refusal';
+    case 'error': return 'error';
+    default: return 'other';
+  }
 }
 
 export const anthropicAdapter: LlmAdapter = {
   async stream(req: LlmRequest, cb: LlmCallbacks): Promise<LlmTurnResult> {
-    const client = makeAnthropicClient(req.apiKey, req.baseUrl);
+    const client = makeClient(req.apiKey, req.baseUrl);
 
-    const stream = client.messages.stream({
-      model: req.model,
-      max_tokens: req.maxTokens,
-      system: req.system,
-      tools: req.tools.map((t) => ({
-        name: encodeToolName(t.name),
+    // Build tool set as Record<encoded_name, ToolDef>. We DO NOT supply
+    // execute — chat owns dispatch (destructive confirm, browser bridge,
+    // memory tools etc all live in agent-loop). Setting stopWhen with
+    // stepCountIs(1) prevents the SDK from auto-rolling a second step.
+    const tools: Record<string, any> = {};
+    for (const t of req.tools) {
+      tools[encodeToolName(t.name)] = {
         description: t.description,
-        input_schema: t.input_schema as Anthropic.Tool.InputSchema,
-      })),
-      messages: historyToApi(req.history),
-    });
-
-    stream.on('text', (delta: string) => cb.onTextDelta(delta));
+        inputSchema: jsonSchema(t.input_schema),
+      };
+    }
 
-    const final = await stream.finalMessage();
+    const result = streamText({
+      model: client(req.model),
+      system: req.system,
+      messages: historyToModelMessages(req.history),
+      tools,
+      maxOutputTokens: req.maxTokens,
+    });
 
-    const content: LlmTurnResult['content'] = [];
-    for (const block of final.content) {
-      if (block.type === 'text') {
-        content.push({ type: 'text', text: block.text });
-      } else if (block.type === 'tool_use') {
-        const decodedName = decodeToolName(block.name);
-        cb.onToolUse({ id: block.id, name: decodedName, input: block.input });
-        content.push({ type: 'tool_use', id: block.id, name: decodedName, input: block.input });
+    const content: ContentBlock[] = [];
+    let textBuf = '';
+    for await (const part of result.fullStream) {
+      if (part.type === 'text-delta') {
+        textBuf += part.text;
+        cb.onTextDelta(part.text);
+      } else if (part.type === 'tool-call') {
+        if (textBuf.length > 0) {
+          content.push({ type: 'text', text: textBuf });
+          textBuf = '';
+        }
+        const decoded = decodeToolName(part.toolName);
+        cb.onToolUse({ id: part.toolCallId, name: decoded, input: part.input });
+        content.push({ type: 'tool_use', id: part.toolCallId, name: decoded, input: part.input });
+      } else if (part.type === 'error') {
+        throw new Error(`Anthropic stream error: ${String((part as any).error)}`);
       }
     }
+    if (textBuf.length > 0) content.push({ type: 'text', text: textBuf });
 
-    return { stopReason: mapStop(final.stop_reason), content };
+    const finishReason = await result.finishReason;
+    return { stopReason: mapStop(finishReason), content };
   },
 };

package/lib/chat/llm/openai.ts

@@ -1,215 +1,110 @@
+/**
+ * OpenAI-compatible adapter — uses Vercel AI SDK (@ai-sdk/openai + ai).
+ * Public contract unchanged from the hand-rolled version; works with any
+ * OpenAI-compat endpoint (api.openai.com, DeepSeek, OpenRouter, Anyscale,
+ * vLLM, Ollama-OpenAI shim, etc.) via the baseUrl override.
+ */
+
+import { createOpenAI } from '@ai-sdk/openai';
+import { jsonSchema, streamText, type ModelMessage } from 'ai';
 import type { ContentBlock, Message } from '../types';
 import type { LlmAdapter, LlmCallbacks, LlmRequest, LlmTurnResult, StopReason } from './types';
 
-// Minimal OpenAI-compatible Chat Completions types — covers what we use.
-interface OAIToolCall {
-  index?: number;
-  id?: string;
-  type?: 'function';
-  function?: { name?: string; arguments?: string };
-}
-
-interface OAITool {
-  type: 'function';
-  function: {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-  };
-}
-
-type OAIMessage =
-  | { role: 'system'; content: string }
-  | { role: 'user'; content: string }
-  | { role: 'assistant'; content: string | null; tool_calls?: { id: string; type: 'function'; function: { name: string; arguments: string } }[] }
-  | { role: 'tool'; tool_call_id: string; content: string };
-
-interface OAIChunk {
-  choices?: {
-    index?: number;
-    delta?: {
-      role?: string;
-      content?: string | null;
-      tool_calls?: OAIToolCall[];
-    };
-    finish_reason?: string | null;
-  }[];
-}
-
-function defaultBase(baseUrl: string): string {
-  return (baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '');
-}
-
-function historyToApi(history: Message[]): OAIMessage[] {
-  const out: OAIMessage[] = [];
+function historyToModelMessages(history: Message[]): ModelMessage[] {
+  const out: ModelMessage[] = [];
   for (const m of history) {
     if (m.role === 'user') {
-      // A user message in our model can be plain text OR a vehicle for tool_result blocks.
       const toolResults = m.blocks.filter((b): b is Extract<ContentBlock, { type: 'tool_result' }> => b.type === 'tool_result');
       if (toolResults.length > 0) {
-        for (const r of toolResults) {
-          out.push({ role: 'tool', tool_call_id: r.tool_use_id, content: r.content });
-        }
-      } else {
-        const text = m.blocks
-          .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
-          .map((b) => b.text)
-          .join('\n');
-        if (text.length > 0) out.push({ role: 'user', content: text });
+        out.push({
+          role: 'tool',
+          content: toolResults.map((r) => ({
+            type: 'tool-result' as const,
+            toolCallId: r.tool_use_id,
+            toolName: '',
+            output: { type: 'text', value: r.content },
+          })),
+        });
+        continue;
       }
-    } else {
-      // assistant
       const text = m.blocks
         .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
-        .map((b) => b.text)
-        .join('');
-      const tcs = m.blocks
-        .filter((b): b is Extract<ContentBlock, { type: 'tool_use' }> => b.type === 'tool_use')
-        .map((b) => ({
-          id: b.id,
-          type: 'function' as const,
-          function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
-        }));
-      if (text.length === 0 && tcs.length === 0) continue;
-      out.push({
-        role: 'assistant',
-        content: text.length > 0 ? text : null,
-        ...(tcs.length > 0 ? { tool_calls: tcs } : {}),
-      });
+        .map((b) => b.text).join('\n');
+      if (text.length > 0) out.push({ role: 'user', content: text });
+    } else {
+      const parts: any[] = [];
+      for (const b of m.blocks) {
+        if (b.type === 'text' && b.text.length > 0) {
+          parts.push({ type: 'text', text: b.text });
+        } else if (b.type === 'tool_use') {
+          parts.push({
+            type: 'tool-call',
+            toolCallId: b.id,
+            toolName: b.name,
+            input: b.input ?? {},
+          });
+        }
+      }
+      if (parts.length > 0) out.push({ role: 'assistant', content: parts });
     }
   }
   return out;
 }
 
-function mapStop(r: string | null | undefined): StopReason {
+function mapStop(r: string | undefined): StopReason {
   switch (r) {
-    case 'stop':
-      return 'end_turn';
-    case 'tool_calls':
-    case 'function_call':
-      return 'tool_use';
-    case 'length':
-      return 'max_tokens';
-    case 'content_filter':
-      return 'refusal';
-    default:
-      return 'other';
+    case 'stop': return 'end_turn';
+    case 'tool-calls': return 'tool_use';
+    case 'length': return 'max_tokens';
+    case 'content-filter': return 'refusal';
+    case 'error': return 'error';
+    default: return 'other';
   }
 }
 
 export const openaiAdapter: LlmAdapter = {
   async stream(req: LlmRequest, cb: LlmCallbacks): Promise<LlmTurnResult> {
-    const url = defaultBase(req.baseUrl) + '/chat/completions';
+    const client = createOpenAI({
+      apiKey: req.apiKey,
+      baseURL: req.baseUrl || undefined,
+    });
 
-    const tools: OAITool[] = req.tools.map((t) => ({
-      type: 'function',
-      function: {
-        name: t.name,
+    const tools: Record<string, any> = {};
+    for (const t of req.tools) {
+      tools[t.name] = {
         description: t.description,
-        parameters: t.input_schema,
-      },
-    }));
-
-    const body: Record<string, unknown> = {
-      model: req.model,
-      stream: true,
-      max_tokens: req.maxTokens,
-      messages: [{ role: 'system', content: req.system }, ...historyToApi(req.history)],
-    };
-    if (tools.length > 0) {
-      body.tools = tools;
+        inputSchema: jsonSchema(t.input_schema),
+      };
     }
 
-    const resp = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        ...(req.apiKey ? { Authorization: `Bearer ${req.apiKey}` } : {}),
-      },
-      body: JSON.stringify(body),
+    const result = streamText({
+      model: client(req.model),
+      system: req.system,
+      messages: historyToModelMessages(req.history),
+      tools,
+      maxOutputTokens: req.maxTokens,
     });
 
-    if (!resp.ok || !resp.body) {
-      const text = await resp.text().catch(() => '');
-      throw new Error(`LLM ${resp.status}: ${text.slice(0, 400)}`);
-    }
-
-    const reader = resp.body.getReader();
-    const decoder = new TextDecoder();
-
-    let buffer = '';
-    let accumText = '';
-    // Tool call accumulators keyed by index (OpenAI streams partial JSON for arguments).
-    const toolByIndex = new Map<number, { id: string; name: string; argsRaw: string }>();
-    let finishReason: string | null | undefined;
-
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-
-      // SSE events are separated by blank lines; each event has one or more lines starting with "data: ".
-      const events = buffer.split('\n\n');
-      buffer = events.pop() ?? '';
-
-      for (const rawEvent of events) {
-        for (const line of rawEvent.split('\n')) {
-          if (!line.startsWith('data:')) continue;
-          const payload = line.slice(5).trim();
-          if (!payload || payload === '[DONE]') continue;
-          let chunk: OAIChunk;
-          try {
-            chunk = JSON.parse(payload) as OAIChunk;
-          } catch {
-            continue;
-          }
-          const choice = chunk.choices?.[0];
-          if (!choice) continue;
-          if (choice.finish_reason) finishReason = choice.finish_reason;
-          const delta = choice.delta;
-          if (!delta) continue;
-          if (typeof delta.content === 'string' && delta.content.length > 0) {
-            accumText += delta.content;
-            cb.onTextDelta(delta.content);
-          }
-          if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              const idx = tc.index ?? 0;
-              let agg = toolByIndex.get(idx);
-              if (!agg) {
-                agg = { id: tc.id ?? '', name: tc.function?.name ?? '', argsRaw: '' };
-                toolByIndex.set(idx, agg);
-              }
-              if (tc.id && !agg.id) agg.id = tc.id;
-              if (tc.function?.name && !agg.name) agg.name = tc.function.name;
-              if (tc.function?.arguments) agg.argsRaw += tc.function.arguments;
-            }
-          }
-        }
-      }
-    }
-
     const content: ContentBlock[] = [];
-    if (accumText.length > 0) content.push({ type: 'text', text: accumText });
-
-    // Sort tool calls by index for stable ordering.
-    const tcKeys = Array.from(toolByIndex.keys()).sort((a, b) => a - b);
-    for (const idx of tcKeys) {
-      const agg = toolByIndex.get(idx);
-      if (!agg) continue;
-      let input: unknown = {};
-      if (agg.argsRaw.length > 0) {
-        try {
-          input = JSON.parse(agg.argsRaw);
-        } catch {
-          input = { _raw: agg.argsRaw };
+    let textBuf = '';
+    for await (const part of result.fullStream) {
+      if (part.type === 'text-delta') {
+        textBuf += part.text;
+        cb.onTextDelta(part.text);
+      } else if (part.type === 'tool-call') {
+        if (textBuf.length > 0) {
+          content.push({ type: 'text', text: textBuf });
+          textBuf = '';
         }
+        cb.onToolUse({ id: part.toolCallId, name: part.toolName, input: part.input });
+        content.push({ type: 'tool_use', id: part.toolCallId, name: part.toolName, input: part.input });
+      } else if (part.type === 'error') {
+        throw new Error(`OpenAI stream error: ${String((part as any).error)}`);
       }
-      const id = agg.id || `call_${idx}`;
-      cb.onToolUse({ id, name: agg.name, input });
-      content.push({ type: 'tool_use', id, name: agg.name, input });
     }
+    if (textBuf.length > 0) content.push({ type: 'text', text: textBuf });
 
+    const finishReason = await result.finishReason;
     return { stopReason: mapStop(finishReason), content };
   },
 };

package/lib/chat/tool-dispatcher.ts

@@ -37,6 +37,183 @@ export type BuiltinHandler = (input: unknown) => Promise<string>;
 
 const BUILTINS: Record<string, BuiltinHandler> = {
   get_current_time: async () => new Date().toISOString(),
+
+  // Trigger a pipeline workflow defined under flows/<name>.yaml. Mirrors
+  // the same MCP tool used by Claude Code tasks (forge-mcp-server.ts), but
+  // available directly inside the chat agent so users can say "run the
+  // mantis-bug-fix pipeline for bug 1234" and have the agent dispatch it.
+  //
+  // Call without args first to see workflows + their input schemas — saves
+  // a round-trip of guessing field names. Schema includes which fields are
+  // required (no default) vs optional (have default) so the agent can omit
+  // optional ones rather than passing wrong placeholder values.
+  trigger_pipeline: async (input) => {
+    const params = (input as { workflow?: string; input?: Record<string, unknown> } | undefined) || {};
+    const { listWorkflows, startPipeline, getPipeline } = await import('../pipeline');
+    if (!params.workflow) {
+      const workflows = listWorkflows();
+      if (workflows.length === 0) return 'No workflows found. Create one in <dataDir>/flows/.';
+      const lines: string[] = ['Available workflows (only pass the marked-required inputs; optional ones use their default):', ''];
+      for (const w of workflows) {
+        lines.push(`• ${w.name}${w.description ? ' — ' + w.description.split('\n')[0].slice(0, 160) : ''}`);
+        const entries = Object.entries(w.input || {});
+        if (entries.length === 0) {
+          lines.push('  Inputs: (none)');
+        } else {
+          for (const [name, spec] of entries) {
+            // spec may be a string (legacy description-only) or an object.
+            const isObj = spec && typeof spec === 'object';
+            const desc = isObj ? (spec as any).description : (typeof spec === 'string' ? spec : '');
+            const type = isObj ? ((spec as any).type || 'string') : 'string';
+            const required = isObj ? !!(spec as any).required : false;
+            const hasDefault = isObj && Object.prototype.hasOwnProperty.call(spec, 'default');
+            const def = hasDefault ? (spec as any).default : undefined;
+            const star = required ? '*' : '';
+            const defNote = hasDefault
+              ? ` [default: ${String(def).split('\n')[0].slice(0, 60)}${String(def).length > 60 ? '…' : ''}]`
+              : '';
+            const descShort = desc ? ` — ${String(desc).split('\n')[0].slice(0, 120)}` : '';
+            lines.push(`    - ${name}${star} (${type})${defNote}${descShort}`);
+          }
+        }
+        lines.push('');
+      }
+      lines.push('Required inputs are marked with *. Optional ones with defaults will use the default if you omit them — DO NOT pass empty strings or guesses for those.');
+      return lines.join('\n');
+    }
+    // Pre-flight schema validation. The pipeline orchestrator currently
+    // silently accepts unknown input keys and lets required fields default to
+    // empty — leading to "status: done" no-op runs. Surface those mistakes
+    // here so the LLM (or any caller) gets a structured error instead of a
+    // misleading success. Workflow-side validation (B in the plan) is deferred
+    // because it'd affect schedules.
+    const workflows = listWorkflows();
+    const wf = workflows.find((w: any) => w.name === params.workflow);
+    if (!wf) {
+      return `Unknown workflow: "${params.workflow}". Available: ${workflows.map((w: any) => w.name).join(', ') || '(none)'}. Call trigger_pipeline() with no args to see schemas.`;
+    }
+    const declared = wf.input || {};
+    const declaredKeys = new Set(Object.keys(declared));
+    const requiredKeys: string[] = [];
+    for (const [k, spec] of Object.entries(declared)) {
+      if (spec && typeof spec === 'object') {
+        const s = spec as any;
+        const hasDefault = Object.prototype.hasOwnProperty.call(s, 'default');
+        if (s.required && !hasDefault) requiredKeys.push(k);
+      }
+    }
+    const givenKeys = Object.keys(params.input || {});
+    const unknown = givenKeys.filter((k) => !declaredKeys.has(k));
+    if (unknown.length > 0) {
+      return `Unknown input fields for "${params.workflow}": ${unknown.join(', ')}. This workflow only accepts: ${[...declaredKeys].join(', ')}. NOTE: input field names are snake_case (e.g. bug_id) — they are NOT the same as the bash variable names inside pipeline scripts (e.g. BUG_ID). Consider memory_remember_block({key: "rule.pipeline_input_naming", value: "Forge pipeline input fields are exact, snake_case, declared in the workflow yaml. Never invent uppercase / bash-variable names like BUG_ID, BASE, PROJECT_PATH.", pinned: true}) to save this lesson.`;
+    }
+    const missing = requiredKeys.filter((k) => {
+      const v = (params.input || {})[k];
+      return v == null || (typeof v === 'string' && v.trim() === '');
+    });
+    if (missing.length > 0) {
+      return `Missing required input fields for "${params.workflow}": ${missing.join(', ')}. All required fields (no defaults): ${requiredKeys.join(', ') || '(none)'}. Re-call with these provided.`;
+    }
+
+    // Coerce numbers/booleans to strings (pipeline orchestrator expects Record<string, string>).
+    const stringInput: Record<string, string> = {};
+    for (const [k, v] of Object.entries(params.input || {})) {
+      stringInput[k] = v == null ? '' : typeof v === 'string' ? v : String(v);
+    }
+    const pipeline = startPipeline(params.workflow, stringInput);
+    let line = `Pipeline started: ${pipeline.id} (workflow: ${params.workflow}, status: ${pipeline.status})`;
+    if (pipeline.status === 'failed') {
+      const fresh = getPipeline(pipeline.id) || pipeline;
+      const errs: string[] = [];
+      for (const [nid, n] of Object.entries(fresh.nodes || {})) {
+        if ((n as any).error) errs.push(`${nid}: ${(n as any).error}`);
+      }
+      if (errs.length > 0) line += `\nFailure(s): ${errs.join(' | ').slice(0, 500)}`;
+    } else if (pipeline.status === 'done') {
+      // For for_each workflows, a "done" with zero iterations is the silent
+      // failure mode (empty source). Warn the LLM explicitly so it doesn't
+      // claim success.
+      const fresh = getPipeline(pipeline.id) || pipeline;
+      const forEach = (fresh as any).forEach;
+      if (forEach && typeof forEach === 'object') {
+        const iters = Array.isArray(forEach.iterations) ? forEach.iterations.length : 0;
+        const total = typeof forEach.total === 'number' ? forEach.total : iters;
+        if (total === 0) {
+          line += '\n⚠ Pipeline finished with 0 iterations — likely empty source list. This is NOT a success; the work the user asked for did NOT happen. Re-check input fields (especially the one feeding for_each.source) and retry.';
+        }
+      }
+    } else {
+      line += '. Watch progress in the Pipelines view.';
+    }
+    return line;
+  },
+
+  // Surface Forge's local context (projects + agents + skills) so the chat
+  // agent can pick valid values for inputs like trigger_pipeline.input.project
+  // without guessing. Cheap call — read-only directory + DB lookups.
+  list_forge_context: async () => {
+    const out: string[] = [];
+    try {
+      const { scanProjects } = await import('../projects');
+      const projects = scanProjects();
+      out.push('Forge projects (use the name as input.project for tasks / pipelines):');
+      if (projects.length === 0) out.push('  (none — configure project roots in Settings)');
+      for (const p of projects) {
+        out.push(`  - ${p.name}${p.hasClaudeMd ? ' [has CLAUDE.md]' : ''}${p.language ? ' [' + p.language + ']' : ''}`);
+      }
+    } catch (e) {
+      out.push(`(failed to list projects: ${(e as Error).message})`);
+    }
+    out.push('');
+    try {
+      const { loadSettings } = await import('../settings');
+      const settings = loadSettings();
+      const agents = settings.agents || {};
+      out.push('Agent profiles (CLI agents; use the id as dispatch_task.agent):');
+      const ids = Object.keys(agents);
+      if (ids.length === 0) out.push('  (none configured)');
+      for (const id of ids) {
+        const a = agents[id] as any;
+        out.push(`  - ${id}${a?.name ? ' (' + a.name + ')' : ''}`);
+      }
+    } catch (e) {
+      out.push(`(failed to list agents: ${(e as Error).message})`);
+    }
+    out.push('');
+    try {
+      const { listSkills } = await import('../skills');
+      const skills = listSkills();
+      out.push('Skills (available to dispatch_task / pipeline via auto-install):');
+      if (skills.length === 0) out.push('  (none)');
+      for (const s of skills) {
+        out.push(`  - ${s.name}${s.description ? ' — ' + s.description.slice(0, 80) : ''}`);
+      }
+    } catch (e) {
+      out.push(`(failed to list skills: ${(e as Error).message})`);
+    }
+    return out.join('\n');
+  },
+
+  // Dispatch a one-shot background task. Agent + skills optional; project is
+  // required (defaults to 'scratch' if not given). Returns the task id; the
+  // caller can ask "what's the status of task <id>?" later — we don't block.
+  dispatch_task: async (input) => {
+    const params = (input as { project?: string; prompt?: string; agent?: string } | undefined) || {};
+    if (!params.prompt) return 'dispatch_task failed: prompt is required';
+    const { getProjectInfo, SCRATCH_PROJECT_NAME } = await import('../projects');
+    const projectName = params.project?.trim() || SCRATCH_PROJECT_NAME;
+    const project = getProjectInfo(projectName);
+    if (!project) return `dispatch_task failed: project "${projectName}" not found`;
+    const { createTask } = await import('../task-manager');
+    const task = createTask({
+      projectName: project.name,
+      projectPath: project.path,
+      prompt: params.prompt,
+      conversationId: '',
+      agent: params.agent || undefined,
+    });
+    return `Task dispatched: ${task.id} (project: ${project.name}, status: ${task.status}). Watch in the Tasks view.`;
+  },
 };
 
 export interface BuiltinToolDef {
@@ -51,6 +228,50 @@ export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
     description: 'Get the current local time as an ISO 8601 string. Use whenever the user asks about "now" or "today".',
     input_schema: { type: 'object', properties: {} },
   },
+  {
+    name: 'trigger_pipeline',
+    description: 'Trigger a Forge pipeline workflow (YAML under flows/). Two-step usage: (1) call with NO args first — returns every workflow + its input schema (which fields are required vs have defaults). (2) call again with workflow=<name> and input={...} passing ONLY required fields and any optional fields the user explicitly specified. NEVER pass invented placeholder values for optional fields with defaults — omit them and the default is used. If the pipeline fails immediately, the response includes the validation error so you can fix the inputs and retry.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        workflow: {
+          type: 'string',
+          description: 'Workflow name (file basename of flows/<name>.yaml). Omit to list workflows + schemas.',
+        },
+        input: {
+          type: 'object',
+          description: 'Pipeline input fields as a flat object. Pass ONLY required fields (marked * in the list response) and optional fields the user explicitly named. Omit optional fields to use their defaults.',
+        },
+      },
+    },
+  },
+  {
+    name: 'list_forge_context',
+    description: "Return the current Forge instance's local context: project names (use these as input.project for pipelines / dispatch_task), agent profile ids, and installed skills. Call this whenever the user references a project / agent / skill by name and you need to validate the name OR when picking defaults for trigger_pipeline / dispatch_task. No arguments.",
+    input_schema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'dispatch_task',
+    description: 'Dispatch a one-shot background Claude task in a Forge project. Use for longer-running asks the user wants to fire-and-forget ("analyze X codebase and write findings to a file", "run the test suite and summarize failures"). Returns immediately with the task id; the task runs in the background and the user can check the Tasks view for output.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        prompt: {
+          type: 'string',
+          description: 'The full instruction text Claude should execute. Be specific about what files to read, what to produce.',
+        },
+        project: {
+          type: 'string',
+          description: 'Forge project name (the working directory). Defaults to "scratch" if omitted. Use "scratch" for connector-only / no-filesystem tasks.',
+        },
+        agent: {
+          type: 'string',
+          description: 'Optional agent id override. Omit to use the project default.',
+        },
+      },
+      required: ['prompt'],
+    },
+  },
 ];
 
 // ─── Connector dispatch ──────────────────────────────────

package/lib/pipeline.ts

@@ -871,6 +871,25 @@ export function startPipeline(
   const workflow = getWorkflow(workflowName);
   if (!workflow) throw new Error(`Workflow not found: ${workflowName}`);
 
+  // Apply declared defaults for any field the caller didn't pass. UI callers
+  // (Schedule form, Fire dialog) already pre-fill all fields with their
+  // defaults at form-load time, so for them this merge is a no-op. Sparse-input
+  // callers (chat trigger_pipeline, MCP, direct API) only send what the user
+  // explicitly named; without this merge multi-line defaults like
+  // mr_body_template / user_prompt come through as empty → "{{input.X}}"
+  // renders to '' → MR body empty / triage prompt empty.
+  //
+  // Semantics: ONLY fill when the key is missing from the input map. An
+  // empty-string value is respected as "intentionally cleared" so schedule
+  // users who clear a field in the form keep that behaviour.
+  for (const [key, spec] of Object.entries(workflow.input || {})) {
+    if (Object.prototype.hasOwnProperty.call(input, key)) continue;
+    if (!spec || typeof spec !== 'object') continue;
+    const def = (spec as WorkflowInputFieldSpec).default;
+    if (def == null) continue;
+    input = { ...input, [key]: String(def) };
+  }
+
   // Conversation mode — separate execution path
   if (workflow.type === 'conversation' && workflow.conversation) {
     return startConversationPipeline(workflow, input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.9.13",
+  "version": "0.9.14",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {