polymorph-sdk 0.1.0

package/README.md

@@ -0,0 +1,102 @@
+# Polymorph SDK for TypeScript
+
+Tool logging wrapper for Vercel AI SDK. Automatically logs tool calls to the Polymorph API for monitoring and analytics.
+
+## Installation
+
+```bash
+npm install polymorph-sdk ai
+```
+
+## Usage
+
+```typescript
+import { streamText, tool } from "ai";
+import { anthropic } from "@ai-sdk/anthropic";
+import { z } from "zod";
+import { PolymorphConfig, createPolymorphAIClient } from "polymorph-sdk";
+
+// Create Polymorph config
+const config = new PolymorphConfig({
+  role: "user",
+  apiKey: "your-api-key", // or set POLYMORPH_API_KEY env var
+  baseUrl: "https://api.polymorph.dev", // or set POLYMORPH_BASE_URL env var
+});
+
+// Create Polymorph client
+const polymorph = createPolymorphAIClient({ config });
+
+// Define your tools
+const tools = {
+  getWeather: tool({
+    description: "Get the weather for a location",
+    parameters: z.object({
+      location: z.string().describe("The location to get weather for"),
+    }),
+    execute: async ({ location }) => {
+      // Your tool implementation
+      return { temperature: 72, condition: "sunny" };
+    },
+  }),
+};
+
+// Wrap tools with Polymorph logging
+const wrappedTools = polymorph.wrapTools(tools);
+
+// Use with streamText
+const result = await streamText({
+  model: anthropic("claude-sonnet-4-20250514"),
+  tools: wrappedTools,
+  messages: [{ role: "user", content: "What's the weather in San Francisco?" }],
+});
+```
+
+### Alternative: Wrap streamText/generateText
+
+You can also wrap the AI SDK functions directly:
+
+```typescript
+import { streamText, generateText } from "ai";
+import { PolymorphConfig, createPolymorphAIClient } from "polymorph-sdk";
+
+const config = new PolymorphConfig({ role: "user" });
+const polymorph = createPolymorphAIClient({ config });
+
+// Create wrapped versions of streamText and generateText
+const polymorphStreamText = polymorph.streamText(streamText);
+const polymorphGenerateText = polymorph.generateText(generateText);
+
+// Now use these wrapped functions - tools will be automatically logged
+const result = await polymorphStreamText({
+  model: anthropic("claude-sonnet-4-20250514"),
+  tools: myTools, // Tools are automatically wrapped
+  messages: [...],
+});
+```
+
+## Configuration
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `role` | `string` | (required) | User role for RBAC functionality |
+| `apiKey` | `string` | `POLYMORPH_API_KEY` env var | API key for authentication |
+| `baseUrl` | `string` | `POLYMORPH_BASE_URL` env var | Base URL for Polymorph API |
+| `httpTimeout` | `number` | `10000` | HTTP request timeout in milliseconds |
+| `httpEnabled` | `boolean` | `true` | Whether HTTP logging is enabled |
+
+## Environment Variables
+
+- `POLYMORPH_API_KEY` - API key for authentication
+- `POLYMORPH_BASE_URL` - Base URL for Polymorph API
+
+## API Endpoints
+
+The SDK sends events to the following endpoints:
+
+- `POST /sdk/init` - Called on client initialization
+- `POST /sdk/tool/pre` - Called before tool execution
+- `POST /sdk/tool/post` - Called after tool execution
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,135 @@
+import { ToolSet, streamText, generateText } from 'ai';
+
+/**
+ * Configuration options for Polymorph SDK.
+ */
+interface PolymorphConfigOptions {
+    /**
+     * User role for potential RBAC functionality.
+     */
+    role: string;
+    /**
+     * API key for authentication. Can also be set via POLYMORPH_API_KEY env var.
+     */
+    apiKey?: string;
+    /**
+     * Base URL for the Polymorph API. Can also be set via POLYMORPH_BASE_URL env var.
+     */
+    baseUrl?: string;
+    /**
+     * HTTP request timeout in milliseconds. Defaults to 10000 (10 seconds).
+     */
+    httpTimeout?: number;
+    /**
+     * Whether HTTP logging is enabled. Defaults to true.
+     */
+    httpEnabled?: boolean;
+}
+/**
+ * Configuration for tool logging and permissions.
+ */
+declare class PolymorphConfig {
+    readonly role: string;
+    readonly apiKey: string | undefined;
+    readonly baseUrl: string | undefined;
+    readonly httpTimeout: number;
+    readonly httpEnabled: boolean;
+    constructor(options: PolymorphConfigOptions);
+    private getEnv;
+}
+
+/**
+ * HTTP client for Polymorph API calls.
+ *
+ * All errors are caught and logged - never crashes the SDK.
+ */
+declare class PolymorphHTTPClient {
+    private baseUrl;
+    private apiKey;
+    private timeout;
+    private enabled;
+    constructor(options: {
+        baseUrl?: string;
+        apiKey?: string;
+        timeout?: number;
+        enabled?: boolean;
+    });
+    /**
+     * Make a POST request to the given endpoint.
+     *
+     * Returns the response JSON if successful, undefined otherwise.
+     * All errors are caught and logged.
+     */
+    post<T = unknown>(endpoint: string, payload: Record<string, unknown>): Promise<T | undefined>;
+    /**
+     * Fire-and-forget POST request. Does not wait for response.
+     */
+    postFireAndForget(endpoint: string, payload: Record<string, unknown>): void;
+}
+
+/**
+ * Log an entry to configured destinations.
+ */
+declare function log(entry: Record<string, unknown>): void;
+
+type StreamTextParams = Parameters<typeof streamText>[0];
+type GenerateTextParams = Parameters<typeof generateText>[0];
+type StreamTextResult = ReturnType<typeof streamText>;
+type GenerateTextResult = ReturnType<typeof generateText>;
+/**
+ * Hook context passed to pre/post tool hooks.
+ */
+interface ToolHookContext {
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+}
+/**
+ * Pre-tool hook result. Return `{ deny: true, reason: string }` to deny the tool call.
+ */
+interface PreToolHookResult {
+    deny?: boolean;
+    reason?: string;
+}
+/**
+ * Post-tool hook context with the result.
+ */
+interface PostToolHookContext extends ToolHookContext {
+    result: unknown;
+    error?: Error;
+    durationMs: number;
+}
+/**
+ * Options for creating a Polymorph AI client.
+ */
+interface PolymorphAIClientOptions {
+    config: PolymorphConfig;
+}
+/**
+ * Polymorph AI client that wraps Vercel AI SDK functions with tool logging.
+ */
+declare class PolymorphAIClient {
+    private config;
+    private httpClient;
+    private preToolHook;
+    private postToolHook;
+    constructor(options: PolymorphAIClientOptions);
+    /**
+     * Wraps tools with Polymorph logging hooks.
+     */
+    wrapTools<T extends ToolSet>(tools: T): T;
+    /**
+     * Creates a wrapped streamText function that automatically wraps tools.
+     */
+    streamText(originalStreamText: typeof streamText): (params: StreamTextParams) => StreamTextResult;
+    /**
+     * Creates a wrapped generateText function that automatically wraps tools.
+     */
+    generateText(originalGenerateText: typeof generateText): (params: GenerateTextParams) => GenerateTextResult;
+}
+/**
+ * Creates a Polymorph AI client for wrapping Vercel AI SDK functions.
+ */
+declare function createPolymorphAIClient(options: PolymorphAIClientOptions): PolymorphAIClient;
+
+export { PolymorphAIClient, type PolymorphAIClientOptions, PolymorphConfig, type PolymorphConfigOptions, PolymorphHTTPClient, type PostToolHookContext, type PreToolHookResult, type ToolHookContext, createPolymorphAIClient, log };

