@gram-ai/elements 1.27.3 → 1.27.5

package/src/lib/api.test.ts

@@ -1,90 +1,90 @@
-import type { ElementsConfig } from '@/types'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ElementsConfig } from "@/types";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
-describe('getApiUrl', () => {
+describe("getApiUrl", () => {
   beforeEach(() => {
-    vi.resetModules()
-  })
+    vi.resetModules();
+  });
 
   async function loadGetApiUrl(gramApiUrl: string | undefined) {
-    vi.stubGlobal('__GRAM_API_URL__', gramApiUrl)
-    const { getApiUrl } = await import('./api')
-    return getApiUrl
+    vi.stubGlobal("__GRAM_API_URL__", gramApiUrl);
+    const { getApiUrl } = await import("./api");
+    return getApiUrl;
   }
 
-  it('uses config.api.url when set', async () => {
-    const getApiUrl = await loadGetApiUrl('https://env.example.com')
+  it("uses config.api.url when set", async () => {
+    const getApiUrl = await loadGetApiUrl("https://env.example.com");
     const config: ElementsConfig = {
-      projectSlug: 'test',
-      api: { url: 'https://config.example.com', session: 'test-key' },
-    }
+      projectSlug: "test",
+      api: { url: "https://config.example.com", session: "test-key" },
+    };
 
-    expect(getApiUrl(config)).toBe('https://config.example.com')
-  })
+    expect(getApiUrl(config)).toBe("https://config.example.com");
+  });
 
-  it('falls back to __GRAM_API_URL__ when config.api.url is not set', async () => {
-    const getApiUrl = await loadGetApiUrl('https://env.example.com')
+  it("falls back to __GRAM_API_URL__ when config.api.url is not set", async () => {
+    const getApiUrl = await loadGetApiUrl("https://env.example.com");
     const config: ElementsConfig = {
-      projectSlug: 'test',
-      api: { session: 'test-key' },
-    }
+      projectSlug: "test",
+      api: { session: "test-key" },
+    };
 
-    expect(getApiUrl(config)).toBe('https://env.example.com')
-  })
+    expect(getApiUrl(config)).toBe("https://env.example.com");
+  });
 
-  it('falls back to __GRAM_API_URL__ when config.api is undefined', async () => {
-    const getApiUrl = await loadGetApiUrl('https://env.example.com')
+  it("falls back to __GRAM_API_URL__ when config.api is undefined", async () => {
+    const getApiUrl = await loadGetApiUrl("https://env.example.com");
     const config: ElementsConfig = {
-      projectSlug: 'test',
-    }
+      projectSlug: "test",
+    };
 
-    expect(getApiUrl(config)).toBe('https://env.example.com')
-  })
+    expect(getApiUrl(config)).toBe("https://env.example.com");
+  });
 
-  it('falls back to default URL when both config.api.url and __GRAM_API_URL__ are not set', async () => {
-    const getApiUrl = await loadGetApiUrl('')
+  it("falls back to default URL when both config.api.url and __GRAM_API_URL__ are not set", async () => {
+    const getApiUrl = await loadGetApiUrl("");
     const config: ElementsConfig = {
-      projectSlug: 'test',
-    }
+      projectSlug: "test",
+    };
 
-    expect(getApiUrl(config)).toBe('https://app.getgram.ai')
-  })
+    expect(getApiUrl(config)).toBe("https://app.getgram.ai");
+  });
 
-  it('falls back to default URL when __GRAM_API_URL__ is undefined', async () => {
-    const getApiUrl = await loadGetApiUrl(undefined)
+  it("falls back to default URL when __GRAM_API_URL__ is undefined", async () => {
+    const getApiUrl = await loadGetApiUrl(undefined);
     const config: ElementsConfig = {
-      projectSlug: 'test',
-    }
+      projectSlug: "test",
+    };
 
-    expect(getApiUrl(config)).toBe('https://app.getgram.ai')
-  })
+    expect(getApiUrl(config)).toBe("https://app.getgram.ai");
+  });
 
