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

package/src/cloud/contracts.ts

@@ -16,6 +16,17 @@ export type HostedDeployArtifact = {
     source: string;
     sha256: string;
   };
+  knowledge_sources?: {
+    content_type: "application/json";
+    sources: Array<{
+      kind: "file";
+      source_key: string;
+      title: string | null;
+      content: string;
+      sha256: string;
+    }>;
+    sha256: string;
+  };
 };
 
 export type CreateDeployRequest = {
@@ -37,6 +48,11 @@ export type CreateDeployResponse = {
       mode: string;
       private_token?: string;
     };
+    knowledge?: {
+      enabled: boolean;
+      sources: number;
+      chunks: number;
+    };
   };
 };
 

package/src/create-project.ts

@@ -1,10 +1,10 @@
 import { execFile } from "node:child_process";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
 
-import { getTemplate } from "./templates";
+import { getTemplate, type TemplateFile } from "./templates";
 
 const execFileAsync = promisify(execFile);
 const moduleDir = dirname(fileURLToPath(import.meta.url));
@@ -27,9 +27,12 @@ export async function createProject(options: CreateProjectOptions): Promise<Crea
 
   const template = getTemplate(options.template);
   const projectPath = target.path;
-  const files = template.files(target.name, {
-    agentkitDependency: await resolveAgentKitDependency(),
-  });
+  const files = [
+    ...template.files(target.name, {
+      agentkitDependency: await resolveAgentKitDependency(),
+    }),
+    ...(await loadDefaultSkillFiles()),
+  ];
 
   if (target.currentDirectory) {
     await ensureNoFileCollisions(projectPath, files.map((file) => file.path));
@@ -126,6 +129,35 @@ async function resolveAgentKitDependency(): Promise<string> {
   return packageJson.version;
 }
 
+async function loadDefaultSkillFiles(): Promise<TemplateFile[]> {
+  const sourceRoot = join(moduleDir, "templates", "skills");
+  const sourceFiles = await listFiles(sourceRoot);
+
+  return Promise.all(
+    sourceFiles.map(async (sourcePath) => ({
+      path: join("skills", relative(sourceRoot, sourcePath)).replaceAll("\\", "/"),
+      contents: await readFile(sourcePath, "utf8"),
+    })),
+  );
+}
+
+async function listFiles(directory: string): Promise<string[]> {
+  const entries = await readdir(directory, { withFileTypes: true });
+  const files = await Promise.all(
+    entries.map(async (entry) => {
+      const path = join(directory, entry.name);
+
+      if (entry.isDirectory()) {
+        return listFiles(path);
+      }
+
+      return entry.isFile() ? [path] : [];
+    }),
+  );
+
+  return files.flat().sort();
+}
+
 async function directoryExists(path: string): Promise<boolean> {
   try {
     const result = await stat(path);

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;
@@ -90,6 +118,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>;
@@ -157,6 +216,7 @@ export type AgentConfig = {
   secrets: string[];
   tools?: AgentTool[];
   channels?: AgentChannel[];
+  knowledge?: AgentKnowledgeConfig;
   access: {
     mode: AccessMode;
   };
@@ -184,6 +244,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 +259,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 +273,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,6 +299,41 @@ 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";

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)) {

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,

package/src/runtime/deploy-readiness.ts

@@ -24,6 +24,12 @@ export type DeployReadinessContext = {
   userManagedSecrets: string[];
   agentKitManagedSecrets: string[];
   localSecrets: Record<string, DeployReadinessSecretSource>;
+  knowledge: {
+    enabled: boolean;
+    sourceCount: number;
+    embeddingProvider: string;
+    databaseDriver: "none" | "turso";
+  };
 };
 
 export async function loadDeployReadinessContext(
@@ -70,6 +76,12 @@ export async function loadDeployReadinessContext(
     userManagedSecrets: requiredSecrets.filter((name) => !managed.has(name)),
     agentKitManagedSecrets,
     localSecrets,
+    knowledge: {
+      enabled: manifest.knowledge.enabled,
+      sourceCount: manifest.knowledge.sources.length,
+      embeddingProvider: manifest.knowledge.embedding.provider,
+      databaseDriver: manifest.storage.database.driver,
+    },
   };
 }