@workglow/ai 0.2.32 → 0.2.34

package/dist/bun.js

@@ -1014,6 +1014,28 @@ var TypeCategory = {
   description: "Classification category with label and score"
 };
 
+// src/task/base/responseFormat.ts
+function buildResponseFormatAddendum(format) {
+  if (format === "markdown") {
+    return [
+      "Format your reply as GitHub-flavored Markdown:",
+      "- Use headings, bullet lists, numbered lists, tables, and fenced code blocks where they help readability.",
+      "- Use **bold** and *italic* sparingly for emphasis.",
+      "- Keep paragraphs short."
+    ].join(`
+`);
+  }
+  return "";
+}
+var KB_INLINE_CITATION_DIRECTIVE = [
+  "When you reference information from the context above, cite it inline as a",
+  "Markdown link: write the natural anchor text in brackets followed by the",
+  "URL in parentheses, e.g. `[the dashboard](https://workglow.com/help/dashboard)`.",
+  "Do not use numeric `[1]`-style citations. If a context entry has no URL,",
+  "describe it in prose without a link."
+].join(`
+`);
+
 // src/task/base/StreamingAiTask.ts
 import { getStreamingPorts, TaskConfigurationError as TaskConfigurationError3 } from "@workglow/task-graph";
 
@@ -1430,6 +1452,14 @@ var AiChatInputSchema = {
       minimum: 1,
       default: 100,
       "x-ui-group": "Configuration"
+    },
+    responseFormat: {
+      type: "string",
+      enum: ["text", "markdown"],
+      default: "text",
+      title: "Response format",
+      description: "How the model is instructed to format replies. 'text' = plain text. " + "'markdown' = GitHub-flavored Markdown.",
+      "x-ui-group": "Configuration"
     }
   },
   required: ["model", "prompt"],