-  it('skips empty string config.api.url and uses __GRAM_API_URL__', async () => {
-    const getApiUrl = await loadGetApiUrl('https://env.example.com')
+  it("skips empty string config.api.url and uses __GRAM_API_URL__", async () => {
+    const getApiUrl = await loadGetApiUrl("https://env.example.com");
     const config: ElementsConfig = {
-      projectSlug: 'test',
-      api: { url: '', session: 'test-key' },
-    }
+      projectSlug: "test",
+      api: { url: "", session: "test-key" },
+    };
 
-    expect(getApiUrl(config)).toBe('https://env.example.com')
-  })
+    expect(getApiUrl(config)).toBe("https://env.example.com");
+  });
 
-  it('removes trailing slashes from the URL', async () => {
-    const getApiUrl = await loadGetApiUrl('')
+  it("removes trailing slashes from the URL", async () => {
+    const getApiUrl = await loadGetApiUrl("");
     const config: ElementsConfig = {
-      projectSlug: 'test',
-      api: { url: 'https://config.example.com///', session: 'test-key' },
-    }
+      projectSlug: "test",
+      api: { url: "https://config.example.com///", session: "test-key" },
+    };
 
-    expect(getApiUrl(config)).toBe('https://config.example.com')
-  })
+    expect(getApiUrl(config)).toBe("https://config.example.com");
+  });
 
-  it('removes trailing slashes from __GRAM_API_URL__', async () => {
-    const getApiUrl = await loadGetApiUrl('https://env.example.com//')
+  it("removes trailing slashes from __GRAM_API_URL__", async () => {
+    const getApiUrl = await loadGetApiUrl("https://env.example.com//");
     const config: ElementsConfig = {
-      projectSlug: 'test',
-    }
+      projectSlug: "test",
+    };
 
-    expect(getApiUrl(config)).toBe('https://env.example.com')
-  })
-})
+    expect(getApiUrl(config)).toBe("https://env.example.com");
+  });
+});

package/src/lib/api.ts

@@ -1,8 +1,9 @@
-import { ElementsConfig } from '@/types'
+import { ElementsConfig } from "@/types";
 
 export function getApiUrl(config: ElementsConfig): string {
   // The api.url in the config should take precedence over the __GRAM_API_URL__ environment variable
   // because it is a user-defined override
-  const apiURL = config.api?.url || __GRAM_API_URL__ || 'https://app.getgram.ai'
-  return apiURL.replace(/\/+$/, '') // Remove trailing slashes
+  const apiURL =
+    config.api?.url || __GRAM_API_URL__ || "https://app.getgram.ai";
+  return apiURL.replace(/\/+$/, ""); // Remove trailing slashes
 }

package/src/lib/auth.ts

@@ -6,42 +6,42 @@ import {
   SessionAuthConfig,
   StaticSessionAuthConfig,
   UnifiedSessionAuthConfig,
-} from '@/types'
+} from "@/types";
 
 export function isDangerousApiKeyAuth(
-  auth: ApiConfig | undefined
+  auth: ApiConfig | undefined,
 ): auth is DangerousApiKeyAuthConfig {
-  return !!auth && 'dangerousApiKey' in auth
+  return !!auth && "dangerousApiKey" in auth;
 }
 
 export function isUnifiedStaticSession(
-  auth: ApiConfig | undefined
+  auth: ApiConfig | undefined,
 ): auth is UnifiedSessionAuthConfig & { session: string } {
-  return !!auth && 'session' in auth && typeof auth.session === 'string'
+  return !!auth && "session" in auth && typeof auth.session === "string";
 }
 
 export function isUnifiedFunctionSession(
-  auth: ApiConfig | undefined
+  auth: ApiConfig | undefined,
 ): auth is BaseApiConfig & { session: GetSessionFn } {
-  return !!auth && 'session' in auth && typeof auth.session === 'function'
+  return !!auth && "session" in auth && typeof auth.session === "function";
 }
 
 /** @deprecated Legacy check for `{ sessionToken }` configs. */
 export function isStaticSessionAuth(
-  auth: ApiConfig | undefined
+  auth: ApiConfig | undefined,
 ): auth is StaticSessionAuthConfig {
-  return !!auth && 'sessionToken' in auth
+  return !!auth && "sessionToken" in auth;
 }
 
 /** @deprecated Legacy check for `{ sessionFn }` configs. */
 export function hasExplicitSessionAuth(
-  auth: ApiConfig | undefined
+  auth: ApiConfig | undefined,
 ): auth is SessionAuthConfig {
-  if (!auth) return false
-  return 'sessionFn' in auth
+  if (!auth) return false;
+  return "sessionFn" in auth;
 }
 
 /** Returns true when either the legacy `sessionToken` or the unified static `session` string is used. */
 export function isAnyStaticSession(auth: ApiConfig | undefined): boolean {
-  return isStaticSessionAuth(auth) || isUnifiedStaticSession(auth)
+  return isStaticSessionAuth(auth) || isUnifiedStaticSession(auth);
 }

