@andreprado/agentkit 0.1.0-alpha.9 → 0.1.1

package/src/runtime/core/manifest.ts

@@ -1,9 +1,17 @@
 import { relative, resolve } from "node:path";
 
+import { AgentKitError } from "../errors";
+
 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;
@@ -15,6 +23,7 @@ export type SharedAgentManifest = {
   name: string;
   runtime: AgentConfig["runtime"];
   provider: AgentConfig["provider"];
+  timeZone: string | null;
   prompt: string;
   secrets: string[];
   tools: Array<{
@@ -26,7 +35,29 @@ 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<{
@@ -75,14 +106,22 @@ export function buildSharedAgentManifest(
   capsule: LoadedAgentCapsule,
   options: { databaseSchema?: ManifestSchema | null } = {},
 ): SharedAgentManifest {
+  if (capsule.config.provider.name === "openai-codex") {
+    throw new AgentKitError(
+      "target_runtime_incompatible",
+      "openai-codex uses a local ChatGPT login. Use agentkit dev/chat/eval locally, or select an API-key provider with managed secrets for Cloudflare, container, or VPS deployment.",
+    );
+  }
+
   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");
@@ -101,7 +140,15 @@ export function buildSharedAgentManifest(
     requiredSecrets.add(knowledge.embedding.secret);
   }
 
-  for (const tool of capsule.config.tools ?? []) {
+  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);
     }
@@ -118,9 +165,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,
@@ -129,7 +177,29 @@ 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) => ({

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" | "webhook";
 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", "webhook"],
       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", "webhook"],
       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", "webhook"],
       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", "webhook"],
       providers: ["server-env"],
     },
   },

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;
@@ -30,6 +34,14 @@ export type DeployReadinessContext = {
     embeddingProvider: string;
     databaseDriver: "none" | "turso";
   };
+  integrations: {
+    managedComposio: {
+      enabled: boolean;
+      toolkits: string[];
+      toolCount: number;
+      userId: string | null;
+    };
+  };
 };
 
 export async function loadDeployReadinessContext(
@@ -38,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> = {};
@@ -57,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);
@@ -82,22 +96,38 @@ export async function loadDeployReadinessContext(
       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;
   }