@andreprado/agentkit 0.1.0-alpha.10

package/src/providers/test.ts

@@ -0,0 +1,133 @@
+import { AgentKitError } from "../runtime/errors";
+import type { AgentMessage, ProviderAdapter } from "./types";
+
+export const testProviderAdapter: ProviderAdapter = {
+  name: "test",
+  async run(input) {
+    if (input.agent.provider.model !== "fake") {
+      throw new AgentKitError("provider_model_unsupported", 'The test provider only supports model "fake".');
+    }
+
+    const userMessage = findLastUserMessage(input.messages);
+
+    if (!userMessage) {
+      throw new AgentKitError("runtime_error", "Cannot run the test provider without a user message.");
+    }
+
+    const toolRequest = parseToolRequest(userMessage.content);
+
+    if (toolRequest) {
+      if (!input.toolRuntime) {
+        throw new AgentKitError("runtime_error", "The runtime did not provide a tool registry.");
+      }
+
+      const toolResult = await input.toolRuntime.execute(toolRequest);
+
+      return {
+        message: {
+          role: "assistant",
+          content:
+            toolResult.visibility === "internal"
+              ? `Tool ${toolResult.name}: completed`
+              : toolResult.rendered?.text ?? `Tool ${toolResult.name}: ${JSON.stringify(toolResult.output)}`,
+        },
+        raw: {
+          toolCalls: [toolResult],
+        },
+      };
+    }
+
+    const rememberedName = answerRememberedName(input.messages);
+
+    if (rememberedName) {
+      return {
+        message: {
+          role: "assistant",
+          content: rememberedName,
+        },
+      };
+    }
+
+    return {
+      message: {
+        role: "assistant",
+        content: `Echo: ${userMessage.content}`,
+      },
+    };
+  },
+};
+
+function findLastUserMessage(messages: AgentMessage[]): AgentMessage | undefined {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+
+    if (message.role === "user") {
+      return message;
+    }
+  }
+
+  return undefined;
+}
+
+function answerRememberedName(messages: AgentMessage[]): string | null {
+  const lastUserMessage = findLastUserMessage(messages);
+
+  if (!lastUserMessage || !asksForName(lastUserMessage.content)) {
+    return null;
+  }
+
+  for (let index = messages.length - 2; index >= 0; index -= 1) {
+    const message = messages[index];
+
+    if (message.role !== "user") {
+      continue;
+    }
+
+    const name = extractName(message.content);
+
+    if (name) {
+      return /meu nome|qual\s+(é|e)\s*meu nome|como\s+(é|e)\s*meu nome/i.test(lastUserMessage.content)
+        ? `Seu nome é ${name}.`
+        : `Your name is ${name}.`;
+    }
+  }
+
+  return null;
+}
+
+function asksForName(content: string): boolean {
+  return /what(?:'s| is) my name\??/i.test(content) || /(como|qual)\s+(é|e)\s*(o\s+)?meu nome\??/i.test(content);
+}
+
+function extractName(content: string): string | null {
+  const match = content.match(/\bmy name is\s+(.+)$/i) ?? content.match(/\bmeu nome (?:é|e)\s+(.+)$/i);
+
+  if (!match) {
+    return null;
+  }
+
+  return match[1].trim().replace(/[.!?]+$/g, "") || null;
+}
+
+function parseToolRequest(content: string): { name: string; input?: unknown } | null {
+  let parsed: unknown;
+
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return null;
+  }
+
+  if (!isRecord(parsed) || typeof parsed.tool !== "string" || parsed.tool.length === 0) {
+    return null;
+  }
+
+  return {
+    name: parsed.tool,
+    input: "input" in parsed ? parsed.input : {},
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/providers/types.ts

@@ -0,0 +1,34 @@
+import type { AgentConfig, AgentProviderName, AgentTool } from "../index";
+import type { ToolRuntime } from "../runtime/tools";
+
+export type AgentMessageRole = "system" | "user" | "assistant";
+
+export type AgentMessage = {
+  role: AgentMessageRole;
+  content: string;
+};
+
+export type ProviderRunInput = {
+  agent: Pick<AgentConfig, "name" | "runtime" | "provider">;
+  instructions: string;
+  messages: AgentMessage[];
+  tools: AgentTool[];
+  toolRuntime?: ToolRuntime;
+  env?: Record<string, string | undefined>;
+  signal?: AbortSignal;
+};
+
+export type ProviderRunResult = {
+  message: AgentMessage & { role: "assistant" };
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+  };
+  raw?: unknown;
+};
+
+export type ProviderAdapter = {
+  name: AgentProviderName;
+  run(input: ProviderRunInput): Promise<ProviderRunResult>;
+};

package/src/runtime/build.ts

@@ -0,0 +1,43 @@
+import { resolveBuildTarget, type RuntimeTargetId } from "./core/targets";
+import { buildContainerAgentCapsule, type ContainerBuildResult } from "./targets/container/build";
+import {
+  buildCloudflareAgentCapsule,
+  type AgentBuildResult as CloudflareBuildResult,
+  type AgentManifest,
+  type AgentManifestWithBundle,
+} from "./targets/cloudflare/build";
+
+export type BuildTarget = RuntimeTargetId;
+
+export type BuildAgentOptions = {
+  target?: string;
+};
+
+export type AgentBuildResult = CloudflareBuildResult | ContainerBuildResult;
+export type { AgentManifest, AgentManifestWithBundle };
+
+export async function buildAgentCapsule(
+  cwd?: string,
+  options?: { target?: "cloudflare" },
+): Promise<CloudflareBuildResult>;
+export async function buildAgentCapsule(
+  cwd: string | undefined,
+  options: { target: "container" },
+): Promise<ContainerBuildResult>;
+export async function buildAgentCapsule(cwd?: string, options?: BuildAgentOptions): Promise<AgentBuildResult>;
+export async function buildAgentCapsule(
+  cwd = process.cwd(),
+  options: BuildAgentOptions = {},
+): Promise<AgentBuildResult> {
+  const target = resolveBuildTarget(options.target);
+
+  if (target.id === "cloudflare") {
+    return buildCloudflareAgentCapsule(cwd);
+  }
+
+  if (target.id === "container") {
+    return buildContainerAgentCapsule(cwd);
+  }
+
+  throw new Error(`Target registry returned unsupported build target "${target.id}".`);
+}

package/src/runtime/channel-buffer.ts

@@ -0,0 +1,30 @@
+import type { ChannelBufferConfig, ChannelType } from "../index";
+
+export type ChannelBufferCarrier = {
+  type: ChannelType;
+  buffer?: ChannelBufferConfig;
+};
+
+export type ChannelBufferedMessage = {
+  content: string;
+  receivedAt: string;
+};
+
+export function resolveChannelBuffer(channel: ChannelBufferCarrier): ChannelBufferConfig {
+  return channel.buffer ?? { mode: "off" };
+}
+
+export function isChannelBufferEnabled(channel: ChannelBufferCarrier): boolean {
+  return resolveChannelBuffer(channel).mode === "debounce";
+}
+
+export function renderBufferedChannelMessage(messages: ChannelBufferedMessage[]): string {
+  if (messages.length === 1) {
+    return messages[0]?.content ?? "";
+  }
+
+  const lines = messages.map((message, index) => `${index + 1}. ${message.content}`);
+
+  return `The client sent ${messages.length} messages in one burst. Answer once, using the full context below:\n\n${lines.join("\n")}`;
+}
+

package/src/runtime/channel-test-harness.ts

@@ -0,0 +1,112 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { ChannelProvider, ChannelType } from "../index";
+import type { NormalizedChannelEvent, RawWebhookEvent } from "./channels";
+
+export type ChannelFixtureName =
+  | "website-message"
+  | "telegram-message"
+  | "telegram-duplicate-message"
+  | "telegram-malformed-payload"
+  | "zapster-message"
+  | "zapster-duplicate-message"
+  | "zapster-unsupported-media";
+
+export type ChannelFixture = {
+  name: ChannelFixtureName;
+  channelId: string;
+  type: ChannelType;
+  provider: ChannelProvider;
+  request: {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: unknown;
+    rawBody?: string;
+  };
+  expected: {
+    kind?: NormalizedChannelEvent["kind"];
+    providerEventId?: string;
+    dedupeKey?: string;
+    identityKey?: string;
+    text?: string;
+    unsupportedReason?: string;
+    errorCode?: string;
+  };
+  forbidden: string[];
+};
+
+const FIXTURE_DIR = join(dirname(fileURLToPath(import.meta.url)), "fixtures/channels");
+
+export async function loadChannelFixture(name: ChannelFixtureName): Promise<ChannelFixture> {
+  const source = await readFile(join(FIXTURE_DIR, `${name}.json`), "utf8");
+  return JSON.parse(source) as ChannelFixture;
+}
+
+export function channelFixtureToRawEvent(
+  fixture: ChannelFixture,
+  overrides: Partial<RawWebhookEvent> = {},
+): RawWebhookEvent {
+  return {
+    type: fixture.type,
+    provider: fixture.provider,
+    channelId: fixture.channelId,
+    method: fixture.request.method,
+    url: fixture.request.url,
+    headers: new Headers(fixture.request.headers),
+    rawBody: fixture.request.rawBody ?? JSON.stringify(fixture.request.body),
+    receivedAt: "2026-05-27T15:00:00.000Z",
+    ...overrides,
+  };
+}
+
+export function assertMatchesFixtureEvent(event: NormalizedChannelEvent, fixture: ChannelFixture): void {
+  const expected = fixture.expected;
+
+  if (expected.kind !== undefined && event.kind !== expected.kind) {
+    throw new Error(`Expected event kind ${expected.kind}, received ${event.kind}.`);
+  }
+
+  if (expected.providerEventId !== undefined && event.providerEventId !== expected.providerEventId) {
+    throw new Error(`Expected providerEventId ${expected.providerEventId}, received ${event.providerEventId}.`);
+  }
+
+  if (expected.dedupeKey !== undefined && event.dedupeKey !== expected.dedupeKey) {
+    throw new Error(`Expected dedupeKey ${expected.dedupeKey}, received ${event.dedupeKey}.`);
+  }
+
+  if (expected.identityKey !== undefined && event.externalIdentity.key !== expected.identityKey) {
+    throw new Error(`Expected identity key ${expected.identityKey}, received ${event.externalIdentity.key}.`);
+  }
+
+  if (expected.text !== undefined && event.message?.content !== expected.text) {
+    throw new Error(`Expected message text ${JSON.stringify(expected.text)}, received ${JSON.stringify(event.message?.content)}.`);
+  }
+
+  if (expected.unsupportedReason !== undefined && event.unsupportedReason !== expected.unsupportedReason) {
+    throw new Error(
+      `Expected unsupportedReason ${expected.unsupportedReason}, received ${event.unsupportedReason}.`,
+    );
+  }
+}
+
+export function assertNoForbiddenValues(value: unknown, forbidden: string[]): void {
+  const serialized = JSON.stringify(value);
+
+  for (const forbiddenValue of forbidden) {
+    if (forbiddenValue && serialized.includes(forbiddenValue)) {
+      throw new Error(`Serialized value contains forbidden fixture value: ${forbiddenValue}`);
+    }
+  }
+}
+
+export function assertRedactedExternalIdentity(event: NormalizedChannelEvent): void {
+  const display = event.externalIdentity.display;
+  const redactedDisplay = event.externalIdentity.redactedDisplay;
+
+  if (display && redactedDisplay && display === redactedDisplay) {
+    throw new Error("externalIdentity.redactedDisplay must not equal display when both are set.");
+  }
+}