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

package/src/messages.ts

@@ -0,0 +1,102 @@
+import type { LanguageModelV2Prompt } from "@ai-sdk/provider";
+import { safeJsonStringify } from "./json";
+import { logger } from "./logger";
+
+export interface ConvertedPrompt {
+  systemPrompt: string;
+  prompt: string;
+}
+
+/**
+ * Converts an AI SDK LanguageModelV2 prompt (array of system/user/assistant/tool messages)
+ * into a system prompt string and a user prompt string for the Claude Agent SDK's query().
+ *
+ * Since we use maxTurns: 1, the Agent SDK makes a single LLM call. We serialize the full
+ * conversation history into the prompt so the LLM has context from prior turns.
+ */
+export function convertMessages(messages: LanguageModelV2Prompt): ConvertedPrompt {
+  logger.debug("Converting messages:", { count: messages.length });
+
+  const systemParts: string[] = [];
+  const conversationParts: string[] = [];
+
+  for (const message of messages) {
+    logger.debug("Processing message:", { role: message.role });
+    switch (message.role) {
+      case "system": {
+        systemParts.push(message.content);
+        break;
+      }
+
+      case "user": {
+        const parts: string[] = [];
+        logger.debug("Processing user message parts:", { count: message.content.length });
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text":
+              parts.push(part.text);
+              break;
+            case "file":
+              parts.push(`[File: ${part.filename ?? part.mediaType}]`);
+              break;
+          }
+        }
+        if (parts.length > 0) {
+          conversationParts.push(`[user]\n${parts.join("\n")}`);
+        }
+        break;
+      }
+
+      case "assistant": {
+        const parts: string[] = [];
+        logger.debug("Processing assistant message parts:", { count: message.content.length });
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text":
+              parts.push(part.text);
+              break;
+            case "tool-call":
+              parts.push(`[tool_call: ${part.toolName}(${safeJsonStringify(part.input)})]`);
+              break;
+            case "reasoning":
+              parts.push(`[thinking]\n${part.text}\n[/thinking]`);
+              break;
+          }
+        }
+        if (parts.length > 0) {
+          conversationParts.push(`[assistant]\n${parts.join("\n")}`);
+        }
+        break;
+      }
+
+      case "tool": {
+        const parts: string[] = [];
+        for (const part of message.content) {
+          const output = part.output;
+          let outputText: string;
+          if (Array.isArray(output)) {
+            // Output is LanguageModelV2ToolResultOutput (array of parts)
+            outputText = output
+              .map((o) => {
+                if (o.type === "text") return o.text;
+                return `[${o.type}]`;
+              })
+              .join("\n");
+          } else {
+            outputText = typeof output === "string" ? output : safeJsonStringify(output);
+          }
+          parts.push(`[tool_result: ${part.toolName} (id: ${part.toolCallId})]\n${outputText}`);
+        }
+        if (parts.length > 0) {
+          conversationParts.push(parts.join("\n"));
+        }
+        break;
+      }
+    }
+  }
+
+  return {
+    systemPrompt: systemParts.join("\n\n"),
+    prompt: conversationParts.join("\n\n"),
+  };
+}

package/src/provider.ts

@@ -0,0 +1,45 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import {
+  ClaudeAgentLanguageModel,
+  type ClaudeAgentLanguageModelConfig,
+} from "./language-model";
+import { safeJsonStringify } from "./json";
+import { logger } from "./logger";
+
+export interface ClaudeAgentProviderSettings {
+  name?: string;
+
+  /**
+   * Working directory for the Agent SDK.
+   * @default process.cwd()
+   */
+  cwd?: string;
+}
+
+export interface ClaudeAgentProvider {
+  (modelId: string): LanguageModelV2;
+  languageModel(modelId: string): LanguageModelV2;
+}
+
+export function createClaudeAgent(
+  options: ClaudeAgentProviderSettings = {},
+): ClaudeAgentProvider {
+  const config: ClaudeAgentLanguageModelConfig = {
+    provider: options.name ?? "claude-agent",
+    cwd: options.cwd,
+  };
+
+  logger.debug("Creating agent with:", safeJsonStringify(options));
+
+  const createLanguageModel = (modelId: string): LanguageModelV2 => {
+    return new ClaudeAgentLanguageModel(modelId, config);
+  };
+
+  const provider = function (modelId: string) {
+    return createLanguageModel(modelId);
+  };
+
+  provider.languageModel = createLanguageModel;
+
+  return provider as ClaudeAgentProvider;
+}

