@omarestrella/ai-sdk-agent-sdk 1.0.0-beta.1

package/src/language-model.ts

@@ -0,0 +1,526 @@
+import type {
+  LanguageModelV2,
+  LanguageModelV2CallOptions,
+  LanguageModelV2CallWarning,
+  LanguageModelV2Content,
+  LanguageModelV2FinishReason,
+  LanguageModelV2StreamPart,
+  LanguageModelV2Usage,
+} from "@ai-sdk/provider";
+import { query, type Options } from "@anthropic-ai/claude-agent-sdk";
+import { safeJsonStringify } from "./json";
+import { convertMessages } from "./messages";
+import { AI_SDK_MCP_SERVER_NAME, convertTools } from "./tools";
+import { logger } from "./logger";
+
+/**
+ * Strips the MCP prefix from tool names returned by the Agent SDK.
+ * The Agent SDK returns tools in format: mcp__{serverName}__{toolName}
+ * The AI SDK expects just the original tool name.
+ */
+function stripMcpPrefix(toolName: string): string {
+  const prefix = `mcp__${AI_SDK_MCP_SERVER_NAME}__`;
+  if (toolName.startsWith(prefix)) {
+    return toolName.slice(prefix.length);
+  }
+  return toolName;
+}
+
+function mapFinishReason(
+  stopReason: string | null | undefined,
+  hasToolCalls: boolean,
+): LanguageModelV2FinishReason {
+  if (hasToolCalls) return "tool-calls";
+
+  switch (stopReason) {
+    case "end_turn":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "stop_sequence":
+      return "stop";
+    case "tool_use":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+
+export interface ClaudeAgentLanguageModelConfig {
+  provider: string;
+  cwd?: string;
+}
+
+type DoGenerateOptions = Parameters<LanguageModelV2["doGenerate"]>[0];
+type DoGenerateResult = Awaited<ReturnType<LanguageModelV2["doGenerate"]>>;
+type DoStreamOptions = Parameters<LanguageModelV2["doStream"]>[0];
+type DoStreamResult = Awaited<ReturnType<LanguageModelV2["doStream"]>>;
+
+let idCounter = 0;
+function generateId(): string {
+  return `agent-${Date.now()}-${++idCounter}`;
+}
+
+export class ClaudeAgentLanguageModel implements LanguageModelV2 {
+  readonly specificationVersion = "v2" as const;
+  readonly modelId: string;
+  readonly defaultObjectGenerationMode = undefined;
+
+  private readonly config: ClaudeAgentLanguageModelConfig;
+
+  constructor(modelId: string, config: ClaudeAgentLanguageModelConfig) {
+    this.modelId = modelId;
+    this.config = config;
+  }
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  get supportedUrls(): Record<string, RegExp[]> {
+    return {};
+  }
+
+  private buildQueryOptions(options: LanguageModelV2CallOptions) {
+    const { systemPrompt, prompt } = convertMessages(options.prompt);
+    const convertedTools = convertTools(options.tools as any);
+
+    const abortController = new AbortController();
+    if (options.abortSignal) {
+      options.abortSignal.addEventListener("abort", () => {
+        abortController.abort();
+      });
+    }
+
+    const queryOptions: Options = {
+      model: this.modelId,
+      maxTurns: 1,
+      permissionMode: "bypassPermissions" as const,
+      allowDangerouslySkipPermissions: true,
+      abortController,
+      tools: [],
+      allowedTools: [`mcp__${AI_SDK_MCP_SERVER_NAME}__*`],
+      ...(this.config.cwd ? { cwd: this.config.cwd } : {}),
+    };
+
+    if (systemPrompt) {
+      queryOptions.systemPrompt = systemPrompt;
+    }
+
+    if (convertedTools?.mcpServer) {
+      queryOptions.mcpServers = {
+        [AI_SDK_MCP_SERVER_NAME]: convertedTools.mcpServer,
+      };
+    }
+
+    return { prompt, queryOptions };
+  }
+
+  async doGenerate(options: DoGenerateOptions): Promise<DoGenerateResult> {
+    const warnings: LanguageModelV2CallWarning[] = [];
+    const { prompt, queryOptions } = this.buildQueryOptions(options);
+
+    const generator = query({
+      prompt,
+      options: queryOptions as any,
+    });
+
+    const content: LanguageModelV2Content[] = [];
+    let usage: LanguageModelV2Usage = {
+      inputTokens: undefined,
+      outputTokens: undefined,
+      totalTokens: undefined,
+    };
+    let finishReason: LanguageModelV2FinishReason = "unknown";
+    let hasToolCalls = false;
+
+    // Track message UUIDs to avoid counting usage multiple times
+    // Per SDK docs: all messages with same ID have identical usage
+    const seenMessageIds = new Set<string>();
+
+    for await (const message of generator) {
+      if (message.type === "assistant") {
+        const apiMessage = message.message as any;
+        const messageId = (message as any).uuid as string | undefined;
+
+        if (Array.isArray(apiMessage.content)) {
+          for (const block of apiMessage.content) {
+            if (block.type === "text") {
+              content.push({ type: "text", text: block.text });
+            } else if (block.type === "tool_use") {
+              hasToolCalls = true;
+              const originalToolName = stripMcpPrefix(block.name);
+              content.push({
+                type: "tool-call",
+                toolCallId: block.id,
+                toolName: originalToolName,
+                input:
+                  typeof block.input === "string"
+                    ? block.input
+                    : safeJsonStringify(block.input),
+              });
+            } else if (block.type === "thinking") {
+              content.push({
+                type: "reasoning",
+                text: block.thinking ?? "",
+              });
+            }
+          }
+
+          // Only record usage once per unique message ID
+          if (apiMessage.usage && messageId && !seenMessageIds.has(messageId)) {
+            seenMessageIds.add(messageId);
+            usage = {
+              inputTokens: apiMessage.usage.input_tokens,
+              outputTokens: apiMessage.usage.output_tokens,
+              totalTokens:
+                (apiMessage.usage.input_tokens ?? 0) +
+                (apiMessage.usage.output_tokens ?? 0),
+            };
+            logger.debug("Usage reported in doGenerate", {
+              messageId,
+              inputTokens: usage.inputTokens,
+              outputTokens: usage.outputTokens,
+              totalTokens: usage.totalTokens,
+            });
+          }
+
+          finishReason = mapFinishReason(apiMessage.stop_reason, hasToolCalls);
+        }
+      }
+
+      if (message.type === "result") {
+        // Result message contains cumulative usage from all steps
+        if (message.usage) {
+          usage = {
+            inputTokens: message.usage.input_tokens ?? usage.inputTokens,
+            outputTokens: message.usage.output_tokens ?? usage.outputTokens,
+            totalTokens: usage.totalTokens,
+          };
+          logger.debug("Final usage from result message", {
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+          });
+        }
+      }
+    }
+
+    // Calculate total tokens if we have both input and output
+    if (usage.inputTokens !== undefined && usage.outputTokens !== undefined) {
+      usage.totalTokens = usage.inputTokens + usage.outputTokens;
+    }
+
+    return {
+      content,
+      finishReason,
+      usage,
+      warnings,
+      request: { body: queryOptions },
+      response: {
+        headers: undefined,
+      },
+    };
+  }
+
+  async doStream(options: DoStreamOptions): Promise<DoStreamResult> {
+    const warnings: LanguageModelV2CallWarning[] = [];
+    const { prompt, queryOptions } = this.buildQueryOptions(options);
+
+    // Enable partial messages to get raw Anthropic streaming events
+    queryOptions.includePartialMessages = true;
+
+    const generator = query({
+      prompt,
+      options: queryOptions,
+    });
+
+    let hasToolCalls = false;
+
+    const stream = new ReadableStream<LanguageModelV2StreamPart>({
+      async start(controller) {
+        controller.enqueue({ type: "stream-start", warnings });
+
+        let finishReason: LanguageModelV2FinishReason = "unknown";
+        let usage: LanguageModelV2Usage = {
+          inputTokens: undefined,
+          outputTokens: undefined,
+          totalTokens: undefined,
+        };
+
+        // Track active text block for start/delta/end lifecycle
+        let activeTextId: string | null = null;
+        // Track active reasoning block
+        let activeReasoningId: string | null = null;
+
+        // Track tool calls being streamed (keyed by content block index)
+        const toolCalls: Map<
+          number,
+          { toolCallId: string; toolName: string; argsText: string }
+        > = new Map();
+
+        // Track message UUIDs to avoid counting usage multiple times
+        // Per SDK docs: all messages with same ID have identical usage
+        const seenMessageIds = new Set<string>();
+
+        try {
+          for await (const message of generator) {
+            if (message.type === "stream_event") {
+              const event = message.event;
+
+              if (!event || !event.type) continue;
+
+              switch (event.type) {
+                case "message_start": {
+                  const msg = event.message;
+                  if (msg) {
+                    controller.enqueue({
+                      type: "response-metadata",
+                      id: msg.id,
+                      timestamp: new Date(),
+                      modelId: msg.model,
+                    });
+                    if (msg.usage) {
+                      usage.inputTokens = msg.usage.input_tokens;
+                      logger.debug(
+                        "Initial usage reported in doStream (message_start)",
+                        {
+                          inputTokens: usage.inputTokens,
+                        },
+                      );
+                    }
+                  }
+                  break;
+                }
+
+                case "content_block_start": {
+                  const block = event.content_block;
+                  const index = event.index as number;
+
+                  if (block?.type === "text") {
+                    activeTextId = generateId();
+                    controller.enqueue({
+                      type: "text-start",
+                      id: activeTextId,
+                    });
+                  } else if (block?.type === "tool_use") {
+                    hasToolCalls = true;
+                    const id = block.id ?? generateId();
+                    toolCalls.set(index, {
+                      toolCallId: id,
+                      toolName: block.name,
+                      argsText: "",
+                    });
+                    controller.enqueue({
+                      type: "tool-input-start",
+                      id,
+                      toolName: block.name,
+                    });
+                  } else if (block?.type === "thinking") {
+                    activeReasoningId = generateId();
+                    controller.enqueue({
+                      type: "reasoning-start",
+                      id: activeReasoningId,
+                    });
+                  }
+                  break;
+                }
+
+                case "content_block_delta": {
+                  const delta = event.delta;
+                  const index = event.index as number;
+
+                  if (delta?.type === "text_delta") {
+                    if (!activeTextId) {
+                      activeTextId = generateId();
+                      controller.enqueue({
+                        type: "text-start",
+                        id: activeTextId,
+                      });
+                    }
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: activeTextId,
+                      delta: delta.text,
+                    });
+                  } else if (delta?.type === "input_json_delta") {
+                    const tc = toolCalls.get(index);
+                    if (tc) {
+                      tc.argsText += delta.partial_json;
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        id: tc.toolCallId,
+                        delta: delta.partial_json,
+                      });
+                    }
+                  } else if (delta?.type === "thinking_delta") {
+                    if (!activeReasoningId) {
+                      activeReasoningId = generateId();
+                      controller.enqueue({
+                        type: "reasoning-start",
+                        id: activeReasoningId,
+                      });
+                    }
+                    controller.enqueue({
+                      type: "reasoning-delta",
+                      id: activeReasoningId,
+                      delta: delta.thinking,
+                    });
+                  }
+                  break;
+                }
+
+                case "content_block_stop": {
+                  const index = event.index as number;
+                  const tc = toolCalls.get(index);
+
+                  if (tc) {
+                    const originalToolName = stripMcpPrefix(tc.toolName);
+                    // End the tool input stream
+                    controller.enqueue({
+                      type: "tool-input-end",
+                      id: tc.toolCallId,
+                    });
+                    // Emit the complete tool call
+                    controller.enqueue({
+                      type: "tool-call",
+                      toolCallId: tc.toolCallId,
+                      toolName: originalToolName,
+                      input: tc.argsText,
+                    });
+                    toolCalls.delete(index);
+                  } else if (activeTextId) {
+                    controller.enqueue({
+                      type: "text-end",
+                      id: activeTextId,
+                    });
+                    activeTextId = null;
+                  } else if (activeReasoningId) {
+                    controller.enqueue({
+                      type: "reasoning-end",
+                      id: activeReasoningId,
+                    });
+                    activeReasoningId = null;
+                  }
+                  break;
+                }
+
+                case "message_delta": {
+                  if (event.usage) {
+                    usage.outputTokens = event.usage.output_tokens;
+                    if (usage.inputTokens !== undefined) {
+                      usage.totalTokens =
+                        usage.inputTokens + (event.usage.output_tokens ?? 0);
+                    }
+                    logger.debug(
+                      "Usage delta reported in doStream (message_delta)",
+                      {
+                        outputTokens: usage.outputTokens,
+                        totalTokens: usage.totalTokens,
+                      },
+                    );
+                  }
+                  finishReason = mapFinishReason(
+                    event.delta?.stop_reason,
+                    hasToolCalls,
+                  );
+                  break;
+                }
+
+                case "message_stop": {
+                  // Final streaming event
+                  break;
+                }
+              }
+            } else if (message.type === "assistant") {
+              // Full assistant message — only update finish reason, not usage
+              // Usage is tracked from streaming events (message_start, message_delta)
+              // Per SDK docs: assistant messages share usage with streaming events
+              const apiMessage = (message as any).message;
+              const messageId = (message as any).uuid as string | undefined;
+
+              if (Array.isArray(apiMessage?.content)) {
+                for (const block of apiMessage.content) {
+                  if (block.type === "tool_use") {
+                    hasToolCalls = true;
+                  }
+                }
+              }
+
+              // Don't overwrite usage from streaming events - they are more accurate
+              // and already tracked. Only log if this is a new message ID.
+              if (
+                apiMessage?.usage &&
+                messageId &&
+                !seenMessageIds.has(messageId)
+              ) {
+                seenMessageIds.add(messageId);
+                logger.debug(
+                  "Assistant message usage (already tracked from streaming)",
+                  {
+                    messageId,
+                    inputTokens: apiMessage.usage.input_tokens,
+                    outputTokens: apiMessage.usage.output_tokens,
+                  },
+                );
+              }
+
+              if (apiMessage?.stop_reason) {
+                finishReason = mapFinishReason(
+                  apiMessage.stop_reason,
+                  hasToolCalls,
+                );
+              }
+            } else if (message.type === "result") {
+              // Final result with cumulative usage from all steps
+              const result = message as any;
+              if (result.usage) {
+                usage.inputTokens =
+                  result.usage.input_tokens ?? usage.inputTokens;
+                usage.outputTokens =
+                  result.usage.output_tokens ?? usage.outputTokens;
+                logger.debug("Final usage from result message", {
+                  inputTokens: usage.inputTokens,
+                  outputTokens: usage.outputTokens,
+                });
+              }
+            }
+          }
+        } catch (error) {
+          controller.enqueue({ type: "error", error });
+        }
+
+        // Close any dangling blocks
+        if (activeTextId) {
+          controller.enqueue({ type: "text-end", id: activeTextId });
+        }
+        if (activeReasoningId) {
+          controller.enqueue({ type: "reasoning-end", id: activeReasoningId });
+        }
+
+        // Calculate total tokens if not already done
+        if (
+          usage.inputTokens !== undefined &&
+          usage.outputTokens !== undefined
+        ) {
+          usage.totalTokens = usage.inputTokens + usage.outputTokens;
+        }
+
+        controller.enqueue({
+          type: "finish",
+          finishReason,
+          usage,
+        });
+
+        controller.close();
+      },
+    });
+
+    return {
+      stream,
+      request: { body: queryOptions },
+      response: {
+        headers: undefined,
+      },
+    };
+  }
+}

