@andreprado/agentkit 0.1.0-alpha.5 → 0.1.0-alpha.7

package/src/index.ts

@@ -17,6 +17,28 @@ export type ChannelLimits = {
   usdPerDay?: number;
 };
 
+export type ChannelBufferMode = "off" | "debounce";
+
+export type ChannelBufferInput = {
+  mode?: ChannelBufferMode;
+  quietWindowMs?: number;
+  maxWaitMs?: number;
+  maxMessages?: number;
+  maxChars?: number;
+};
+
+export type ChannelBufferConfig =
+  | {
+      mode: "off";
+    }
+  | {
+      mode: "debounce";
+      quietWindowMs: number;
+      maxWaitMs: number;
+      maxMessages: number;
+      maxChars: number;
+    };
+
 export type WebsiteChannelAccess = {
   mode: "token";
 };
@@ -26,6 +48,7 @@ export type WebsiteChannelInput = {
   access?: WebsiteChannelAccess;
   secrets?: string[];
   limits?: ChannelLimits;
+  buffer?: ChannelBufferInput;
 };
 
 export type WebsiteChannelConfig = {
@@ -35,6 +58,7 @@ export type WebsiteChannelConfig = {
   access: WebsiteChannelAccess;
   secrets: string[];
   limits?: ChannelLimits;
+  buffer?: ChannelBufferConfig;
 };
 
 export type TelegramChannelInput = {
@@ -42,6 +66,7 @@ export type TelegramChannelInput = {
   secrets?: string[];
   allowedUpdates?: TelegramAllowedUpdate[];
   limits?: ChannelLimits;
+  buffer?: ChannelBufferInput;
 };
 
 export type TelegramChannelConfig = {
@@ -51,6 +76,7 @@ export type TelegramChannelConfig = {
   secrets: string[];
   allowedUpdates: TelegramAllowedUpdate[];
   limits?: ChannelLimits;
+  buffer?: ChannelBufferConfig;
 };
 
 export type WhatsappChannelInput = {
@@ -58,6 +84,7 @@ export type WhatsappChannelInput = {
   provider: WhatsappChannelProvider;
   secrets?: string[];
   limits?: ChannelLimits;
+  buffer?: ChannelBufferInput;
 };
 
 export type WhatsappChannelConfig = {
@@ -66,6 +93,7 @@ export type WhatsappChannelConfig = {
   name: string;
   secrets: string[];
   limits?: ChannelLimits;
+  buffer?: ChannelBufferConfig;
 };
 
 export type AgentChannel = WebsiteChannelConfig | TelegramChannelConfig | WhatsappChannelConfig;
@@ -77,6 +105,7 @@ export type AgentDatabaseConfig =
   | {
       driver: "turso";
       schema?: string;
+      migrations?: string;
     };
 
 export type AgentFilesConfig =
@@ -90,6 +119,37 @@ export type AgentFilesConfig =
       maxUploadBytes?: number;
     };
 
+export type AgentKnowledgeSource =
+  | string
+  | {
+      path: string;
+      title?: string;
+    }
+  | {
+      url: string;
+      title?: string;
+    };
+
+export type AgentKnowledgeEmbeddingProvider = "none" | "test" | "openai";
+
+export type AgentKnowledgeEmbeddingConfig = {
+  provider?: AgentKnowledgeEmbeddingProvider;
+  model?: string;
+  dimensions?: number;
+  secret?: string;
+};
+
+export type AgentKnowledgeRetrievalConfig = {
+  topK?: number;
+  hybrid?: boolean;
+};
+
+export type AgentKnowledgeConfig = {
+  sources?: AgentKnowledgeSource[];
+  embedding?: AgentKnowledgeEmbeddingConfig;
+  retrieval?: AgentKnowledgeRetrievalConfig;
+};
+
 export type JsonSchema = {
   type: string | string[];
   properties?: Record<string, JsonSchema>;
@@ -119,9 +179,42 @@ export type DatabaseRunner = {
   batch(statements: DatabaseStatement[]): Promise<DatabaseResult[]>;
 };
 
+export type ToolRenderField = {
+  label: string;
+  value: string;
+};
+
+export type ToolRenderAction = {
+  label: string;
+  href?: string;
+};
+
+export type ToolRenderBlock =
+  | {
+      type: "text";
+      text: string;
+    }
+  | {
+      type: "card";
+      title: string;
+      subtitle?: string;
+      fields?: ToolRenderField[];
+      actions?: ToolRenderAction[];
+    };
+
+export type ToolRenderResult = {
+  text: string;
+  blocks?: ToolRenderBlock[];
+};
+
+export type ToolRenderContext<Input = unknown> = {
+  input: Input;
+  runtime: ToolRuntimeContext;
+};
+
 export type ToolRuntimeContext = {
   environment: "local" | "hosted" | "eval" | "test";
-  invocation: "chat" | "tool" | "dev" | "channel" | "eval";
+  invocation: "chat" | "tool" | "dev" | "channel" | "eval" | "sync";
   target: "bun" | "cloudflare";
   database: "sqlite" | "turso" | "none";
 };
@@ -137,6 +230,13 @@ export type ToolContext = {
   };
 };
 
+export type SyncContext = {
+  env: Record<string, string | undefined>;
+  database: DatabaseRunner;
+  db: DatabaseRunner;
+  runtime: ToolRuntimeContext;
+};
+
 export type AgentTool<Input = unknown, Output = unknown> = {
   name: string;
   description: string;
@@ -147,6 +247,7 @@ export type AgentTool<Input = unknown, Output = unknown> = {
   permissions?: string[];
   timeoutMs?: number;
   execute(input: Input, ctx: ToolContext): Promise<Output> | Output;
+  render?(output: Output, ctx: ToolRenderContext<Input>): string | ToolRenderResult;
 };
 
 export type AgentConfig = {
@@ -157,6 +258,7 @@ export type AgentConfig = {
   secrets: string[];
   tools?: AgentTool[];
   channels?: AgentChannel[];
+  knowledge?: AgentKnowledgeConfig;
   access: {
     mode: AccessMode;
   };
@@ -184,6 +286,7 @@ export function websiteChannel(input: WebsiteChannelInput): WebsiteChannelConfig
     access: input.access ?? { mode: "token" },
     secrets: normalizeChannelSecrets(input.secrets ?? ["AGENTKIT_WEBSITE_CHANNEL_TOKEN"], "website channel"),
     ...(input.limits ? { limits: input.limits } : {}),
+    ...(input.buffer ? { buffer: normalizeChannelBuffer(input.buffer, "website channel") } : {}),
   };
 }
 
@@ -198,6 +301,7 @@ export function telegramChannel(input: TelegramChannelInput): TelegramChannelCon
     ),
     allowedUpdates: input.allowedUpdates ?? ["message"],
     ...(input.limits ? { limits: input.limits } : {}),
+    ...(input.buffer ? { buffer: normalizeChannelBuffer(input.buffer, "telegram channel") } : {}),
   };
 }
 
@@ -211,6 +315,7 @@ export function whatsappChannel(input: WhatsappChannelInput): WhatsappChannelCon
       `${input.provider} whatsapp channel`,
     ),
     ...(input.limits ? { limits: input.limits } : {}),
+    ...(input.buffer ? { buffer: normalizeChannelBuffer(input.buffer, `${input.provider} whatsapp channel`) } : {}),
   };
 }
 
