@boldvideo/bold-js 0.8.0 → 0.8.2

package/AGENTS.md

@@ -22,10 +22,36 @@ pnpm install          # Install dependencies
 pnpm run build        # Build to dist/ (ESM + CJS + type declarations)
 pnpm run lint         # Type checking with tsc
 pnpm changeset        # Create a changeset for versioning
-pnpm changeset version   # Apply changesets and bump versions
-pnpm changeset publish   # Publish to npm
 ```
 
+## Release Workflow
+
+This project uses [Changesets](https://github.com/changesets/changesets) with automated GitHub Actions for publishing.
+
+### How to Release
+
+1. **Create a changeset** when making changes that should be released:
+   ```bash
+   pnpm changeset
+   ```
+   This creates a markdown file in `.changeset/` describing the change and version bump type (patch/minor/major).
+
+2. **Commit and push** your changes (including the changeset file) to `main`.
+
+3. **Automated release process**:
+   - The `changeset-release.yml` workflow runs on push to `main`
+   - If changesets exist, it creates a "Release PR" that:
+     - Bumps the version in `package.json`
+     - Updates `CHANGELOG.md`
+     - Removes the changeset files
+   - When you merge that Release PR, the workflow automatically publishes to npm
+
+### Important Notes
+
+- **Never run `pnpm changeset version` or `pnpm changeset publish` locally** - the GitHub Action handles this automatically
+- The CI workflow (`ci.yml`) runs `pnpm run build` which generates the `dist/` folder - this ensures compiled files are always included in the published package
+- The `release.yml` workflow can also publish when a `v*` tag is pushed (alternative release method)
+
 ## Project Structure
 
 ```

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @boldvideo/bold-js
 
+## 0.8.2
+
+### Patch Changes
+
+- e8876a9: Fix release workflow to build dist files before publishing
+
+## 0.8.1
+
+### Patch Changes
+
+- c643c04: Fix missing compiled dist files in published package
+
 ## 0.8.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -0,0 +1,367 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_API_BASE_URL: () => DEFAULT_API_BASE_URL,
