@workglow/ai 0.2.32 → 0.2.33

package/dist/node.js

@@ -1013,6 +1013,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";
 
@@ -1429,6 +1451,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"],
@@ -1503,8 +1533,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 });
@@ -1523,8 +1560,6 @@ class AiChatTask extends StreamingAiTask {
       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);
@@ -1536,12 +1571,475 @@ 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);
+      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" };
+  }
+}
+
+// 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: "Last assistant response",
+      "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 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 docUrls = new Map;
+      const docFetches = [];
+      for (const { kb, r } of allChunks) {
+        if (!kb)
+          continue;
+        const key = `${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(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 }]
@@ -1557,7 +2055,7 @@ class AiChatTask extends StreamingAiTask {
         targetHumanId: "default",
         kind: "elicit",
         message: "",
-        contentSchema: chatConnectorContentSchema,
+        contentSchema: chatConnectorContentSchema2,
         contentData: undefined,
         expectsResponse: true,
         mode: "multi-turn",
@@ -1586,28 +2084,67 @@ class AiChatTask extends StreamingAiTask {
         objectDelta: [userMsg]
       };
     }
-    yield {
-      type: "finish",
-      data: {
-        text: lastAssistantText,
-        messages: [...history],
-        iterations
-      }
-    };
+    yield { type: "finish" };
   }
-  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() + "…" : 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
@@ -1616,12 +2153,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
@@ -1653,22 +2190,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: {
@@ -1677,7 +2214,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema3
+    model: modelSchema4
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1709,13 +2246,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"
     }),
@@ -1788,7 +2325,7 @@ var inputSchema = {
   else: {},
   additionalProperties: false
 };
-var outputSchema = {
+var outputSchema2 = {
   type: "object",
   properties: {
     chunks: {
@@ -1849,17 +2386,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 {
@@ -1930,18 +2467,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"
     }),
@@ -1959,7 +2496,7 @@ var inputSchema2 = {
   required: ["knowledgeBase", "chunks", "vector"],
   additionalProperties: false
 };
-var outputSchema2 = {
+var outputSchema3 = {
   type: "object",
   properties: {
     count: {
@@ -1983,17 +2520,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;
@@ -2038,19 +2575,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: {
@@ -2059,7 +2596,7 @@ var CountTokensInputSchema = {
       title: "Text",
       description: "The text to count tokens for"
     },
-    model: modelSchema4
+    model: modelSchema5
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2093,7 +2630,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 = {
@@ -2103,11 +2640,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: {
@@ -2167,12 +2704,12 @@ var inputSchema3 = {
 
 `
     },
-    model: modelSchema5
+    model: modelSchema6
   },
   required: ["chunks"],
   additionalProperties: false
 };