@@ -1441,7 +1471,7 @@ var AiChatOutputSchema = {
     text: {
       type: "string",
       title: "Text",
-      description: "Last assistant response",
+      description: "Full streamed transcript across all assistant turns",
       "x-stream": "append"
     },
     messages: {
@@ -1504,8 +1534,15 @@ class AiChatTask extends StreamingAiTask {
     }
     const connector = resolveHumanConnector(context);
     const history = [];
-    if (input.systemPrompt) {
-      history.push({ role: "system", content: [{ type: "text", text: input.systemPrompt }] });
+    const addendum = buildResponseFormatAddendum(input.responseFormat);
+    const composedSystemPrompt = [input.systemPrompt ?? "", addendum].filter((s) => s.length > 0).join(`
+
+`);
+    if (composedSystemPrompt.length > 0) {
+      history.push({
+        role: "system",
+        content: [{ type: "text", text: composedSystemPrompt }]
+      });
     }
     const firstUserBlocks = typeof input.prompt === "string" ? [{ type: "text", text: input.prompt }] : input.prompt;
     history.push({ role: "user", content: firstUserBlocks });
@@ -1519,13 +1556,12 @@ class AiChatTask extends StreamingAiTask {
         await getAiProviderRegistry().disposeSession(model.provider, sessionId);
       });
     }
+    let completedTurns = 0;
     yield {
       type: "object-delta",
       port: "messages",
       objectDelta: [...history]
     };
-    let iterations = 0;
-    let lastAssistantText = "";
     for (let turn = 0;turn < maxIterations; turn++) {
       const perTurnInput = { ...input, messages: [...history] };
       const turnJobInput = await this.getJobInput(perTurnInput);
@@ -1537,17 +1573,487 @@ class AiChatTask extends StreamingAiTask {
             ...event,
             port: event.port ?? "text"
           };
-        } else if (event.type === "finish") {} else {
-          yield event;
+        } else if (event.type === "finish") {} else {
+          yield event;
+        }
+      }
+      const assistantMsg = {
+        role: "assistant",
+        content: [{ type: "text", text: assistantText }]
+      };
+      history.push(assistantMsg);
+      completedTurns = turn + 1;
+      yield {
+        type: "object-delta",
+        port: "messages",
+        objectDelta: [assistantMsg]
+      };
+      const request = {
+        requestId: crypto.randomUUID(),
+        targetHumanId: "default",
+        kind: "elicit",
+        message: "",
+        contentSchema: chatConnectorContentSchema,
+        contentData: undefined,
+        expectsResponse: true,
+        mode: "multi-turn",
+        metadata: { iteration: turn, taskId: this.id }
+      };
+      const response = await connector.send(request, context.signal);
+      if (response.action === "cancel" || response.action === "decline")
+        break;
+      const raw = response.content?.content;
+      let userContent;
+      if (typeof raw === "string") {
+        const text = raw.trim();
+        userContent = text.length > 0 ? [{ type: "text", text: raw }] : [];
+      } else if (Array.isArray(raw)) {
+        userContent = raw;
+      } else {
+        userContent = [];
+      }
+      if (userContent.length === 0)
+        break;
+      const userMsg = { role: "user", content: userContent };
+      history.push(userMsg);
+      yield {
+        type: "object-delta",
+        port: "messages",
+        objectDelta: [userMsg]
+      };
+    }
+    yield {
+      type: "finish",
+      data: { iterations: completedTurns }
+    };
+  }
+}
+
+// src/task/AiChatWithKbTask.ts
+import { getKnowledgeBase, slugifyHeading } from "@workglow/knowledge-base";
+import { TaskConfigSchema as TaskConfigSchema3 } from "@workglow/task-graph";
+import { resolveHumanConnector as resolveHumanConnector2 } from "@workglow/util";
+
+// src/task/KbSearchTask.ts
+import { TypeKnowledgeBase } from "@workglow/knowledge-base";
+import { CreateWorkflow, Task as Task2, Workflow } from "@workglow/task-graph";
+var inputSchema = {
+  type: "object",
+  properties: {
+    knowledgeBase: TypeKnowledgeBase({
+      title: "Knowledge Base",
+      description: "The knowledge base instance to search in"
+    }),
+    query: {
+      type: "string",
+      title: "Query",
+      description: "Search query (the KB's onSearch handles embedding internally)"
+    },
+    topK: {
+      type: "number",
+      title: "Top K",
+      description: "Number of top results to return",
+      minimum: 1,
+      default: 5
+    },
+    filter: {
+      type: "object",
+      title: "Metadata Filter",
+      description: "Filter results by metadata fields"
+    }
+  },
+  required: ["knowledgeBase", "query"],
+  additionalProperties: false
+};
+var outputSchema = {
+  type: "object",
+  properties: {
+    results: {
+      type: "array",
+      items: {
+        type: "object",
+        title: "Chunk Search Result",
+        description: "A single chunk match with score and metadata"
+      },
+      title: "Results",
+      description: "Matching chunks in score-desc order"
+    },
+    count: {
+      type: "number",
+      title: "Count",
+      description: "Number of results returned"
+    }
+  },
+  required: ["results", "count"],
+  additionalProperties: false
+};
+
+class KbSearchTask extends Task2 {
+  static type = "KbSearchTask";
+  static category = "RAG";
+  static title = "KB Search";
+  static description = "Search a knowledge base for chunks matching a text query. Wraps the KB's `search` method (which embeds and retrieves via the KB's onSearch callback).";
+  static cacheable = true;
+  static inputSchema() {
+    return inputSchema;
+  }
+  static outputSchema() {
+    return outputSchema;
+  }
+  async execute(input, _context) {
+    const { knowledgeBase, query, topK = 5, filter } = input;
+    const kb = knowledgeBase;
+    const results = await kb.search(query, { topK, filter });
+    return { results, count: results.length };
+  }
+}
+var kbSearch = (input, config) => {
+  return new KbSearchTask(config).run(input);
+};
+Workflow.prototype.kbSearch = CreateWorkflow(KbSearchTask);
+
+// src/task/AiChatWithKbTask.ts
+var modelSchema2 = TypeModel("model:AiChatWithKbTask");
+var chatChunkReferenceSchema = {
+  type: "object",
+  properties: {
+    kbId: { type: "string" },
+    kbLabel: { type: "string" },
+    title: { type: "string" },
+    url: { type: "string" },
+    snippet: { type: "string" },
+    score: { type: "number" },
+    index: { type: "number" }
+  },
+  required: ["kbId", "kbLabel", "title", "snippet", "score", "index"]
+};
+var chatConnectorContentSchema2 = {
+  type: "object",
+  properties: {
+    content: {
+      type: "string",
+      title: "Message",
+      description: "Your reply (leave blank to end the conversation)"
+    }
+  },
+  additionalProperties: false
+};
+var AiChatWithKbInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema2,
+    prompt: {
+      oneOf: [
+        { type: "string", title: "Prompt", description: "The initial user message" },
+        {
+          type: "array",
+          title: "Prompt",
+          description: "The initial user message as structured content blocks",
+          items: ContentBlockSchema
+        }
+      ],
+      title: "Prompt",
+      description: "The first user message to start the conversation"
+    },
+    messages: {
+      type: "array",
+      title: "Messages",
+      description: "Conversation history (managed internally by the chat loop; not a user-facing input)",
+      items: ChatMessageSchema,
+      "x-ui-hidden": true
+    },
+    systemPrompt: {
+      type: "string",
+      title: "System Prompt",
+      description: "Optional system instructions for the model"
+    },
+    maxTokens: {
+      type: "number",
+      title: "Max Tokens",
+      description: "Per-turn token limit",
+      minimum: 1,
+      "x-ui-group": "Configuration"
+    },
+    temperature: {
+      type: "number",
+      title: "Temperature",
+      description: "Sampling temperature",
+      minimum: 0,
+      maximum: 2,
+      "x-ui-group": "Configuration"
+    },
+    maxIterations: {
+      type: "number",
+      title: "Max Iterations",
+      description: "Safety cap on conversation turns",
+      minimum: 1,
+      default: 100,
+      "x-ui-group": "Configuration"
+    },
+    knowledgeBaseIds: {
+      type: "array",
+      title: "Knowledge Base IDs",
+      description: "Knowledge bases to retrieve from on each turn",
+      items: { type: "string" }
+    },
+    topKPerKb: {
+      type: "number",
+      title: "Top K per KB",
+      description: "Top results per KB before threshold filtering",
+      minimum: 1,
+      default: 4,
+      "x-ui-group": "Configuration"
+    },
+    minScore: {
+      type: "number",
+      title: "Min score",
+      description: "Score floor for a chunk to count as a useful match",
+      minimum: 0,
+      maximum: 1,
+      default: 0.3,
+      "x-ui-group": "Configuration"
+    },
+    maxReferences: {
+      type: "number",
+      title: "Max references",
+      description: "Cap on the chunk references emitted per turn",
+      minimum: 1,
+      default: 6,
+      "x-ui-group": "Configuration"
+    },
+    noMatchReply: {
+      type: "string",
+      title: "No-match reply",
+      description: "When set and zero chunks match: emit this verbatim and skip the provider",
+      "x-ui-group": "Configuration"
+    },
+    noMatchReferences: {
+      type: "array",
+      title: "No-match references",
+      description: "When set and zero chunks match: emit these verbatim on the references port",
+      items: chatChunkReferenceSchema,
+      "x-ui-group": "Configuration"
+    },
+    responseFormat: {
+      type: "string",
+      enum: ["text", "markdown"],
+      default: "text",
+      title: "Response format",
+      description: "How the model is instructed to format replies. 'text' = plain text. " + "'markdown' = GitHub-flavored Markdown; citations are emitted as inline " + "[anchor](url) links instead of [N] numbers.",
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["model", "prompt", "knowledgeBaseIds"],
+  additionalProperties: false
+};
+var AiChatWithKbOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "Full streamed transcript across all assistant turns",
+      "x-stream": "append"
+    },
+    messages: {
+      type: "array",
+      title: "Messages",
+      description: "Full conversation history",
+      items: ChatMessageSchema,
+      "x-stream": "object"
+    },
+    iterations: {
+      type: "number",
+      title: "Iterations",
+      description: "Number of completed turns"
+    },
+    references: {
+      type: "array",
+      title: "References",
+      description: "Per-chunk citation references emitted each turn (one entry per surviving chunk; not deduped)",
+      items: chatChunkReferenceSchema,
+      "x-stream": "object"
+    }
+  },
+  required: ["text", "messages", "iterations", "references"],
+  additionalProperties: false
+};
+
+class AiChatWithKbTask extends StreamingAiTask {
+  static type = "AiChatWithKbTask";
+  static streamingPhaseLabel = "Replying";
+  static category = "AI Chat";
+  static title = "AI Chat (Knowledge Base)";
+  static description = "Multi-turn chat grounded in one or more knowledge bases. Retrieves on every user turn, injects numbered context, and emits structured per-chunk citation references.";
+  static cacheable = false;
+  static configSchema() {
+    return {
+      type: "object",
+      properties: {
+        ...TaskConfigSchema3["properties"]
+      },
+      additionalProperties: false
+    };
+  }
+  static inputSchema() {
+    return AiChatWithKbInputSchema;
+  }
+  static outputSchema() {
+    return AiChatWithKbOutputSchema;
+  }
+  _sessionId;
+  async getJobInput(input) {
+    const model = input.model;
+    if (!this._sessionId) {
+      this._sessionId = getAiProviderRegistry().createSession(model.provider, model);
+    }
+    return {
+      taskType: "AiChatWithKbTask",
+      aiProvider: model.provider,
+      taskInput: input,
+      sessionId: this._sessionId
+    };
+  }
+  async* executeStream(input, context) {
+    this._sessionId = undefined;
+    const model = input.model;
+    if (!model || typeof model !== "object") {
+      throw new Error("AiChatWithKbTask: model was not resolved to ModelConfig");
+    }
+    const connector = resolveHumanConnector2(context);
+    const history = [];
+    if (input.systemPrompt) {
+      history.push({ role: "system", content: [{ type: "text", text: input.systemPrompt }] });
+    }
+    const firstUserBlocks = typeof input.prompt === "string" ? [{ type: "text", text: input.prompt }] : input.prompt;
+    history.push({ role: "user", content: firstUserBlocks });
+    const workingInput = { ...input, messages: history };
+    await this.getJobInput(workingInput);
+    const maxIterations = input.maxIterations ?? 100;
+    if (context.resourceScope && this._sessionId) {
+      const sessionId = this._sessionId;
+      context.resourceScope.register(`ai:session:${sessionId}`, async () => {
+        await getAiProviderRegistry().disposeSession(model.provider, sessionId);
+      });
+    }
+    yield {
+      type: "object-delta",
+      port: "messages",
+      objectDelta: [...history]
+    };
+    const topK = input.topKPerKb ?? 4;
+    const minScore = input.minScore ?? 0.3;
+    const maxRefs = input.maxReferences ?? 6;
+    let completedTurns = 0;
+    let lastNonEmptyRefs = [];
+    for (let turn = 0;turn < maxIterations; turn++) {
+      const lastUserText = extractLastUserText(history);
+      let perKbResults = [];
+      if (lastUserText.length > 0) {
+        perKbResults = await Promise.all((input.knowledgeBaseIds ?? []).map(async (kbId) => {
+          const kb = getKnowledgeBase(kbId);
+          if (!kb) {
+            console.warn(`[AiChatWithKbTask] knowledge base "${kbId}" not registered`);
+            return { kbId, kbLabel: kbId, kb: undefined, results: [] };
+          }
+          const search = context.own(new KbSearchTask);
+          const out = await search.run({
+            knowledgeBase: kb,
+            query: lastUserText,
+            topK
+          });
+          return {
+            kbId,
+            kbLabel: kb.title || kbId,
+            kb,
+            results: out.results
+          };
+        }));
+      }
+      const allChunks = perKbResults.flatMap(({ kbId, kbLabel, kb, results }) => results.filter((r) => r.score >= minScore).map((r) => ({ kbId, kbLabel, kb, r }))).sort((a, b) => b.r.score - a.r.score).slice(0, maxRefs);
+      const docUrlKey = (kbId, docId) => `${kbId}:${docId}`;
+      const docUrls = new Map;
+      const docFetches = [];
+      for (const { kbId, kb, r } of allChunks) {
+        if (!kb)
+          continue;
+        const key = docUrlKey(kbId, r.doc_id);
+        if (docUrls.has(key))
+          continue;
+        docUrls.set(key, undefined);
+        docFetches.push(kb.getDocument(r.doc_id).then((doc) => {
+          const md = doc?.metadata ?? {};
+          const url = typeof md.url === "string" ? md.url : undefined;
+          docUrls.set(key, url);
+        }).catch(() => {}));
+      }
+      await Promise.all(docFetches);
+      const refs = allChunks.map((entry, i) => buildChunkReference({
+        index: i + 1,
+        kbId: entry.kbId,
+        kbLabel: entry.kbLabel,
+        result: entry.r,
+        url: docUrls.get(docUrlKey(entry.kbId, entry.r.doc_id))
+      }));
+      const effectiveRefs = refs.length > 0 ? refs : lastNonEmptyRefs;
+      if (refs.length > 0) {
+        lastNonEmptyRefs = refs;
+      }
+      const emitted = effectiveRefs.length > 0 ? [...effectiveRefs] : input.noMatchReferences ?? [];
+      yield {
+        type: "object-delta",
+        port: "references",
+        objectDelta: emitted
+      };
+      let assistantText = "";
+      if (effectiveRefs.length === 0 && input.noMatchReply) {
+        yield {
+          type: "text-delta",
+          port: "text",
+          textDelta: input.noMatchReply
+        };
+        assistantText = input.noMatchReply;
+      } else {
+        const addendum = buildResponseFormatAddendum(input.responseFormat);
+        const directive = input.responseFormat === "markdown" ? KB_INLINE_CITATION_DIRECTIVE : "";
+        const userSystemPrompt = input.systemPrompt ?? "";
+        const turnSystemPrompt = [
+          userSystemPrompt,
+          addendum,
+          directive,
+          "--- Context ---",
+          formatChunksForPrompt(effectiveRefs, input.responseFormat)
+        ].filter((s) => s.length > 0).join(`
+
+`);
+        const perTurnInput = {
+          ...input,
+          messages: [
+            { role: "system", content: [{ type: "text", text: turnSystemPrompt }] },
+            ...history.filter((m) => m.role !== "system")
+          ],
+          systemPrompt: turnSystemPrompt
+        };
+        const turnJobInput = await this.getJobInput(perTurnInput);
+        const strategy = getAiProviderRegistry().getStrategy(model);
+        for await (const event of strategy.executeStream(turnJobInput, context, this.runConfig.runnerId)) {
+          if (event.type === "text-delta") {
+            assistantText += event.textDelta;
+            yield {
+              ...event,
+              port: event.port ?? "text"
+            };
+          } else if (event.type === "finish") {} else {
+            yield event;
+          }
         }
       }
-      iterations++;
-      lastAssistantText = assistantText;
       const assistantMsg = {
         role: "assistant",
         content: [{ type: "text", text: assistantText }]
       };
       history.push(assistantMsg);
+      completedTurns = turn + 1;
       yield {
         type: "object-delta",
         port: "messages",
@@ -1558,7 +2064,7 @@ class AiChatTask extends StreamingAiTask {
         targetHumanId: "default",
         kind: "elicit",
         message: "",
-        contentSchema: chatConnectorContentSchema,
+        contentSchema: chatConnectorContentSchema2,
         contentData: undefined,
         expectsResponse: true,
         mode: "multi-turn",
@@ -1589,26 +2095,68 @@ class AiChatTask extends StreamingAiTask {
     }
     yield {
       type: "finish",
-      data: {
-        text: lastAssistantText,
-        messages: [...history],
-        iterations
-      }
+      data: { iterations: completedTurns }
     };
   }
-  async execute(input, context) {
-    let result;
-    for await (const event of this.executeStream(input, context)) {
-      if (event.type === "finish") {
-        result = event.data;
-      }
+}
+function extractLastUserText(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const m = messages[i];
+    if (!m || m.role !== "user")
+      continue;
+    const text = m.content.map((b) => b.type === "text" ? b.text : "").join(" ").trim();
+    if (text.length > 0)
+      return text;
+  }
+  return "";
+}
+function buildChunkReference(args) {
+  const md = args.result.metadata ?? {};
+  const title = md.doc_title ?? md.title ?? args.result.doc_id ?? "Untitled";
+  const baseUrl = args.url ?? md.url ?? undefined;
+  const url = withSectionAnchor(baseUrl, md.sectionTitles);
+  const text = md.text ?? "";
+  const snippet = text.length > 150 ? text.slice(0, 150).trim() + "\u2026" : text;
+  return {
+    index: args.index,
+    kbId: args.kbId,
+    kbLabel: args.kbLabel,
+    title,
+    url,
+    snippet,
+    score: args.result.score
+  };
+}
+function withSectionAnchor(url, sectionTitles) {
+  if (!url)
+    return url;
+  if (url.includes("#"))
+    return url;
+  if (!sectionTitles || sectionTitles.length === 0)
+    return url;
+  const deepest = sectionTitles[sectionTitles.length - 1];
+  if (typeof deepest !== "string")
+    return url;
+  const slug = slugifyHeading(deepest);
+  if (slug.length === 0)
+    return url;
+  return `${url}#${slug}`;
+}
+function formatChunksForPrompt(refs, responseFormat) {
+  return refs.map((r) => {
+    const head = `[${r.index}] [${r.kbLabel}] (${r.title})`;
+    if (responseFormat === "markdown" && r.url) {
+      return `${head} <${r.url}>
+    ${r.snippet}`;
     }
-    return result;
-  }
+    return `${head} ${r.snippet}`;
+  }).join(`
+
+`);
 }
 
 // src/task/BackgroundRemovalTask.ts
-import { CreateWorkflow, Workflow } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow2, Workflow as Workflow2 } from "@workglow/task-graph";
 import { ImageValueSchema } from "@workglow/util/media";
 
 // src/task/base/AiVisionTask.ts
@@ -1617,12 +2165,12 @@ class AiVisionTask extends AiTask {
 }
 
 // src/task/BackgroundRemovalTask.ts
-var modelSchema2 = TypeModel("model:BackgroundRemovalTask");
+var modelSchema3 = TypeModel("model:BackgroundRemovalTask");
 var BackgroundRemovalInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema2
+    model: modelSchema3
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -1654,22 +2202,22 @@ class BackgroundRemovalTask extends AiVisionTask {
 var backgroundRemoval = (input, config) => {
   return new BackgroundRemovalTask(config).run(input);
 };
-Workflow.prototype.backgroundRemoval = CreateWorkflow(BackgroundRemovalTask);
+Workflow2.prototype.backgroundRemoval = CreateWorkflow2(BackgroundRemovalTask);
 
 // src/task/ChunkRetrievalTask.ts
-import { TypeKnowledgeBase } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow3, Task as Task2, Workflow as Workflow3 } from "@workglow/task-graph";
+import { TypeKnowledgeBase as TypeKnowledgeBase2 } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow4, Task as Task3, Workflow as Workflow4 } from "@workglow/task-graph";
 import {
   isTypedArray,
   TypedArraySchema as TypedArraySchema2
 } from "@workglow/util/schema";
 
 // src/task/TextEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow2, Workflow as Workflow2 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow3, Workflow as Workflow3 } from "@workglow/task-graph";
 import {
   TypedArraySchema
 } from "@workglow/util/schema";
-var modelSchema3 = TypeModel("model:TextEmbeddingTask");
+var modelSchema4 = TypeModel("model:TextEmbeddingTask");
 var TextEmbeddingInputSchema = {
   type: "object",
   properties: {
@@ -1678,7 +2226,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema3
+    model: modelSchema4
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1710,13 +2258,13 @@ class TextEmbeddingTask extends AiTask {
 var textEmbedding = async (input, config) => {
   return new TextEmbeddingTask(config).run(input);
 };
-Workflow2.prototype.textEmbedding = CreateWorkflow2(TextEmbeddingTask);
+Workflow3.prototype.textEmbedding = CreateWorkflow3(TextEmbeddingTask);
 
 // src/task/ChunkRetrievalTask.ts
-var inputSchema = {
+var inputSchema2 = {
   type: "object",
   properties: {
-    knowledgeBase: TypeKnowledgeBase({
+    knowledgeBase: TypeKnowledgeBase2({
       title: "Knowledge Base",
       description: "The knowledge base instance to search in"
     }),
@@ -1789,7 +2337,7 @@ var inputSchema = {
   else: {},
   additionalProperties: false
 };
-var outputSchema = {
+var outputSchema2 = {
   type: "object",
   properties: {
     chunks: {
@@ -1850,17 +2398,17 @@ var outputSchema = {
   additionalProperties: false
 };
 
-class ChunkRetrievalTask extends Task2 {
+class ChunkRetrievalTask extends Task3 {
   static type = "ChunkRetrievalTask";
   static category = "RAG";
   static title = "Chunk Retrieval";
   static description = "End-to-end retrieval: embed query (if string) and search the knowledge base. Supports similarity and hybrid methods.";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema;
+    return inputSchema2;
   }
   static outputSchema() {
-    return outputSchema;
+    return outputSchema2;
   }
   async execute(input, context) {
     const {
@@ -1931,18 +2479,18 @@ class ChunkRetrievalTask extends Task2 {
 var chunkRetrieval = (input, config) => {
   return new ChunkRetrievalTask(config).run(input);
 };
-Workflow3.prototype.chunkRetrieval = CreateWorkflow3(ChunkRetrievalTask);
+Workflow4.prototype.chunkRetrieval = CreateWorkflow4(ChunkRetrievalTask);
 
 // src/task/ChunkVectorUpsertTask.ts
-import { ChunkRecordArraySchema, TypeKnowledgeBase as TypeKnowledgeBase2 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow4, Task as Task3, Workflow as Workflow4 } from "@workglow/task-graph";
+import { ChunkRecordArraySchema, TypeKnowledgeBase as TypeKnowledgeBase3 } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow5, Task as Task4, Workflow as Workflow5 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema3
 } from "@workglow/util/schema";
-var inputSchema2 = {
+var inputSchema3 = {
   type: "object",
   properties: {
-    knowledgeBase: TypeKnowledgeBase2({
+    knowledgeBase: TypeKnowledgeBase3({
       title: "Knowledge Base",
       description: "The knowledge base instance to store vectors in"
     }),
@@ -1960,7 +2508,7 @@ var inputSchema2 = {
   required: ["knowledgeBase", "chunks", "vector"],
   additionalProperties: false
 };
-var outputSchema2 = {
+var outputSchema3 = {
   type: "object",
   properties: {
     count: {
@@ -1984,17 +2532,17 @@ var outputSchema2 = {
   additionalProperties: false
 };
 
-class ChunkVectorUpsertTask extends Task3 {
+class ChunkVectorUpsertTask extends Task4 {
   static type = "ChunkVectorUpsertTask";
   static category = "Document";
   static title = "Add to Vector Store";
   static description = "Store chunks + their embeddings in a knowledge base (1:1 aligned)";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema2;
+    return inputSchema3;
   }
   static outputSchema() {
-    return outputSchema2;
+    return outputSchema3;
   }
   async execute(input, context) {
     const { knowledgeBase, chunks, vector, doc_title } = input;
@@ -2039,19 +2587,19 @@ class ChunkVectorUpsertTask extends Task3 {
 var chunkVectorUpsert = (input, config) => {
   return new ChunkVectorUpsertTask(config).run(input);
 };
-Workflow4.prototype.chunkVectorUpsert = CreateWorkflow4(ChunkVectorUpsertTask);
+Workflow5.prototype.chunkVectorUpsert = CreateWorkflow5(ChunkVectorUpsertTask);
 
 // src/task/ContextBuilderTask.ts
 import { estimateTokens } from "@workglow/knowledge-base";
 import {
-  CreateWorkflow as CreateWorkflow6,
-  Task as Task4,
-  Workflow as Workflow6
+  CreateWorkflow as CreateWorkflow7,
+  Task as Task5,
+  Workflow as Workflow7
 } from "@workglow/task-graph";
 
 // src/task/CountTokensTask.ts
-import { CreateWorkflow as CreateWorkflow5, Workflow as Workflow5 } from "@workglow/task-graph";
-var modelSchema4 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow6, Workflow as Workflow6 } from "@workglow/task-graph";
+var modelSchema5 = TypeModel("model");
 var CountTokensInputSchema = {
   type: "object",
   properties: {
@@ -2060,7 +2608,7 @@ var CountTokensInputSchema = {
       title: "Text",
       description: "The text to count tokens for"
     },
-    model: modelSchema4
+    model: modelSchema5
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2094,7 +2642,7 @@ class CountTokensTask extends AiTask {
 var countTokens = async (input, config) => {
   return new CountTokensTask(config).run(input);
 };
-Workflow5.prototype.countTokens = CreateWorkflow5(CountTokensTask);
+Workflow6.prototype.countTokens = CreateWorkflow6(CountTokensTask);
 
 // src/task/ContextBuilderTask.ts
 var ContextFormat = {
@@ -2104,11 +2652,11 @@ var ContextFormat = {
   MARKDOWN: "markdown",
   JSON: "json"
 };
-var modelSchema5 = TypeModel("model", {
+var modelSchema6 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting (optional, falls back to estimation)"
 });
-var inputSchema3 = {
+var inputSchema4 = {
   type: "object",
   properties: {
     chunks: {
@@ -2168,12 +2716,12 @@ var inputSchema3 = {
 
 `
     },
-    model: modelSchema5
+    model: modelSchema6
   },
   required: ["chunks"],
   additionalProperties: false
 };
-var outputSchema3 = {
+var outputSchema4 = {
   type: "object",
   properties: {
     context: {
@@ -2201,17 +2749,17 @@ var outputSchema3 = {
   additionalProperties: false
 };
 
-class ContextBuilderTask extends Task4 {
+class ContextBuilderTask extends Task5 {
   static type = "ContextBuilderTask";
   static category = "RAG";
   static title = "Context Builder";
   static description = "Format retrieved chunks into context for LLM prompts";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema3;
+    return inputSchema4;
   }
   static outputSchema() {
-    return outputSchema3;
+    return outputSchema4;
   }
   async execute(input, context) {
     return this.executePreview(input, context);
@@ -2397,15 +2945,15 @@ class ContextBuilderTask extends Task4 {
 var contextBuilder = (input, config) => {
   return new ContextBuilderTask(config).run(input);
 };
-Workflow6.prototype.contextBuilder = CreateWorkflow6(ContextBuilderTask);
+Workflow7.prototype.contextBuilder = CreateWorkflow7(ContextBuilderTask);
 
 // src/task/DocumentEnricherTask.ts
 import { getChildren, hasChildren } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow9, Task as Task5, Workflow as Workflow9 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow10, Task as Task6, Workflow as Workflow10 } from "@workglow/task-graph";
 
 // src/task/TextNamedEntityRecognitionTask.ts
-import { CreateWorkflow as CreateWorkflow7, Workflow as Workflow7 } from "@workglow/task-graph";
-var modelSchema6 = TypeModel("model:TextNamedEntityRecognitionTask");
+import { CreateWorkflow as CreateWorkflow8, Workflow as Workflow8 } from "@workglow/task-graph";
+var modelSchema7 = TypeModel("model:TextNamedEntityRecognitionTask");
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
   properties: {
@@ -2424,7 +2972,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema6
+    model: modelSchema7
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2479,11 +3027,11 @@ class TextNamedEntityRecognitionTask extends AiTask {
 var textNamedEntityRecognition = (input, config) => {
   return new TextNamedEntityRecognitionTask(config).run(input);
 };
-Workflow7.prototype.textNamedEntityRecognition = CreateWorkflow7(TextNamedEntityRecognitionTask);
+Workflow8.prototype.textNamedEntityRecognition = CreateWorkflow8(TextNamedEntityRecognitionTask);
 
 // src/task/TextSummaryTask.ts
-import { CreateWorkflow as CreateWorkflow8, Workflow as Workflow8 } from "@workglow/task-graph";
-var modelSchema7 = TypeModel("model:TextSummaryTask");
+import { CreateWorkflow as CreateWorkflow9, Workflow as Workflow9 } from "@workglow/task-graph";
+var modelSchema8 = TypeModel("model:TextSummaryTask");
 var TextSummaryInputSchema = {
   type: "object",
   properties: {
@@ -2492,7 +3040,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     },
-    model: modelSchema7
+    model: modelSchema8
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2527,10 +3075,10 @@ class TextSummaryTask extends StreamingAiTask {
 var textSummary = async (input, config) => {
   return new TextSummaryTask(config).run(input);
 };
-Workflow8.prototype.textSummary = CreateWorkflow8(TextSummaryTask);
+Workflow9.prototype.textSummary = CreateWorkflow9(TextSummaryTask);
 
 // src/task/DocumentEnricherTask.ts
-var inputSchema4 = {
+var inputSchema5 = {
   type: "object",
   properties: {
     doc_id: {
@@ -2574,7 +3122,7 @@ var inputSchema4 = {
   required: [],
   additionalProperties: false
 };
-var outputSchema4 = {
+var outputSchema5 = {
   type: "object",
   properties: {
     doc_id: {
@@ -2601,17 +3149,17 @@ var outputSchema4 = {
   additionalProperties: false
 };
 
-class DocumentEnricherTask extends Task5 {
+class DocumentEnricherTask extends Task6 {
   static type = "DocumentEnricherTask";
   static category = "Document";
   static title = "Document Enricher";
   static description = "Enrich document nodes with summaries and entities";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema4;
+    return inputSchema5;
   }
   static outputSchema() {
-    return outputSchema4;
+    return outputSchema5;
   }
   async execute(input, context) {
     const {
@@ -2760,19 +3308,19 @@ class DocumentEnricherTask extends Task5 {
 var documentEnricher = (input, config) => {
   return new DocumentEnricherTask(config).run(input);
 };
-Workflow9.prototype.documentEnricher = CreateWorkflow9(DocumentEnricherTask);
+Workflow10.prototype.documentEnricher = CreateWorkflow10(DocumentEnricherTask);
 
 // src/task/DocumentUpsertTask.ts
 import {
   Document,
   DocumentMetadataSchema,
-  TypeKnowledgeBase as TypeKnowledgeBase3
+  TypeKnowledgeBase as TypeKnowledgeBase4
 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow10, Task as Task6, Workflow as Workflow10 } from "@workglow/task-graph";
-var inputSchema5 = {
+import { CreateWorkflow as CreateWorkflow11, Task as Task7, Workflow as Workflow11 } from "@workglow/task-graph";
+var inputSchema6 = {
   type: "object",
   properties: {
-    knowledgeBase: TypeKnowledgeBase3({
+    knowledgeBase: TypeKnowledgeBase4({
       title: "Knowledge Base",
       description: "The knowledge base instance to store the document in"
     }),
@@ -2800,7 +3348,7 @@ var inputSchema5 = {
   required: ["knowledgeBase", "doc_id", "documentTree"],
   additionalProperties: false
 };
-var outputSchema5 = {
+var outputSchema6 = {
   type: "object",
   properties: {
     doc_id: {
@@ -2813,17 +3361,17 @@ var outputSchema5 = {
   additionalProperties: false
 };
 
-class DocumentUpsertTask extends Task6 {
+class DocumentUpsertTask extends Task7 {
   static type = "DocumentUpsertTask";
   static category = "Document";
   static title = "Add Document";
   static description = "Persist a parsed document tree to a knowledge base";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema5;
+    return inputSchema6;
   }
   static outputSchema() {
-    return outputSchema5;
+    return outputSchema6;
   }
   async execute(input, context) {
     const { knowledgeBase, doc_id, documentTree, title, metadata } = input;
@@ -2846,15 +3394,15 @@ class DocumentUpsertTask extends Task6 {
 var documentUpsert = (input, config) => {
   return new DocumentUpsertTask(config).run(input);
 };
-Workflow10.prototype.documentUpsert = CreateWorkflow10(DocumentUpsertTask);
+Workflow11.prototype.documentUpsert = CreateWorkflow11(DocumentUpsertTask);
 
 // src/task/DownloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow11, Workflow as Workflow11 } from "@workglow/task-graph";
-var modelSchema8 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow12, Workflow as Workflow12 } from "@workglow/task-graph";
+var modelSchema9 = TypeModel("model");
 var DownloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema8
+    model: modelSchema9
   },
   required: ["model"],
   additionalProperties: false
@@ -2862,7 +3410,7 @@ var DownloadModelInputSchema = {
 var DownloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema8
+    model: modelSchema9
   },
   required: ["model"],
   additionalProperties: false
@@ -2916,10 +3464,10 @@ class DownloadModelTask extends AiTask {
 var downloadModel = (input, config) => {
   return new DownloadModelTask(config).run(input);
 };
-Workflow11.prototype.downloadModel = CreateWorkflow11(DownloadModelTask);
+Workflow12.prototype.downloadModel = CreateWorkflow12(DownloadModelTask);
 
 // src/task/generation/ImageEditTask.ts
-import { CreateWorkflow as CreateWorkflow12, Workflow as Workflow12 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
 import { ImageValueSchema as ImageValueSchema3 } from "@workglow/util/media";
 
 // src/task/base/AiImageOutputTask.ts
@@ -3051,11 +3599,11 @@ var AiImageOutputSchema = {
 };
 
 // src/task/generation/ImageEditTask.ts
-var modelSchema9 = TypeModel("model:ImageEditTask");
+var modelSchema10 = TypeModel("model:ImageEditTask");
 var ImageEditInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema9,
+    model: modelSchema10,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -3103,11 +3651,11 @@ class ImageEditTask extends AiImageOutputTask {
   }
 }
 var imageEdit = (input, config) => new ImageEditTask(config).run(input);
-Workflow12.prototype.imageEdit = CreateWorkflow12(ImageEditTask);
+Workflow13.prototype.imageEdit = CreateWorkflow13(ImageEditTask);
 
 // src/task/FaceDetectorTask.ts
-import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
-var modelSchema10 = TypeModel("model:FaceDetectorTask");
+import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
+var modelSchema11 = TypeModel("model:FaceDetectorTask");
 var TypeBoundingBox2 = {
   type: "object",
   properties: {
@@ -3180,7 +3728,7 @@ var FaceDetectorInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema10,
+    model: modelSchema11,
     minDetectionConfidence: {
       type: "number",
       minimum: 0,
@@ -3234,11 +3782,11 @@ class FaceDetectorTask extends AiVisionTask {
 var faceDetector = (input, config) => {
   return new FaceDetectorTask(config).run(input);
 };
-Workflow13.prototype.faceDetector = CreateWorkflow13(FaceDetectorTask);
+Workflow14.prototype.faceDetector = CreateWorkflow14(FaceDetectorTask);
 
 // src/task/FaceLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
-var modelSchema11 = TypeModel("model:FaceLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
+var modelSchema12 = TypeModel("model:FaceLandmarkerTask");
 var TypeBlendshape = {
   type: "object",
   properties: {
@@ -3289,7 +3837,7 @@ var FaceLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema11,
+    model: modelSchema12,
     numFaces: {
       type: "number",
       minimum: 1,
@@ -3375,15 +3923,15 @@ class FaceLandmarkerTask extends AiVisionTask {
 var faceLandmarker = (input, config) => {
   return new FaceLandmarkerTask(config).run(input);
 };
-Workflow14.prototype.faceLandmarker = CreateWorkflow14(FaceLandmarkerTask);
+Workflow15.prototype.faceLandmarker = CreateWorkflow15(FaceLandmarkerTask);
 
 // src/task/generation/ImageGenerateTask.ts
-import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
-var modelSchema12 = TypeModel("model:ImageGenerateTask");
+import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
+var modelSchema13 = TypeModel("model:ImageGenerateTask");
 var ImageGenerateInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema12,
+    model: modelSchema13,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -3417,11 +3965,11 @@ class ImageGenerateTask extends AiImageOutputTask {
   }
 }
 var imageGenerate = (input, config) => new ImageGenerateTask(config).run(input);
-Workflow15.prototype.imageGenerate = CreateWorkflow15(ImageGenerateTask);
+Workflow16.prototype.imageGenerate = CreateWorkflow16(ImageGenerateTask);
 
 // src/task/GestureRecognizerTask.ts
-import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
-var modelSchema13 = TypeModel("model:GestureRecognizerTask");
+import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
+var modelSchema14 = TypeModel("model:GestureRecognizerTask");
 var TypeGesture = {
   type: "object",
   properties: {
@@ -3493,7 +4041,7 @@ var GestureRecognizerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema13,
+    model: modelSchema14,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3565,11 +4113,11 @@ class GestureRecognizerTask extends AiVisionTask {
 var gestureRecognizer = (input, config) => {
   return new GestureRecognizerTask(config).run(input);
 };
-Workflow16.prototype.gestureRecognizer = CreateWorkflow16(GestureRecognizerTask);
+Workflow17.prototype.gestureRecognizer = CreateWorkflow17(GestureRecognizerTask);
 
 // src/task/HandLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
-var modelSchema14 = TypeModel("model:HandLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow18, Workflow as Workflow18 } from "@workglow/task-graph";
+var modelSchema15 = TypeModel("model:HandLandmarkerTask");
 var TypeHandedness2 = {
   type: "object",
   properties: {
@@ -3618,7 +4166,7 @@ var HandLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema14,
+    model: modelSchema15,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3690,22 +4238,23 @@ class HandLandmarkerTask extends AiVisionTask {
 var handLandmarker = (input, config) => {
   return new HandLandmarkerTask(config).run(input);
 };
-Workflow17.prototype.handLandmarker = CreateWorkflow17(HandLandmarkerTask);
+Workflow18.prototype.handLandmarker = CreateWorkflow18(HandLandmarkerTask);
 
 // src/task/HierarchicalChunkerTask.ts
 import {
   ChunkRecordSchema,
   estimateTokens as estimateTokens2,
   getChildren as getChildren2,
-  hasChildren as hasChildren2
+  hasChildren as hasChildren2,
+  NodeKind
 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow18, Task as Task7, Workflow as Workflow18 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow19, Task as Task8, Workflow as Workflow19 } from "@workglow/task-graph";
 import { uuid4 } from "@workglow/util";
-var modelSchema15 = TypeModel("model", {
+var modelSchema16 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting"
 });
-var inputSchema6 = {
+var inputSchema7 = {
   type: "object",
   properties: {
     doc_id: {
@@ -3747,12 +4296,12 @@ var inputSchema6 = {
       description: "Strategy for chunking",
       default: "hierarchical"
     },
-    model: modelSchema15
+    model: modelSchema16
   },
   required: ["doc_id", "documentTree"],
   additionalProperties: false
 };
-var outputSchema6 = {
+var outputSchema7 = {
   type: "object",
   properties: {
     doc_id: {
@@ -3782,17 +4331,17 @@ var outputSchema6 = {
   additionalProperties: false
 };
 
-class HierarchicalChunkerTask extends Task7 {
+class HierarchicalChunkerTask extends Task8 {
   static type = "HierarchicalChunkerTask";
   static category = "Document";
   static title = "Hierarchical Chunker";
   static description = "Chunk documents hierarchically respecting token budgets";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema6;
+    return inputSchema7;
   }
   static outputSchema() {
-    return outputSchema6;
+    return outputSchema7;
   }
   async execute(input, context) {
     const {
@@ -3829,7 +4378,7 @@ class HierarchicalChunkerTask extends Task7 {
     }
     const chunks = [];
     if (strategy === "hierarchical") {
-      await this.chunkHierarchically(root, [], doc_id, tokenBudget, chunks, countFn);
+      await this.chunkHierarchically(root, [], [], doc_id, tokenBudget, chunks, countFn);
     } else {
       await this.chunkFlat(root, doc_id, tokenBudget, chunks, countFn);
     }
@@ -3840,23 +4389,35 @@ class HierarchicalChunkerTask extends Task7 {
       count: chunks.length
     };
   }
-  async chunkHierarchically(node, nodePath, doc_id, tokenBudget, chunks, countFn) {
+  async chunkHierarchically(node, nodePath, headingPath, doc_id, tokenBudget, chunks, countFn) {
     const currentPath = [...nodePath, node.nodeId];
+    const currentHeadings = node.kind === NodeKind.SECTION && typeof node.title === "string" && node.title.trim().length > 0 ? [...headingPath, node.title.trim()] : headingPath;
     if (!hasChildren2(node)) {
-      await this.chunkText(node.text, currentPath, doc_id, tokenBudget, chunks, node.nodeId, countFn);
+      await this.chunkText(node.text, currentPath, currentHeadings, doc_id, tokenBudget, chunks, node.nodeId, countFn);
       return;
     }
     const children = getChildren2(node);
     for (const child of children) {
-      await this.chunkHierarchically(child, currentPath, doc_id, tokenBudget, chunks, countFn);
+      await this.chunkHierarchically(child, currentPath, currentHeadings, doc_id, tokenBudget, chunks, countFn);
     }
   }
-  async chunkText(text, nodePath, doc_id, tokenBudget, chunks, leafNodeId, countFn) {
-    const maxTokens = tokenBudget.maxTokensPerChunk - tokenBudget.reservedTokens;
+  async chunkText(text, nodePath, headingPath, doc_id, tokenBudget, chunks, leafNodeId, countFn) {
+    if (text.trim().length === 0)
+      return;
+    const budgetAfterReserved = tokenBudget.maxTokensPerChunk - tokenBudget.reservedTokens;
     const overlapTokens = tokenBudget.overlapTokens;
-    if (maxTokens <= 0) {
+    if (budgetAfterReserved <= 0) {
       throw new Error(`Invalid token budget: reservedTokens (${tokenBudget.reservedTokens}) must be less than maxTokensPerChunk (${tokenBudget.maxTokensPerChunk})`);
     }
+    const breadcrumb = headingPath.join(" > ");
+    const candidatePrefix = breadcrumb ? `${breadcrumb}
+
+` : "";
+    const prefixTokens = candidatePrefix ? await countFn(candidatePrefix) : 0;
+    const usePrefix = prefixTokens > 0 && prefixTokens < budgetAfterReserved;
+    const prefix = usePrefix ? candidatePrefix : "";
+    const effectivePrefixTokens = usePrefix ? prefixTokens : 0;
+    const maxTokens = budgetAfterReserved - effectivePrefixTokens;
     if (overlapTokens >= maxTokens) {
       throw new Error(`Invalid token budget: overlapTokens (${overlapTokens}) must be less than effective maxTokens (${maxTokens})`);
     }
@@ -3865,9 +4426,11 @@ class HierarchicalChunkerTask extends Task7 {
       chunks.push({
         chunkId: uuid4(),
         doc_id,
-        text,
+        text: prefix + text,
         nodePath,
-        depth: nodePath.length
+        depth: nodePath.length,
+        leafNodeId,
+        sectionTitles: [...headingPath]
       });
       return;
     }
@@ -3892,9 +4455,11 @@ class HierarchicalChunkerTask extends Task7 {
       chunks.push({
         chunkId: uuid4(),
         doc_id,
-        text: text.substring(startOffset, endOffset),
+        text: prefix + text.substring(startOffset, endOffset),
         nodePath,
-        depth: nodePath.length
+        depth: nodePath.length,
+        leafNodeId,
+        sectionTitles: [...headingPath]
       });
       if (endOffset >= text.length)
         break;
@@ -3904,7 +4469,7 @@ class HierarchicalChunkerTask extends Task7 {
   }
   async chunkFlat(root, doc_id, tokenBudget, chunks, countFn) {
     const allText = this.collectAllText(root);
-    await this.chunkText(allText, [root.nodeId], doc_id, tokenBudget, chunks, root.nodeId, countFn);
+    await this.chunkText(allText, [root.nodeId], [], doc_id, tokenBudget, chunks, root.nodeId, countFn);
   }
   collectAllText(node) {
     const texts = [];
@@ -3926,15 +4491,15 @@ class HierarchicalChunkerTask extends Task7 {
 var hierarchicalChunker = (input, config) => {
   return new HierarchicalChunkerTask(config).run(input);
 };
-Workflow18.prototype.hierarchicalChunker = CreateWorkflow18(HierarchicalChunkerTask);
+Workflow19.prototype.hierarchicalChunker = CreateWorkflow19(HierarchicalChunkerTask);
 
 // src/task/HierarchyJoinTask.ts
-import { ChunkRecordArraySchema as ChunkRecordArraySchema2, TypeKnowledgeBase as TypeKnowledgeBase4 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow19, Task as Task8, Workflow as Workflow19 } from "@workglow/task-graph";
-var inputSchema7 = {
+import { ChunkRecordArraySchema as ChunkRecordArraySchema2, TypeKnowledgeBase as TypeKnowledgeBase5 } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow20, Task as Task9, Workflow as Workflow20 } from "@workglow/task-graph";
+var inputSchema8 = {
   type: "object",
   properties: {
-    knowledgeBase: TypeKnowledgeBase4({
+    knowledgeBase: TypeKnowledgeBase5({
       title: "Knowledge Base",
       description: "The knowledge base to query for hierarchy"
     }),
@@ -3973,7 +4538,7 @@ var inputSchema7 = {
   required: ["knowledgeBase", "metadata"],
   additionalProperties: false
 };
-var outputSchema7 = {
+var outputSchema8 = {
   type: "object",
   properties: {
     metadata: ChunkRecordArraySchema2,
@@ -4005,17 +4570,17 @@ var outputSchema7 = {
   additionalProperties: false
 };
 
-class HierarchyJoinTask extends Task8 {
+class HierarchyJoinTask extends Task9 {
   static type = "HierarchyJoinTask";
   static category = "RAG";
   static title = "Hierarchy Join";
   static description = "Enrich retrieval metadata with document hierarchy context";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema7;
+    return inputSchema8;
   }
   static outputSchema() {
-    return outputSchema7;
+    return outputSchema8;
   }
   async execute(input, context) {
     const {
@@ -4101,15 +4666,15 @@ class HierarchyJoinTask extends Task8 {
 var hierarchyJoin = (input, config) => {
   return new HierarchyJoinTask(config).run(input);
 };
-Workflow19.prototype.hierarchyJoin = CreateWorkflow19(HierarchyJoinTask);
+Workflow20.prototype.hierarchyJoin = CreateWorkflow20(HierarchyJoinTask);
 
 // src/task/KbToDocumentsTask.ts
-import { TypeKnowledgeBase as TypeKnowledgeBase5 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow20, Task as Task9, Workflow as Workflow20 } from "@workglow/task-graph";
-var inputSchema8 = {
+import { TypeKnowledgeBase as TypeKnowledgeBase6 } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow21, Task as Task10, Workflow as Workflow21 } from "@workglow/task-graph";
+var inputSchema9 = {
   type: "object",
   properties: {
-    knowledgeBase: TypeKnowledgeBase5({
+    knowledgeBase: TypeKnowledgeBase6({
       title: "Knowledge Base",
       description: "The knowledge base instance to list documents from"
     }),
@@ -4123,7 +4688,7 @@ var inputSchema8 = {
   required: ["knowledgeBase"],
   additionalProperties: false
 };
-var outputSchema8 = {
+var outputSchema9 = {
   type: "object",
   properties: {
     doc_id: {
@@ -4149,17 +4714,17 @@ var outputSchema8 = {
   additionalProperties: false
 };
 
-class KbToDocumentsTask extends Task9 {
+class KbToDocumentsTask extends Task10 {
   static type = "KbToDocumentsTask";
   static category = "Document";
   static title = "Knowledge Base to Documents";
   static description = "List documents from a knowledge base, optionally filtering to only those that need embedding";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema8;
+    return inputSchema9;
   }
   static outputSchema() {
-    return outputSchema8;
+    return outputSchema9;
   }
   async execute(input, context) {
     const { knowledgeBase, onlyStale = true } = input;
@@ -4190,16 +4755,16 @@ class KbToDocumentsTask extends Task9 {
 var kbToDocuments = (input, config) => {
   return new KbToDocumentsTask(config).run(input);
 };
-Workflow20.prototype.kbToDocuments = CreateWorkflow20(KbToDocumentsTask);
+Workflow21.prototype.kbToDocuments = CreateWorkflow21(KbToDocumentsTask);
 
 // src/task/ImageClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow21, Workflow as Workflow21 } from "@workglow/task-graph";
-var modelSchema16 = TypeModel("model:ImageClassificationTask");
+import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
+var modelSchema17 = TypeModel("model:ImageClassificationTask");
 var ImageClassificationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema16,
+    model: modelSchema17,
     categories: {
       type: "array",
       items: {
@@ -4253,19 +4818,19 @@ class ImageClassificationTask extends AiVisionTask {
 var imageClassification = (input, config) => {
   return new ImageClassificationTask(config).run(input);
 };
-Workflow21.prototype.imageClassification = CreateWorkflow21(ImageClassificationTask);
+Workflow22.prototype.imageClassification = CreateWorkflow22(ImageClassificationTask);
 
 // src/task/ImageEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema4
 } from "@workglow/util/schema";
-var modelSchema17 = TypeModel("model:ImageEmbeddingTask");
+var modelSchema18 = TypeModel("model:ImageEmbeddingTask");
 var ImageEmbeddingInputSchema = {
   type: "object",
   properties: {
     image: TypeSingleOrArray(TypeImageInput),
-    model: modelSchema17
+    model: modelSchema18
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -4297,16 +4862,16 @@ class ImageEmbeddingTask extends AiVisionTask {
 var imageEmbedding = (input, config) => {
   return new ImageEmbeddingTask(config).run(input);
 };
-Workflow22.prototype.imageEmbedding = CreateWorkflow22(ImageEmbeddingTask);
+Workflow23.prototype.imageEmbedding = CreateWorkflow23(ImageEmbeddingTask);
 
 // src/task/ImageSegmentationTask.ts
-import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
-var modelSchema18 = TypeModel("model:ImageSegmentationTask");
+import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
+var modelSchema19 = TypeModel("model:ImageSegmentationTask");
 var ImageSegmentationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema18,
+    model: modelSchema19,
     threshold: {
       type: "number",
       title: "Threshold",
@@ -4385,11 +4950,11 @@ class ImageSegmentationTask extends AiVisionTask {
 var imageSegmentation = (input, config) => {
   return new ImageSegmentationTask(config).run(input);
 };
-Workflow23.prototype.imageSegmentation = CreateWorkflow23(ImageSegmentationTask);
+Workflow24.prototype.imageSegmentation = CreateWorkflow24(ImageSegmentationTask);
 
 // src/task/ImageToTextTask.ts
-import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
-var modelSchema19 = TypeModel("model:ImageToTextTask");
+import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
+var modelSchema20 = TypeModel("model:ImageToTextTask");
 var generatedTextSchema = {
   type: "string",
   title: "Text",
@@ -4399,7 +4964,7 @@ var ImageToTextInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema19,
+    model: modelSchema20,
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -4440,15 +5005,15 @@ class ImageToTextTask extends AiVisionTask {
 var imageToText = (input, config) => {
   return new ImageToTextTask(config).run(input);
 };
-Workflow24.prototype.imageToText = CreateWorkflow24(ImageToTextTask);
+Workflow25.prototype.imageToText = CreateWorkflow25(ImageToTextTask);
 
 // src/task/ModelInfoTask.ts
-import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
-var modelSchema20 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
+var modelSchema21 = TypeModel("model");
 var ModelInfoInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema20,
+    model: modelSchema21,
     detail: {
       type: "string",
       enum: ["cached_status", "files", "files_with_metadata", "dimensions"],
@@ -4461,7 +5026,7 @@ var ModelInfoInputSchema = {
 var ModelInfoOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema20,
+    model: modelSchema21,
     is_local: { type: "boolean" },
     is_remote: { type: "boolean" },
     supports_browser: { type: "boolean" },
@@ -4519,10 +5084,10 @@ class ModelInfoTask extends AiTask {
 var modelInfo = (input, config) => {
   return new ModelInfoTask(config).run(input);
 };
-Workflow25.prototype.modelInfo = CreateWorkflow25(ModelInfoTask);
+Workflow26.prototype.modelInfo = CreateWorkflow26(ModelInfoTask);
 
 // src/task/ModelSearchTask.ts
-import { CreateWorkflow as CreateWorkflow26, Task as Task10, Workflow as Workflow26 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow27, Task as Task11, Workflow as Workflow27 } from "@workglow/task-graph";
 var ModelSearchInputSchema = {
   type: "object",
   properties: {
@@ -4595,7 +5160,7 @@ var ModelSearchOutputSchema = {
   additionalProperties: false
 };
 
-class ModelSearchTask extends Task10 {
+class ModelSearchTask extends Task11 {
   static type = "ModelSearchTask";
   static category = "AI Model";
   static title = "Model Search";
@@ -4621,11 +5186,11 @@ class ModelSearchTask extends Task10 {
 var modelSearch = (input, config) => {
   return new ModelSearchTask(config).run(input);
 };
-Workflow26.prototype.modelSearch = CreateWorkflow26(ModelSearchTask);
+Workflow27.prototype.modelSearch = CreateWorkflow27(ModelSearchTask);
 
 // src/task/ObjectDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow27, Workflow as Workflow27 } from "@workglow/task-graph";
-var modelSchema21 = TypeModel("model:ObjectDetectionTask");
+import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
+var modelSchema22 = TypeModel("model:ObjectDetectionTask");
 var detectionSchema = {
   type: "object",
   properties: {
@@ -4650,7 +5215,7 @@ var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema21,
+    model: modelSchema22,
     labels: {
       type: "array",
       items: {
@@ -4704,11 +5269,11 @@ class ObjectDetectionTask extends AiVisionTask {
 var objectDetection = (input, config) => {
   return new ObjectDetectionTask(config).run(input);
 };
-Workflow27.prototype.objectDetection = CreateWorkflow27(ObjectDetectionTask);
+Workflow28.prototype.objectDetection = CreateWorkflow28(ObjectDetectionTask);
 
 // src/task/PoseLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
-var modelSchema22 = TypeModel("model:PoseLandmarkerTask");
+import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
+var modelSchema23 = TypeModel("model:PoseLandmarkerTask");
 var TypeSegmentationMask = {
   type: "object",
   properties: {
@@ -4755,7 +5320,7 @@ var PoseLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema22,
+    model: modelSchema23,
     numPoses: {
       type: "number",
       minimum: 1,
@@ -4834,15 +5399,15 @@ class PoseLandmarkerTask extends AiVisionTask {
 var poseLandmarker = (input, config) => {
   return new PoseLandmarkerTask(config).run(input);
 };
-Workflow28.prototype.poseLandmarker = CreateWorkflow28(PoseLandmarkerTask);
+Workflow29.prototype.poseLandmarker = CreateWorkflow29(PoseLandmarkerTask);
 
 // src/task/QueryExpanderTask.ts
-import { CreateWorkflow as CreateWorkflow29, Task as Task11, Workflow as Workflow29 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow30, Task as Task12, Workflow as Workflow30 } from "@workglow/task-graph";
 var QueryExpansionMethod = {
   MULTI_QUERY: "multi-query",
   SYNONYMS: "synonyms"
 };
-var inputSchema9 = {
+var inputSchema10 = {
   type: "object",
   properties: {
     query: {
@@ -4869,7 +5434,7 @@ var inputSchema9 = {
   required: ["query"],
   additionalProperties: false
 };
-var outputSchema9 = {
+var outputSchema10 = {
   type: "object",
   properties: {
     query: {
@@ -4898,17 +5463,17 @@ var outputSchema9 = {
   additionalProperties: false
 };
 
-class QueryExpanderTask extends Task11 {
+class QueryExpanderTask extends Task12 {
   static type = "QueryExpanderTask";
   static category = "RAG";
   static title = "Query Expander";
   static description = "Expand queries to improve retrieval coverage";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema9;
+    return inputSchema10;
   }
   static outputSchema() {
-    return outputSchema9;
+    return outputSchema10;
   }
   async execute(input, context) {
     const { query, method = QueryExpansionMethod.MULTI_QUERY, numVariations = 3 } = input;
@@ -5007,11 +5572,11 @@ class QueryExpanderTask extends Task11 {
 var queryExpander = (input, config) => {
   return new QueryExpanderTask(config).run(input);
 };
-Workflow29.prototype.queryExpander = CreateWorkflow29(QueryExpanderTask);
+Workflow30.prototype.queryExpander = CreateWorkflow30(QueryExpanderTask);
 
 // src/task/RerankerTask.ts
-import { CreateWorkflow as CreateWorkflow30, Task as Task12, Workflow as Workflow30 } from "@workglow/task-graph";
-var inputSchema10 = {
+import { CreateWorkflow as CreateWorkflow31, Task as Task13, Workflow as Workflow31 } from "@workglow/task-graph";
+var inputSchema11 = {
   type: "object",
   properties: {
     query: {
@@ -5058,7 +5623,7 @@ var inputSchema10 = {
   required: ["query", "chunks"],
   additionalProperties: false
 };
-var outputSchema10 = {
+var outputSchema11 = {
   type: "object",
   properties: {
     chunks: {
@@ -5099,17 +5664,17 @@ var outputSchema10 = {
   additionalProperties: false
 };
 
-class RerankerTask extends Task12 {
+class RerankerTask extends Task13 {
   static type = "RerankerTask";
   static category = "RAG";
   static title = "Reranker";
   static description = "Rerank retrieved chunks to improve relevance";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema10;
+    return inputSchema11;
   }
   static outputSchema() {
-    return outputSchema10;
+    return outputSchema11;
   }
   async execute(input, context) {
     const { query, chunks, scores = [], metadata = [], topK, method = "simple" } = input;
@@ -5172,13 +5737,13 @@ class RerankerTask extends Task12 {
 var reranker = (input, config) => {
   return new RerankerTask(config).run(input);
 };
-Workflow30.prototype.reranker = CreateWorkflow30(RerankerTask);
+Workflow31.prototype.reranker = CreateWorkflow31(RerankerTask);
 
 // src/task/StructuralParserTask.ts
 import { StructuralParser } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow31, Task as Task13, Workflow as Workflow31 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow32, Task as Task14, Workflow as Workflow32 } from "@workglow/task-graph";
 import { uuid4 as uuid42 } from "@workglow/util";
-var inputSchema11 = {
+var inputSchema12 = {
   type: "object",
   properties: {
     text: {
@@ -5212,7 +5777,7 @@ var inputSchema11 = {
   required: ["text", "title"],
   additionalProperties: false
 };
-var outputSchema11 = {
+var outputSchema12 = {
   type: "object",
   properties: {
     doc_id: {
@@ -5236,17 +5801,17 @@ var outputSchema11 = {
   additionalProperties: false
 };
 
-class StructuralParserTask extends Task13 {
+class StructuralParserTask extends Task14 {
   static type = "StructuralParserTask";
   static category = "Document";
   static title = "Structural Parser";
   static description = "Parse documents into hierarchical tree structure";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema11;
+    return inputSchema12;
   }
   static outputSchema() {
-    return outputSchema11;
+    return outputSchema12;
   }
   async execute(input, context) {
     const { text, title, format = "auto", sourceUri, doc_id: providedDocId } = input;
@@ -5279,16 +5844,16 @@ class StructuralParserTask extends Task13 {
 var structuralParser = (input, config) => {
   return new StructuralParserTask(config).run(input);
 };
-Workflow31.prototype.structuralParser = CreateWorkflow31(StructuralParserTask);
+Workflow32.prototype.structuralParser = CreateWorkflow32(StructuralParserTask);
 
 // src/task/StructuredGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow32, TaskConfigurationError as TaskConfigurationError4, TaskError, Workflow as Workflow32 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow33, TaskConfigurationError as TaskConfigurationError4, TaskError, Workflow as Workflow33 } from "@workglow/task-graph";
 import { compileSchema as compileSchema2 } from "@workglow/util/schema";
-var modelSchema23 = TypeModel("model:StructuredGenerationTask");
+var modelSchema24 = TypeModel("model:StructuredGenerationTask");
 var StructuredGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema23,
+    model: modelSchema24,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5457,18 +6022,18 @@ class StructuredGenerationTask extends StreamingAiTask {
 var structuredGeneration = (input, config) => {
   return new StructuredGenerationTask(config).run(input);
 };
-Workflow32.prototype.structuredGeneration = CreateWorkflow32(StructuredGenerationTask);
+Workflow33.prototype.structuredGeneration = CreateWorkflow33(StructuredGenerationTask);
 
 // src/task/TextChunkerTask.ts
 import { ChunkRecordArraySchema as ChunkRecordArraySchema3 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow33, Task as Task14, Workflow as Workflow33 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow34, Task as Task15, Workflow as Workflow34 } from "@workglow/task-graph";
 var ChunkingStrategy = {
   FIXED: "fixed",
   SENTENCE: "sentence",
   PARAGRAPH: "paragraph",
   SEMANTIC: "semantic"
 };
-var inputSchema12 = {
+var inputSchema13 = {
   type: "object",
   properties: {
     text: {
@@ -5506,7 +6071,7 @@ var inputSchema12 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema12 = {
+var outputSchema13 = {
   type: "object",
   properties: {
     doc_id: {
@@ -5531,17 +6096,17 @@ var outputSchema12 = {
   additionalProperties: false
 };
 
-class TextChunkerTask extends Task14 {
+class TextChunkerTask extends Task15 {
   static type = "TextChunkerTask";
   static category = "Document";
   static title = "Text Chunker";
   static description = "Splits text into chunks using various strategies (fixed, sentence, paragraph)";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema12;
+    return inputSchema13;
   }
   static outputSchema() {
-    return outputSchema12;
+    return outputSchema13;
   }
   async execute(input, context) {
     const {
@@ -5711,11 +6276,11 @@ class TextChunkerTask extends Task14 {
 var textChunker = (input, config) => {
   return new TextChunkerTask(config).run(input);
 };
-Workflow33.prototype.textChunker = CreateWorkflow33(TextChunkerTask);
+Workflow34.prototype.textChunker = CreateWorkflow34(TextChunkerTask);
 
 // src/task/TextClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
-var modelSchema24 = TypeModel("model:TextClassificationTask");
+import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } from "@workglow/task-graph";
+var modelSchema25 = TypeModel("model:TextClassificationTask");
 var TextClassificationInputSchema = {
   type: "object",
   properties: {
@@ -5742,7 +6307,7 @@ var TextClassificationInputSchema = {
       description: "The maximum number of categories to return",
       "x-ui-group": "Configuration"
     },
-    model: modelSchema24
+    model: modelSchema25
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5792,11 +6357,11 @@ class TextClassificationTask extends AiTask {
 var textClassification = (input, config) => {
   return new TextClassificationTask(config).run(input);
 };
-Workflow34.prototype.textClassification = CreateWorkflow34(TextClassificationTask);
+Workflow35.prototype.textClassification = CreateWorkflow35(TextClassificationTask);
 
 // src/task/TextFillMaskTask.ts
-import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } from "@workglow/task-graph";
-var modelSchema25 = TypeModel("model:TextFillMaskTask");
+import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
+var modelSchema26 = TypeModel("model:TextFillMaskTask");
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
@@ -5805,7 +6370,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     },
-    model: modelSchema25
+    model: modelSchema26
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5860,21 +6425,21 @@ class TextFillMaskTask extends AiTask {
 var textFillMask = (input, config) => {
   return new TextFillMaskTask(config).run(input);
 };
-Workflow35.prototype.textFillMask = CreateWorkflow35(TextFillMaskTask);
+Workflow36.prototype.textFillMask = CreateWorkflow36(TextFillMaskTask);
 
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
 var generatedTextSchema2 = {
   type: "string",
   title: "Text",
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema26 = TypeModel("model:TextGenerationTask");
+var modelSchema27 = TypeModel("model:TextGenerationTask");
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema26,
+    model: modelSchema27,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5949,11 +6514,11 @@ class TextGenerationTask extends StreamingAiTask {
 var textGeneration = (input, config) => {
   return new TextGenerationTask(config).run(input);
 };
-Workflow36.prototype.textGeneration = CreateWorkflow36(TextGenerationTask);
+Workflow37.prototype.textGeneration = CreateWorkflow37(TextGenerationTask);
 
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
-var modelSchema27 = TypeModel("model:TextLanguageDetectionTask");
+import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
+var modelSchema28 = TypeModel("model:TextLanguageDetectionTask");
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
@@ -5970,7 +6535,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema27
+    model: modelSchema28
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -6020,10 +6585,10 @@ class TextLanguageDetectionTask extends AiTask {
 var textLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask(config).run(input);
 };
-Workflow37.prototype.textLanguageDetection = CreateWorkflow37(TextLanguageDetectionTask);
+Workflow38.prototype.textLanguageDetection = CreateWorkflow38(TextLanguageDetectionTask);
 
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
 var contextSchema = {
   type: "string",
   title: "Context",
@@ -6040,13 +6605,13 @@ var textSchema = {
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema28 = TypeModel("model:TextQuestionAnswerTask");
+var modelSchema29 = TypeModel("model:TextQuestionAnswerTask");
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: contextSchema,
     question: questionSchema,
-    model: modelSchema28
+    model: modelSchema29
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -6076,11 +6641,11 @@ class TextQuestionAnswerTask extends StreamingAiTask {
 var textQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask(config).run(input);
 };
-Workflow38.prototype.textQuestionAnswer = CreateWorkflow38(TextQuestionAnswerTask);
+Workflow39.prototype.textQuestionAnswer = CreateWorkflow39(TextQuestionAnswerTask);
 
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
-var modelSchema29 = TypeModel("model:TextRewriterTask");
+import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
+var modelSchema30 = TypeModel("model:TextRewriterTask");
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
@@ -6094,7 +6659,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     },
-    model: modelSchema29
+    model: modelSchema30
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -6129,11 +6694,11 @@ class TextRewriterTask extends StreamingAiTask {
 var textRewriter = (input, config) => {
   return new TextRewriterTask(config).run(input);
 };
-Workflow39.prototype.textRewriter = CreateWorkflow39(TextRewriterTask);
+Workflow40.prototype.textRewriter = CreateWorkflow40(TextRewriterTask);
 
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
-var modelSchema30 = TypeModel("model:TextTranslationTask");
+import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
+var modelSchema31 = TypeModel("model:TextTranslationTask");
 var translationTextSchema = {
   type: "string",
   title: "Text",
@@ -6160,7 +6725,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     }),
-    model: modelSchema30
+    model: modelSchema31
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -6196,10 +6761,10 @@ class TextTranslationTask extends StreamingAiTask {
 var textTranslation = (input, config) => {
   return new TextTranslationTask(config).run(input);
 };
-Workflow40.prototype.textTranslation = CreateWorkflow40(TextTranslationTask);
+Workflow41.prototype.textTranslation = CreateWorkflow41(TextTranslationTask);
 
 // src/task/ToolCallingTask.ts
-import { CreateWorkflow as CreateWorkflow41, getTaskConstructors, Workflow as Workflow41 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow42, getTaskConstructors, Workflow as Workflow42 } from "@workglow/task-graph";
 import { makeFingerprint } from "@workglow/util";
 function taskTypesToTools(taskNames, registry) {
   const constructors = getTaskConstructors(registry);
@@ -6283,11 +6848,11 @@ var ToolCallSchema = {
   required: ["id", "name", "input"],
   additionalProperties: false
 };
-var modelSchema31 = TypeModel("model:ToolCallingTask");
+var modelSchema32 = TypeModel("model:ToolCallingTask");
 var ToolCallingInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema31,
+    model: modelSchema32,
     prompt: {
       oneOf: [
         { type: "string", title: "Prompt", description: "The prompt to send to the model" },
@@ -6432,16 +6997,16 @@ class ToolCallingTask extends StreamingAiTask {
 var toolCalling = (input, config) => {
   return new ToolCallingTask(config).run(input);
 };
-Workflow41.prototype.toolCalling = CreateWorkflow41(ToolCallingTask);
+Workflow42.prototype.toolCalling = CreateWorkflow42(ToolCallingTask);
 
 // src/task/TopicSegmenterTask.ts
-import { CreateWorkflow as CreateWorkflow42, Task as Task15, Workflow as Workflow42 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow43, Task as Task16, Workflow as Workflow43 } from "@workglow/task-graph";
 var SegmentationMethod = {
   HEURISTIC: "heuristic",
   EMBEDDING_SIMILARITY: "embedding-similarity",
   HYBRID: "hybrid"
 };
-var inputSchema13 = {
+var inputSchema14 = {
   type: "object",
   properties: {
     text: {
@@ -6482,7 +7047,7 @@ var inputSchema13 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema13 = {
+var outputSchema14 = {
   type: "object",
   properties: {
     segments: {
@@ -6510,7 +7075,7 @@ var outputSchema13 = {
   additionalProperties: false
 };
 
-class TopicSegmenterTask extends Task15 {
+class TopicSegmenterTask extends Task16 {
   static type = "TopicSegmenterTask";
   static category = "Document";
   static title = "Topic Segmenter";
@@ -6518,10 +7083,10 @@ class TopicSegmenterTask extends Task15 {
   static cacheable = true;
   static EMBEDDING_DIMENSIONS = 256;
   static inputSchema() {
-    return inputSchema13;
+    return inputSchema14;
   }
   static outputSchema() {
-    return outputSchema13;
+    return outputSchema14;
   }
   async execute(input, context) {
     const {
@@ -6715,15 +7280,15 @@ class TopicSegmenterTask extends Task15 {
 var topicSegmenter = (input, config) => {
   return new TopicSegmenterTask(config).run(input);
 };
-Workflow42.prototype.topicSegmenter = CreateWorkflow42(TopicSegmenterTask);
+Workflow43.prototype.topicSegmenter = CreateWorkflow43(TopicSegmenterTask);
 
 // src/task/UnloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow43, Workflow as Workflow43 } from "@workglow/task-graph";
-var modelSchema32 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow44, Workflow as Workflow44 } from "@workglow/task-graph";
+var modelSchema33 = TypeModel("model");
 var UnloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema32
+    model: modelSchema33
   },
   required: ["model"],
   additionalProperties: false
@@ -6731,7 +7296,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema32
+    model: modelSchema33
   },
   required: ["model"],
   additionalProperties: false
@@ -6753,16 +7318,16 @@ class UnloadModelTask extends AiTask {
 var unloadModel = (input, config) => {
   return new UnloadModelTask(config).run(input);
 };
-Workflow43.prototype.unloadModel = CreateWorkflow43(UnloadModelTask);
+Workflow44.prototype.unloadModel = CreateWorkflow44(UnloadModelTask);
 
 // src/task/VectorQuantizeTask.ts
-import { CreateWorkflow as CreateWorkflow44, Task as Task16, Workflow as Workflow44 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow45, Task as Task17, Workflow as Workflow45 } from "@workglow/task-graph";
 import {
   normalizeNumberArray,
   TensorType,
   TypedArraySchema as TypedArraySchema5
 } from "@workglow/util/schema";
-var inputSchema14 = {
+var inputSchema15 = {
   type: "object",
   properties: {
     vector: {
@@ -6799,7 +7364,7 @@ var inputSchema14 = {
   required: ["vector", "targetType"],
   additionalProperties: false
 };
-var outputSchema14 = {
+var outputSchema15 = {
   type: "object",
   properties: {
     vector: {
@@ -6836,17 +7401,17 @@ var outputSchema14 = {
   additionalProperties: false
 };
 
-class VectorQuantizeTask extends Task16 {
+class VectorQuantizeTask extends Task17 {
   static type = "VectorQuantizeTask";
   static category = "Vector";
   static title = "Quantize";
   static description = "Quantize vectors to reduce storage and improve performance";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema14;
+    return inputSchema15;
   }
   static outputSchema() {
-    return outputSchema14;
+    return outputSchema15;
   }
   async execute(input) {
     return this.executePreview(input);
@@ -6939,10 +7504,10 @@ class VectorQuantizeTask extends Task16 {
 var vectorQuantize = (input, config) => {
   return new VectorQuantizeTask(config).run(input);
 };
-Workflow44.prototype.vectorQuantize = CreateWorkflow44(VectorQuantizeTask);
+Workflow45.prototype.vectorQuantize = CreateWorkflow45(VectorQuantizeTask);
 
 // src/task/VectorSimilarityTask.ts
-import { CreateWorkflow as CreateWorkflow45, GraphAsTask, Workflow as Workflow45 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow46, GraphAsTask, Workflow as Workflow46 } from "@workglow/task-graph";
 import {
   cosineSimilarity,
   hammingSimilarity,
@@ -7056,7 +7621,7 @@ class VectorSimilarityTask extends GraphAsTask {
 var similarity = (input, config) => {
   return new VectorSimilarityTask(config).run(input);
 };
-Workflow45.prototype.similarity = CreateWorkflow45(VectorSimilarityTask);
+Workflow46.prototype.similarity = CreateWorkflow46(VectorSimilarityTask);
 // src/task/MessageConversion.ts
 function getInputMessages(input) {
   const messages = input.messages;
@@ -7209,6 +7774,7 @@ function toTextFlatMessages(input) {
 var registerAiTasks = () => {
   const tasks = [
     AiChatTask,
+    AiChatWithKbTask,
     BackgroundRemovalTask,
     CountTokensTask,
     ContextBuilderTask,
@@ -7225,6 +7791,7 @@ var registerAiTasks = () => {
     HandLandmarkerTask,
     HierarchicalChunkerTask,
     HierarchyJoinTask,
+    KbSearchTask,
     KbToDocumentsTask,
     ImageClassificationTask,
     ImageEmbeddingTask,
@@ -7294,6 +7861,7 @@ export {
   modelSearch,
   modelInfo,
   kbToDocuments,
+  kbSearch,
   isContentBlockInToolResultBody,
   isContentBlock,
   isChatMessage,
@@ -7322,6 +7890,7 @@ export {
   chunkVectorUpsert,
   chunkRetrieval,
   buildToolDescription,
+  buildResponseFormatAddendum,
   backgroundRemoval,
   VectorSimilarityTask,
   VectorQuantizeTask,
@@ -7401,6 +7970,8 @@ export {
   ModelConfigSchema,
   MODEL_REPOSITORY,
   KbToDocumentsTask,
+  KbSearchTask,
+  KB_INLINE_CITATION_DIRECTIVE,
   InMemoryModelRepository,
   ImageToTextTask,
   ImageToTextOutputSchema,
@@ -7459,10 +8030,13 @@ export {
   AiProvider,
   AiJob,
   AiImageOutputTask,
+  AiChatWithKbTask,
+  AiChatWithKbOutputSchema,
+  AiChatWithKbInputSchema,
   AiChatTask,
   AiChatOutputSchema,
   AiChatInputSchema,
   AI_PROVIDER_REGISTRY
 };
 
-//# debugId=49834ABDD781320E64756E2164756E21
+//# debugId=79B4A8A40215A1E864756E2164756E21