package/src/lib/cassette.ts

@@ -10,35 +10,35 @@
  * 3. Pass it to `<Replay cassette={...}>` to play it back
  */
 
-import { createUIMessageStream, type ChatTransport, type UIMessage } from 'ai'
-import type { ThreadMessage } from '@assistant-ui/react'
+import { createUIMessageStream, type ChatTransport, type UIMessage } from "ai";
+import type { ThreadMessage } from "@assistant-ui/react";
 
 // ---------------------------------------------------------------------------
 // Cassette types
 // ---------------------------------------------------------------------------
 
-export type CassetteTextPart = { type: 'text'; text: string }
-export type CassetteReasoningPart = { type: 'reasoning'; text: string }
+export type CassetteTextPart = { type: "text"; text: string };
+export type CassetteReasoningPart = { type: "reasoning"; text: string };
 export type CassetteToolCallPart = {
-  type: 'tool-call'
-  toolCallId: string
-  toolName: string
-  args: unknown
-  result?: unknown
-}
+  type: "tool-call";
+  toolCallId: string;
+  toolName: string;
+  args: unknown;
+  result?: unknown;
+};
 
 export type CassettePart =
   | CassetteTextPart
   | CassetteReasoningPart
-  | CassetteToolCallPart
+  | CassetteToolCallPart;
 
 export interface CassetteMessage {
-  role: 'user' | 'assistant'
-  content: CassettePart[]
+  role: "user" | "assistant";
+  content: CassettePart[];
 }
 
 export interface Cassette {
-  messages: CassetteMessage[]
+  messages: CassetteMessage[];
 }
 
 // ---------------------------------------------------------------------------
@@ -47,13 +47,13 @@ export interface Cassette {
 
 export interface ReplayOptions {
   /** Milliseconds per character when streaming text. @default 15 */
-  typingSpeed?: number
+  typingSpeed?: number;
   /** Milliseconds to wait before showing each user message. @default 800 */
-  userMessageDelay?: number
+  userMessageDelay?: number;
   /** Milliseconds to wait before the assistant starts "typing". @default 400 */
-  assistantStartDelay?: number
+  assistantStartDelay?: number;
   /** Called when the full replay sequence finishes. */
-  onComplete?: () => void
+  onComplete?: () => void;
 }
 
 // ---------------------------------------------------------------------------
@@ -65,47 +65,47 @@ export interface ReplayOptions {
  * System messages are filtered out since they aren't displayed.
  */
 export function recordCassette(messages: readonly ThreadMessage[]): Cassette {
-  const cassetteMessages: CassetteMessage[] = []
+  const cassetteMessages: CassetteMessage[] = [];
 
   for (const msg of messages) {
-    if (msg.role === 'system') continue
+    if (msg.role === "system") continue;
 
-    const parts: CassettePart[] = []
+    const parts: CassettePart[] = [];
 
     for (const part of msg.content) {
       switch (part.type) {
-        case 'text':
+        case "text":
           if (part.text) {
-            parts.push({ type: 'text', text: part.text })
+            parts.push({ type: "text", text: part.text });
           }
-          break
-        case 'reasoning':
+          break;
+        case "reasoning":
           if (part.text) {
-            parts.push({ type: 'reasoning', text: part.text })
+            parts.push({ type: "reasoning", text: part.text });
           }
-          break
-        case 'tool-call':
+          break;
+        case "tool-call":
           parts.push({
-            type: 'tool-call',
+            type: "tool-call",
             toolCallId: part.toolCallId,
             toolName: part.toolName,
             args: part.args,
             result: part.result,
-          })
-          break
+          });
+          break;
         // Skip image, file, audio, source, data parts for now
       }
     }
 
     if (parts.length > 0) {
       cassetteMessages.push({
-        role: msg.role as 'user' | 'assistant',
+        role: msg.role as "user" | "assistant",
         content: parts,
-      })
+      });
     }
   }
 
