polymorph-sdk 0.1.0 → 0.2.0

package/src/theme.ts

@@ -0,0 +1,53 @@
+import type { MantineColorsTuple, MantineThemeOverride } from "@mantine/core";
+import { createTheme } from "@mantine/core";
+
+function hexToMantineTuple(hex: string): MantineColorsTuple {
+  const r = Number.parseInt(hex.slice(1, 3), 16);
+  const g = Number.parseInt(hex.slice(3, 5), 16);
+  const b = Number.parseInt(hex.slice(5, 7), 16);
+
+  const lighten = (amt: number) =>
+    `#${[r, g, b]
+      .map((c) =>
+        Math.min(255, Math.round(c + (255 - c) * amt))
+          .toString(16)
+          .padStart(2, "0"),
+      )
+      .join("")}`;
+
+  const darken = (amt: number) =>
+    `#${[r, g, b]
+      .map((c) =>
+        Math.max(0, Math.round(c * (1 - amt)))
+          .toString(16)
+          .padStart(2, "0"),
+      )
+      .join("")}`;
+
+  return [
+    lighten(0.92),
+    lighten(0.84),
+    lighten(0.72),
+    lighten(0.56),
+    lighten(0.36),
+    hex,
+    darken(0.08),
+    darken(0.16),
+    darken(0.28),
+    darken(0.4),
+  ];
+}
+
+export function buildWidgetTheme(
+  primaryColor = "#171717",
+): MantineThemeOverride {
+  return createTheme({
+    fontFamily:
+      '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif',
+    primaryColor: "brand",
+    colors: {
+      brand: hexToMantineTuple(primaryColor),
+    },
+    defaultRadius: "md",
+  });
+}

package/src/types.ts

@@ -0,0 +1,36 @@
+export interface WidgetConfig {
+  apiBaseUrl: string;
+  apiKey?: string;
+  metadata?: Record<string, string>;
+  branding?: WidgetBranding;
+  position?: "bottom-right" | "bottom-left";
+  /** Enable voice call (default: true). When false, widget is chat-only. */
+  enableVoice?: boolean;
+  /** Participant identity sent to LiveKit */
+  userIdentity?: string;
+  /** Participant display name sent to LiveKit */
+  userName?: string;
+  /** Extra options passed to fetch (e.g. { credentials: "include" }) */
+  fetchOptions?: RequestInit;
+}
+
+export interface WidgetBranding {
+  /** FAB and accent color (default: "#171717") */
+  primaryColor?: string;
+  /** Panel header title (default: "Hi there") */
+  title?: string;
+  /** Panel subheader */
+  subtitle?: string;
+  /** Initial message shown before agent connects */
+  greeting?: string;
+}
+
+export interface ChatMessage {
+  id: string;
+  role: "user" | "agent";
+  text: string;
+  source: "chat" | "voice";
+  timestamp: number;
+}
+
+export type SessionStatus = "idle" | "connecting" | "connected" | "error";

package/src/usePolymorphSession.ts

@@ -0,0 +1,134 @@
+import { useCallback, useRef, useState } from "react";
+import type { Room } from "livekit-client";
+import type { ChatMessage, SessionStatus, WidgetConfig } from "./types";
+
+interface RoomConnection {
+  token: string;
+  livekitUrl: string;
+}
+
+function makeGreeting(text: string): ChatMessage {
+  return {
+    id: "greeting",
+    role: "agent",
+    text,
+    source: "chat",
+    timestamp: Date.now(),
+  };
+}
+
+export function usePolymorphSession(config: WidgetConfig) {
+  const [status, setStatus] = useState<SessionStatus>("idle");
+  const [roomConnection, setRoomConnection] = useState<RoomConnection | null>(null);
+  const [messages, setMessages] = useState<ChatMessage[]>(() => {
+    if (config.branding?.greeting) {
+      return [makeGreeting(config.branding.greeting)];
+    }
+    return [];
+  });
+  const [isVoiceEnabled, setIsVoiceEnabled] = useState(config.enableVoice !== false);
+  const [isMicActive, setIsMicActive] = useState(config.enableVoice !== false);
+  const [error, setError] = useState<string | null>(null);
+  const roomRef = useRef<Room | null>(null);
+
+  const addMessage = useCallback((role: "user" | "agent", text: string, source: "chat" | "voice") => {
+    setMessages(prev => [...prev, {
+      id: crypto.randomUUID(),
+      role,
+      text,
+      source,
+      timestamp: Date.now(),
+    }]);
+  }, []);
+
+  const connect = useCallback(async () => {
+    if (status === "connecting" || status === "connected") return;
+    setStatus("connecting");
+    setError(null);
+    try {
+      const { headers: extraHeaders, ...restFetchOptions } = config.fetchOptions ?? {};
+      const authHeaders: Record<string, string> = {};
+      if (config.apiKey) {
+        authHeaders["Authorization"] = `Bearer ${config.apiKey}`;
+      }
+      const response = await fetch(`${config.apiBaseUrl}/voice-rooms/start`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...authHeaders,
+          ...(extraHeaders instanceof Headers
+            ? Object.fromEntries(extraHeaders.entries())
+            : extraHeaders),
+        },
+        body: JSON.stringify({
+          agent_name: "custom-voice-agent",
+          metadata: config.metadata,
+          user_identity: config.userIdentity,
+          user_name: config.userName,
+        }),
+        ...restFetchOptions,
+      });
+      if (!response.ok) {
+        throw new Error(await response.text() || "Failed to start session");
+      }
+      const data = await response.json();
+      setRoomConnection({ token: data.token, livekitUrl: data.livekit_url });
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Something went wrong");
+      setStatus("error");
+    }
+  }, [config, status]);
+
+  const disconnect = useCallback(() => {
+    roomRef.current?.disconnect();
+    roomRef.current = null;
+    setRoomConnection(null);
+    setStatus("idle");
+  }, []);
+
+  const sendMessage = useCallback((text: string) => {
+    const room = roomRef.current;
+    if (!room || !text.trim()) return;
+    addMessage("user", text.trim(), "chat");
+    const payload = new TextEncoder().encode(JSON.stringify({ text: text.trim() }));
+    room.localParticipant.publishData(payload, { reliable: true, topic: "chat_message" });
+  }, [addMessage]);
+
+  const toggleMic = useCallback(async () => {
+    const room = roomRef.current;
+    if (!room) return;
+    const newState = !isMicActive;
+    await room.localParticipant.setMicrophoneEnabled(newState);
+    setIsMicActive(newState);
+  }, [isMicActive]);
+
+  const toggleVoice = useCallback(async () => {
+    const room = roomRef.current;
+    if (!room) return;
+    const newState = !isVoiceEnabled;
+    await room.localParticipant.setMicrophoneEnabled(newState);
+    setIsVoiceEnabled(newState);
+    setIsMicActive(newState);
+  }, [isVoiceEnabled]);
+
+  const setRoom = useCallback((room: Room | null) => {
+    roomRef.current = room;
+    if (room) setStatus("connected");
+  }, []);
+
+  return {
+    status,
+    roomConnection,
+    messages,
+    isVoiceEnabled,
+    isMicActive,
+    error,
+    connect,
+    disconnect,
+    addMessage,
+    sendMessage,
+    toggleMic,
+    toggleVoice,
+    setRoom,
+  };
+}

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
-};