polymorph-sdk 0.1.0 → 0.2.2

package/dist/index.d.mts

@@ -1,135 +0,0 @@
-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.mjs

@@ -1,233 +0,0 @@
-// 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
-};