package/src/logger.ts

@@ -0,0 +1,171 @@
+import { createWriteStream, existsSync, mkdirSync } from "fs";
+import type { WriteStream } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { safeJsonStringify } from "./json";
+
+/**
+ * This is a weird file. We want to log to a file, but only if the consola package
+ * we are using is available.
+ */
+
+// Environment configuration
+const LOG_LEVEL = (process.env.LOG_LEVEL as string) || "debug";
+const LOG_DIR =
+  process.env.LOG_DIR || join(homedir(), ".cache", "ai-sdk-claude-agent");
+const LOG_FILE = process.env.LOG_FILE || "ai-sdk-claude-agent.log";
+
+// Ensure log directory exists
+if (!existsSync(LOG_DIR)) {
+  try {
+    mkdirSync(LOG_DIR, { recursive: true });
+  } catch {
+    // Silent fail
+  }
+}
+
+const LOG_FILE_PATH = join(LOG_DIR, LOG_FILE);
+
+// Persistent write stream for file logging
+let logStream: WriteStream | null = null;
+
+function getLogStream(): WriteStream {
+  if (!logStream) {
+    logStream = createWriteStream(LOG_FILE_PATH, { flags: "a" });
+  }
+  return logStream;
+}
+
+// Type definitions for consola
+interface ConsolaInstance {
+  debug: (message: string, ...args: unknown[]) => void;
+  info: (message: string, ...args: unknown[]) => void;
+  warn: (message: string, ...args: unknown[]) => void;
+  error: (message: string, ...args: unknown[]) => void;
+  log: (message: string, ...args: unknown[]) => void;
+}
+
+let consolaInstance: ConsolaInstance | null = null;
+let consolaLoadAttempted = false;
+
+/**
+ * Dynamically loads consola if available.
+ * This is an optional peer dependency - if not installed, logging is a no-op.
+ */
+async function loadConsola(): Promise<ConsolaInstance | null> {
+  if (consolaLoadAttempted) return consolaInstance;
+  consolaLoadAttempted = true;
+
+  try {
+    // Dynamic import - will fail gracefully if consola is not installed
+    const { createConsola } = await import("consola");
+
+    const reporters = [];
+
+    // File reporter configuration
+    if (LOG_FILE) {
+      reporters.push({
+        log: (logObj: { level: number; args: unknown[]; date: Date }) => {
+          // Consola levels: 0=fatal/error, 1=warn, 2=log, 3=info, 4=debug, 5=trace
+          const levelNames: Record<number, string> = {
+            0: "ERROR",
+            1: "WARN",
+            2: "LOG",
+            3: "INFO",
+            4: "DEBUG",
+            5: "TRACE",
+          };
+          const levelName = levelNames[logObj.level] || "LOG";
+          const message = logObj.args
+            .map((arg) =>
+              typeof arg === "object" ? safeJsonStringify(arg) : String(arg),
+            )
+            .join(" ");
+
+          const line =
+            safeJsonStringify({
+              timestamp: logObj.date.toISOString(),
+              level: levelName,
+              message,
+            }) + "\n";
+
+          // Append to file using persistent stream
+          getLogStream().write(line);
+        },
+      });
+    }
+
+    consolaInstance = createConsola({
+      // Consola levels: 0=fatal/error, 1=warn, 2=log, 3=info, 4=debug, 5=trace
+      level:
+        LOG_LEVEL === "trace"
+          ? 5
+          : LOG_LEVEL === "debug"
+            ? 4
+            : LOG_LEVEL === "info"
+              ? 3
+              : LOG_LEVEL === "warn"
+                ? 1
+                : 0,
+      reporters,
+    }) as ConsolaInstance;
+
+    consolaInstance.info("Logger initialized with consola", {
+      level: LOG_LEVEL,
+      file: LOG_FILE_PATH,
+    });
+
+    return consolaInstance;
+  } catch {
+    // consola is not installed - logging will be a no-op
+    return null;
+  }
+}
+
+// Initialize consola asynchronously
+const consolaPromise = loadConsola();
+
+/**
+ * Logger interface that wraps consola if available, otherwise no-op.
+ */
+export const logger = {
+  debug(message: string, ...args: unknown[]): void {
+    if (consolaInstance) {
+      consolaInstance.debug(message, ...args);
+    } else {
+      consolaPromise.then((c) => c?.debug(message, ...args));
+    }
+  },
+
+  info(message: string, ...args: unknown[]): void {
+    if (consolaInstance) {
+      consolaInstance.info(message, ...args);
+    } else {
+      consolaPromise.then((c) => c?.info(message, ...args));
+    }
+  },
+
+  warn(message: string, ...args: unknown[]): void {
+    if (consolaInstance) {
+      consolaInstance.warn(message, ...args);
+    } else {
+      consolaPromise.then((c) => c?.warn(message, ...args));
+    }
+  },
+
+  error(message: string, ...args: unknown[]): void {
+    if (consolaInstance) {
+      consolaInstance.error(message, ...args);
+    } else {
+      consolaPromise.then((c) => c?.error(message, ...args));
+    }
+  },
+
+  /**
+   * Legacy method - logs at info level
+   * @deprecated Use logger.info() or logger.debug() instead
+   */
+  log(message: string, ...args: unknown[]): void {
+    this.info(message, ...args);
+  },
+};