@andreprado/agentkit 0.1.0-alpha.2 → 0.1.0-alpha.20

package/src/runtime/core/manifest.ts

@@ -2,6 +2,14 @@ import { relative, resolve } from "node:path";
 
 import type { AgentConfig, AgentTool } from "../../index";
 import type { LoadedAgentCapsule } from "../config";
+import {
+  createManagedComposioTools,
+  managedComposioRequiredSecrets,
+  resolveManagedComposioIntegrations,
+} from "../integrations/composio";
+import { resolveKnowledgeConfig } from "../knowledge/config";
+import { KNOWLEDGE_SEARCH_TOOL_NAME } from "../knowledge/tool";
+import { resolveTranscriptionConfig } from "../transcription";
 
 export type ManifestSchema = {
   source: string;
@@ -13,6 +21,7 @@ export type SharedAgentManifest = {
   name: string;
   runtime: AgentConfig["runtime"];
   provider: AgentConfig["provider"];
+  timeZone: string | null;
   prompt: string;
   secrets: string[];
   tools: Array<{
@@ -24,7 +33,48 @@ export type SharedAgentManifest = {
     permissions: string[];
     timeoutMs: number | null;
   }>;
+  integrations: Array<{
+    name: string;
+    provider: "composio";
+    mode: "managed";
+    toolkits: string[];
+    tools: string[];
+    userId: string;
+    confirmExternalWrites: boolean;
+  }>;
   channels: NonNullable<AgentConfig["channels"]>;
+  transcription: {
+    enabled: boolean;
+    provider: string | null;
+    model: string | null;
+    secret: string | null;
+    language: string | null;
+    prompt: string | null;
+    limits: {
+      maxDurationSeconds: number | null;
+      maxBytes: number | null;
+    };
+    rawAudioTtlSeconds: number | null;
+  };
+  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,10 +107,12 @@ 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);
+  const integrationTools = createManagedComposioTools(capsule.config);
+  const tools = [...integrationTools, ...(capsule.config.tools ?? [])];
+  const transcription = resolveTranscriptionConfig(capsule.config.transcription);
 
-  if (capsule.config.access.mode === "private") {
-    requiredSecrets.add("AGENTKIT_PRIVATE_TOKEN");
-  }
+  requiredSecrets.add("AGENTKIT_PRIVATE_TOKEN");
 
   if (capsule.config.access.mode === "token") {
     requiredSecrets.add("AGENTKIT_ACCESS_TOKEN");
@@ -75,7 +127,19 @@ export function buildSharedAgentManifest(
     requiredSecrets.add("TURSO_AUTH_TOKEN");
   }
 
-  for (const tool of capsule.config.tools ?? []) {
+  if (knowledge.embedding.secret) {
+    requiredSecrets.add(knowledge.embedding.secret);
+  }
+
+  if (transcription.secret) {
+    requiredSecrets.add(transcription.secret);
+  }
+
+  for (const secret of managedComposioRequiredSecrets(capsule.config)) {
+    requiredSecrets.add(secret);
+  }
+
+  for (const tool of tools) {
     for (const secret of tool.secrets ?? []) {
       requiredSecrets.add(secret);
     }
@@ -92,9 +156,10 @@ export function buildSharedAgentManifest(
     name: capsule.config.name,
     runtime: capsule.config.runtime,
     provider: capsule.config.provider,
+    timeZone: capsule.config.timeZone ?? null,
     prompt: toCapsulePath(capsule, capsule.instructionsPath),
     secrets: Array.from(requiredSecrets).sort(),
-    tools: (capsule.config.tools ?? []).map((tool) => ({
+    tools: tools.map((tool) => ({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -103,7 +168,40 @@ export function buildSharedAgentManifest(
       permissions: [...(tool.permissions ?? [])].sort(),
       timeoutMs: tool.timeoutMs ?? null,
     })),
+    integrations: resolveManagedComposioIntegrations(capsule.config).map((integration) => ({
+      name: integration.name,
+      provider: integration.provider,
+      mode: integration.mode,
+      toolkits: integration.toolkits,
+      tools: integration.allowedTools,
+      userId: integration.userId,
+      confirmExternalWrites: integration.confirmExternalWrites !== false,
+    })),
     channels: capsule.config.channels ?? [],
+    transcription: {
+      enabled: transcription.enabled,
+      provider: transcription.enabled ? transcription.provider : null,
+      model: transcription.enabled ? transcription.model : null,
+      secret: transcription.secret,
+      language: transcription.language,
+      prompt: transcription.prompt,
+      limits: {
+        maxDurationSeconds: transcription.limits.maxDurationSeconds ?? null,
+        maxBytes: transcription.limits.maxBytes ?? null,
+      },
+      rawAudioTtlSeconds: transcription.rawAudioTtlSeconds,
+    },
+    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/core/targets.ts

@@ -6,7 +6,7 @@ export type RuntimeTargetId = (typeof runtimeTargetIds)[number];
 export type RuntimeTargetCapabilityState = "available" | "planned" | "unsupported";
 export type RuntimeStorageCapability = "agentkit" | "durable-object-sqlite" | "local-sqlite" | "postgres";
 export type RuntimeFilesCapability = "none" | "r2" | "local-disk" | "s3-compatible";
-export type RuntimeChannelCapability = "website" | "telegram" | "whatsapp";
+export type RuntimeChannelCapability = "website" | "telegram" | "whatsapp" | "discord" | "slack";
 export type RuntimeProviderSupport = "pi-local" | "edge-compatible" | "server-env";
 
 export type RuntimeTargetCapabilities = {
@@ -35,7 +35,7 @@ export const runtimeTargets: Readonly<Record<RuntimeTargetId, RuntimeTarget>> =
       dev: "available",
       storage: ["local-sqlite"],
       files: ["local-disk"],
-      channels: ["website"],
+      channels: ["website", "slack"],
       providers: ["pi-local"],
     },
   },
@@ -48,7 +48,7 @@ export const runtimeTargets: Readonly<Record<RuntimeTargetId, RuntimeTarget>> =
       dev: "planned",
       storage: ["agentkit", "durable-object-sqlite", "postgres"],
       files: ["none", "r2"],
-      channels: ["website", "telegram", "whatsapp"],
+      channels: ["website", "telegram", "whatsapp", "discord", "slack"],
       providers: ["edge-compatible"],
     },
   },
@@ -61,7 +61,7 @@ export const runtimeTargets: Readonly<Record<RuntimeTargetId, RuntimeTarget>> =
       dev: "planned",
       storage: ["local-sqlite", "postgres"],
       files: ["none", "local-disk", "s3-compatible"],
-      channels: ["website", "telegram", "whatsapp"],
+      channels: ["website", "telegram", "whatsapp", "discord", "slack"],
       providers: ["server-env"],
     },
   },
@@ -74,7 +74,7 @@ export const runtimeTargets: Readonly<Record<RuntimeTargetId, RuntimeTarget>> =
       dev: "unsupported",
       storage: ["local-sqlite", "postgres"],
       files: ["none", "local-disk", "s3-compatible"],
-      channels: ["website", "telegram", "whatsapp"],
+      channels: ["website", "telegram", "whatsapp", "discord", "slack"],
       providers: ["server-env"],
     },
   },

package/src/runtime/database.ts

@@ -1,5 +1,6 @@
-import { readFile } from "node:fs/promises";
-import { relative, resolve } from "node:path";
+import { readdir, readFile } from "node:fs/promises";
+import type { Dirent } from "node:fs";
+import { basename, relative, resolve } from "node:path";
 
 import type { DatabaseArgs, DatabaseResult, DatabaseRunner, DatabaseStatement } from "../index";
 import { openCapsuleStore, type SqliteAgentKitStore } from "../storage/sqlite";
@@ -9,6 +10,12 @@ import { AgentKitError } from "./errors";
 export type LocalDatabasePrepareResult = {
   store: SqliteAgentKitStore;
   databasePath: string;
+  migrations: {
+    configured: boolean;
+    path: string | null;
+    applied: string[];
+    skipped: string[];
+  };
   schema: {
     configured: boolean;
     applied: boolean;
@@ -20,10 +27,12 @@ export async function openPreparedCapsuleStore(capsule: LoadedAgentCapsule): Pro
   const store = await openCapsuleStore(capsule);
 
   try {
+    const migrations = await applyCapsuleDatabaseMigrations(capsule, store);
     const schema = await applyCapsuleDatabaseSchema(capsule, store);
     return {
       store,
       databasePath: store.dbPath,
+      migrations,
       schema,
     };
   } catch (error) {
@@ -32,6 +41,84 @@ export async function openPreparedCapsuleStore(capsule: LoadedAgentCapsule): Pro
   }
 }
 
+export async function applyCapsuleDatabaseMigrations(
+  capsule: LoadedAgentCapsule,
+  store: SqliteAgentKitStore,
+): Promise<LocalDatabasePrepareResult["migrations"]> {
+  const database = capsule.config.storage.database;
+
+  if (!database || database.driver !== "turso") {
+    return {
+      configured: false,
+      path: null,
+      applied: [],
+      skipped: [],
+    };
+  }
+
+  const migrationsPath = resolve(capsule.root, database.migrations ?? "migrations");
+  const migrations = await readMigrationFiles(migrationsPath);
+
+  if (migrations.length === 0) {
+    return {
+      configured: false,
+      path: migrationsPath,
+      applied: [],
+      skipped: [],
+    };
+  }
+
+  try {
+    const result = store.applyApplicationMigrations(migrations);
+    return {
+      configured: true,
+      path: migrationsPath,
+      applied: result.applied,
+      skipped: result.skipped,
+    };
+  } catch (error) {
+    if (error instanceof AgentKitError && error.code === "database_schema_error") {
+      throw new AgentKitError(
+        "database_schema_error",
+        [
+          `Could not apply database migrations from ${relative(capsule.root, migrationsPath)}.`,
+          "Migrations must be ordered .sql files and should use safe, forward-only changes.",
+          error.message,
+        ].join(" "),
+        { cause: error },
+      );
+    }
+
+    throw error;
+  }
+}
+
+async function readMigrationFiles(directory: string): Promise<Array<{ id: string; sql: string }>> {
+  let entries: Dirent[];
+
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return [];
+    }
+
+    throw error;
+  }
+
+  const files = entries
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".sql"))
+    .map((entry) => entry.name)
+    .sort();
+
+  return Promise.all(
+    files.map(async (file) => ({
+      id: basename(file, ".sql"),
+      sql: await readFile(resolve(directory, file), "utf8"),
+    })),
+  );
+}
+
 export async function applyCapsuleDatabaseSchema(
   capsule: LoadedAgentCapsule,
   store: SqliteAgentKitStore,
@@ -163,3 +250,7 @@ function validateStatements(statements: DatabaseStatement[]): void {
     validateSql(statement.sql, statement.args ?? []);
   }
 }
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return typeof error === "object" && error !== null && "code" in error;
+}