package/src/tools.ts

@@ -0,0 +1,112 @@
+import type { LanguageModelV2FunctionTool } from "@ai-sdk/provider";
+import {
+  createSdkMcpServer,
+  tool,
+  type McpServerConfig,
+} from "@anthropic-ai/claude-agent-sdk";
+import * as z from "zod";
+import { safeJsonStringify } from "./json";
+import { logger } from "./logger";
+
+/**
+ * The name of the MCP server that hosts AI SDK tools.
+ * This is used to identify tools when the Agent SDK returns them
+ * in the format: mcp__{SERVER_NAME}__{tool_name}
+ */
+export const AI_SDK_MCP_SERVER_NAME = "ai-sdk-tools";
+
+/**
+ * Extracts Zod schema from AI SDK tool inputSchema using Zod 4's native
+ * JSON Schema conversion.
+ */
+function extractZodSchema(
+  tool: LanguageModelV2FunctionTool,
+): Record<string, z.ZodTypeAny> {
+  const inputSchema = tool.inputSchema as Record<string, unknown> | undefined;
+
+  if (!inputSchema || typeof inputSchema !== "object") {
+    return {};
+  }
+
+  try {
+    const zodSchema = z.fromJSONSchema(inputSchema);
+    if (zodSchema instanceof z.ZodObject) {
+      return zodSchema.shape;
+    }
+    return { value: zodSchema };
+  } catch (error) {
+    logger.error("Failed to convert JSON Schema to Zod:", {
+      tool: tool.name,
+      error,
+    });
+    return {};
+  }
+}
+
+/**
+ * Converts AI SDK function tool definitions into an in-process Agent SDK MCP server.
+ *
+ * Each AI SDK tool becomes an MCP tool with proper parameter validation.
+ * Since we use maxTurns: 1, the Agent SDK will report tool_use blocks in the
+ * assistant message but won't execute them. The AI SDK caller handles actual
+ * tool execution.
+ */
+export function convertTools(tools: LanguageModelV2FunctionTool[] | undefined):
+  | {
+      mcpServer: McpServerConfig;
+      allowedTools: string[];
+    }
+  | undefined {
+  if (!tools || tools.length === 0) return undefined;
+
+  logger.debug("Converting tools:", {
+    count: tools.length,
+    tools: tools.map((t) => t.name),
+  });
+
+  const mcpTools = tools.map((aiTool) => {
+    const zodSchema = extractZodSchema(aiTool);
+
+    logger.debug("Creating tool:", {
+      name: aiTool.name,
+      schemaKeys: Object.keys(zodSchema),
+    });
+
+    return tool(
+      aiTool.name,
+      aiTool.description ?? "",
+      zodSchema,
+      async () => {
+        // Stub handler — tool execution is deferred to the AI SDK caller.
+        // This should rarely (if ever) be called with maxTurns: 1.
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: safeJsonStringify({
+                _deferred: true,
+                message: "Tool execution deferred to AI SDK caller",
+              }),
+            },
+          ],
+        };
+      },
+    );
+  });
+
+  logger.info("Created MCP server with", mcpTools.length, "tools");
+
+  const mcpServer = createSdkMcpServer({
+    name: AI_SDK_MCP_SERVER_NAME,
+    tools: mcpTools,
+  });
+
+  // Generate the allowed tool names with MCP prefix format
+  const allowedTools = tools.map(
+    (t) => `mcp__${AI_SDK_MCP_SERVER_NAME}__${t.name}`,
+  );
+
+  logger.debug("Allowed tools:", allowedTools);
+
+  return { mcpServer, allowedTools };
+}