@andreprado/agentkit 0.1.0-alpha.15 → 0.1.0-alpha.17

package/src/runtime/targets/cloudflare/build.ts

@@ -36,7 +36,9 @@ export type AgentManifest = {
   prompt: SharedAgentManifest["prompt"];
   secrets: SharedAgentManifest["secrets"];
   tools: SharedAgentManifest["tools"];
+  integrations: SharedAgentManifest["integrations"];
   channels: SharedAgentManifest["channels"];
+  transcription: SharedAgentManifest["transcription"];
   knowledge: SharedAgentManifest["knowledge"];
   access: SharedAgentManifest["access"];
   storage: {
@@ -197,7 +199,9 @@ function buildManifest(
     prompt: shared.prompt,
     secrets: shared.secrets,
     tools: shared.tools,
+    integrations: shared.integrations,
     channels: shared.channels,
+    transcription: shared.transcription,
     knowledge: shared.knowledge,
     access: shared.access,
     storage: {
@@ -381,6 +385,23 @@ export function defineTool(tool) {
   return tool;
 }
 
+export function composioManaged(input) {
+  const name = normalizeIntegrationName(input.name ?? "composio", "composio integration name");
+  const toolkits = normalizeToolkitList(input.toolkits, "composioManaged.toolkits");
+  const tools = input.tools ? normalizeComposioToolMap(input.tools, toolkits) : undefined;
+  const tags = input.tags ? normalizeIntegrationTags(input.tags) : undefined;
+
+  return {
+    type: "composio",
+    provider: "composio",
+    mode: "managed",
+    name,
+    toolkits,
+    ...(tools ? { tools } : {}),
+    ...(tags ? { tags } : {}),
+  };
+}
+
 export function websiteChannel(input) {
   return {
     type: "website",
@@ -438,6 +459,105 @@ function normalizeChannelSecrets(secrets, context) {
   return Array.from(uniqueSecrets).sort();
 }
 
+function normalizeIntegrationName(value, context) {
+  const name = value.trim();
+
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new Error(\`\${context} must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens.\`);
+  }
+
+  return name;
+}
+
+function normalizeToolkitList(values, context) {
+  if (!Array.isArray(values) || values.length === 0) {
+    throw new Error(\`\${context} must include at least one toolkit slug.\`);
+  }
+
+  const toolkits = new Set();
+
+  for (const value of values) {
+    if (typeof value !== "string") {
+      throw new Error(\`\${context} entries must be toolkit slug strings.\`);
+    }
+
+    const toolkit = value.trim().toLowerCase();
+
+    if (!/^[a-z][a-z0-9_-]*$/.test(toolkit)) {
+      throw new Error(\`\${context} entries must start with a letter and contain only letters, numbers, underscores, and hyphens.\`);
+    }
+
+    toolkits.add(toolkit);
+  }
+
+  return Array.from(toolkits).sort();
+}
+
+function normalizeComposioToolMap(values, toolkits) {
+  const toolkitSet = new Set(toolkits);
+  const normalized = {};
+
+  for (const [rawToolkit, rawTools] of Object.entries(values)) {
+    const toolkit = rawToolkit.trim().toLowerCase();
+
+    if (!toolkitSet.has(toolkit)) {
+      throw new Error(\`composioManaged.tools.\${rawToolkit} must reference a toolkit listed in composioManaged.toolkits.\`);
+    }
+
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+      throw new Error(\`composioManaged.tools.\${rawToolkit} must include at least one Composio action slug.\`);
+    }
+
+    const tools = new Set();
+
+    for (const rawTool of rawTools) {
+      if (typeof rawTool !== "string") {
+        throw new Error(\`composioManaged.tools.\${rawToolkit} entries must be Composio action slug strings.\`);
+      }
+
+      const tool = rawTool.trim().toUpperCase();
+
+      if (!/^[A-Z][A-Z0-9_]*$/.test(tool)) {
+        throw new Error(\`composioManaged.tools.\${rawToolkit} entries must be uppercase Composio action slugs.\`);
+      }
+
+      tools.add(tool);
+    }
+
+    normalized[toolkit] = Array.from(tools).sort();
+  }
+
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+function normalizeIntegrationTags(tags) {
+  const normalized = {};
+
+  if (tags.enable !== undefined) {
+    normalized.enable = normalizeTagList(tags.enable, "composioManaged.tags.enable");
+  }
+
+  if (tags.disable !== undefined) {
+    normalized.disable = normalizeTagList(tags.disable, "composioManaged.tags.disable");
+  }
+
+  return normalized;
+}
+
+function normalizeTagList(values, context) {
+  if (!Array.isArray(values)) {
+    throw new Error(\`\${context} must be an array of tag strings.\`);
+  }
+
+  return Array.from(new Set(values.map((value) => {
+    if (typeof value !== "string" || value.trim().length === 0) {
+      throw new Error(\`\${context} entries must be non-empty strings.\`);
+    }
+
+    return value.trim();
+  }))).sort();
+}
+
 function normalizeChannelBuffer(input, context) {
   if (input.mode === "off") {
     return { mode: "off" };
@@ -540,17 +660,18 @@ function renderCloudflareWorker(input: { manifest: AgentManifest; instructions:
   const instructionsJson = JSON.stringify(input.instructions);
   const configImportPath = JSON.stringify(input.configPath);
   const providerImportPath = JSON.stringify(resolve(moduleDir, "../../../providers/index.ts"));
+  const composioIntegrationImportPath = JSON.stringify(resolve(moduleDir, "../../integrations/composio.ts"));
   const promptContextImportPath = JSON.stringify(resolve(moduleDir, "../../prompt-context.ts"));
 
   return `import { DurableObject } from "cloudflare:workers";
 import agentConfig from ${configImportPath};
 import { getProviderAdapter } from ${providerImportPath};
+import { MANAGED_COMPOSIO_USER_ID_BINDING, createManagedComposioTools } from ${composioIntegrationImportPath};
 import { appendRuntimePromptContext, buildRuntimeClockContext } from ${promptContextImportPath};
 
 const manifest = ${manifestJson};
 const instructions = ${instructionsJson};
 const hostedKnowledgeTool = manifest.knowledge.enabled ? createHostedKnowledgeSearchTool() : null;
-const hostedTools = hostedKnowledgeTool ? [hostedKnowledgeTool, ...(agentConfig.tools ?? [])] : (agentConfig.tools ?? []);
 const DEFAULT_TOOL_TIMEOUT_MS = 30000;
 
 export class AgentKitConversationStore extends DurableObject {
@@ -719,13 +840,16 @@ export default {
         return auth;
       }
 
+      const hostedTools = createHostedTools(env);
+
       return Response.json({
         agent: manifest.name,
         runtime: manifest.runtime,
         target: manifest.target,
         provider: manifest.provider,
         prompt: manifest.prompt,
-        tools: manifest.tools.map((tool) => tool.name),
+        tools: hostedTools.map((tool) => tool.name),
+        integrations: hostedIntegrations(env),
         channels: manifest.channels.map((channel) => ({
           name: channel.name,
           type: channel.type,
@@ -1127,6 +1251,7 @@ function isRecord(value) {
 
 async function callHostedProvider(env, messages, signal) {
   const adapter = getProviderAdapter(manifest.provider);
+  const hostedTools = createHostedTools(env);
   const clock = buildRuntimeClockContext({
     timeZone: manifest.timeZone,
     env,
@@ -1624,18 +1749,49 @@ function inspectHostedDatabase() {
 }
 
 function hostedManagedSecrets() {
-  if (manifest.storage.database.driver !== "turso") {
-    return [];
+  const secrets = [];
+
+  if (manifest.storage.database.driver === "turso") {
+    secrets.push("TURSO_AUTH_TOKEN", "TURSO_DATABASE_URL");
   }
 
-  return ["TURSO_AUTH_TOKEN", "TURSO_DATABASE_URL"];
+  if (manifest.integrations.some((integration) => integration.provider === "composio" && integration.mode === "managed")) {
+    secrets.push("COMPOSIO_API_KEY");
+  }
+
+  return secrets.sort();
+}
+
+function createHostedTools(env) {
+  return [
+    ...(hostedKnowledgeTool ? [hostedKnowledgeTool] : []),
+    ...createManagedComposioTools(agentConfig, { userId: env[MANAGED_COMPOSIO_USER_ID_BINDING] }),
+    ...(agentConfig.tools ?? []),
+  ];
+}
+
+function hostedIntegrations(env) {
+  const userId = env[MANAGED_COMPOSIO_USER_ID_BINDING];
+
+  if (!userId) {
+    return manifest.integrations;
+  }
+
+  return manifest.integrations.map((integration) =>
+    integration.provider === "composio" && integration.mode === "managed"
+      ? { ...integration, userId }
+      : integration,
+  );
 }
 
 function createHostedProviderToolRuntime(env, signal, clock) {
+  const hostedTools = createHostedTools(env);
+
   return {
     definitions: hostedTools,
     execute(request) {
       return executeHostedTool({
+        tools: hostedTools,
         name: request.name,
         input: request.input,
         env,
@@ -1648,6 +1804,7 @@ function createHostedProviderToolRuntime(env, signal, clock) {
 }
 
 async function executeHostedTool(request) {
+  const hostedTools = request.tools ?? createHostedTools(request.env);
   const tool = hostedTools.find((candidate) => candidate.name === request.name);
   const id = crypto.randomUUID();
 

package/src/runtime/tool-runner.ts

@@ -2,6 +2,7 @@ import { loadAgentCapsule } from "./config";
 import { openPreparedCapsuleStore } from "./database";
 import { loadCapsuleEnv } from "./env";
 import { isAgentKitError } from "./errors";
+import { createManagedComposioTools } from "./integrations/composio";
 import { buildRuntimeClockContext } from "./prompt-context";
 import { createToolRuntime, type ToolCallResult } from "./tools";
 
@@ -26,7 +27,7 @@ export async function runToolFromCwd(cwd: string, options: RunToolOptions): Prom
     model: capsule.config.provider.model,
   });
   const toolRuntime = createToolRuntime({
-    tools: capsule.config.tools ?? [],
+    tools: [...createManagedComposioTools(capsule.config), ...(capsule.config.tools ?? [])],
     store,
     runId: run.id,
     conversationId: conversation.id,