@andreprado/agentkit 0.1.0-alpha.8 → 0.1.0

package/src/runtime/channels.ts

@@ -1,16 +1,28 @@
 import type { AgentChannel, ChannelProvider, ChannelType } from "../index";
 
 export type ChannelMessageRole = "user" | "assistant";
-export type ChannelMessageContentType = "text";
+export type ChannelMessageContentType = "text" | "audio";
 export type ChannelEventKind = "message" | "delivery_status" | "unsupported";
 export type ChannelDeliveryDirection = "inbound" | "outbound";
 export type ChannelDeliveryState =
+  | "webhook_received"
   | "received"
   | "validated"
+  | "audio_received"
+  | "audio_downloaded"
+  | "transcribing"
+  | "transcribed"
   | "duplicate"
   | "buffered"
   | "queued"
   | "running"
+  | "agent_completed"
+  | "adapter_stubbed"
+  | "provider_request_built"
+  | "provider_sent"
+  | "outbound_sent"
+  | "provider_failed"
+  | "synthetic_expected_failure"
   | "sent"
   | "delivered"
   | "failed"
@@ -37,11 +49,41 @@ export type ChannelExternalIdentity = {
   redactedDisplay?: string;
 };
 
+export type ChannelReplyTarget =
+  | {
+      type: "discord_interaction";
+      applicationId: string;
+      interactionId: string;
+      interactionToken: string;
+    }
+  | {
+      type: "discord_message";
+      channelId: string;
+      messageId: string;
+    }
+  | {
+      type: "slack_message";
+      channelId: string;
+      messageTs: string;
+      threadTs?: string;
+    };
+
+export type ChannelAudioAttachment = {
+  providerMediaId: string;
+  kind: "voice" | "audio";
+  mimeType?: string;
+  filename?: string;
+  durationSeconds?: number;
+  sizeBytes?: number;
+  downloadUrl?: string;
+};
+
 export type NormalizedChannelMessage = {
   role: ChannelMessageRole;
   contentType: ChannelMessageContentType;
   content: string;
   providerMessageId?: string;
+  audio?: ChannelAudioAttachment;
 };
 
 export type NormalizedChannelEvent = ChannelAdapterId & {
@@ -54,6 +96,7 @@ export type NormalizedChannelEvent = ChannelAdapterId & {
   receivedAt: string;
   unsupportedReason?: string;
   providerMetadata?: Record<string, unknown>;
+  replyTarget?: ChannelReplyTarget;
 };
 
 export type WebhookVerificationInput = RawWebhookEvent & {
@@ -71,26 +114,66 @@ export type WebhookVerificationResult =
       message: string;
     };
 
+export type ChannelWebhookResponse = {
+  status?: number;
+  headers?: Record<string, string>;
+  body: string | Record<string, unknown>;
+};
+
 export type ChannelSendInput = ChannelAdapterId & {
   channelId: string;
+  channel?: AgentChannel;
+  jobId?: string;
+  deliveryId?: string;
   conversationId: string;
   externalIdentity: ChannelExternalIdentity;
+  replyTarget?: ChannelReplyTarget;
   message: NormalizedChannelMessage;
   secrets: Record<string, string>;
 };
 
+export type ChannelMediaDownloadInput = ChannelAdapterId & {
+  channelId: string;
+  message: NormalizedChannelMessage;
+  secrets: Record<string, string>;
+  maxBytes?: number;
+};
+
+export type ChannelMediaDownloadResult =
+  | {
+      ok: true;
+      audio: Uint8Array;
+      filename: string;
+      mimeType?: string;
+      durationSeconds?: number;
+      sizeBytes?: number;
+      providerMetadata?: Record<string, unknown>;
+    }
+  | {
+      ok: false;
+      retryable: boolean;
+      code:
+        | "channel_secret_missing"
+        | "channel_audio_download_unavailable"
+        | "channel_audio_too_large"
+        | "channel_provider_unavailable"
+        | "channel_media_download_failed";
+      message: string;
+      providerMetadata?: Record<string, unknown>;
+    };
+
 export type ChannelSendResult =
   | {
       ok: true;
       providerRequestId?: string;
       providerMessageId?: string;
-      status: "sent" | "delivered";
+      status: "stubbed" | "sent" | "delivered";
       providerMetadata?: Record<string, unknown>;
     }
   | {
       ok: false;
       retryable: boolean;
-      code: "channel_secret_missing" | "channel_provider_unavailable" | "channel_send_failed";
+      code: "channel_secret_missing" | "channel_provider_unavailable" | "channel_send_failed" | "synthetic_expected_failure";
       message: string;
       providerRequestId?: string;
       providerMetadata?: Record<string, unknown>;
@@ -112,13 +195,15 @@ export type ChannelStatusResult = {
 export type ChannelAdapter = ChannelAdapterId & {
   requiredSecrets: string[];
   normalizeInbound(input: RawWebhookEvent): Promise<NormalizedChannelEvent[]> | NormalizedChannelEvent[];
+  downloadMedia?(input: ChannelMediaDownloadInput): Promise<ChannelMediaDownloadResult>;
   sendMessage(input: ChannelSendInput): Promise<ChannelSendResult>;
   verifyWebhook?(input: WebhookVerificationInput): Promise<WebhookVerificationResult> | WebhookVerificationResult;
+  getWebhookResponse?(input: WebhookVerificationInput): Promise<ChannelWebhookResponse | null> | ChannelWebhookResponse | null;
   getStatus?(input: ChannelStatusInput): Promise<ChannelStatusResult> | ChannelStatusResult;
 };
 
 export type PortableChannelRouteContract = {
-  route: "/channels/:name/:type/:provider/webhook";
+  route: "/channels/:name/:type/:provider/webhook" | "/channels/:name/webhook";
   verification: WebhookVerificationResult;
   dedupe: {
     key: string;

package/src/runtime/chat.ts

@@ -1,3 +1,4 @@
+import { getCodexApiKey } from "../providers/codex-auth";
 import { getProviderAdapter } from "../providers";
 import type { AgentMessage, ProviderRunResult } from "../providers";
 import type { ToolRuntimeContext } from "../index";
@@ -7,9 +8,11 @@ import { loadAgentCapsule } from "./config";
 import { openPreparedCapsuleStore } from "./database";
 import { loadCapsuleEnv } from "./env";
 import { AgentKitError, isAgentKitError } from "./errors";
+import { createManagedComposioTools } from "./integrations/composio";
 import { syncConfiguredKnowledgeSources } from "./knowledge/ingest";
 import { appendKnowledgePromptPolicy } from "./knowledge/prompt-policy";
 import { createKnowledgeSearchTool } from "./knowledge/tool";
+import { appendRuntimePromptContext, buildRuntimeClockContext } from "./prompt-context";
 import { createToolRuntime } from "./tools";
 
 export type RunAgentMessageOptions = {
@@ -17,6 +20,8 @@ export type RunAgentMessageOptions = {
   conversationId?: string;
   signal?: AbortSignal;
   runtime?: Partial<ToolRuntimeContext>;
+  now?: Date;
+  localStoragePath?: string;
 };
 
 export type AgentRunResult = ProviderRunResult & PersistedChatRun;
@@ -25,7 +30,8 @@ export async function runAgentMessageFromCwd(
   cwd: string,
   options: RunAgentMessageOptions,
 ): Promise<AgentRunResult> {
-  return runAgentMessage(await loadAgentCapsule(cwd), options);
+  const capsule = await loadAgentCapsule(cwd);
+  return runAgentMessage(withLocalStoragePath(capsule, options.localStoragePath), options);
 }
 
 export async function runAgentMessage(
@@ -41,56 +47,70 @@ 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, {
-    agentName: capsule.config.name,
-    conversationId,
-    firstMessage: content,
-  });
-  const messages: AgentMessage[] = [...previousMessages, { role: "user", content }];
-  const userMessage = store.appendMessage({
-    conversationId: conversation.id,
-    role: "user",
-    content,
-  });
-  const run = store.createRun({
-    conversationId: conversation.id,
-    provider: capsule.config.provider.name,
-    model: capsule.config.provider.model,
-  });
-  const runtimeTools = withKnowledgeTools(capsule);
-  const toolRuntime = createToolRuntime({
-    tools: runtimeTools,
-    store,
-    runId: run.id,
-    conversationId: conversation.id,
-    env,
-    signal: options.signal,
-    runtime: {
-      environment: "local",
-      invocation: "chat",
-      target: "bun",
-      database: "sqlite",
-      ...options.runtime,
-    },
-  });
+  const { store } = await openPreparedCapsuleStore(capsule);
+  let runId: string | null = null;
 
   try {
+    const { conversation, previousMessages } = resolveConversation(store, {
+      agentName: capsule.config.name,
+      conversationId,
+      firstMessage: content,
+    });
+    const messages: AgentMessage[] = [...previousMessages, { role: "user", content }];
+    const userMessage = store.appendMessage({
+      conversationId: conversation.id,
+      role: "user",
+      content,
+    });
+    const run = store.createRun({
+      conversationId: conversation.id,
+      provider: capsule.config.provider.name,
+      model: capsule.config.provider.model,
+    });
+    runId = run.id;
+    const runtimeTools = withKnowledgeTools(capsule);
+    const clock = buildRuntimeClockContext({
+      timeZone: capsule.config.timeZone,
+      env,
+      now: options.now,
+    });
+    const toolRuntime = createToolRuntime({
+      tools: runtimeTools,
+      store,
+      runId: run.id,
+      conversationId: conversation.id,
+      env,
+      signal: options.signal,
+      clock,
+      runtime: {
+        environment: "local",
+        invocation: "chat",
+        target: "bun",
+        database: "sqlite",
+        ...options.runtime,
+      },
+    });
     const result = await adapter.run({
       agent: {
         name: capsule.config.name,
         runtime: capsule.config.runtime,
         provider: capsule.config.provider,
       },
-      instructions: withToolVisibilityInstructions(
-        appendKnowledgePromptPolicy(capsule.instructions, capsule.config),
-        runtimeTools,
+      instructions: appendRuntimePromptContext(
+        withToolVisibilityInstructions(
+          appendKnowledgePromptPolicy(capsule.instructions, capsule.config),
+          runtimeTools,
+        ),
+        {
+          clock,
+        },
       ),
       messages,
       tools: toolRuntime.definitions,
       toolRuntime,
       env,
+      apiKey: capsule.config.provider.name === "openai-codex" ? await getCodexApiKey() : undefined,
       signal: options.signal,
     });
 
@@ -114,12 +134,14 @@ export async function runAgentMessage(
       assistantMessageId: assistantMessage.id,
     };
   } catch (error) {
-    store.completeRun({
-      runId: run.id,
-      status: "failed",
-      errorCode: isAgentKitError(error) ? error.code : "runtime_error",
-      errorMessage: error instanceof Error ? error.message : String(error),
-    });
+    if (runId) {
+      store.completeRun({
+        runId,
+        status: "failed",
+        errorCode: isAgentKitError(error) ? error.code : "runtime_error",
+        errorMessage: error instanceof Error ? error.message : String(error),
+      });
+    }
 
     throw error;
   } finally {
@@ -128,7 +150,7 @@ export async function runAgentMessage(
 }
 
 function withKnowledgeTools(capsule: LoadedAgentCapsule): NonNullable<LoadedAgentCapsule["config"]["tools"]> {
-  const tools = [...(capsule.config.tools ?? [])];
+  const tools = [...createManagedComposioTools(capsule.config), ...(capsule.config.tools ?? [])];
   const knowledgeTool = createKnowledgeSearchTool(capsule);
 
   if (knowledgeTool) {
@@ -190,6 +212,10 @@ function normalizeConversationId(value: string | undefined): string | undefined
   return conversationId;
 }
 
+function withLocalStoragePath(capsule: LoadedAgentCapsule, storagePath?: string): LoadedAgentCapsule {
+  return storagePath ? { ...capsule, storagePath } : capsule;
+}
+
 function withToolVisibilityInstructions(instructions: string, tools: LoadedAgentCapsule["config"]["tools"] = []): string {
   const internalTools = tools.filter((tool) => tool.visibility === "internal").map((tool) => tool.name).sort();