package/dist/index.d.ts

@@ -0,0 +1,135 @@
+import { ToolSet, streamText, generateText } from 'ai';
+
+/**
+ * Configuration options for Polymorph SDK.
+ */
+interface PolymorphConfigOptions {
+    /**
+     * User role for potential RBAC functionality.
+     */
+    role: string;
+    /**
+     * API key for authentication. Can also be set via POLYMORPH_API_KEY env var.
+     */
+    apiKey?: string;
+    /**
+     * Base URL for the Polymorph API. Can also be set via POLYMORPH_BASE_URL env var.
+     */
+    baseUrl?: string;
+    /**
+     * HTTP request timeout in milliseconds. Defaults to 10000 (10 seconds).
+     */
+    httpTimeout?: number;
+    /**
+     * Whether HTTP logging is enabled. Defaults to true.
+     */
+    httpEnabled?: boolean;
+}
+/**
+ * Configuration for tool logging and permissions.
+ */
+declare class PolymorphConfig {
+    readonly role: string;
+    readonly apiKey: string | undefined;
+    readonly baseUrl: string | undefined;
+    readonly httpTimeout: number;
+    readonly httpEnabled: boolean;
+    constructor(options: PolymorphConfigOptions);
+    private getEnv;
+}
+
+/**
+ * HTTP client for Polymorph API calls.
+ *
+ * All errors are caught and logged - never crashes the SDK.
+ */
+declare class PolymorphHTTPClient {
+    private baseUrl;
+    private apiKey;
+    private timeout;
+    private enabled;
+    constructor(options: {
+        baseUrl?: string;
+        apiKey?: string;
+        timeout?: number;
+        enabled?: boolean;
+    });
+    /**
+     * Make a POST request to the given endpoint.
+     *
+     * Returns the response JSON if successful, undefined otherwise.
+     * All errors are caught and logged.
+     */
+    post<T = unknown>(endpoint: string, payload: Record<string, unknown>): Promise<T | undefined>;
+    /**
+     * Fire-and-forget POST request. Does not wait for response.
+     */
+    postFireAndForget(endpoint: string, payload: Record<string, unknown>): void;
+}
+
+/**
+ * Log an entry to configured destinations.
+ */
+declare function log(entry: Record<string, unknown>): void;
+
+type StreamTextParams = Parameters<typeof streamText>[0];
+type GenerateTextParams = Parameters<typeof generateText>[0];
+type StreamTextResult = ReturnType<typeof streamText>;
+type GenerateTextResult = ReturnType<typeof generateText>;
+/**
+ * Hook context passed to pre/post tool hooks.
+ */
+interface ToolHookContext {
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+}
+/**
+ * Pre-tool hook result. Return `{ deny: true, reason: string }` to deny the tool call.
+ */
+interface PreToolHookResult {
+    deny?: boolean;
+    reason?: string;
+}
+/**
+ * Post-tool hook context with the result.
+ */
+interface PostToolHookContext extends ToolHookContext {
+    result: unknown;
+    error?: Error;
+    durationMs: number;
+}
+/**
+ * Options for creating a Polymorph AI client.
+ */
+interface PolymorphAIClientOptions {
+    config: PolymorphConfig;
+}
+/**
+ * Polymorph AI client that wraps Vercel AI SDK functions with tool logging.
+ */
+declare class PolymorphAIClient {
+    private config;
+    private httpClient;
+    private preToolHook;
+    private postToolHook;
+    constructor(options: PolymorphAIClientOptions);
+    /**
+     * Wraps tools with Polymorph logging hooks.
+     */
+    wrapTools<T extends ToolSet>(tools: T): T;
+    /**
+     * Creates a wrapped streamText function that automatically wraps tools.
+     */
+    streamText(originalStreamText: typeof streamText): (params: StreamTextParams) => StreamTextResult;
+    /**
+     * Creates a wrapped generateText function that automatically wraps tools.
+     */
+    generateText(originalGenerateText: typeof generateText): (params: GenerateTextParams) => GenerateTextResult;
+}
+/**
+ * Creates a Polymorph AI client for wrapping Vercel AI SDK functions.
+ */
+declare function createPolymorphAIClient(options: PolymorphAIClientOptions): PolymorphAIClient;
+
+export { PolymorphAIClient, type PolymorphAIClientOptions, PolymorphConfig, type PolymorphConfigOptions, PolymorphHTTPClient, type PostToolHookContext, type PreToolHookResult, type ToolHookContext, createPolymorphAIClient, log };

