@gram-ai/elements 1.27.4 → 1.27.6

package/src/lib/models.ts

@@ -1,23 +1,31 @@
 // List of openrouter models available to the user
 // This list should be updated to match the model whitelist on the backend side.
 export const MODELS = [
-  'anthropic/claude-opus-4.6',
-  'anthropic/claude-sonnet-4.5',
-  'anthropic/claude-haiku-4.5',
-  'anthropic/claude-sonnet-4',
-  'anthropic/claude-opus-4.5',
-  'openai/gpt-4o',
-  'openai/gpt-4o-mini',
-  'openai/gpt-5.1-codex',
-  'openai/gpt-5',
-  'openai/gpt-5.1',
-  'openai/gpt-4.1',
-  'anthropic/claude-3.7-sonnet',
-  'anthropic/claude-opus-4',
-  'google/gemini-2.5-pro-preview',
-  'google/gemini-3-pro-preview',
-  'moonshotai/kimi-k2',
-  'mistralai/mistral-medium-3',
-  'mistralai/mistral-medium-3.1',
-  'mistralai/codestral-2501',
-] as const
+  "anthropic/claude-opus-4.6",
+  "anthropic/claude-sonnet-4.6",
+  "anthropic/claude-sonnet-4.5",
+  "anthropic/claude-opus-4.5",
+  "anthropic/claude-haiku-4.5",
+  "anthropic/claude-opus-4.1",
+  "anthropic/claude-sonnet-4",
+  "openai/gpt-5.4",
+  "openai/gpt-5.4-mini",
+  "openai/gpt-5.1",
+  "openai/gpt-5.1-codex",
+  "openai/gpt-5",
+  "openai/gpt-4.1",
+  "openai/o4-mini",
+  "openai/o3",
+  "google/gemini-3.1-pro-preview",
+  "google/gemini-2.5-pro",
+  "google/gemini-2.5-flash",
+  "deepseek/deepseek-r1",
+  "deepseek/deepseek-v3.2",
+  "meta-llama/llama-4-maverick",
+  "x-ai/grok-4",
+  "qwen/qwen3-coder",
+  "moonshotai/kimi-k2.5",
+  "mistralai/mistral-medium-3.1",
+  "mistralai/codestral-2508",
+  "mistralai/devstral-small",
+] as const;

package/src/lib/token.test.ts