-var outputSchema3 = {
+var outputSchema4 = {
   type: "object",
   properties: {
     context: {
@@ -2200,17 +2737,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);
@@ -2396,15 +2933,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: {
@@ -2423,7 +2960,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema6
+    model: modelSchema7
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2478,11 +3015,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: {
@@ -2491,7 +3028,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     },
-    model: modelSchema7
+    model: modelSchema8
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -2526,10 +3063,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: {
@@ -2573,7 +3110,7 @@ var inputSchema4 = {
   required: [],
   additionalProperties: false
 };
-var outputSchema4 = {
+var outputSchema5 = {
   type: "object",
   properties: {
     doc_id: {
@@ -2600,17 +3137,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 {
@@ -2759,19 +3296,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"
     }),
@@ -2799,7 +3336,7 @@ var inputSchema5 = {
   required: ["knowledgeBase", "doc_id", "documentTree"],
   additionalProperties: false
 };
-var outputSchema5 = {
+var outputSchema6 = {
   type: "object",
   properties: {
     doc_id: {
@@ -2812,17 +3349,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;
@@ -2845,15 +3382,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
@@ -2861,7 +3398,7 @@ var DownloadModelInputSchema = {
 var DownloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema8
+    model: modelSchema9
   },
   required: ["model"],
   additionalProperties: false
@@ -2915,10 +3452,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
@@ -3050,11 +3587,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",
@@ -3102,11 +3639,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: {
@@ -3179,7 +3716,7 @@ var FaceDetectorInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema10,
+    model: modelSchema11,
     minDetectionConfidence: {
       type: "number",
       minimum: 0,
@@ -3233,11 +3770,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: {
@@ -3288,7 +3825,7 @@ var FaceLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema11,
+    model: modelSchema12,
     numFaces: {
       type: "number",
       minimum: 1,
@@ -3374,15 +3911,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",
@@ -3416,11 +3953,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: {
@@ -3492,7 +4029,7 @@ var GestureRecognizerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema13,
+    model: modelSchema14,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3564,11 +4101,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: {
@@ -3617,7 +4154,7 @@ var HandLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema14,
+    model: modelSchema15,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3689,22 +4226,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: {
@@ -3746,12 +4284,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: {
@@ -3781,17 +4319,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 {
@@ -3828,7 +4366,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);
     }
@@ -3839,23 +4377,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})`);
     }
@@ -3864,9 +4414,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;
     }
@@ -3891,9 +4443,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;
@@ -3903,7 +4457,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 = [];
@@ -3925,15 +4479,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"
     }),
@@ -3972,7 +4526,7 @@ var inputSchema7 = {
   required: ["knowledgeBase", "metadata"],
   additionalProperties: false
 };
-var outputSchema7 = {
+var outputSchema8 = {
   type: "object",
   properties: {
     metadata: ChunkRecordArraySchema2,
@@ -4004,17 +4558,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 {
@@ -4100,15 +4654,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"
     }),
@@ -4122,7 +4676,7 @@ var inputSchema8 = {
   required: ["knowledgeBase"],
   additionalProperties: false
 };
-var outputSchema8 = {
+var outputSchema9 = {
   type: "object",
   properties: {
     doc_id: {
@@ -4148,17 +4702,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;
@@ -4189,16 +4743,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: {
@@ -4252,19 +4806,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
@@ -4296,16 +4850,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",
@@ -4384,11 +4938,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",
@@ -4398,7 +4952,7 @@ var ImageToTextInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema19,
+    model: modelSchema20,
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -4439,15 +4993,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"],
@@ -4460,7 +5014,7 @@ var ModelInfoInputSchema = {
 var ModelInfoOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema20,
+    model: modelSchema21,
     is_local: { type: "boolean" },
     is_remote: { type: "boolean" },
     supports_browser: { type: "boolean" },
@@ -4518,10 +5072,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: {
@@ -4594,7 +5148,7 @@ var ModelSearchOutputSchema = {
   additionalProperties: false
 };
 
-class ModelSearchTask extends Task10 {
+class ModelSearchTask extends Task11 {
   static type = "ModelSearchTask";
   static category = "AI Model";
   static title = "Model Search";
@@ -4620,11 +5174,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: {
@@ -4649,7 +5203,7 @@ var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema21,
+    model: modelSchema22,
     labels: {
       type: "array",
       items: {
@@ -4703,11 +5257,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: {
@@ -4754,7 +5308,7 @@ var PoseLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema22,
+    model: modelSchema23,
     numPoses: {
       type: "number",
       minimum: 1,
@@ -4833,15 +5387,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: {
@@ -4868,7 +5422,7 @@ var inputSchema9 = {
   required: ["query"],
   additionalProperties: false
 };
-var outputSchema9 = {
+var outputSchema10 = {
   type: "object",
   properties: {
     query: {
@@ -4897,17 +5451,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;
@@ -5006,11 +5560,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: {
@@ -5057,7 +5611,7 @@ var inputSchema10 = {
   required: ["query", "chunks"],
   additionalProperties: false
 };
-var outputSchema10 = {
+var outputSchema11 = {
   type: "object",
   properties: {
     chunks: {
@@ -5098,17 +5652,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;
@@ -5171,13 +5725,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: {
@@ -5211,7 +5765,7 @@ var inputSchema11 = {
   required: ["text", "title"],
   additionalProperties: false
 };
-var outputSchema11 = {
+var outputSchema12 = {
   type: "object",
   properties: {
     doc_id: {
@@ -5235,17 +5789,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;
@@ -5278,16 +5832,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",
@@ -5456,18 +6010,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: {
@@ -5505,7 +6059,7 @@ var inputSchema12 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema12 = {
+var outputSchema13 = {
   type: "object",
   properties: {
     doc_id: {
@@ -5530,17 +6084,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 {
@@ -5710,11 +6264,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: {
@@ -5741,7 +6295,7 @@ var TextClassificationInputSchema = {
       description: "The maximum number of categories to return",
       "x-ui-group": "Configuration"
     },
-    model: modelSchema24
+    model: modelSchema25
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5791,11 +6345,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: {
@@ -5804,7 +6358,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     },
-    model: modelSchema25
+    model: modelSchema26
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5859,21 +6413,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",
@@ -5948,11 +6502,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: {
@@ -5969,7 +6523,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema27
+    model: modelSchema28
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -6019,10 +6573,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",
@@ -6039,13 +6593,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
@@ -6075,11 +6629,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: {
@@ -6093,7 +6647,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     },
-    model: modelSchema29
+    model: modelSchema30
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -6128,11 +6682,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",
@@ -6159,7 +6713,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     }),
-    model: modelSchema30
+    model: modelSchema31
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -6195,10 +6749,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);
@@ -6282,11 +6836,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" },
@@ -6431,16 +6985,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: {
@@ -6481,7 +7035,7 @@ var inputSchema13 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema13 = {
+var outputSchema14 = {
   type: "object",
   properties: {
     segments: {
@@ -6509,7 +7063,7 @@ var outputSchema13 = {
   additionalProperties: false
 };
 
-class TopicSegmenterTask extends Task15 {
+class TopicSegmenterTask extends Task16 {
   static type = "TopicSegmenterTask";
   static category = "Document";
   static title = "Topic Segmenter";
@@ -6517,10 +7071,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 {
@@ -6714,15 +7268,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
@@ -6730,7 +7284,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema32
+    model: modelSchema33
   },
   required: ["model"],
   additionalProperties: false
@@ -6752,16 +7306,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: {
@@ -6798,7 +7352,7 @@ var inputSchema14 = {
   required: ["vector", "targetType"],
   additionalProperties: false
 };
-var outputSchema14 = {
+var outputSchema15 = {
   type: "object",
   properties: {
     vector: {
@@ -6835,17 +7389,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);
@@ -6938,10 +7492,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,
@@ -7055,7 +7609,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;
@@ -7208,6 +7762,7 @@ function toTextFlatMessages(input) {
 var registerAiTasks = () => {
   const tasks = [
     AiChatTask,
+    AiChatWithKbTask,
     BackgroundRemovalTask,
     CountTokensTask,
     ContextBuilderTask,
@@ -7224,6 +7779,7 @@ var registerAiTasks = () => {
     HandLandmarkerTask,
     HierarchicalChunkerTask,
     HierarchyJoinTask,
+    KbSearchTask,
     KbToDocumentsTask,
     ImageClassificationTask,
     ImageEmbeddingTask,
@@ -7293,6 +7849,7 @@ export {
   modelSearch,
   modelInfo,
   kbToDocuments,
+  kbSearch,
   isContentBlockInToolResultBody,
   isContentBlock,
   isChatMessage,
@@ -7321,6 +7878,7 @@ export {
   chunkVectorUpsert,
   chunkRetrieval,
   buildToolDescription,
+  buildResponseFormatAddendum,
   backgroundRemoval,
   VectorSimilarityTask,
   VectorQuantizeTask,
@@ -7400,6 +7958,8 @@ export {
   ModelConfigSchema,
   MODEL_REPOSITORY,
   KbToDocumentsTask,
+  KbSearchTask,
+  KB_INLINE_CITATION_DIRECTIVE,
   InMemoryModelRepository,
   ImageToTextTask,
   ImageToTextOutputSchema,
@@ -7458,10 +8018,13 @@ export {
   AiProvider,
   AiJob,
   AiImageOutputTask,
+  AiChatWithKbTask,
+  AiChatWithKbOutputSchema,
+  AiChatWithKbInputSchema,
   AiChatTask,
   AiChatOutputSchema,
   AiChatInputSchema,
   AI_PROVIDER_REGISTRY
 };
 
-//# debugId=C49AE667395C5D5064756E2164756E21
+//# debugId=CA7309C15AE94A6564756E2164756E21