package/dist/index.js

@@ -0,0 +1,264 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PolymorphAIClient: () => PolymorphAIClient,
+  PolymorphConfig: () => PolymorphConfig,
+  PolymorphHTTPClient: () => PolymorphHTTPClient,
+  createPolymorphAIClient: () => createPolymorphAIClient,
+  log: () => log
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var PolymorphConfig = class {
+  constructor(options) {
+    this.role = options.role;
+    this.apiKey = options.apiKey ?? this.getEnv("POLYMORPH_API_KEY");
+    this.baseUrl = options.baseUrl ?? this.getEnv("POLYMORPH_BASE_URL");
+    this.httpTimeout = options.httpTimeout ?? 1e4;
+    this.httpEnabled = options.httpEnabled ?? true;
+    if (!this.apiKey) {
+      throw new Error(
+        "apiKey is required. Provide it in the constructor or set POLYMORPH_API_KEY env var."
+      );
+    }
+  }
+  getEnv(key) {
+    if (typeof process !== "undefined" && process.env) {
+      return process.env[key];
+    }
+    return void 0;
+  }
+};
+
+// src/http-client.ts
+var PolymorphHTTPClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl;
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout ?? 1e4;
+    this.enabled = options.enabled ?? true;
+  }
+  /**
+   * Make a POST request to the given endpoint.
+   *
+   * Returns the response JSON if successful, undefined otherwise.
+   * All errors are caught and logged.
+   */
+  async post(endpoint, payload) {
+    if (!this.enabled) {
+      console.debug(`[Polymorph] HTTP client disabled, skipping POST to ${endpoint}`);
+      return void 0;
+    }
+    if (!this.baseUrl) {
+      console.debug(`[Polymorph] No baseUrl configured, skipping POST to ${endpoint}`);
+      return void 0;
+    }
+    const url = `${this.baseUrl.replace(/\/$/, "")}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        console.warn(
+          `[Polymorph] HTTP error ${response.status} while posting to ${url}`
+        );
+        return void 0;
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          console.warn(`[Polymorph] Timeout while posting to ${url}`);
+        } else {
+          console.warn(`[Polymorph] Request error while posting to ${url}:`, error.message);
+        }
+      } else {
+        console.warn(`[Polymorph] Unexpected error while posting to ${url}:`, error);
+      }
+      return void 0;
+    }
+  }
+  /**
+   * Fire-and-forget POST request. Does not wait for response.
+   */
+  postFireAndForget(endpoint, payload) {
+    this.post(endpoint, payload);
+  }
+};
+
+// src/logging.ts
+function log(entry) {
+  console.log("[Polymorph]", entry);
+}
+
+// src/providers/vercel-ai.ts
+function createHooks(config, httpClient) {
+  async function preToolHook(context) {
+    const payload = {
+      event: "tool_call_start",
+      tool: context.toolName,
+      input: context.input,
+      tool_use_id: context.toolCallId,
+      role: config.role
+    };
+    log(payload);
+    httpClient.postFireAndForget("/sdk/tool/pre", payload);
+    return {};
+  }
+  async function postToolHook(context) {
+    const payload = {
+      event: "tool_call_end",
+      tool: context.toolName,
+      tool_use_id: context.toolCallId,
+      duration_ms: context.durationMs,
+      success: !context.error,
+      error: context.error?.message,
+      role: config.role
+    };
+    log(payload);
+    httpClient.postFireAndForget("/sdk/tool/post", payload);
+  }
+  return { preToolHook, postToolHook };
+}
+function wrapTool(toolName, tool, preToolHook, postToolHook) {
+  if (!tool.execute) {
+    return tool;
+  }
+  const originalExecute = tool.execute;
+  const wrappedExecute = async (input, options) => {
+    const toolCallId = options?.toolCallId ?? `call_${Date.now()}`;
+    const context = {
+      toolName,
+      toolCallId,
+      input
+    };
+    const preResult = await preToolHook(context);
+    if (preResult.deny) {
+      throw new Error(
+        `Tool '${toolName}' denied: ${preResult.reason ?? "Permission denied"}`
+      );
+    }
+    const startTime = Date.now();
+    let result;
+    let error;
+    try {
+      result = await originalExecute(input, options);
+    } catch (e) {
+      error = e instanceof Error ? e : new Error(String(e));
+      throw error;
+    } finally {
+      const durationMs = Date.now() - startTime;
+      await postToolHook({
+        ...context,
+        result,
+        error,
+        durationMs
+      });
+    }
+    return result;
+  };
+  return {
+    ...tool,
+    execute: wrappedExecute
+  };
+}
+function wrapTools(tools, preToolHook, postToolHook) {
+  const wrappedTools = {};
+  for (const [name, tool] of Object.entries(tools)) {
+    wrappedTools[name] = wrapTool(name, tool, preToolHook, postToolHook);
+  }
+  return wrappedTools;
+}
+var PolymorphAIClient = class {
+  constructor(options) {
+    this.config = options.config;
+    this.httpClient = new PolymorphHTTPClient({
+      baseUrl: this.config.baseUrl,
+      apiKey: this.config.apiKey,
+      timeout: this.config.httpTimeout,
+      enabled: this.config.httpEnabled
+    });
+    const hooks = createHooks(this.config, this.httpClient);
+    this.preToolHook = hooks.preToolHook;
+    this.postToolHook = hooks.postToolHook;
+    this.httpClient.postFireAndForget("/sdk/init", {
+      role: this.config.role,
+      sdk: "vercel-ai",
+      version: "0.1.0"
+    });
+  }
+  /**
+   * Wraps tools with Polymorph logging hooks.
+   */
+  wrapTools(tools) {
+    return wrapTools(tools, this.preToolHook, this.postToolHook);
+  }
+  /**
+   * Creates a wrapped streamText function that automatically wraps tools.
+   */
+  streamText(originalStreamText) {
+    return (params) => {
+      const wrappedParams = {
+        ...params,
+        tools: params.tools ? this.wrapTools(params.tools) : void 0
+      };
+      return originalStreamText(wrappedParams);
+    };
+  }
+  /**
+   * Creates a wrapped generateText function that automatically wraps tools.
+   */
+  generateText(originalGenerateText) {
+    return (params) => {
+      const wrappedParams = {
+        ...params,
+        tools: params.tools ? this.wrapTools(params.tools) : void 0
+      };
+      return originalGenerateText(wrappedParams);
+    };
+  }
+};
+function createPolymorphAIClient(options) {
+  return new PolymorphAIClient(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PolymorphAIClient,
+  PolymorphConfig,
+  PolymorphHTTPClient,
+  createPolymorphAIClient,
+  log
+});

package/dist/index.mjs

@@ -0,0 +1,233 @@
+// src/config.ts
+var PolymorphConfig = class {
+  constructor(options) {
+    this.role = options.role;
+    this.apiKey = options.apiKey ?? this.getEnv("POLYMORPH_API_KEY");
+    this.baseUrl = options.baseUrl ?? this.getEnv("POLYMORPH_BASE_URL");
+    this.httpTimeout = options.httpTimeout ?? 1e4;
+    this.httpEnabled = options.httpEnabled ?? true;
+    if (!this.apiKey) {
+      throw new Error(
+        "apiKey is required. Provide it in the constructor or set POLYMORPH_API_KEY env var."
+      );
+    }
+  }
+  getEnv(key) {
+    if (typeof process !== "undefined" && process.env) {
+      return process.env[key];
+    }
+    return void 0;
+  }
+};
+
+// src/http-client.ts
+var PolymorphHTTPClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl;
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout ?? 1e4;
+    this.enabled = options.enabled ?? true;
+  }
+  /**
+   * Make a POST request to the given endpoint.
+   *
+   * Returns the response JSON if successful, undefined otherwise.
+   * All errors are caught and logged.
+   */
+  async post(endpoint, payload) {
+    if (!this.enabled) {
+      console.debug(`[Polymorph] HTTP client disabled, skipping POST to ${endpoint}`);
+      return void 0;
+    }
+    if (!this.baseUrl) {
+      console.debug(`[Polymorph] No baseUrl configured, skipping POST to ${endpoint}`);
+      return void 0;
+    }
+    const url = `${this.baseUrl.replace(/\/$/, "")}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        console.warn(
+          `[Polymorph] HTTP error ${response.status} while posting to ${url}`
+        );
+        return void 0;
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          console.warn(`[Polymorph] Timeout while posting to ${url}`);
+        } else {
+          console.warn(`[Polymorph] Request error while posting to ${url}:`, error.message);
+        }
+      } else {
+        console.warn(`[Polymorph] Unexpected error while posting to ${url}:`, error);
+      }
+      return void 0;
+    }
+  }
+  /**
+   * Fire-and-forget POST request. Does not wait for response.
+   */
+  postFireAndForget(endpoint, payload) {
+    this.post(endpoint, payload);
+  }
+};
+
+// src/logging.ts
+function log(entry) {
+  console.log("[Polymorph]", entry);
+}
+
+// src/providers/vercel-ai.ts
+function createHooks(config, httpClient) {
+  async function preToolHook(context) {
+    const payload = {
+      event: "tool_call_start",
+      tool: context.toolName,
+      input: context.input,
+      tool_use_id: context.toolCallId,
+      role: config.role
+    };
+    log(payload);
+    httpClient.postFireAndForget("/sdk/tool/pre", payload);
+    return {};
+  }
+  async function postToolHook(context) {
+    const payload = {
+      event: "tool_call_end",
+      tool: context.toolName,
+      tool_use_id: context.toolCallId,
+      duration_ms: context.durationMs,
+      success: !context.error,
+      error: context.error?.message,
+      role: config.role
+    };
+    log(payload);
+    httpClient.postFireAndForget("/sdk/tool/post", payload);
+  }
+  return { preToolHook, postToolHook };
+}
+function wrapTool(toolName, tool, preToolHook, postToolHook) {
+  if (!tool.execute) {
+    return tool;
+  }
+  const originalExecute = tool.execute;
+  const wrappedExecute = async (input, options) => {
+    const toolCallId = options?.toolCallId ?? `call_${Date.now()}`;
+    const context = {
+      toolName,
+      toolCallId,
+      input
+    };
+    const preResult = await preToolHook(context);
+    if (preResult.deny) {
+      throw new Error(
+        `Tool '${toolName}' denied: ${preResult.reason ?? "Permission denied"}`
+      );
+    }
+    const startTime = Date.now();
+    let result;
+    let error;
+    try {
+      result = await originalExecute(input, options);
+    } catch (e) {
+      error = e instanceof Error ? e : new Error(String(e));
+      throw error;
+    } finally {
+      const durationMs = Date.now() - startTime;
+      await postToolHook({
+        ...context,
+        result,
+        error,
+        durationMs
+      });
+    }
+    return result;
+  };
+  return {
+    ...tool,
+    execute: wrappedExecute
+  };
+}
+function wrapTools(tools, preToolHook, postToolHook) {
+  const wrappedTools = {};
+  for (const [name, tool] of Object.entries(tools)) {
+    wrappedTools[name] = wrapTool(name, tool, preToolHook, postToolHook);
+  }
+  return wrappedTools;
+}
+var PolymorphAIClient = class {
+  constructor(options) {
+    this.config = options.config;
+    this.httpClient = new PolymorphHTTPClient({
+      baseUrl: this.config.baseUrl,
+      apiKey: this.config.apiKey,
+      timeout: this.config.httpTimeout,
+      enabled: this.config.httpEnabled
+    });
+    const hooks = createHooks(this.config, this.httpClient);
+    this.preToolHook = hooks.preToolHook;
+    this.postToolHook = hooks.postToolHook;
+    this.httpClient.postFireAndForget("/sdk/init", {
+      role: this.config.role,
+      sdk: "vercel-ai",
+      version: "0.1.0"
+    });
+  }
+  /**
+   * Wraps tools with Polymorph logging hooks.
+   */
+  wrapTools(tools) {
+    return wrapTools(tools, this.preToolHook, this.postToolHook);
+  }
+  /**
+   * Creates a wrapped streamText function that automatically wraps tools.
+   */
+  streamText(originalStreamText) {
+    return (params) => {
+      const wrappedParams = {
+        ...params,
+        tools: params.tools ? this.wrapTools(params.tools) : void 0
+      };
+      return originalStreamText(wrappedParams);
+    };
+  }
+  /**
+   * Creates a wrapped generateText function that automatically wraps tools.
+   */
+  generateText(originalGenerateText) {
+    return (params) => {
+      const wrappedParams = {
+        ...params,
+        tools: params.tools ? this.wrapTools(params.tools) : void 0
+      };
+      return originalGenerateText(wrappedParams);
+    };
+  }
+};
+function createPolymorphAIClient(options) {
+  return new PolymorphAIClient(options);
+}
+export {
+  PolymorphAIClient,
+  PolymorphConfig,
+  PolymorphHTTPClient,
+  createPolymorphAIClient,
+  log
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "polymorph-sdk",
+  "version": "0.1.0",
+  "description": "Tool logging wrapper for Vercel AI SDK",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "vercel",
+    "ai-sdk",
+    "polymorph",
+    "tool-logging"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "ai": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  },
+  "peerDependencies": {
+    "ai": ">=4.0.0"
+  }
+}