agent-accelerator 0.1.0

package/src/ai-sdk/converters.ts

@@ -0,0 +1,342 @@
+import type {
+  LanguageModelV4Prompt,
+  LanguageModelV4FunctionTool,
+  LanguageModelV4FinishReason,
+} from "@ai-sdk/provider";
+import type { ProviderContext, ContentPart, Message } from "../types/message.ts";
+import type { StandardToolDeclaration, ToolCallRecord } from "../types/tool.ts";
+import type { ProviderGenerateResult, ProviderRequestOptions } from "../types/model.ts";
+import type { TokenUsage } from "../types/core.ts";
+import { normalizeMediaInput } from "../utils/media.ts";
+import { base64ToBytes } from "../utils/base64.ts";
+import { safeStringify } from "../utils/serialization.ts";
+import { stripSchemaForGoogle } from "../tools/schema.ts";
+
+/**
+ * Converts Agent Accelerator tools to Vercel AI SDK tools format.
+ */
+export function toAiSdkTools(
+  tools?: StandardToolDeclaration[],
+  providerId?: string
+): LanguageModelV4FunctionTool[] | undefined {
+  if (!tools || tools.length === 0) return undefined;
+  const norm = providerId?.toLowerCase().trim();
+
+  return tools.map((t) => {
+    const raw = (t.parameters || { type: "object", properties: {} }) as Record<string, unknown>;
+    const inputSchema = norm === "google" || norm === "gemini" ? (stripSchemaForGoogle(raw) as any) : (raw as any);
+    return {
+      type: "function",
+      name: t.name,
+      description: t.description,
+      inputSchema,
+      ...(t.strict !== undefined ? { strict: t.strict } : {}),
+    };
+  });
+}
+
+function guessFilename(input: unknown, mimeType: string): string | undefined {
+  if (typeof input !== "string" || input.startsWith("data:") || input.startsWith("http")) return undefined;
+  const base = input.split(/[\\/]/).pop()?.split("?")[0]?.trim();
+  if (base && base.includes(".")) return base;
+  const ext = mimeType.split("/")[1]?.split(";")[0]?.trim();
+  return ext ? `file.${ext}` : undefined;
+}
+
+/**
+ * Providers known to accept echoed reasoning in history. Vercel serializes
+ * prompt `reasoning` parts to `reasoning_content`, which strict
+ * OpenAI-compatible endpoints (groq, ollama, …) reject with 400 — so off-list
+ * providers get history without the thinking trace (tool calls preserved).
+ */
+const REASONING_HISTORY_PROVIDERS = new Set([
+  "google",
+  "gemini",
+  "openai",
+  "openrouter",
+  "opencode",
+  "opencode-go",
+]);
+
+/**
+ * Converts Agent Accelerator ProviderContext to Vercel AI SDK LanguageModelV4Prompt.
+ */
+export async function toAiSdkPrompt(
+  context: ProviderContext,
+  providerId?: string
+): Promise<LanguageModelV4Prompt> {
+  const prompt: LanguageModelV4Prompt = [];
+
+  if (context.systemPrompt) {
+    prompt.push({
+      role: "system",
+      content: context.systemPrompt,
+    });
+  }
+
+  for (const msg of context.messages) {
+    if (typeof msg.content === "string") {
+      if (msg.role === "system") {
+        prompt.push({ role: "system", content: msg.content });
+      } else if (msg.role === "assistant") {
+        prompt.push({
+          role: "assistant",
+          content: [{ type: "text", text: msg.content }],
+        });
+      } else if (msg.role === "tool") {
+        prompt.push({
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: (msg as any).tool_call_id || (msg as any).id || "call_0",
+              toolName: (msg as any).name || "unknown",
+              output: { type: "text", value: msg.content },
+            },
+          ],
+        });
+      } else {
+        prompt.push({
+          role: "user",
+          content: [{ type: "text", text: msg.content }],
+        });
+      }
+    } else if (Array.isArray(msg.content)) {
+      if (msg.role === "assistant") {
+        const assistantParts: Array<any> = [];
+        for (const part of msg.content) {
+          if (part.type === "text" && part.text) {
+            assistantParts.push({ type: "text", text: part.text });
+          } else if (part.type === "thinking" && part.thinking) {
+            const keepReasoning =
+              !providerId || REASONING_HISTORY_PROVIDERS.has(providerId.toLowerCase().trim());
+            if (keepReasoning) {
+              assistantParts.push({ type: "reasoning", text: part.thinking });
+            }
+          } else if (part.type === "tool_call") {
+            assistantParts.push({
+              type: "tool-call",
+              toolCallId: part.id,
+              toolName: part.name,
+              input: part.arguments || {},
+              providerMetadata: part.thoughtSignature
+                ? { google: { thoughtSignature: part.thoughtSignature } }
+                : undefined,
+            });
+          }
+        }
+        if (assistantParts.length > 0) {
+          prompt.push({ role: "assistant", content: assistantParts });
+        }
+      } else if (msg.role === "tool") {
+        const toolParts: Array<any> = [];
+        for (const part of msg.content) {
+          if (part.type === "tool_result") {
+            toolParts.push({
+              type: "tool-result",
+              toolCallId: part.id,
+              toolName: part.name,
+              output: {
+                type: "text",
+                value: typeof part.result === "string" ? part.result : safeStringify(part.result),
+              },
+              isError: part.isError,
+            });
+          }
+        }
+        if (toolParts.length > 0) {
+          prompt.push({ role: "tool", content: toolParts });
+        }
+      } else {
+        const userParts: Array<any> = [];
+        for (const part of msg.content) {
+          if (part.type === "text" && part.text) {
+            userParts.push({ type: "text", text: part.text });
+          } else if (
+            part.type === "image" ||
+            part.type === "audio" ||
+            part.type === "video" ||
+            part.type === "file"
+          ) {
+            // Vercel V4 has no `image` part: every media part is a `file` part
+            // with a tagged data payload. Images use image/* media types so all
+            // providers route them to their native image input.
+            const raw = (part as any).image ?? (part as any).audio ?? (part as any).video ?? (part as any).file;
+            const norm = await normalizeMediaInput(raw, (part as any).mimeType);
+            const bytes = base64ToBytes(norm.base64Data);
+            const filename =
+              (part as any).filename ?? guessFilename(raw, norm.mimeType);
+            userParts.push({
+              type: "file",
+              mediaType: norm.mimeType,
+              data: { type: "data", data: bytes },
+              ...(filename ? { filename } : {}),
+            });
+          }
+        }
+        if (userParts.length > 0) {
+          prompt.push({ role: "user", content: userParts });
+        }
+      }
+    }
+  }
+
+  return prompt;
+}
+
+/**
+ * Extracts normalized TokenUsage from Vercel AI SDK usage structure.
+ */
+export function extractAiSdkUsage(rawUsage?: any): TokenUsage {
+  if (!rawUsage) {
+    return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  }
+
+  const input =
+    rawUsage.inputTokens?.total ??
+    rawUsage.prompt_tokens ??
+    rawUsage.input_tokens ??
+    0;
+
+  const output =
+    rawUsage.outputTokens?.total ??
+    rawUsage.completion_tokens ??
+    rawUsage.output_tokens ??
+    0;
+
+  const total =
+    rawUsage.total_tokens ??
+    rawUsage.totalTokens ??
+    input + output;
+
+  const cached =
+    rawUsage.inputTokens?.cacheRead ??
+    rawUsage.prompt_tokens_details?.cached_tokens ??
+    rawUsage.cached_tokens ??
+    0;
+
+  const cacheWrite =
+    rawUsage.inputTokens?.cacheWrite ??
+    rawUsage.prompt_tokens_details?.cache_write_tokens ??
+    rawUsage.cache_write_tokens ??
+    0;
+
+  const thinking =
+    rawUsage.outputTokens?.reasoning ??
+    rawUsage.completion_tokens_details?.reasoning_tokens ??
+    rawUsage.reasoning_tokens ??
+    0;
+
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens: total,
+    cachedTokens: cached,
+    cacheReadTokens: cached,
+    cacheWriteTokens: cacheWrite,
+    thinkingTokens: thinking,
+  };
+}
+
+/**
+ * Converts Vercel AI SDK doGenerate result into Agent Accelerator ProviderGenerateResult.
+ */
+export function fromAiSdkGenerateResult(
+  aiResult: any,
+  providerId: string,
+  modelId: string,
+  durationMs: number
+): ProviderGenerateResult {
+  let text = "";
+  let thinking: string | undefined;
+  let thoughtSignature: string | undefined;
+  const toolCalls: ToolCallRecord[] = [];
+
+  if (aiResult.content && Array.isArray(aiResult.content)) {
+    for (const part of aiResult.content) {
+      if (part.type === "text" && part.text) {
+        text += part.text;
+      } else if (part.type === "reasoning" && part.text) {
+        thinking = (thinking ? thinking + "\n" : "") + part.text;
+        const sig =
+          part.providerMetadata?.google?.thoughtSignature ||
+          part.providerMetadata?.custom?.thoughtSignature;
+        if (sig && typeof sig === "string") {
+          thoughtSignature = sig;
+        }
+      } else if (part.type === "tool-call") {
+        let args: Record<string, unknown> = {};
+        if (typeof part.input === "string") {
+          try {
+            args = JSON.parse(part.input);
+          } catch {
+            args = { raw: part.input };
+          }
+        } else if (typeof part.input === "object" && part.input !== null) {
+          args = part.input as Record<string, unknown>;
+        }
+
+        const sig =
+          part.providerMetadata?.google?.thoughtSignature ||
+          part.providerMetadata?.custom?.thoughtSignature;
+
+        toolCalls.push({
+          id: part.toolCallId || `call_${Math.random().toString(36).slice(2, 9)}`,
+          name: part.toolName,
+          arguments: args,
+          rawArguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input || {}),
+          thoughtSignature: typeof sig === "string" ? sig : undefined,
+        });
+
+        if (sig && !thoughtSignature) {
+          thoughtSignature = sig;
+        }
+      }
+    }
+  }
+
+  // Fallback / extraction from raw response body if Vercel AI SDK parts omitted custom metadata
+  const rawBody = aiResult.response?.body;
+  if (rawBody && typeof rawBody === "object") {
+    const rawChoice = rawBody.choices?.[0];
+    const rawMsg = rawChoice?.message;
+    if (!thinking && rawMsg?.reasoning_content) {
+      thinking = rawMsg.reasoning_content;
+    }
+    if (rawMsg?.tool_calls && Array.isArray(rawMsg.tool_calls)) {
+      for (let i = 0; i < rawMsg.tool_calls.length; i++) {
+        const rawTc = rawMsg.tool_calls[i];
+        const extraSig = rawTc?.extra_content?.google?.thought_signature;
+        if (extraSig && toolCalls[i]) {
+          toolCalls[i]!.thoughtSignature = extraSig;
+          if (!thoughtSignature) thoughtSignature = extraSig;
+        }
+      }
+    }
+  }
+
+  const usage = extractAiSdkUsage(aiResult.usage ?? rawBody?.usage);
+  const finishReason =
+    typeof aiResult.finishReason === "object" && aiResult.finishReason !== null
+      ? aiResult.finishReason.raw || aiResult.finishReason.unified || "stop"
+      : String(aiResult.finishReason || "stop");
+
+  const responseId = aiResult.response?.id || rawBody?.id;
+
+  return {
+    text,
+    thinking,
+    thoughtSignature,
+    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+    usage,
+    finishReason,
+    responseId,
+    model: modelId,
+    provider: providerId as any,
+    raw: {
+      request: aiResult.request,
+      response: aiResult.response,
+    },
+    durationMs,
+  };
+}

