@andreprado/agentkit 0.1.0-alpha.8 → 0.1.0

package/src/providers/codex-auth.ts

@@ -0,0 +1,111 @@
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+
+import { refreshOpenAICodexToken, type OAuthCredentials } from "@earendil-works/pi-ai/oauth";
+
+import { AgentKitError } from "../runtime/errors";
+
+export function codexAuthPath(): string {
+  return join(homedir(), ".agentkit", "providers", "openai-codex.json");
+}
+
+function validateCredentials(value: unknown): OAuthCredentials {
+  if (!value || typeof value !== "object" ||
+    !("access" in value) || typeof value.access !== "string" || !value.access.trim() ||
+    !("refresh" in value) || typeof value.refresh !== "string" || !value.refresh.trim() ||
+    !("expires" in value) || typeof value.expires !== "number" || !Number.isFinite(value.expires) || value.expires <= 0) {
+    throw new AgentKitError("provider_auth_invalid", "Invalid Codex credentials. Run agentkit provider login openai-codex again.");
+  }
+  return value as OAuthCredentials;
+}
+
+async function readCredentials(path: string): Promise<OAuthCredentials | null> {
+  let source: string;
+  try {
+    source = await readFile(path, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw new AgentKitError("provider_auth_unreadable", "Cannot read the local Codex login. Check credential file permissions.");
+  }
+  try {
+    return validateCredentials(JSON.parse(source));
+  } catch {
+    throw new AgentKitError("provider_auth_invalid", "Invalid Codex credentials. Run agentkit provider login openai-codex again.");
+  }
+}
+
+async function writeCredentials(path: string, credentials: OAuthCredentials): Promise<void> {
+  validateCredentials(credentials);
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, JSON.stringify(credentials), { mode: 0o600, flag: "wx" });
+    await rename(temporary, path);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+
+async function withAuthLock<T>(path: string, action: () => Promise<T>): Promise<T> {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  await chmod(dirname(path), 0o700);
+  const lock = `${path}.lock`;
+  const deadline = Date.now() + 10_000;
+  while (true) {
+    try {
+      await mkdir(lock, { mode: 0o700 });
+      break;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+      if (Date.now() >= deadline) {
+        throw new AgentKitError("provider_auth_busy", `Codex credentials are busy. Retry; if the previous process crashed, remove ${lock} after stopping AgentKit processes.`);
+      }
+      await delay(50);
+    }
+  }
+  try {
+    return await action();
+  } finally {
+    await rm(lock, { recursive: true, force: true });
+  }
+}
+
+export async function saveCodexLogin(credentials: OAuthCredentials, path = codexAuthPath()): Promise<void> {
+  await withAuthLock(path, () => writeCredentials(path, credentials));
+}
+
+export async function clearCodexLogin(path = codexAuthPath()): Promise<void> {
+  await withAuthLock(path, () => rm(path, { force: true }));
+}
+
+export async function codexLoginStatus(path = codexAuthPath()) {
+  const credentials = await readCredentials(path);
+  return {
+    provider: "openai-codex",
+    status: !credentials ? "logged_out" : credentials.expires <= Date.now() ? "refresh_required" : "logged_in",
+  };
+}
+
+export async function getCodexApiKey(
+  path = codexAuthPath(),
+  refresh = refreshOpenAICodexToken,
+): Promise<string> {
+  return withAuthLock(path, async () => {
+    const credentials = await readCredentials(path);
+    if (!credentials) {
+      throw new AgentKitError("provider_auth_required", "Run agentkit provider login openai-codex before using this provider.");
+    }
+    if (credentials.expires > Date.now() + 60_000) return credentials.access;
+    let updated: OAuthCredentials;
+    try {
+      updated = validateCredentials(await refresh(credentials.refresh));
+    } catch {
+      // Do not persist or expose provider error bodies containing credentials.
+      throw new AgentKitError("provider_auth_refresh_failed", "Could not refresh the Codex login. Run agentkit provider login openai-codex again.");
+    }
+    await writeCredentials(path, updated);
+    return updated.access;
+  });
+}

package/src/providers/pi.ts

@@ -17,8 +17,11 @@ import type { AgentProviderName, AgentTool } from "../index";
 import { AgentKitError } from "../runtime/errors";
 import type { ProviderAdapter, ProviderRunInput, ProviderRunResult } from "./types";
 
-const PI_PROVIDER_NAMES = ["openai", "anthropic", "openrouter"] as const satisfies AgentProviderName[];
+const PI_PROVIDER_NAMES = ["openai", "openai-codex", "anthropic", "openrouter", "opencode", "opencode-go"] 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,
@@ -29,7 +32,7 @@ export const piProviderAdapters: ProviderAdapter[] = PI_PROVIDER_NAMES.map((name
 
 async function runPiProvider(input: ProviderRunInput): Promise<ProviderRunResult> {
   const provider = toPiProvider(input.agent.provider.name);
-  const apiKey = requireProviderApiKey(provider, input.env ?? process.env);
+  const apiKey = input.apiKey ?? requireProviderApiKey(provider, input.env ?? process.env);
   const model = resolveModel(provider, input.agent.provider.model);
   const messages = toPiMessages(input.messages);
   const tools = input.tools.map(toPiTool);
@@ -97,7 +100,7 @@ async function runPiProvider(input: ProviderRunInput): Promise<ProviderRunResult
         content: [
           {
             type: "text",
-            text: result.rendered?.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],
@@ -143,7 +159,14 @@ async function runPiTurn(
 }
 
 function toPiProvider(provider: string): Provider {
-  if (provider === "openai" || provider === "anthropic" || provider === "openrouter") {
+  if (
+    provider === "openai" ||
+    provider === "openai-codex" ||
+    provider === "anthropic" ||
+    provider === "openrouter" ||
+    provider === "opencode" ||
+    provider === "opencode-go"
+  ) {
     return provider;
   }
 
@@ -151,6 +174,10 @@ function toPiProvider(provider: string): Provider {
 }
 
 function requireProviderApiKey(provider: Provider, env: Record<string, string | undefined>): string {
+  if (provider === "openai-codex") {
+    throw new AgentKitError("provider_auth_required", "Run agentkit provider login openai-codex, then use local chat, dev, or eval.");
+  }
+
   const envNames = findEnvKeys(provider) ?? defaultProviderSecretNames(provider);
   const setName = envNames.find((name) => env[name]);
 
@@ -165,6 +192,10 @@ function requireProviderApiKey(provider: Provider, env: Record<string, string |
 }
 
 function defaultProviderSecretNames(provider: Provider): string[] {
+  if (provider === "opencode" || provider === "opencode-go") {
+    return ["OPENCODE_API_KEY"];
+  }
+
   return [`${provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`];
 }
 
@@ -176,25 +207,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 +306,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

@@ -37,6 +37,17 @@ 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) {
@@ -95,6 +106,31 @@ function answerRememberedName(messages: AgentMessage[]): string | null {
   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);
 }

package/src/providers/types.ts

@@ -15,6 +15,7 @@ export type ProviderRunInput = {
   tools: AgentTool[];
   toolRuntime?: ToolRuntime;
   env?: Record<string, string | undefined>;
+  apiKey?: string;
   signal?: AbortSignal;
 };
 
@@ -24,6 +25,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-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;