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

package/src/runtime/channels.ts

@@ -1,15 +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"
@@ -36,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 & {
@@ -53,6 +96,7 @@ export type NormalizedChannelEvent = ChannelAdapterId & {
   receivedAt: string;
   unsupportedReason?: string;
   providerMetadata?: Record<string, unknown>;
+  replyTarget?: ChannelReplyTarget;
 };
 
 export type WebhookVerificationInput = RawWebhookEvent & {
@@ -70,26 +114,63 @@ 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;
   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>;
@@ -111,13 +192,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,18 +1,25 @@
 import { getProviderAdapter } from "../providers";
 import type { AgentMessage, ProviderRunResult } from "../providers";
 import type { ToolRuntimeContext } from "../index";
-import type { PersistedChatRun } from "../storage/sqlite";
+import type { ConversationRecord, ConversationSummary, PersistedChatRun } from "../storage/sqlite";
 import type { LoadedAgentCapsule } from "./config";
 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 = {
   message: string;
+  conversationId?: string;
   signal?: AbortSignal;
   runtime?: Partial<ToolRuntimeContext>;
+  now?: Date;
 };
 
 export type AgentRunResult = ProviderRunResult & PersistedChatRun;
@@ -36,46 +43,66 @@ export async function runAgentMessage(
 
   const adapter = getProviderAdapter(capsule.config.provider);
   const env = await loadCapsuleEnv(capsule.root);
-  const messages: AgentMessage[] = [{ role: "user", content }];
+  await syncConfiguredKnowledgeSources(capsule);
+  const conversationId = normalizeConversationId(options.conversationId);
   const { store } = await openPreparedCapsuleStore(capsule);
-  const conversation = store.createConversation({
-    agentName: capsule.config.name,
-    title: titleFromMessage(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 toolRuntime = createToolRuntime({
-    tools: capsule.config.tools ?? [],
-    store,
-    runId: run.id,
-    conversationId: conversation.id,
-    env,
-    signal: options.signal,
-    runtime: {
-      environment: "local",
-      invocation: "chat",
-      target: "bun",
-      database: "sqlite",
-      ...options.runtime,
-    },
-  });
+  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(capsule.instructions, capsule.config.tools ?? []),
+      instructions: appendRuntimePromptContext(
+        withToolVisibilityInstructions(
+          appendKnowledgePromptPolicy(capsule.instructions, capsule.config),
+          runtimeTools,
+        ),
+        {
+          clock,
+        },
+      ),
       messages,
       tools: toolRuntime.definitions,
       toolRuntime,
@@ -103,12 +130,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 {
@@ -116,6 +145,69 @@ export async function runAgentMessage(
   }
 }
 
+function withKnowledgeTools(capsule: LoadedAgentCapsule): NonNullable<LoadedAgentCapsule["config"]["tools"]> {
+  const tools = [...createManagedComposioTools(capsule.config), ...(capsule.config.tools ?? [])];
+  const knowledgeTool = createKnowledgeSearchTool(capsule);
+
+  if (knowledgeTool) {
+    return [knowledgeTool, ...tools];
+  }
+
+  return tools;
+}
+
+function resolveConversation(
+  store: Awaited<ReturnType<typeof openPreparedCapsuleStore>>["store"],
+  input: {
+    agentName: string;
+    conversationId?: string;
+    firstMessage: string;
+  },
+): { conversation: ConversationSummary; previousMessages: AgentMessage[] } {
+  if (input.conversationId) {
+    const existing = store.getConversation(input.conversationId);
+
+    if (existing) {
+      return {
+        conversation: existing,
+        previousMessages: toProviderMessages(existing),
+      };
+    }
+  }
+
+  const conversation = store.createConversation({
+    id: input.conversationId,
+    agentName: input.agentName,
+    title: titleFromMessage(input.firstMessage),
+  });
+
+  return {
+    conversation,
+    previousMessages: [],
+  };
+}
+
+function toProviderMessages(conversation: ConversationRecord): AgentMessage[] {
+  return conversation.messages.map((message) => ({
+    role: message.role,
+    content: message.content,
+  }));
+}
+
+function normalizeConversationId(value: string | undefined): string | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  const conversationId = value.trim();
+
+  if (!conversationId) {
+    throw new AgentKitError("validation_error", "conversationId must be a non-empty string when provided.");
+  }
+
+  return conversationId;
+}
+
 function withToolVisibilityInstructions(instructions: string, tools: LoadedAgentCapsule["config"]["tools"] = []): string {
   const internalTools = tools.filter((tool) => tool.visibility === "internal").map((tool) => tool.name).sort();