package/src/runtime/db-commands.ts

@@ -10,6 +10,9 @@ import { AgentKitError } from "./errors";
 export type DbMigrateResult = {
   root: string;
   databasePath: string;
+  migrationsPath: string | null;
+  migrationsApplied: string[];
+  migrationsSkipped: string[];
   schemaPath: string | null;
   schemaApplied: boolean;
 };
@@ -43,6 +46,9 @@ export async function migrateLocalDatabase(cwd = process.cwd()): Promise<DbMigra
     return {
       root: capsule.root,
       databasePath: prepared.databasePath,
+      migrationsPath: prepared.migrations.path,
+      migrationsApplied: prepared.migrations.applied,
+      migrationsSkipped: prepared.migrations.skipped,
       schemaPath: prepared.schema.path,
       schemaApplied: prepared.schema.applied,
     };
@@ -87,6 +93,9 @@ export async function seedLocalDatabase(cwd = process.cwd(), seedFile = "seed.sq
     return {
       root: capsule.root,
       databasePath: prepared.databasePath,
+      migrationsPath: prepared.migrations.path,
+      migrationsApplied: prepared.migrations.applied,
+      migrationsSkipped: prepared.migrations.skipped,
       schemaPath: prepared.schema.path,
       schemaApplied: prepared.schema.applied,
       seedPath,

package/src/runtime/deploy-readiness.ts

@@ -3,6 +3,10 @@ import { createHash } from "node:crypto";
 import { loadAgentCapsule } from "./config";
 import { buildSharedAgentManifest } from "./core/manifest";
 import { listCapsuleEnv } from "./env";
+import {
+  MANAGED_COMPOSIO_API_KEY_SECRET,
+  resolveManagedComposioIntegrations,
+} from "./integrations/composio";
 
 export type DeployReadinessSecretSource = {
   dotenv: boolean;
@@ -24,6 +28,20 @@ export type DeployReadinessContext = {
   userManagedSecrets: string[];
   agentKitManagedSecrets: string[];
   localSecrets: Record<string, DeployReadinessSecretSource>;
+  knowledge: {
+    enabled: boolean;
+    sourceCount: number;
+    embeddingProvider: string;
+    databaseDriver: "none" | "turso";
+  };
+  integrations: {
+    managedComposio: {
+      enabled: boolean;
+      toolkits: string[];
+      toolCount: number;
+      userId: string | null;
+    };
+  };
 };
 
 export async function loadDeployReadinessContext(
@@ -32,6 +50,7 @@ export async function loadDeployReadinessContext(
 ): Promise<DeployReadinessContext> {
   const capsule = await loadAgentCapsule(cwd);
   const manifest = buildSharedAgentManifest(capsule);
+  const managedComposio = resolveManagedComposioIntegrations(capsule.config)[0];
   const dotenvNames = new Set(await listCapsuleEnv(capsule.root));
   const requiredSecrets = manifest.secrets;
   const localSecrets: Record<string, DeployReadinessSecretSource> = {};
@@ -51,6 +70,7 @@ export async function loadDeployReadinessContext(
     isAgentKitManagedDeploySecret(name, {
       accessMode: capsule.config.access.mode,
       databaseDriver: manifest.storage.database.driver,
+      managedComposioEnabled: Boolean(managedComposio),
     }),
   );
   const managed = new Set(agentKitManagedSecrets);
@@ -70,22 +90,44 @@ 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,
+    },
+    integrations: {
+      managedComposio: {
+        enabled: Boolean(managedComposio),
+        toolkits: managedComposio?.toolkits ?? [],
+        toolCount: managedComposio?.allowedTools.length ?? 0,
+        userId: managedComposio?.userId ?? null,
+      },
+    },
   };
 }
 
-export function stableCloudProjectId(name: string): string {
-  return `proj_${createHash("sha256").update(name).digest("hex").slice(0, 16)}`;
+export function stableCloudProjectId(name: string, accountId?: string | null): string {
+  return `proj_${createHash("sha256").update(`${accountId ? `account:${accountId}` : "anonymous"}:${name}`).digest("hex").slice(0, 16)}`;
 }
 
 function isAgentKitManagedDeploySecret(
   name: string,
-  context: { accessMode: DeployReadinessContext["accessMode"]; databaseDriver: "none" | "turso" },
+  context: {
+    accessMode: DeployReadinessContext["accessMode"];
+    databaseDriver: "none" | "turso";
+    managedComposioEnabled: boolean;
+  },
 ): boolean {
   if (context.databaseDriver === "turso" && (name === "TURSO_DATABASE_URL" || name === "TURSO_AUTH_TOKEN")) {
     return true;
   }
 
-  if (context.accessMode === "private" && name === "AGENTKIT_PRIVATE_TOKEN") {
+  if (name === "AGENTKIT_PRIVATE_TOKEN") {
+    return true;
+  }
+
+  if (context.managedComposioEnabled && name === MANAGED_COMPOSIO_API_KEY_SECRET) {
     return true;
   }
 

package/src/runtime/deploy.ts

@@ -1 +1 @@
-export * from "./targets/cloudflare/deploy";
+export * from "../cloud";