+  DEFAULT_INTERNAL_API_BASE_URL: () => DEFAULT_INTERNAL_API_BASE_URL,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/lib/client.ts
+var import_axios = __toESM(require("axios"), 1);
+
+// src/lib/fetchers.ts
+async function get(client, url) {
+  try {
+    const res = await client.get(url);
+    if (res.status !== 200) {
+      throw new Error(`Unexpected response status: ${res.status}`);
+    }
+    return res.data;
+  } catch (error) {
+    console.error(`Error fetching data from URL: ${url}`, error);
+    throw error;
+  }
+}
+function fetchSettings(client) {
+  return async (videoLimit = 12) => {
+    try {
+      return await get(
+        client,
+        `settings?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching settings with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  };
+}
+function fetchVideos(client) {
+  return async (videoLimit = 12) => {
+    try {
+      return await get(
+        client,
+        `videos/latest?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching videos with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  };
+}
+function searchVideos(client) {
+  return async (term) => {
+    try {
+      return await get(client, `videos?query=${term}`);
+    } catch (error) {
+      console.error(`Error searching for videos with term: ${term}`, error);
+      throw error;
+    }
+  };
+}
+function fetchVideo(client) {
+  return async (id) => {
+    try {
+      return await get(client, `videos/${id}`);
+    } catch (error) {
+      console.error(`Error fetching video with ID: ${id}`, error);
+      throw error;
+    }
+  };
+}
+function fetchPlaylists(client) {
+  return async () => {
+    try {
+      return await get(client, "playlists");
+    } catch (error) {
+      console.error("Error fetching playlists", error);
+      throw error;
+    }
+  };
+}
+function fetchPlaylist(client) {
+  return async (id) => {
+    try {
+      return await get(client, `playlists/${id}`);
+    } catch (error) {
+      console.error(`Error fetching playlist with ID: ${id}`, error);
+      throw error;
+    }
+  };
+}
+
+// src/util/throttle.ts
+var throttle = (fn, delay) => {
+  let wait = false;
+  let timeout;
+  let cancelled = false;
+  return [
+    (...args) => {
+      if (cancelled)
+        return void 0;
+      if (wait)
+        return void 0;
+      const val = fn(...args);
+      wait = true;
+      timeout = window.setTimeout(() => {
+        wait = false;
+      }, delay);
+      return val;
+    },
+    () => {
+      cancelled = true;
+      clearTimeout(timeout);
+    }
+  ];
+};
+
+// src/lib/tracking.ts
+function sendEvent(client, eventName, data, debug) {
+  const payload = {
+    n: eventName,
+    u: data.url,
+    usr: data.userId,
+    d: data.domain,
+    ua: data.userAgent,
+    w: data.deviceWidth,
+    vid: data?.videoId || void 0,
+    vt: data.title,
+    vdur: data?.videoDuration || void 0,
+    time: data?.currentTime || void 0
+  };
+  if (debug)
+    console.log(`Bold SDK - Logging event '${eventName}'`, payload);
+  client.post("/event", payload);
+}
+var [throttledSendEvent] = throttle(sendEvent, 5e3);
+function trackEvent(client, userId, options) {
+  return (video, event) => {
+    const eventDetails = {
+      ...basicInfos(),
+      userId,
+      videoId: video.id,
+      title: video.title,
+      videoDuration: video.duration,
+      currentTime: event.target?.currentTime || 0
+    };
+    if (event.type == "timeupdate" || event.type == "time-update") {
+      throttledSendEvent(
+        client,
+        getEventName(event),
+        eventDetails,
+        options.debug
+      );
+    } else {
+      sendEvent(client, getEventName(event), eventDetails, options.debug);
+    }
+  };
+}
+function trackPageView(client, userId, options) {
+  return (title) => {
+    const eventDetails = {
+      ...basicInfos(),
+      userId,
+      title
+    };
+    sendEvent(client, "page_view", eventDetails, options.debug);
+  };
+}
+function getEventName(event) {
+  switch (event.type) {
+    case "pause":
+      return "video_pause";
+    case "play":
+      return "video_resume";
+    case "loadedmetadata":
+    case "loaded-metadata":
+      return "video_load";
+    case "time-update":
+    case "timeupdate":
+      return "video_progress";
+    default:
+      return "unknown_event";
+  }
+}
+function basicInfos() {
+  return {
+    url: location.href,
+    domain: location.hostname,
+    referrer: document.referrer || null,
+    deviceWidth: window.innerWidth,
+    userAgent: navigator.userAgent
+  };
+}
+
+// src/lib/ai.ts
+async function* parseSSE(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(/\r?\n\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data:"))
+          continue;
+        const json = trimmed.slice(5).trim();
+        if (!json)
+          continue;
+        try {
+          const event = JSON.parse(json);
+          yield event;
+          if (event.type === "complete") {
+            await reader.cancel();
+            return;
+          }
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function streamRequest(path, body, config) {
+  const baseURL = config.baseURL.endsWith("/") ? config.baseURL : `${config.baseURL}/`;
+  const url = new URL(path, baseURL);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Accept": "text/event-stream",
+      ...config.headers
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new Error(`AI request failed: ${response.status} ${response.statusText}`);
+  }
+  return parseSSE(response);
+}
+function createAI(config) {
+  return {
+    /**
+     * Coach - Library-wide RAG assistant
+     *
+     * Requires native fetch (Node 18+ or browser)
+     *
+     * @example
+     * const stream = await bold.ai.coach({ message: "How do I price my SaaS?" });
+     * for await (const event of stream) {
+     *   if (event.type === "token") console.log(event.content);
+     * }
+     */
+    async coach(options) {
+      const path = options.conversationId ? `coach/${options.conversationId}` : "coach";
+      const body = { message: options.message };
+      if (options.collectionId)
+        body.collection_id = options.collectionId;
+      return streamRequest(path, body, config);
+    },
+    /**
+     * Ask - Video-specific Q&A
+     *
+     * Requires native fetch (Node 18+ or browser)
+     *
+     * @example
+     * const stream = await bold.ai.ask("video-id", { message: "What is this about?" });
+     * for await (const event of stream) {
+     *   if (event.type === "token") console.log(event.content);
+     * }
+     */
+    async ask(videoId, options) {
+      const path = `videos/${videoId}/ask`;
+      return streamRequest(path, { message: options.message }, config);
+    }
+  };
+}
+
+// src/lib/constants.ts
+var DEFAULT_API_BASE_URL = "https://app.boldvideo.io/api/v1/";
+var DEFAULT_INTERNAL_API_BASE_URL = "https://app.boldvideo.io/i/v1/";
+
+// src/lib/client.ts
+function createClient(apiKey, options = {}) {
+  if (!apiKey || typeof apiKey !== "string") {
+    throw new Error("API key is missing or invalid");
+  }
+  const { debug = false, headers = {} } = options;
+  const apiClientOptions = {
+    baseURL: options.baseURL ?? DEFAULT_API_BASE_URL,
+    headers: {
+      Authorization: apiKey,
+      ...headers
+    }
+  };
+  let apiClient;
+  try {
+    apiClient = import_axios.default.create(apiClientOptions);
+  } catch (error) {
+    console.error("Error creating API client", error);
+    throw error;
+  }
+  const userId = [...Array(30)].map(() => Math.random().toString(36)[2]).join("");
+  const aiConfig = {
+    baseURL: apiClientOptions.baseURL,
+    headers: apiClientOptions.headers
+  };
+  return {
+    settings: fetchSettings(apiClient),
+    videos: {
+      list: fetchVideos(apiClient),
+      get: fetchVideo(apiClient),
+      search: searchVideos(apiClient)
+    },
+    playlists: {
+      list: fetchPlaylists(apiClient),
+      get: fetchPlaylist(apiClient)
+    },
+    ai: createAI(aiConfig),
+    trackEvent: trackEvent(apiClient, userId, { debug }),
+    trackPageView: trackPageView(apiClient, userId, { debug })
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_API_BASE_URL,
+  DEFAULT_INTERNAL_API_BASE_URL,
+  createClient
+});

package/dist/index.d.ts

@@ -0,0 +1,255 @@
+type VideoAttachment = {
+    id: string;
+    title: string;
+    file_url: string;
+    file_size?: number;
+    file_type?: string;
+};
+type VideoDownloadUrls = {
+    mp4?: string;
+    audio?: string;
+    legacy_mp4?: string;
+};
+type VideoSubtitles = {
+    label: string;
+    url: string;
+    engine?: string;
+    language: string;
+};
+type VideoTranscript = {
+    text: string;
+    json: any;
+};
+type VideoMetadata = {
+    description: string;
+    title: string;
+    image: string | null;
+};
+type Video = {
+    captions: string;
+    captions_label: string;
+    captions_lang: string;
+    description: string | null;
+    duration: number;
+    id: string;
+    imported_from: string | null;
+    legacy_video_url: string | null;
+    playback_id: string;
+    published_at: string;
+    stream_url: string;
+    teaser: string | null;
+    thumbnail: string;
+    title: string;
+    type: string;
+    meta_data: VideoMetadata;
+    chapters?: string;
+    attachments?: VideoAttachment[];
+    cta?: any | null;
+    download_urls?: VideoDownloadUrls;
+    internal_id?: string;
+    playback_speed?: number;
+    subtitles?: VideoSubtitles;
+    tags?: string[];
+    transcript?: VideoTranscript;
+};
+type Playlist = {
+    description?: string;
+    id: string;
+    is_private: boolean;
+    title: string;
+    type: string;
+    videos: Video[];
+};
+type MenuItem = {
+    icon: string;
+    is_ext: boolean;
+    label: string;
+    url: string;
+};
+type PortalDisplay = {
+    show_chapters: boolean;
+    show_transcripts: boolean;
+};
+type AssistantConfig = {
+    headline: string;
+    subheadline: string;
+    suggestions: string[];
+};
+type PortalLayout = {
+    assistant_config: AssistantConfig | null;
+    show_playlists: boolean;
+    type: string;
+    videos_limit: number;
+};
+type PortalNavigation = {
+    show_ai_search: boolean;
+    show_header: boolean;
+    show_search: boolean;
+};
+type PortalTheme = {
+    background: string;
+    font_body: string;
+    font_header: string;
+    foreground: string;
+    logo_height: number;
+    logo_url: string;
+    logo_width: number;
+    primary: string;
+};
+type Portal = {
+    color_scheme?: 'toggle' | 'light' | 'dark';
+    display: PortalDisplay;
+    layout: PortalLayout;
+    navigation: PortalNavigation;
+    theme: PortalTheme;
+};
+type ThemeColors = {
+    background: string;
+    border: string;
+    card: string;
+    "card-foreground": string;
+    destructive: string;
+    "destructive-foreground": string;
+    foreground: string;
+    input: string;
+    muted: string;
+    "muted-foreground": string;
+    popover: string;
+    "popover-foreground": string;
+    primary: string;
+    "primary-foreground": string;
+    ring: string;
+    secondary: string;
+    "secondary-foreground": string;
+};
+type ThemeConfig = {
+    dark: ThemeColors;
+    light: ThemeColors;
+    radius: string;
+};
+type AccountAI = {
+    avatar_url: string;
+    enabled: boolean;
+    greeting: string;
+    name: string;
+};
+type Account = {
+    ai: AccountAI;
+    name: string;
+    slug: string;
+};
+type Settings = {
+    featured_playlists: Playlist[];
+    menu_items: MenuItem[];
+    ai_avatar: string;
+    ai_name: string;
+    ai_greeting?: string;
+    has_ai: boolean;
+    account: Account;
+    favicon_url?: string;
+    logo_dark_url?: string;
+    logo_url?: string;
+    meta_data: {
+        channel_name: string;
+        description: string;
+        image: string | null;
+        no_seo: boolean;
+        social_graph_image_url?: string;
+        title: string;
+        title_suffix: string;
+    };
+    portal: Portal;
+    theme_config: ThemeConfig;
+    version: string;
+};
+interface Citation {
+    video_id: string;
+    title: string;
+    timestamp_ms: number;
+    text: string;
+}
+interface Usage {
+    input_tokens: number;
+    output_tokens: number;
+}
+type CoachEvent = {
+    type: "conversation_created";
+    id: string;
+    status: "processing";
+} | {
+    type: "clarification";
+    questions: string[];
+    mode: "clarification";
+    needs_clarification: true;
+} | {
+    type: "token";
+    content: string;
+} | {
+    type: "answer";
+    content: string;
+    citations: Citation[];
+    usage: Usage;
+} | {
+    type: "error";
+    message: string;
+    step?: string;
+    reason?: string;
+    timestamp: string;
+} | {
+    type: "complete";
+};
+interface CoachOptions {
+    message: string;
+    conversationId?: string;
+    collectionId?: string;
+}
+interface AskOptions {
+    message: string;
+}
+
+type ClientOptions = {
+    baseURL?: string;
+    debug?: boolean;
+    headers?: Record<string, string>;
+};
+declare function createClient(apiKey: string, options?: ClientOptions): {
+    settings: (videoLimit?: number) => Promise<{
+        data: Settings;
+    }>;
+    videos: {
+        list: (videoLimit?: number) => Promise<{
+            data: Video[];
+        }>;
+        get: (id: string) => Promise<{
+            data: Video;
+        }>;
+        search: (term: string) => Promise<{
+            data: Video[];
+        }>;
+    };
+    playlists: {
+        list: () => Promise<{
+            data: Playlist[];
+        }>;
+        get: (id: string) => Promise<{
+            data: Playlist;
+        }>;
+    };
+    ai: {
+        coach(options: CoachOptions): Promise<AsyncIterable<CoachEvent>>;
+        ask(videoId: string, options: AskOptions): Promise<AsyncIterable<CoachEvent>>;
+    };
+    trackEvent: (video: any, event: Event) => void;
+    trackPageView: (title: string) => void;
+};
+
+/**
+ * Default API base URL for public API access
+ */
+declare const DEFAULT_API_BASE_URL = "https://app.boldvideo.io/api/v1/";
+/**
+ * Default API base URL for internal/hosted API access
+ */
+declare const DEFAULT_INTERNAL_API_BASE_URL = "https://app.boldvideo.io/i/v1/";
+
+export { Account, AccountAI, AskOptions, AssistantConfig, Citation, ClientOptions, CoachEvent, CoachOptions, DEFAULT_API_BASE_URL, DEFAULT_INTERNAL_API_BASE_URL, MenuItem, Playlist, Portal, PortalDisplay, PortalLayout, PortalNavigation, PortalTheme, Settings, ThemeColors, ThemeConfig, Usage, Video, VideoAttachment, VideoDownloadUrls, VideoMetadata, VideoSubtitles, VideoTranscript, createClient };

package/dist/index.js

@@ -0,0 +1,328 @@
+// src/lib/client.ts
+import axios from "axios";
+
+// src/lib/fetchers.ts
+async function get(client, url) {
+  try {
+    const res = await client.get(url);
+    if (res.status !== 200) {
+      throw new Error(`Unexpected response status: ${res.status}`);
+    }
+    return res.data;
+  } catch (error) {
+    console.error(`Error fetching data from URL: ${url}`, error);
+    throw error;
+  }
+}
+function fetchSettings(client) {
+  return async (videoLimit = 12) => {
+    try {
+      return await get(
+        client,
+        `settings?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching settings with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  };
+}
+function fetchVideos(client) {
+  return async (videoLimit = 12) => {
+    try {
+      return await get(
+        client,
+        `videos/latest?limit=${videoLimit}`
+      );
+    } catch (error) {
+      console.error(`Error fetching videos with limit: ${videoLimit}`, error);
+      throw error;
+    }
+  };
+}
+function searchVideos(client) {
+  return async (term) => {
+    try {
+      return await get(client, `videos?query=${term}`);
+    } catch (error) {
+      console.error(`Error searching for videos with term: ${term}`, error);
+      throw error;
+    }
+  };
+}
+function fetchVideo(client) {
+  return async (id) => {
+    try {
+      return await get(client, `videos/${id}`);
+    } catch (error) {
+      console.error(`Error fetching video with ID: ${id}`, error);
+      throw error;
+    }
+  };
+}
+function fetchPlaylists(client) {
+  return async () => {
+    try {
+      return await get(client, "playlists");
+    } catch (error) {
+      console.error("Error fetching playlists", error);
+      throw error;
+    }
+  };
+}
+function fetchPlaylist(client) {
+  return async (id) => {
+    try {
+      return await get(client, `playlists/${id}`);
+    } catch (error) {
+      console.error(`Error fetching playlist with ID: ${id}`, error);
+      throw error;
+    }
+  };
+}
+
+// src/util/throttle.ts
+var throttle = (fn, delay) => {
+  let wait = false;
+  let timeout;
+  let cancelled = false;
+  return [
+    (...args) => {
+      if (cancelled)
+        return void 0;
+      if (wait)
+        return void 0;
+      const val = fn(...args);
+      wait = true;
+      timeout = window.setTimeout(() => {
+        wait = false;
+      }, delay);
+      return val;
+    },
+    () => {
+      cancelled = true;
+      clearTimeout(timeout);
+    }
+  ];
+};
+
+// src/lib/tracking.ts
+function sendEvent(client, eventName, data, debug) {
+  const payload = {
+    n: eventName,
+    u: data.url,
+    usr: data.userId,
+    d: data.domain,
+    ua: data.userAgent,
+    w: data.deviceWidth,
+    vid: data?.videoId || void 0,
+    vt: data.title,
+    vdur: data?.videoDuration || void 0,
+    time: data?.currentTime || void 0
+  };
+  if (debug)
+    console.log(`Bold SDK - Logging event '${eventName}'`, payload);
+  client.post("/event", payload);
+}
+var [throttledSendEvent] = throttle(sendEvent, 5e3);
+function trackEvent(client, userId, options) {
+  return (video, event) => {
+    const eventDetails = {
+      ...basicInfos(),
+      userId,
+      videoId: video.id,
+      title: video.title,
+      videoDuration: video.duration,
+      currentTime: event.target?.currentTime || 0
+    };
+    if (event.type == "timeupdate" || event.type == "time-update") {
+      throttledSendEvent(
+        client,
+        getEventName(event),
+        eventDetails,
+        options.debug
+      );
+    } else {
+      sendEvent(client, getEventName(event), eventDetails, options.debug);
+    }
+  };
+}
+function trackPageView(client, userId, options) {
+  return (title) => {
+    const eventDetails = {
+      ...basicInfos(),
+      userId,
+      title
+    };
+    sendEvent(client, "page_view", eventDetails, options.debug);
+  };
+}
+function getEventName(event) {
+  switch (event.type) {
+    case "pause":
+      return "video_pause";
+    case "play":
+      return "video_resume";
+    case "loadedmetadata":
+    case "loaded-metadata":
+      return "video_load";
+    case "time-update":
+    case "timeupdate":
+      return "video_progress";
+    default:
+      return "unknown_event";
+  }
+}
+function basicInfos() {
+  return {
+    url: location.href,
+    domain: location.hostname,
+    referrer: document.referrer || null,
+    deviceWidth: window.innerWidth,
+    userAgent: navigator.userAgent
+  };
+}
+
+// src/lib/ai.ts
+async function* parseSSE(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(/\r?\n\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data:"))
+          continue;
+        const json = trimmed.slice(5).trim();
+        if (!json)
+          continue;
+        try {
+          const event = JSON.parse(json);
+          yield event;
+          if (event.type === "complete") {
+            await reader.cancel();
+            return;
+          }
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function streamRequest(path, body, config) {
+  const baseURL = config.baseURL.endsWith("/") ? config.baseURL : `${config.baseURL}/`;
+  const url = new URL(path, baseURL);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Accept": "text/event-stream",
+      ...config.headers
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new Error(`AI request failed: ${response.status} ${response.statusText}`);
+  }
+  return parseSSE(response);
+}
+function createAI(config) {
+  return {
+    /**
+     * Coach - Library-wide RAG assistant
+     *
+     * Requires native fetch (Node 18+ or browser)
+     *
+     * @example
+     * const stream = await bold.ai.coach({ message: "How do I price my SaaS?" });
+     * for await (const event of stream) {
+     *   if (event.type === "token") console.log(event.content);
+     * }
+     */
+    async coach(options) {
+      const path = options.conversationId ? `coach/${options.conversationId}` : "coach";
+      const body = { message: options.message };
+      if (options.collectionId)
+        body.collection_id = options.collectionId;
+      return streamRequest(path, body, config);
+    },
+    /**
+     * Ask - Video-specific Q&A
+     *
+     * Requires native fetch (Node 18+ or browser)
+     *
+     * @example
+     * const stream = await bold.ai.ask("video-id", { message: "What is this about?" });
+     * for await (const event of stream) {
+     *   if (event.type === "token") console.log(event.content);
+     * }
+     */
+    async ask(videoId, options) {
+      const path = `videos/${videoId}/ask`;
+      return streamRequest(path, { message: options.message }, config);
+    }
+  };
+}
+
+// src/lib/constants.ts
+var DEFAULT_API_BASE_URL = "https://app.boldvideo.io/api/v1/";
+var DEFAULT_INTERNAL_API_BASE_URL = "https://app.boldvideo.io/i/v1/";
+
+// src/lib/client.ts
+function createClient(apiKey, options = {}) {
+  if (!apiKey || typeof apiKey !== "string") {
+    throw new Error("API key is missing or invalid");
+  }
+  const { debug = false, headers = {} } = options;
+  const apiClientOptions = {
+    baseURL: options.baseURL ?? DEFAULT_API_BASE_URL,
+    headers: {
+      Authorization: apiKey,
+      ...headers
+    }
+  };
+  let apiClient;
+  try {
+    apiClient = axios.create(apiClientOptions);
+  } catch (error) {
+    console.error("Error creating API client", error);
+    throw error;
+  }
+  const userId = [...Array(30)].map(() => Math.random().toString(36)[2]).join("");
+  const aiConfig = {
+    baseURL: apiClientOptions.baseURL,
+    headers: apiClientOptions.headers
+  };
+  return {
+    settings: fetchSettings(apiClient),
+    videos: {
+      list: fetchVideos(apiClient),
+      get: fetchVideo(apiClient),
+      search: searchVideos(apiClient)
+    },
+    playlists: {
+      list: fetchPlaylists(apiClient),
+      get: fetchPlaylist(apiClient)
+    },
+    ai: createAI(aiConfig),
+    trackEvent: trackEvent(apiClient, userId, { debug }),
+    trackPageView: trackPageView(apiClient, userId, { debug })
+  };
+}
+export {
+  DEFAULT_API_BASE_URL,
+  DEFAULT_INTERNAL_API_BASE_URL,
+  createClient
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@boldvideo/bold-js",
   "license": "MIT",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",