@@ -236,10 +341,46 @@ function normalizeChannelSecrets(secrets: string[], context: string): string[] {
   return Array.from(uniqueSecrets).sort();
 }
 
+function normalizeChannelBuffer(input: ChannelBufferInput, context: string): ChannelBufferConfig {
+  if (input.mode === "off") {
+    return { mode: "off" };
+  }
+
+  if (input.mode !== undefined && input.mode !== "debounce") {
+    throw new Error(`${context} buffer.mode must be "off" or "debounce".`);
+  }
+
+  const buffer: ChannelBufferConfig = {
+    mode: "debounce",
+    quietWindowMs: input.quietWindowMs ?? 2500,
+    maxWaitMs: input.maxWaitMs ?? 12000,
+    maxMessages: input.maxMessages ?? 20,
+    maxChars: input.maxChars ?? 8000,
+  };
+
+  validatePositiveInteger(buffer.quietWindowMs, `${context} buffer.quietWindowMs`);
+  validatePositiveInteger(buffer.maxWaitMs, `${context} buffer.maxWaitMs`);
+  validatePositiveInteger(buffer.maxMessages, `${context} buffer.maxMessages`);
+  validatePositiveInteger(buffer.maxChars, `${context} buffer.maxChars`);
+
+  if (buffer.maxWaitMs < buffer.quietWindowMs) {
+    throw new Error(`${context} buffer.maxWaitMs must be greater than or equal to buffer.quietWindowMs.`);
+  }
+
+  return buffer;
+}
+
+function validatePositiveInteger(value: number, field: string): void {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${field} must be a positive integer.`);
+  }
+}
+
 export { loadAgentCapsule, findAgentCapsuleRoot } from "./runtime/config";
 export { runAgentMessage, runAgentMessageFromCwd } from "./runtime/chat";
 export { listConversationsFromCwd, getConversationFromCwd } from "./runtime/conversations";
 export { runEvalsFromCwd } from "./runtime/evals";
+export { getConversationTraceFromCwd } from "./runtime/traces";
 export { runToolFromCwd } from "./runtime/tool-runner";
 export { startAgentDevServer } from "./runtime/dev-server";
 export { inspectAgentCapsule } from "./runtime/inspect";

package/src/providers/pi.ts

@@ -97,7 +97,7 @@ async function runPiProvider(input: ProviderRunInput): Promise<ProviderRunResult
         content: [
           {
             type: "text",
-            text: JSON.stringify(result.output),
+            text: result.rendered?.text ?? JSON.stringify(result.output),
           },
         ],
         isError: false,

package/src/providers/test.ts

@@ -29,7 +29,7 @@ export const testProviderAdapter: ProviderAdapter = {
           content:
             toolResult.visibility === "internal"
               ? `Tool ${toolResult.name}: completed`
-              : `Tool ${toolResult.name}: ${JSON.stringify(toolResult.output)}`,
+              : toolResult.rendered?.text ?? `Tool ${toolResult.name}: ${JSON.stringify(toolResult.output)}`,
         },
         raw: {
           toolCalls: [toolResult],

package/src/runtime/channel-buffer.ts

@@ -0,0 +1,30 @@
+import type { ChannelBufferConfig, ChannelType } from "../index";
+
+export type ChannelBufferCarrier = {
+  type: ChannelType;
+  buffer?: ChannelBufferConfig;
+};
+
+export type ChannelBufferedMessage = {
+  content: string;
+  receivedAt: string;
+};
+
+export function resolveChannelBuffer(channel: ChannelBufferCarrier): ChannelBufferConfig {
+  return channel.buffer ?? { mode: "off" };
+}
+
+export function isChannelBufferEnabled(channel: ChannelBufferCarrier): boolean {
+  return resolveChannelBuffer(channel).mode === "debounce";
+}
+
+export function renderBufferedChannelMessage(messages: ChannelBufferedMessage[]): string {
+  if (messages.length === 1) {
+    return messages[0]?.content ?? "";
+  }
+
+  const lines = messages.map((message, index) => `${index + 1}. ${message.content}`);
+
+  return `The client sent ${messages.length} messages in one burst. Answer once, using the full context below:\n\n${lines.join("\n")}`;
+}
+

package/src/runtime/channels.ts

@@ -8,6 +8,7 @@ export type ChannelDeliveryState =
   | "received"
   | "validated"
   | "duplicate"
+  | "buffered"
   | "queued"
   | "running"
   | "sent"

package/src/runtime/chat.ts

@@ -7,6 +7,9 @@ import { loadAgentCapsule } from "./config";
 import { openPreparedCapsuleStore } from "./database";
 import { loadCapsuleEnv } from "./env";
 import { AgentKitError, isAgentKitError } from "./errors";
+import { syncConfiguredKnowledgeSources } from "./knowledge/ingest";
+import { appendKnowledgePromptPolicy } from "./knowledge/prompt-policy";
+import { createKnowledgeSearchTool } from "./knowledge/tool";
 import { createToolRuntime } from "./tools";
 
 export type RunAgentMessageOptions = {
@@ -37,6 +40,7 @@ export async function runAgentMessage(
 
   const adapter = getProviderAdapter(capsule.config.provider);
   const env = await loadCapsuleEnv(capsule.root);
+  await syncConfiguredKnowledgeSources(capsule);
   const { store } = await openPreparedCapsuleStore(capsule);
   const conversationId = normalizeConversationId(options.conversationId);
   const { conversation, previousMessages } = resolveConversation(store, {
@@ -55,8 +59,9 @@ export async function runAgentMessage(
     provider: capsule.config.provider.name,
     model: capsule.config.provider.model,
   });
+  const runtimeTools = withKnowledgeTools(capsule);
   const toolRuntime = createToolRuntime({
-    tools: capsule.config.tools ?? [],
+    tools: runtimeTools,
     store,
     runId: run.id,
     conversationId: conversation.id,
@@ -78,7 +83,10 @@ export async function runAgentMessage(
         runtime: capsule.config.runtime,
         provider: capsule.config.provider,
       },
-      instructions: withToolVisibilityInstructions(capsule.instructions, capsule.config.tools ?? []),
+      instructions: withToolVisibilityInstructions(
+        appendKnowledgePromptPolicy(capsule.instructions, capsule.config),
+        runtimeTools,
+      ),
       messages,
       tools: toolRuntime.definitions,
       toolRuntime,
@@ -119,6 +127,17 @@ export async function runAgentMessage(
   }
 }
 
+function withKnowledgeTools(capsule: LoadedAgentCapsule): NonNullable<LoadedAgentCapsule["config"]["tools"]> {
+  const tools = [...(capsule.config.tools ?? [])];
+  const knowledgeTool = createKnowledgeSearchTool(capsule);
+
+  if (knowledgeTool) {
+    return [knowledgeTool, ...tools];
+  }
+
+  return tools;
+}
+
 function resolveConversation(
   store: Awaited<ReturnType<typeof openPreparedCapsuleStore>>["store"],
   input: {

package/src/runtime/config.ts

@@ -14,6 +14,8 @@ import type {
   ChannelProvider,
   ChannelType,
   TelegramAllowedUpdate,
+  AgentKnowledgeEmbeddingProvider,
+  ChannelBufferMode,
 } from "../index";
 import { AgentKitError } from "./errors";
 
@@ -24,7 +26,9 @@ const ACCESS_MODES = new Set<AccessMode>(["private", "token", "public"]);
 const TOOL_VISIBILITIES = new Set<ToolVisibility>(["user", "internal"]);
 const CHANNEL_TYPES = new Set<ChannelType>(["website", "telegram", "whatsapp"]);
 const CHANNEL_PROVIDERS = new Set<ChannelProvider>(["agentkit", "telegram", "zapster", "meta"]);
+const CHANNEL_BUFFER_MODES = new Set<ChannelBufferMode>(["off", "debounce"]);
 const TELEGRAM_ALLOWED_UPDATES = new Set<TelegramAllowedUpdate>(["message"]);
+const KNOWLEDGE_EMBEDDING_PROVIDERS = new Set<AgentKnowledgeEmbeddingProvider>(["none", "test", "openai"]);
 const CHANNEL_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
 const SECRET_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 const moduleDir = dirname(fileURLToPath(import.meta.url));
@@ -205,6 +209,7 @@ function validateAgentConfig(value: unknown): asserts value is AgentConfig {
   }
 
   validateChannels(value.channels, value.runtime as AgentRuntime);
+  validateKnowledgeConfig(value.knowledge);
 
   if (!isRecord(value.access) || !ACCESS_MODES.has(value.access.mode as AccessMode)) {
     throw invalidConfig('access.mode must be "private", "token", or "public".');
@@ -226,6 +231,134 @@ function validateAgentConfig(value: unknown): asserts value is AgentConfig {
   validateFilesConfig(value.storage.files);
 }
 
+function validateKnowledgeConfig(value: unknown): void {
+  if (value === undefined) {
+    return;
+  }
+
+  if (!isRecord(value)) {
+    throw invalidConfig("knowledge must be an object when provided.");
+  }
+
+  if (value.sources !== undefined) {
+    if (!Array.isArray(value.sources)) {
+      throw invalidConfig("knowledge.sources must be an array when provided.");
+    }
+
+    for (const [index, source] of value.sources.entries()) {
+      validateKnowledgeSource(source, index);
+    }
+  }
+
+  if (value.embedding !== undefined) {
+    validateKnowledgeEmbedding(value.embedding);
+  }
+
+  if (value.retrieval !== undefined) {
+    validateKnowledgeRetrieval(value.retrieval);
+  }
+}
+
+function validateKnowledgeSource(value: unknown, index: number): void {
+  if (typeof value === "string") {
+    expectString(value, `knowledge.sources[${index}]`);
+    validateKnowledgeSourceReference(value, `knowledge.sources[${index}]`);
+    return;
+  }
+
+  if (!isRecord(value)) {
+    throw invalidConfig(`knowledge.sources[${index}] must be a path string or an object with path or url.`);
+  }
+
+  const hasPath = "path" in value;
+  const hasUrl = "url" in value;
+
+  if (hasPath === hasUrl) {
+    throw invalidConfig(`knowledge.sources[${index}] must set exactly one of path or url.`);
+  }
+
+  if (hasPath) {
+    expectString(value.path, `knowledge.sources[${index}].path`);
+    validateKnowledgeSourceReference(value.path, `knowledge.sources[${index}].path`);
+  }
+
+  if (hasUrl) {
+    expectString(value.url, `knowledge.sources[${index}].url`);
+    validateKnowledgeUrl(value.url, `knowledge.sources[${index}].url`);
+  }
+
+  if (value.title !== undefined) {
+    expectString(value.title, `knowledge.sources[${index}].title`);
+  }
+}
+
+function validateKnowledgeSourceReference(value: string, label: string): void {
+  if (value.includes("\0")) {
+    throw invalidConfig(`${label} must not contain null bytes.`);
+  }
+
+  if (/^https?:\/\//i.test(value)) {
+    validateKnowledgeUrl(value, label);
+  }
+}
+
+function validateKnowledgeUrl(value: string, label: string): void {
+  let url: URL;
+
+  try {
+    url = new URL(value);
+  } catch {
+    throw invalidConfig(`${label} must be a valid http or https URL.`);
+  }
+
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw invalidConfig(`${label} must be a valid http or https URL.`);
+  }
+}
+
+function validateKnowledgeEmbedding(value: unknown): void {
+  if (!isRecord(value)) {
+    throw invalidConfig("knowledge.embedding must be an object when provided.");
+  }
+
+  if (value.provider !== undefined && !KNOWLEDGE_EMBEDDING_PROVIDERS.has(value.provider as AgentKnowledgeEmbeddingProvider)) {
+    throw invalidConfig(
+      `knowledge.embedding.provider must be one of: ${Array.from(KNOWLEDGE_EMBEDDING_PROVIDERS).join(", ")}.`,
+    );
+  }
+
+  if (value.model !== undefined) {
+    expectString(value.model, "knowledge.embedding.model");
+  }
+
+  if (value.secret !== undefined) {
+    expectString(value.secret, "knowledge.embedding.secret");
+    validateSecretNames([value.secret], "knowledge.embedding.secret");
+  }
+
+  const dimensions = value.dimensions;
+  if (dimensions !== undefined) {
+    if (typeof dimensions !== "number" || !Number.isInteger(dimensions) || dimensions <= 0 || dimensions > 65_536) {
+      throw invalidConfig("knowledge.embedding.dimensions must be a positive integer no larger than 65536.");
+    }
+  }
+}
+
+function validateKnowledgeRetrieval(value: unknown): void {
+  if (!isRecord(value)) {
+    throw invalidConfig("knowledge.retrieval must be an object when provided.");
+  }
+
+  const topK = value.topK;
+  if (topK !== undefined && (typeof topK !== "number" || !Number.isInteger(topK) || topK <= 0 || topK > 50)) {
+    throw invalidConfig("knowledge.retrieval.topK must be a positive integer no larger than 50.");
+  }
+
+  if (value.hybrid !== undefined && typeof value.hybrid !== "boolean") {
+    throw invalidConfig("knowledge.retrieval.hybrid must be a boolean when provided.");
+  }
+}
+
 function validateChannels(value: unknown, runtime: AgentRuntime): void {
   if (value === undefined) {
     return;
@@ -276,6 +409,7 @@ function validateChannel(value: unknown, index: number): asserts value is AgentC
   expectStringArray(value.secrets, `channels[${index}].secrets`);
   validateSecretNames(value.secrets, `channels[${index}].secrets`);
   validateChannelLimits(value.limits, index);
+  validateChannelBuffer(value.buffer, index);
 
   if (value.type === "website") {
     validateWebsiteChannel(value, index);
@@ -361,6 +495,39 @@ function validateChannelLimits(value: unknown, index: number): void {
   }
 }
 
+function validateChannelBuffer(value: unknown, index: number): void {
+  if (value === undefined) {
+    return;
+  }
+
+  if (!isRecord(value)) {
+    throw invalidConfig(`channels[${index}].buffer must be an object when provided.`);
+  }
+
+  if (!CHANNEL_BUFFER_MODES.has(value.mode as ChannelBufferMode)) {
+    throw invalidConfig(`channels[${index}].buffer.mode must be "off" or "debounce".`);
+  }
+
+  if (value.mode === "off") {
+    return;
+  }
+
+  for (const field of ["quietWindowMs", "maxWaitMs", "maxMessages", "maxChars"] as const) {
+    if (
+      value[field] === undefined ||
+      typeof value[field] !== "number" ||
+      !Number.isInteger(value[field]) ||
+      value[field] <= 0
+    ) {
+      throw invalidConfig(`channels[${index}].buffer.${field} must be a positive integer.`);
+    }
+  }
+
+  if ((value.maxWaitMs as number) < (value.quietWindowMs as number)) {
+    throw invalidConfig(`channels[${index}].buffer.maxWaitMs must be greater than or equal to quietWindowMs.`);
+  }
+}
+
 function validateSecretNames(secrets: string[], field: string): void {
   for (const secret of secrets) {
     if (!SECRET_NAME_PATTERN.test(secret)) {
@@ -394,6 +561,10 @@ function validateDatabaseConfig(value: unknown): void {
   if (value.schema !== undefined && typeof value.schema !== "string") {
     throw invalidConfig("storage.database.schema must be a string when provided.");
   }
+
+  if (value.migrations !== undefined && typeof value.migrations !== "string") {
+    throw invalidConfig("storage.database.migrations must be a string when provided.");
+  }
 }
 
 function validateFilesConfig(value: unknown): void {
@@ -464,6 +635,10 @@ function validateTool(value: unknown, index: number): asserts value is AgentTool
   if (typeof value.execute !== "function") {
     throw invalidConfig(`tools[${index}].execute must be a function.`);
   }
+
+  if (value.render !== undefined && typeof value.render !== "function") {
+    throw invalidConfig(`tools[${index}].render must be a function when provided.`);
+  }
 }
 
 function resolvePath(root: string, path: string): string {

package/src/runtime/core/manifest.ts

@@ -2,6 +2,8 @@ import { relative, resolve } from "node:path";
 
 import type { AgentConfig, AgentTool } from "../../index";
 import type { LoadedAgentCapsule } from "../config";
+import { resolveKnowledgeConfig } from "../knowledge/config";
+import { KNOWLEDGE_SEARCH_TOOL_NAME } from "../knowledge/tool";
 
 export type ManifestSchema = {
   source: string;
@@ -25,6 +27,25 @@ export type SharedAgentManifest = {
     timeoutMs: number | null;
   }>;
   channels: NonNullable<AgentConfig["channels"]>;
+  knowledge: {
+    enabled: boolean;
+    sources: Array<{
+      kind: "file" | "url";
+      value: string;
+      title: string | null;
+    }>;
+    embedding: {
+      provider: string;
+      model: string | null;
+      dimensions: number | null;
+      secret: string | null;
+    };
+    retrieval: {
+      topK: number;
+      hybrid: boolean;
+    };
+    internalTool: string | null;
+  };
   access: AgentConfig["access"];
   storage: {
     driver: AgentConfig["storage"]["driver"];
@@ -57,6 +78,7 @@ export function buildSharedAgentManifest(
   const requiredSecrets = new Set(capsule.config.secrets);
   const database = buildDatabaseManifest(capsule, options.databaseSchema ?? null);
   const files = buildFilesManifest(capsule);
+  const knowledge = resolveKnowledgeConfig(capsule.config);
 
   if (capsule.config.access.mode === "private") {
     requiredSecrets.add("AGENTKIT_PRIVATE_TOKEN");
@@ -75,6 +97,10 @@ export function buildSharedAgentManifest(
     requiredSecrets.add("TURSO_AUTH_TOKEN");
   }
 
+  if (knowledge.embedding.secret) {
+    requiredSecrets.add(knowledge.embedding.secret);
+  }
+
   for (const tool of capsule.config.tools ?? []) {
     for (const secret of tool.secrets ?? []) {
       requiredSecrets.add(secret);
@@ -104,6 +130,17 @@ export function buildSharedAgentManifest(
       timeoutMs: tool.timeoutMs ?? null,
     })),
     channels: capsule.config.channels ?? [],
+    knowledge: {
+      enabled: knowledge.enabled,
+      sources: knowledge.sources.map((source) => ({
+        kind: source.kind,
+        value: source.value,
+        title: source.title,
+      })),
+      embedding: knowledge.embedding,
+      retrieval: knowledge.retrieval,
+      internalTool: knowledge.enabled ? KNOWLEDGE_SEARCH_TOOL_NAME : null,
+    },
     access: capsule.config.access,
     storage: {
       driver: capsule.config.storage.driver,