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

package/src/providers/pi.ts

@@ -19,6 +19,9 @@ import type { ProviderAdapter, ProviderRunInput, ProviderRunResult } from "./typ
 
 const PI_PROVIDER_NAMES = ["openai", "anthropic", "openrouter"] as const satisfies AgentProviderName[];
 const MAX_TOOL_TURNS = 8;
+const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+const UNKNOWN_OPENROUTER_CONTEXT_WINDOW = 128000;
+const UNKNOWN_OPENROUTER_MAX_TOKENS = 8192;
 
 export const piProviderAdapters: ProviderAdapter[] = PI_PROVIDER_NAMES.map((name) => ({
   name,
@@ -97,7 +100,7 @@ async function runPiProvider(input: ProviderRunInput): Promise<ProviderRunResult
         content: [
           {
             type: "text",
-            text: JSON.stringify(result.output),
+            text: providerToolResultText(result),
           },
         ],
         isError: false,
@@ -109,6 +112,19 @@ async function runPiProvider(input: ProviderRunInput): Promise<ProviderRunResult
   throw new AgentKitError("runtime_error", `Pi provider exceeded ${MAX_TOOL_TURNS} tool turns.`);
 }
 
+export function providerToolResultText(result: {
+  name: string;
+  visibility?: "user" | "internal";
+  rendered?: { text?: string };
+  output: unknown;
+}): string {
+  if (result.visibility === "internal") {
+    return `Internal tool ${result.name} completed.`;
+  }
+
+  return result.rendered?.text ?? JSON.stringify(result.output);
+}
+
 async function runPiTurn(
   model: Model<any>,
   context: Parameters<typeof stream>[1],
@@ -176,25 +192,56 @@ function formatSecretList(names: string[]): string {
   return `one of: ${names.join(", ")}`;
 }
 
-function resolveModel(provider: Provider, modelId: string): Model<any> {
-  const modelExists = getModels(provider as any).some((model) => model.id === modelId);
+export function resolveModel(provider: Provider, modelId: string): Model<any> {
+  const model = getModel(provider as any, modelId as any) as Model<any> | undefined;
 
-  if (!modelExists) {
-    throw new AgentKitError(
-      "provider_model_unsupported",
-      `Pi SDK could not resolve provider "${provider}" model "${modelId}".`,
-    );
+  if (model) {
+    return model;
   }
 
-  try {
-    return getModel(provider as any, modelId as any) as Model<any>;
-  } catch (error) {
-    throw new AgentKitError(
-      "provider_model_unsupported",
-      `Pi SDK could not resolve provider "${provider}" model "${modelId}".`,
-      { cause: error },
-    );
+  if (provider === "openrouter") {
+    return createOpenRouterPassThroughModel(modelId);
   }
+
+  throw new AgentKitError(
+    "provider_model_unsupported",
+    `Pi SDK could not resolve provider "${provider}" model "${modelId}". ${knownModelHint(provider)}`,
+  );
+}
+
+function createOpenRouterPassThroughModel(modelId: string): Model<"openai-completions"> {
+  return {
+    id: modelId,
+    name: `OpenRouter ${modelId}`,
+    api: "openai-completions",
+    provider: "openrouter",
+    baseUrl: OPENROUTER_BASE_URL,
+    reasoning: false,
+    input: ["text"],
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+    },
+    contextWindow: UNKNOWN_OPENROUTER_CONTEXT_WINDOW,
+    maxTokens: UNKNOWN_OPENROUTER_MAX_TOKENS,
+    compat: {
+      openRouterRouting: {},
+    },
+  };
+}
+
+function knownModelHint(provider: Provider): string {
+  const examples = getModels(provider as any)
+    .slice(0, 5)
+    .map((model) => model.id);
+
+  if (examples.length === 0) {
+    return "Use a model id supported by the installed Pi SDK for that provider.";
+  }
+
+  return `Use a model id supported by the installed Pi SDK for that provider. Examples: ${examples.join(", ")}.`;
 }
 
 function toPiMessages(messages: ProviderRunInput["messages"]): Message[] {
@@ -244,6 +291,13 @@ function normalizeUsage(usage: Usage | undefined): ProviderRunResult["usage"] |
     inputTokens: usage.input,
     outputTokens: usage.output,
     totalTokens: usage.totalTokens,
+    cost: {
+      input: usage.cost.input,
+      output: usage.cost.output,
+      cacheRead: usage.cost.cacheRead,
+      cacheWrite: usage.cost.cacheWrite,
+      total: usage.cost.total,
+    },
   };
 }
 

package/src/providers/test.ts

@@ -29,7 +29,7 @@ export const testProviderAdapter: ProviderAdapter = {
           content:
             toolResult.visibility === "internal"
               ? `Tool ${toolResult.name}: completed`
-              : `Tool ${toolResult.name}: ${JSON.stringify(toolResult.output)}`,
+              : toolResult.rendered?.text ?? `Tool ${toolResult.name}: ${JSON.stringify(toolResult.output)}`,
         },
         raw: {
           toolCalls: [toolResult],
@@ -37,6 +37,28 @@ export const testProviderAdapter: ProviderAdapter = {
       };
     }
 
+    const currentDate = answerCurrentDate(input.instructions, userMessage.content);
+
+    if (currentDate) {
+      return {
+        message: {
+          role: "assistant",
+          content: currentDate,
+        },
+      };
+    }
+
+    const rememberedName = answerRememberedName(input.messages);
+
+    if (rememberedName) {
+      return {
+        message: {
+          role: "assistant",
+          content: rememberedName,
+        },
+      };
+    }
+
     return {
       message: {
         role: "assistant",
@@ -58,6 +80,71 @@ function findLastUserMessage(messages: AgentMessage[]): AgentMessage | undefined
   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 answerCurrentDate(instructions: string, content: string): string | null {
+  if (!/(today|current date|what date|data de hoje|hoje)/i.test(content)) {
+    return null;
+  }
+
+  const localDate = readRuntimeContextValue(instructions, "Local date");
+
+  if (!localDate) {
+    return null;
+  }
+
+  const localWeekday = readRuntimeContextValue(instructions, "Local weekday");
+  const timeZone = readRuntimeContextValue(instructions, "Time zone");
+  const weekday = localWeekday ? ` (${localWeekday})` : "";
+  const zone = timeZone ? ` in ${timeZone}` : "";
+
+  return `Today is ${localDate}${weekday}${zone}.`;
+}
+
+function readRuntimeContextValue(instructions: string, label: string): string | null {
+  const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = instructions.match(new RegExp(`^- ${escapedLabel}: (.+)$`, "m"));
+  return match?.[1]?.trim() || 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;
 

package/src/providers/types.ts

@@ -24,6 +24,13 @@ export type ProviderRunResult = {
     inputTokens?: number;
     outputTokens?: number;
     totalTokens?: number;
+    cost?: {
+      input?: number;
+      output?: number;
+      cacheRead?: number;
+      cacheWrite?: number;
+      total?: number;
+    };
   };
   raw?: unknown;
 };

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

@@ -8,11 +8,31 @@ import type { NormalizedChannelEvent, RawWebhookEvent } from "./channels";
 export type ChannelFixtureName =
   | "website-message"
   | "telegram-message"
+  | "telegram-audio-message"
   | "telegram-duplicate-message"
   | "telegram-malformed-payload"
   | "zapster-message"
+  | "zapster-audio-message"
   | "zapster-duplicate-message"
-  | "zapster-unsupported-media";
+  | "zapster-unsupported-media"
+  | "uazapi-message"
+  | "uazapi-audio-message"
+  | "uazapi-duplicate-message"
+  | "uazapi-unsupported-media"
+  | "uazapi-was-sent-by-api"
+  | "evolution-message"
+  | "evolution-audio-message"
+  | "evolution-captioned-media"
+  | "evolution-duplicate-message"
+  | "evolution-from-me"
+  | "evolution-unsupported-media"
+  | "discord-command"
+  | "discord-message-create"
+  | "discord-ping"
+  | "slack-app-mention"
+  | "slack-direct-message"
+  | "generic-webhook-message"
+  | "generic-webhook-duplicate";
 
 export type ChannelFixture = {
   name: ChannelFixtureName;