-  return { messages: cassetteMessages }
+  return { messages: cassetteMessages };
 }
 
 // ---------------------------------------------------------------------------
@@ -116,19 +116,19 @@ export function recordCassette(messages: readonly ThreadMessage[]): Cassette {
 function sleep(ms: number, signal?: AbortSignal): Promise<void> {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
-      reject(new DOMException('Aborted', 'AbortError'))
-      return
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
     }
-    const timeout = setTimeout(resolve, ms)
+    const timeout = setTimeout(resolve, ms);
     signal?.addEventListener(
-      'abort',
+      "abort",
       () => {
-        clearTimeout(timeout)
-        reject(new DOMException('Aborted', 'AbortError'))
+        clearTimeout(timeout);
+        reject(new DOMException("Aborted", "AbortError"));
       },
-      { once: true }
-    )
-  })
+      { once: true },
+    );
+  });
 }
 
 /**
@@ -138,14 +138,14 @@ function sleep(ms: number, signal?: AbortSignal): Promise<void> {
  */
 export function createReplayTransport(
   cassette: Cassette,
-  options?: ReplayOptions
+  options?: ReplayOptions,
 ): ChatTransport<UIMessage> {
-  const typingSpeed = options?.typingSpeed ?? 15
-  const assistantStartDelay = options?.assistantStartDelay ?? 400
+  const typingSpeed = options?.typingSpeed ?? 15;
+  const assistantStartDelay = options?.assistantStartDelay ?? 400;
 
   // Cursor tracking which message index to serve next.
   // Starts at 0 and advances past user+assistant pairs.
-  let cursor = 0
+  let cursor = 0;
 
   return {
     sendMessages: async ({ abortSignal }) => {
@@ -153,51 +153,51 @@ export function createReplayTransport(
       // Advance cursor past it (it should be pointing at a user message).
       if (
         cursor < cassette.messages.length &&
-        cassette.messages[cursor].role === 'user'
+        cassette.messages[cursor].role === "user"
       ) {
-        cursor++
+        cursor++;
       }
 
       // Collect the next assistant message(s).
       // Multiple consecutive assistant messages are possible (e.g. multi-step tool calls).
-      const assistantMessages: CassetteMessage[] = []
+      const assistantMessages: CassetteMessage[] = [];
       while (
         cursor < cassette.messages.length &&
-        cassette.messages[cursor].role === 'assistant'
+        cassette.messages[cursor].role === "assistant"
       ) {
-        assistantMessages.push(cassette.messages[cursor])
-        cursor++
+        assistantMessages.push(cassette.messages[cursor]);
+        cursor++;
       }
 
       // Return a stream that emits the pre-recorded content
       return createUIMessageStream({
         execute: async ({ writer }) => {
           if (assistantMessages.length === 0) {
-            return
+            return;
           }
 
           try {
-            await sleep(assistantStartDelay, abortSignal)
+            await sleep(assistantStartDelay, abortSignal);
           } catch {
-            return // aborted
+            return; // aborted
           }
 
           for (const message of assistantMessages) {
             for (const part of message.content) {
               try {
-                await writeReplayPart(writer, part, typingSpeed, abortSignal)
+                await writeReplayPart(writer, part, typingSpeed, abortSignal);
               } catch {
-                return // aborted
+                return; // aborted
               }
             }
           }
         },
-      })
+      });
     },
     reconnectToStream: async () => {
-      return null
+      return null;
     },
-  }
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -206,55 +206,55 @@ export function createReplayTransport(
 
 interface StreamWriter {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  write(part: any): void
+  write(part: any): void;
 }
 
 async function writeReplayPart(
   writer: StreamWriter,
   part: CassettePart,
   typingSpeed: number,
-  abortSignal?: AbortSignal
+  abortSignal?: AbortSignal,
 ): Promise<void> {
   switch (part.type) {
-    case 'text': {
-      const partId = crypto.randomUUID()
-      writer.write({ type: 'text-start', id: partId })
+    case "text": {
+      const partId = crypto.randomUUID();
+      writer.write({ type: "text-start", id: partId });
       for (const char of part.text) {
-        writer.write({ type: 'text-delta', id: partId, delta: char })
-        await sleep(typingSpeed, abortSignal)
+        writer.write({ type: "text-delta", id: partId, delta: char });
+        await sleep(typingSpeed, abortSignal);
       }
-      writer.write({ type: 'text-end', id: partId })
-      break
+      writer.write({ type: "text-end", id: partId });
+      break;
     }
 
-    case 'reasoning': {
-      const partId = crypto.randomUUID()
-      writer.write({ type: 'reasoning-start', id: partId })
+    case "reasoning": {
+      const partId = crypto.randomUUID();
+      writer.write({ type: "reasoning-start", id: partId });
       for (const char of part.text) {
-        writer.write({ type: 'reasoning-delta', id: partId, delta: char })
-        await sleep(typingSpeed, abortSignal)
+        writer.write({ type: "reasoning-delta", id: partId, delta: char });
+        await sleep(typingSpeed, abortSignal);
       }
-      writer.write({ type: 'reasoning-end', id: partId })
-      break
+      writer.write({ type: "reasoning-end", id: partId });
+      break;
     }
 
-    case 'tool-call': {
+    case "tool-call": {
       writer.write({
-        type: 'tool-input-available',
+        type: "tool-input-available",
         toolCallId: part.toolCallId,
         toolName: part.toolName,
         input: part.args,
-      })
+      });
       if (part.result !== undefined) {
         // Brief pause to simulate tool execution
-        await sleep(300, abortSignal)
+        await sleep(300, abortSignal);
         writer.write({
-          type: 'tool-output-available',
+          type: "tool-output-available",
           toolCallId: part.toolCallId,
           output: part.result,
-        })
+        });
       }
-      break
+      break;
     }
   }
 }

package/src/lib/easing.ts

@@ -1 +1 @@
-export const EASE_OUT_QUINT = [0.23, 1, 0.32, 1] as const
+export const EASE_OUT_QUINT = [0.23, 1, 0.32, 1] as const;

package/src/lib/errorTracking.config.ts

@@ -9,8 +9,8 @@
  * - VITE_DATADOG_SITE (optional, defaults to datadoghq.com)
  */
 export const DATADOG_CONFIG = {
-  applicationId: import.meta.env.VITE_DATADOG_APPLICATION_ID ?? '',
-  clientToken: import.meta.env.VITE_DATADOG_CLIENT_TOKEN ?? '',
-  site: import.meta.env.VITE_DATADOG_SITE ?? 'datadoghq.com',
-  service: 'gram-elements',
-} as const
+  applicationId: import.meta.env.VITE_DATADOG_APPLICATION_ID ?? "",
+  clientToken: import.meta.env.VITE_DATADOG_CLIENT_TOKEN ?? "",
+  site: import.meta.env.VITE_DATADOG_SITE ?? "datadoghq.com",
+  service: "gram-elements",
+} as const;