package/src/ai-sdk/errors.ts

@@ -0,0 +1,122 @@
+import type { ProviderContext } from "../types/message.ts";
+import { getModelFromCatalog } from "../models/catalog.ts";
+
+const CONCISE = "__agentAccelConcise";
+
+function readStatus(error: any): number | undefined {
+  const s =
+    error?.statusCode ??
+    error?.status ??
+    error?.response?.status ??
+    error?.lastError?.statusCode ??
+    error?.lastError?.status;
+  const n = Number(s);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+
+function readUrl(error: any): string {
+  const raw =
+    (typeof error?.url === "string" && error.url) ||
+    (typeof error?.request?.url === "string" && error.request.url) ||
+    "";
+  return raw.split("?")[0];
+}
+
+function readProviderMessage(error: any): string {
+  const data = error?.data;
+  if (typeof data?.error?.message === "string" && data.error.message.trim()) return data.error.message.trim();
+  if (typeof data?.error === "string" && data.error.trim()) return data.error.trim();
+  if (typeof data?.message === "string" && data.message.trim()) return data.message.trim();
+  const body = error?.responseBody;
+  if (typeof body === "string" && body.trim()) {
+    try {
+      const parsed = JSON.parse(body);
+      if (typeof parsed?.error?.message === "string" && parsed.error.message.trim()) return parsed.error.message.trim();
+      if (typeof parsed?.message === "string" && parsed.message.trim()) return parsed.message.trim();
+    } catch {}
+    if (body.length <= 300) return body.trim();
+  }
+  return String(error?.message ?? error).slice(0, 300);
+}
+
+function displayModel(providerId: string, modelId: string): string {
+  if (modelId.toLowerCase().startsWith(`${providerId.toLowerCase()}/`)) return modelId;
+  return `${providerId}/${modelId}`;
+}
+
+/**
+ * Collapses a Vercel `APICallError` (which carries the full request/response
+ * dump as enumerable props) into a one-line actionable error. Raw details stay
+ * available but non-enumerable, so runtime dumps stay small.
+ */
+export function toConciseProviderError(error: unknown, providerId: string, modelId: string): Error {
+  if (error instanceof Error && (error as any)[CONCISE]) return error;
+  const err = error as any;
+  const status = readStatus(err);
+  const url = readUrl(err);
+  const detail = readProviderMessage(err);
+  const concise = new Error(
+    `[${displayModel(providerId, modelId)}] request failed${status ? ` (${status})` : ""}: ${detail}`
+  );
+  concise.name = "AgentAccelProviderError";
+  Object.defineProperties(concise, {
+    [CONCISE]: { value: true, enumerable: false },
+    statusCode: { value: status, enumerable: false },
+    provider: { value: providerId, enumerable: false },
+    model: { value: modelId, enumerable: false },
+    url: { value: url, enumerable: false },
+    responseBody: {
+      value: typeof err?.responseBody === "string" ? err.responseBody.slice(0, 500) : undefined,
+      enumerable: false,
+    },
+  });
+  return concise;
+}
+
+const PART_TO_MODALITY: Record<string, "image" | "audio" | "video" | "pdf"> = {
+  image: "image",
+  audio: "audio",
+  video: "video",
+  file: "pdf",
+};
+
+/**
+ * Fails fast — before any network call — when the catalog knows the model
+ * lacks a requested input modality (image/audio/video/document). Unknown
+ * models (custom providers, dynamic routers) are skipped: the provider
+ * verdict stands and surfaces via toConciseProviderError instead.
+ */
+export function assertModalitiesSupported(
+  context: ProviderContext,
+  providerId: string,
+  modelId: string
+): void {
+  const needed = new Set<string>();
+  for (const msg of context.messages) {
+    if (!Array.isArray((msg as any)?.content)) continue;
+    for (const part of (msg as any).content) {
+      const mapped = PART_TO_MODALITY[(part as any)?.type];
+      if (mapped) needed.add(mapped);
+    }
+  }
+  if (needed.size === 0) return;
+  let supported: readonly string[] | undefined;
+  try {
+    supported = getModelFromCatalog(providerId, modelId)?.modalities?.input;
+  } catch {
+    return;
+  }
+  if (!supported) return;
+  const missing = [...needed].filter((k) => !supported.includes(k));
+  if (missing.length === 0) return;
+  const err = new Error(
+    `[${displayModel(providerId, modelId)}] unsupported ${missing.join("+")} input (supports: ${supported.join(", ") || "text"}). Use a capable model or drop the ${missing.join("+")} part.`
+  );
+  err.name = "AgentAccelProviderError";
+  Object.defineProperties(err, {
+    [CONCISE]: { value: true, enumerable: false },
+    provider: { value: providerId, enumerable: false },
+    model: { value: modelId, enumerable: false },
+  });
+  throw err;
+}