@@ -1,79 +1,79 @@
-import { describe, expect, it } from 'vitest'
-import { getTokenExpiry, isTokenExpired } from './token'
+import { describe, expect, it } from "vitest";
+import { getTokenExpiry, isTokenExpired } from "./token";
 
 /** Helper: build a JWT with a given payload (no signature verification needed). */
 function makeJwt(payload: Record<string, unknown>): string {
-  const header = btoa(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
-  const body = btoa(JSON.stringify(payload))
-  return `${header}.${body}.fake-signature`
+  const header = btoa(JSON.stringify({ alg: "HS256", typ: "JWT" }));
+  const body = btoa(JSON.stringify(payload));
+  return `${header}.${body}.fake-signature`;
 }
 
-describe('getTokenExpiry', () => {
-  it('returns exp for a valid JWT', () => {
-    const exp = 1700000000
-    expect(getTokenExpiry(makeJwt({ exp }))).toBe(exp)
-  })
+describe("getTokenExpiry", () => {
+  it("returns exp for a valid JWT", () => {
+    const exp = 1700000000;
+    expect(getTokenExpiry(makeJwt({ exp }))).toBe(exp);
+  });
 
-  it('returns null when exp is missing', () => {
-    expect(getTokenExpiry(makeJwt({ sub: 'user' }))).toBeNull()
-  })
+  it("returns null when exp is missing", () => {
+    expect(getTokenExpiry(makeJwt({ sub: "user" }))).toBeNull();
+  });
 
-  it('returns null for a non-JWT string', () => {
-    expect(getTokenExpiry('not-a-jwt')).toBeNull()
-  })
+  it("returns null for a non-JWT string", () => {
+    expect(getTokenExpiry("not-a-jwt")).toBeNull();
+  });
 
-  it('returns null for an empty string', () => {
-    expect(getTokenExpiry('')).toBeNull()
-  })
+  it("returns null for an empty string", () => {
+    expect(getTokenExpiry("")).toBeNull();
+  });
 
-  it('returns null when payload is not valid JSON', () => {
+  it("returns null when payload is not valid JSON", () => {
     // Two dots but the middle segment is not valid base64 JSON
-    expect(getTokenExpiry('a.!!!.b')).toBeNull()
-  })
+    expect(getTokenExpiry("a.!!!.b")).toBeNull();
+  });
 
-  it('handles base64url characters (- and _)', () => {
+  it("handles base64url characters (- and _)", () => {
     // Manually craft a payload with base64url-specific chars
-    const payload = { exp: 1700000000 }
-    const json = JSON.stringify(payload)
+    const payload = { exp: 1700000000 };
+    const json = JSON.stringify(payload);
     const b64 = btoa(json)
-      .replace(/\+/g, '-')
-      .replace(/\//g, '_')
-      .replace(/=+$/, '')
-    const token = `header.${b64}.sig`
-    expect(getTokenExpiry(token)).toBe(1700000000)
-  })
-})
+      .replace(/\+/g, "-")
+      .replace(/\//g, "_")
+      .replace(/=+$/, "");
+    const token = `header.${b64}.sig`;
+    expect(getTokenExpiry(token)).toBe(1700000000);
+  });
+});
 
-describe('isTokenExpired', () => {
-  it('returns true for an expired token', () => {
+describe("isTokenExpired", () => {
+  it("returns true for an expired token", () => {
     // exp = 1 second ago
-    const exp = Math.floor(Date.now() / 1000) - 1
-    expect(isTokenExpired(makeJwt({ exp }))).toBe(true)
-  })
+    const exp = Math.floor(Date.now() / 1000) - 1;
+    expect(isTokenExpired(makeJwt({ exp }))).toBe(true);
+  });
 
-  it('returns true when token is within the buffer window', () => {
+  it("returns true when token is within the buffer window", () => {
     // exp = 20 seconds from now (within 30s default buffer)
-    const exp = Math.floor(Date.now() / 1000) + 20
-    expect(isTokenExpired(makeJwt({ exp }))).toBe(true)
-  })
+    const exp = Math.floor(Date.now() / 1000) + 20;
+    expect(isTokenExpired(makeJwt({ exp }))).toBe(true);
+  });
 
-  it('returns false when token is well outside the buffer', () => {
+  it("returns false when token is well outside the buffer", () => {
     // exp = 5 minutes from now
-    const exp = Math.floor(Date.now() / 1000) + 300
-    expect(isTokenExpired(makeJwt({ exp }))).toBe(false)
-  })
+    const exp = Math.floor(Date.now() / 1000) + 300;
+    expect(isTokenExpired(makeJwt({ exp }))).toBe(false);
+  });
 
-  it('respects a custom buffer', () => {
+  it("respects a custom buffer", () => {
     // exp = 20 seconds from now, buffer = 10s → should NOT be expired
-    const exp = Math.floor(Date.now() / 1000) + 20
-    expect(isTokenExpired(makeJwt({ exp }), 10_000)).toBe(false)
-  })
+    const exp = Math.floor(Date.now() / 1000) + 20;
+    expect(isTokenExpired(makeJwt({ exp }), 10_000)).toBe(false);
+  });
 
-  it('returns false (fail-open) for a non-JWT string', () => {
-    expect(isTokenExpired('opaque-session-token')).toBe(false)
-  })
+  it("returns false (fail-open) for a non-JWT string", () => {
+    expect(isTokenExpired("opaque-session-token")).toBe(false);
+  });
 
-  it('returns false (fail-open) for an empty string', () => {
-    expect(isTokenExpired('')).toBe(false)
-  })
-})
+  it("returns false (fail-open) for an empty string", () => {
+    expect(isTokenExpired("")).toBe(false);
+  });
+});

package/src/lib/token.ts

@@ -5,22 +5,22 @@
  */
 export function getTokenExpiry(token: string): number | null {
   try {
-    const parts = token.split('.')
-    if (parts.length !== 3) return null
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
 
     // base64url → base64 → decode
-    let payload = parts[1].replace(/-/g, '+').replace(/_/g, '/')
-    while (payload.length % 4) payload += '='
+    let payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    while (payload.length % 4) payload += "=";
 
-    const json = atob(payload)
-    const parsed = JSON.parse(json)
+    const json = atob(payload);
+    const parsed = JSON.parse(json);
 
-    if (typeof parsed.exp === 'number') {
-      return parsed.exp
+    if (typeof parsed.exp === "number") {
+      return parsed.exp;
     }
-    return null
+    return null;
   } catch {
-    return null
+    return null;
   }
 }
 
@@ -31,9 +31,9 @@ export function getTokenExpiry(token: string): number | null {
  */
 export function isTokenExpired(
   token: string,
-  bufferMs: number = 30_000
+  bufferMs: number = 30_000,
 ): boolean {
-  const exp = getTokenExpiry(token)
-  if (exp === null) return false // fail-open for non-JWT tokens
-  return Date.now() >= exp * 1000 - bufferMs
+  const exp = getTokenExpiry(token);
+  if (exp === null) return false; // fail-open for non-JWT tokens
+  return Date.now() >= exp * 1000 - bufferMs;
 }

package/src/lib/tool-mentions.ts

@@ -1,106 +1,106 @@
-export type ToolRecord = Record<string, unknown> | undefined
+export type ToolRecord = Record<string, unknown> | undefined;
 
 export interface MentionableTool {
-  id: string
-  name: string
-  description?: string
+  id: string;
+  name: string;
+  description?: string;
 }
 
 export interface MentionContext {
-  isInMention: boolean
-  query: string
-  atPosition: number
+  isInMention: boolean;
+  query: string;
+  atPosition: number;
 }
 
-const MENTION_PATTERN = /@(\w+)/g
+const MENTION_PATTERN = /@(\w+)/g;
 
 export function toolSetToMentionableTools(
-  tools: ToolRecord
+  tools: ToolRecord,
 ): MentionableTool[] {
-  if (!tools) return []
+  if (!tools) return [];
 
   return Object.entries(tools).map(([name, tool]) => ({
     id: name,
     name,
     description:
-      typeof tool === 'object' && tool !== null && 'description' in tool
-        ? String((tool as { description?: unknown }).description ?? '')
+      typeof tool === "object" && tool !== null && "description" in tool
+        ? String((tool as { description?: unknown }).description ?? "")
         : undefined,
-  }))
+  }));
 }
 
 export function parseMentionedTools(text: string, tools: ToolRecord): string[] {
-  if (!tools || !text) return []
+  if (!tools || !text) return [];
 
-  const toolNames = Object.keys(tools)
-  const mentions: string[] = []
-  let match: RegExpExecArray | null
+  const toolNames = Object.keys(tools);
+  const mentions: string[] = [];
+  let match: RegExpExecArray | null;
 
-  MENTION_PATTERN.lastIndex = 0
+  MENTION_PATTERN.lastIndex = 0;
   while ((match = MENTION_PATTERN.exec(text)) !== null) {
-    mentions.push(match[1].toLowerCase())
+    mentions.push(match[1].toLowerCase());
   }
 
   const matchedToolIds = toolNames.filter((name) =>
-    mentions.includes(name.toLowerCase())
-  )
+    mentions.includes(name.toLowerCase()),
+  );
 
-  return [...new Set(matchedToolIds)]
+  return [...new Set(matchedToolIds)];
 }
 
 export function detectMentionContext(
   text: string,
-  cursorPosition: number
+  cursorPosition: number,
 ): MentionContext {
-  const textBeforeCursor = text.slice(0, cursorPosition)
-  const lastAtSymbol = textBeforeCursor.lastIndexOf('@')
+  const textBeforeCursor = text.slice(0, cursorPosition);
+  const lastAtSymbol = textBeforeCursor.lastIndexOf("@");
 
   if (lastAtSymbol === -1) {
-    return { isInMention: false, query: '', atPosition: -1 }
+    return { isInMention: false, query: "", atPosition: -1 };
   }
 
-  const textAfterAt = textBeforeCursor.slice(lastAtSymbol + 1)
+  const textAfterAt = textBeforeCursor.slice(lastAtSymbol + 1);
 
-  if (textAfterAt.includes(' ') || textAfterAt.includes('\n')) {
-    return { isInMention: false, query: '', atPosition: -1 }
+  if (textAfterAt.includes(" ") || textAfterAt.includes("\n")) {
+    return { isInMention: false, query: "", atPosition: -1 };
   }
 
   return {
     isInMention: true,
     query: textAfterAt.toLowerCase(),
     atPosition: lastAtSymbol,
-  }
+  };
 }
 
 export function filterToolsByQuery(
   tools: MentionableTool[],
-  query: string
+  query: string,
 ): MentionableTool[] {
-  if (!query) return tools
+  if (!query) return tools;
 
-  const queryLower = query.toLowerCase()
+  const queryLower = query.toLowerCase();
 
   return tools.filter((tool) => {
-    const nameMatch = tool.name.toLowerCase().includes(queryLower)
-    const descMatch = tool.description?.toLowerCase().includes(queryLower)
-    return nameMatch || descMatch
-  })
+    const nameMatch = tool.name.toLowerCase().includes(queryLower);
+    const descMatch = tool.description?.toLowerCase().includes(queryLower);
+    return nameMatch || descMatch;
+  });
 }
 
 export function insertToolMention(
   text: string,
   toolName: string,
   atPosition: number,
-  cursorPosition: number
+  cursorPosition: number,
 ): { text: string; cursorPosition: number } {
-  const beforeMention = text.slice(0, atPosition)
-  const afterCursor = text.slice(cursorPosition)
-  const newText = `${beforeMention}@${toolName} ${afterCursor}`
-  const newCursorPosition = atPosition + toolName.length + 2
-  return { text: newText, cursorPosition: newCursorPosition }
+  const beforeMention = text.slice(0, atPosition);
+  const afterCursor = text.slice(cursorPosition);
+  const newText = `${beforeMention}@${toolName} ${afterCursor}`;
+  const newCursorPosition = atPosition + toolName.length + 2;
+  return { text: newText, cursorPosition: newCursorPosition };
 }
 
 export function removeToolMention(text: string, toolName: string): string {
-  const pattern = new RegExp(`@${toolName}\\s?`, 'gi')
-  return text.replace(pattern, '')
+  const pattern = new RegExp(`@${toolName}\\s?`, "gi");
+  return text.replace(pattern, "");
 }