@gram-ai/elements 1.33.1 → 1.34.0

package/src/contexts/ElementsProvider.tsx

@@ -67,6 +67,19 @@ import { ElementsContext } from "./contexts";
 import { ToolApprovalProvider } from "./ToolApprovalContext";
 import { ToolExecutionProvider } from "./ToolExecutionContext";
 
+// Reads the active local thread id from the runtime's threads store. Reaches
+// into an assistant-ui internal that isn't part of the public type, so it's
+// isolated here as the single point of breakage if the API moves.
+function getActiveLocalThreadId(
+  runtimeRef: React.RefObject<ReturnType<typeof useChatRuntime> | null>,
+): string | undefined {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const threadsState = (runtimeRef.current as any)?.threads?.getState?.();
+  return (threadsState?.mainThreadId ?? threadsState?.threadIds?.[0]) as
+    | string
+    | undefined;
+}
+
 /**
  * Extracts executable tools from frontend tool definitions.
  * Frontend tools created via defineFrontendTool have an unstable_tool property
@@ -276,8 +289,10 @@ const ElementsProviderInner = ({ children, config }: ElementsProviderProps) => {
   // in a way that's accessible from the transport's sendMessages function.
   const currentRemoteIdRef = useRef<string | null>(null);
 
-  // Create chat transport configuration
-  const transport = useMemo<ChatTransport<UIMessage>>(
+  // Create chat transport configuration. This is the built-in client-side
+  // streaming transport; a consumer can override it via config.transport (see
+  // below) to route the conversation through a server-side assistant instead.
+  const defaultTransport = useMemo<ChatTransport<UIMessage>>(
     () => ({
       sendMessages: async ({ messages, abortSignal }) => {
         const usingCustomModel = !!config.languageModel;
@@ -298,12 +313,7 @@ const ElementsProviderInner = ({ children, config }: ElementsProviderProps) => {
           // chatId is already set correctly from the synced ref
         } else if (isLocalThreadId(chatId) || !chatId) {
           // For local thread IDs or no ID, check/generate UUID mapping
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const runtimeAny = runtimeRef.current as any;
-          const threadsState = runtimeAny?.threads?.getState?.();
-          const localThreadId = (threadsState?.mainThreadId ??
-            threadsState?.threadIds?.[0]) as string | undefined;
-
+          const localThreadId = getActiveLocalThreadId(runtimeRef);
           const lookupKey = chatId ?? localThreadId;
           if (lookupKey) {
             const existingUuid = localIdToUuidMapRef.current.get(lookupKey);
@@ -521,6 +531,43 @@ const ElementsProviderInner = ({ children, config }: ElementsProviderProps) => {
     ],
   );
 
+  // A consumer-supplied transport (e.g. a server-side assistant transport) takes
+  // precedence over the built-in client-side one. It may be a ChatTransport or a
+  // factory: a factory is invoked here, inside the provider, with a getChatId()
+  // sourced from the synced thread state, so the transport can read the active
+  // chat id at send time without reaching into Elements internals. Local
+  // (unpersisted) thread ids read as null so the transport can treat them as a
+  // brand-new conversation.
+  const getChatId = useCallback(() => {
+    const id = currentRemoteIdRef.current;
+    return id && !isLocalThreadId(id) ? id : null;
+  }, []);
+  // Capture the active local thread identity now and return a bind function
+  // closing over it. Consumer transports call this at the start of
+  // `sendMessages`; once a server-minted chat id is known, invoking the
+  // returned function reconciles the captured thread to it — the same
+  // reconciliation the built-in transport does inline when it generates an id.
+  // Closing over the captured id (instead of re-reading active state at bind
+  // time) is what makes a thread switch or a parallel send on another thread
+  // during the round-trip safe.
+  const adoptChatId = useCallback(() => {
+    const capturedLocalThreadId = getActiveLocalThreadId(runtimeRef);
+    return (chatId: string) => {
+      if (capturedLocalThreadId) {
+        localIdToUuidMapRef.current.set(capturedLocalThreadId, chatId);
+      }
+      currentRemoteIdRef.current = chatId;
+      mcpHeaders["Gram-Chat-ID"] = chatId;
+      setCurrentChatId(chatId);
+    };
+  }, [mcpHeaders, setCurrentChatId]);
+  const transport = useMemo<ChatTransport<UIMessage>>(() => {
+    if (typeof config.transport === "function") {
+      return config.transport({ getChatId, adoptChatId });
+    }
+    return config.transport ?? defaultTransport;
+  }, [config.transport, defaultTransport, getChatId, adoptChatId]);
+
   const historyEnabled = config.history?.enabled ?? false;
 
   // Shared context value for ElementsContext
@@ -658,6 +705,8 @@ const ElementsProviderWithHistory = ({
     apiUrl,
     headers,
     localIdToUuidMap,
+    threadListFilters: contextValue?.config.history?.threadListFilters,
+    deferThreadIdMinting: contextValue?.config.history?.deferThreadIdMinting,
   });
   const initialThreadId = contextValue?.config.history?.initialThreadId;
 

package/src/hooks/useAuth.ts

@@ -125,6 +125,14 @@ export const useAuth = ({
 
   const shouldRefresh = !isAnyStaticSession(auth) && !isReplay;
 
+  // `api.headers` from ElementsConfig flows here untouched and is merged into
+  // every header set the hook returns, so it reaches both /chat/completions
+  // (via the OpenRouter model in ElementsProvider) AND /mcp/{slug} (via
+  // useMCPTools). Today the dashboard uses this to forward
+  // `Authorization: Bearer <user-session JWT>` so the runtime gateway can
+  // resolve the user's upstream credentials for issuer-gated toolsets.
+  const extraHeaders = auth?.headers ?? {};
+
   const ensureValidHeaders = useCallback(async (): Promise<
     Record<string, string>
   > => {
@@ -133,6 +141,7 @@ export const useAuth = ({
 
     if (!shouldRefresh || !getSession) {
       return {
+        ...extraHeaders,
         "Gram-Project": projectSlug,
         ...(cachedToken && { "Gram-Chat-Session": cachedToken }),
       };
@@ -151,16 +160,18 @@ export const useAuth = ({
         staleTime,
       });
       return {
+        ...extraHeaders,
         "Gram-Project": projectSlug,
         ...(token && { "Gram-Chat-Session": token }),
       };
     } catch {
       return {
+        ...extraHeaders,
         "Gram-Project": projectSlug,
         ...(cachedToken && { "Gram-Chat-Session": cachedToken }),
       };
     }
-  }, [shouldRefresh, getSession, projectSlug, queryClient]);
+  }, [shouldRefresh, getSession, projectSlug, queryClient, extraHeaders]);
 
   // In replay mode, return immediately without waiting for session
   if (isReplay) {
@@ -178,6 +189,7 @@ export const useAuth = ({
       }
     : {
         headers: {
+          ...extraHeaders,
           "Gram-Project": projectSlug,
           "Gram-Chat-Session": session,
         },

package/src/hooks/useGramThreadListAdapter.tsx

@@ -13,6 +13,7 @@ import {
   convertGramMessagesToExported,
   convertGramMessagesToUIMessages,
 } from "@/lib/messageConverter";
+import { sleep } from "@/lib/utils";
 import {
   useCallback,
   useEffect,
@@ -37,11 +38,46 @@ export function isLocalThreadId(threadId: string | null | undefined): boolean {
   return !!threadId?.startsWith(LOCAL_THREAD_ID_PREFIX);
 }
 
+/**
+ * Polls the shared local→remote id map until the transport assigns an id for
+ * `threadId`, or a deadline passes. Used in deferred-minting mode so a new
+ * thread adopts the backend-minted chat id instead of a client-generated one.
+ * The timeout is generous to tolerate cold serverless boots on the first send.
+ */
+async function waitForMappedId(
+  map: Map<string, string> | undefined,
+  threadId: string,
+  timeoutMs = 30_000,
+  intervalMs = 50,
+): Promise<string | undefined> {
+  if (!map) return undefined;
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const id = map.get(threadId);
+    if (id) return id;
+    if (Date.now() >= deadline) return undefined;
+    await sleep(intervalMs);
+  }
+}
+
 export interface ThreadListAdapterOptions {
   apiUrl: string;
   headers: Record<string, string>;
   /** Map to translate local thread IDs to UUIDs (shared with transport) */
   localIdToUuidMap?: Map<string, string>;
+  /**
+   * Extra query parameters forwarded to `chat.list` to filter which threads are
+   * listed. Opaque to the adapter — the consumer chooses the keys.
+   */
+  threadListFilters?: Record<string, string>;
+  /**
+   * Don't client-mint a chat id for a brand-new thread. When true, `initialize`
+   * waits for the transport to assign the id (via the shared `localIdToUuidMap`,
+   * e.g. a server-minted id reported through the transport context's
+   * `adoptChatId` bind closure) instead of generating one with
+   * `crypto.randomUUID()`. Use this when the backend owns chat-id creation.
+   */
+  deferThreadIdMinting?: boolean;
 }
 
 interface ListChatsResponse {
@@ -213,12 +249,14 @@ export function useGramThreadListAdapter(
 
       async list() {
         try {
-          const response = await fetch(
-            `${optionsRef.current.apiUrl}/rpc/chat.list`,
-            {
-              headers: optionsRef.current.headers,
-            },
-          );
+          const { apiUrl, headers, threadListFilters } = optionsRef.current;
+          const qs = threadListFilters
+            ? new URLSearchParams(threadListFilters).toString()
+            : "";
+          const listUrl = qs
+            ? `${apiUrl}/rpc/chat.list?${qs}`
+            : `${apiUrl}/rpc/chat.list`;
+          const response = await fetch(listUrl, { headers });
 
           if (!response.ok) {
             console.error("Failed to list chats:", response.status);
@@ -252,6 +290,30 @@ export function useGramThreadListAdapter(
               externalId: existingUuid,
             };
           }
+          // When the backend owns chat-id creation, don't client-mint: wait for
+          // the transport to report the server-minted id (it assigns it during
+          // the first send via the adoptChatId bind closure, populating the
+          // shared map — the same path the built-in transport uses).
+          if (optionsRef.current.deferThreadIdMinting) {
+            const mappedUuid = await waitForMappedId(
+              optionsRef.current.localIdToUuidMap,
+              threadId,
+            );
+            if (mappedUuid) {
+              return {
+                remoteId: mappedUuid,
+                externalId: mappedUuid,
+              };
+            }
+            // Falling through to crypto.randomUUID() here would defeat deferred
+            // minting: the client id would race the server-minted one reported
+            // later via the adoptChatId bind closure, leaving runtime state
+            // and the local→remote map disagreeing. Surface the failure to
+            // the user instead.
+            throw new Error(
+              "Backend did not mint a chat id in time — first send may have failed or is still in flight. Retry the send.",
+            );
+          }
           // Otherwise generate a new one and store it
           const uuid = crypto.randomUUID();
           optionsRef.current.localIdToUuidMap?.set(threadId, uuid);

package/src/index.ts

@@ -56,6 +56,8 @@ export type {
   Dimension,
   Dimensions,
   ElementsConfig,
+  ElementsTransportContext,
+  ElementsTransportFactory,
   ErrorTrackingConfigOption,
   GetSessionFn,
   HistoryConfig,
@@ -80,6 +82,20 @@ export type {
 
 export { MODELS } from "./lib/models";
 
+// Chat-message conversion — for consumers building a custom transport against
+// the Gram chat service (e.g. the dashboard's server-assistant transport).
+export {
+  convertGramMessagesToUIMessages,
+  convertGramMessagesToExported,
+} from "@/lib/messageConverter";
+
+export { sleep } from "@/lib/utils";
+export type {
+  GramChat,
+  GramChatMessage,
+  GramChatOverview,
+} from "@/lib/messageConverter";
+
 export type { Plugin } from "./types/plugins";
 
 // Time Range Picker

package/src/lib/cassette.ts

@@ -12,6 +12,7 @@
 
 import { createUIMessageStream, type ChatTransport, type UIMessage } from "ai";
 import type { ThreadMessage } from "@assistant-ui/react";
+import { sleep } from "@/lib/utils";
 
 // ---------------------------------------------------------------------------
 // Cassette types
@@ -112,25 +113,6 @@ export function recordCassette(messages: readonly ThreadMessage[]): Cassette {
 // Playback: Cassette → ChatTransport
 // ---------------------------------------------------------------------------
 
-/** Sleep that respects AbortSignal for clean cancellation. */
-function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new DOMException("Aborted", "AbortError"));
-      return;
-    }
-    const timeout = setTimeout(resolve, ms);
-    signal?.addEventListener(
-      "abort",
-      () => {
-        clearTimeout(timeout);
-        reject(new DOMException("Aborted", "AbortError"));
-      },
-      { once: true },
-    );
-  });
-}
-
 /**
  * Creates a ChatTransport that replays pre-recorded assistant messages
  * from a cassette. Each call to `sendMessages` (triggered by a user message

package/src/lib/contextCompaction.test.ts

@@ -38,8 +38,8 @@ describe("getModelContextLimit", () => {
     expect(getModelContextLimit("anthropic/claude-sonnet-4.6")).toBe(1_000_000);
   });
 
-  it("returns known mapping for Claude 4 (non-1M)", () => {
-    expect(getModelContextLimit("anthropic/claude-sonnet-4")).toBe(200_000);
+  it("returns known mapping for Claude Sonnet 4", () => {
+    expect(getModelContextLimit("anthropic/claude-sonnet-4")).toBe(1_000_000);
   });
 
   it("returns DEFAULT_CONTEXT_LIMIT for unknown models", () => {

package/src/lib/contextCompaction.ts

@@ -32,39 +32,51 @@ export const DEFAULT_CONTEXT_LIMIT = 200_000;
  */
 const MODEL_CONTEXT_LIMITS: Partial<Record<KnownModelId, number>> = {
   // Anthropic (1M tier where available, else 200K)
+  "anthropic/claude-opus-4.8": 1_000_000,
+  "anthropic/claude-opus-4.7": 1_000_000,
   "anthropic/claude-opus-4.6": 1_000_000,
-  "anthropic/claude-opus-4.5": 1_000_000,
-  "anthropic/claude-opus-4.1": 200_000,
+  "anthropic/claude-opus-4.5": 200_000,
   "anthropic/claude-sonnet-4.6": 1_000_000,
   "anthropic/claude-sonnet-4.5": 1_000_000,
-  "anthropic/claude-sonnet-4": 200_000,
+  "anthropic/claude-sonnet-4": 1_000_000,
   "anthropic/claude-haiku-4.5": 200_000,
 
   // OpenAI
-  "openai/gpt-5.4": 400_000,
+  "openai/gpt-5.5": 1_000_000,
+  "openai/gpt-5.5-pro": 1_000_000,
+  "openai/gpt-5.4": 1_000_000,
   "openai/gpt-5.4-mini": 400_000,
+  "openai/gpt-5.4-nano": 400_000,
+  "openai/gpt-5.3-codex": 400_000,
   "openai/gpt-5.1": 400_000,
-  "openai/gpt-5.1-codex": 400_000,
   "openai/gpt-5": 400_000,
   "openai/gpt-4.1": 1_000_000,
   "openai/o4-mini": 200_000,
   "openai/o3": 200_000,
 
   // Google
+  "google/gemini-3.5-flash": 1_000_000,
   "google/gemini-3.1-pro-preview": 1_000_000,
+  "google/gemini-3.1-flash-lite": 1_000_000,
   "google/gemini-2.5-pro": 1_000_000,
   "google/gemini-2.5-flash": 1_000_000,
 
   // Others
+  "deepseek/deepseek-v4-pro": 1_000_000,
+  "deepseek/deepseek-v4-flash": 1_000_000,
   "deepseek/deepseek-r1": 128_000,
   "deepseek/deepseek-v3.2": 128_000,
   "meta-llama/llama-4-maverick": 1_000_000,
-  "x-ai/grok-4": 256_000,
+  "x-ai/grok-4.3": 1_000_000,
+  "x-ai/grok-4.20": 2_000_000,
+  "qwen/qwen3.7-max": 1_000_000,
   "qwen/qwen3-coder": 256_000,
-  "moonshotai/kimi-k2.5": 128_000,
+  "moonshotai/kimi-k2.6": 256_000,
+  "moonshotai/kimi-k2.5": 256_000,
+  "mistralai/mistral-medium-3-5": 256_000,
   "mistralai/mistral-medium-3.1": 128_000,
   "mistralai/codestral-2508": 256_000,
-  "mistralai/devstral-small": 128_000,
+  "mistralai/devstral-2512": 256_000,
 };
 
 /**

package/src/lib/messageConverter.ts

@@ -19,23 +19,69 @@ import type {
   ThreadAssistantMessagePart,
   TextMessagePart,
 } from "@assistant-ui/react";
-import type {
-  Message,
-  UserMessage,
-  AssistantMessage,
-  ToolResponseMessage,
-} from "@openrouter/sdk/models";
 import { UIMessage } from "ai";
 
 /**
- * Represents a chat message from the Gram API.
- * This mirrors the ChatMessage type from @gram/sdk without requiring the SDK dependency.
+ * A single text part of a multi-modal chat message.
+ */
+export interface GramChatTextPart {
+  type: "text";
+  text: string;
+}
+
+/**
+ * A single image part of a multi-modal chat message. The wire shape mirrors the
+ * upstream OpenAI/OpenRouter chat schema (`image_url.url`) so the converter can
+ * read it without normalisation.
+ */
+export interface GramChatImagePart {
+  type: "image_url";
+  image_url?: { url?: string };
+}
+
+/**
+ * A single audio part of a multi-modal chat message. Mirrors the OpenAI/OpenRouter
+ * `input_audio.{data, format}` shape on the wire.
+ */
+export interface GramChatAudioPart {
+  type: "input_audio";
+  input_audio?: { data?: string; format?: string };
+}
+
+/**
+ * Content part of a multi-modal chat message.
+ */
+export type GramChatContentPart =
+  | GramChatTextPart
+  | GramChatImagePart
+  | GramChatAudioPart;
+
+/**
+ * Content of a chat message — either a plain string or an array of parts for
+ * multi-modal messages.
+ */
+export type GramChatContent = string | GramChatContentPart[];
+
+/**
+ * Represents a chat message from the Gram API. Only fields actually surfaced
+ * through Elements' public converters are modelled; provider-specific extras
+ * remain on the wire shape but are intentionally not part of the contract.
+ *
+ * `tool_calls` is the JSON-encoded string the Gram chat service stores on
+ * assistant rows; `tool_call_id` is the id the corresponding tool-response row
+ * carries when `role === "tool"`.
  */
-export type GramChatMessage = Message & {
+export interface GramChatMessage {
   id: string;
   model: string;
   created_at: Date | string;
-};
+  role: "system" | "developer" | "user" | "assistant" | "tool";
+  content?: GramChatContent | null;
+  name?: string;
+  tool_calls?: string;
+  tool_call_id?: string;
+  reasoning?: string | null;
+}
 
 /**
  * Represents a chat from the Gram API.
@@ -96,29 +142,23 @@ function buildUserContentParts(msg: GramChatMessage): ThreadUserMessagePart[] {
           text: item.text,
         });
         break;
-      case "image_url":
+      case "image_url": {
+        const url = item.image_url?.url ?? "";
         parts.push({
           type: "image",
-          image: (item as any).image_url?.url as FIXME<
-            string,
-            "Fixed by switching to Gram TS SDK."
-          >,
+          image: url,
         });
         break;
+      }
       case "input_audio": {
-        const format = (item as any).input_audio?.format as FIXME<
-          string,
-          "Fixed by switching to Gram TS SDK."
-        >;
-        if (format === "mp3" || format === "wav") {
+        const format = item.input_audio?.format;
+        const data = item.input_audio?.data;
+        if ((format === "mp3" || format === "wav") && data) {
           parts.push({
             type: "audio",
             audio: {
-              data: (item as any).input_audio.data as FIXME<
-                string,
-                "Fixed by switching to Gram TS SDK."
-              >,
-              format: format,
+              data,
+              format,
             },
           });
         }
@@ -155,12 +195,7 @@ function buildAssistantContentParts(
     });
   }
 
-  const toolCallsJSON = (msg as any).tool_calls as FIXME<
-    string | undefined,
-    "Fixed by switching to Gram TS SDK."
-  >;
-
-  let toolCalls = tryParseJSON(toolCallsJSON || "[]");
+  let toolCalls = tryParseJSON(msg.tool_calls || "[]");
   if (!Array.isArray(toolCalls)) {
     console.warn("Invalid tool_calls format, expected an array.");
     toolCalls = [];
@@ -280,8 +315,10 @@ function convertGramMessageToThreadMessage(
  * Converts an array of Gram ChatMessages to an ExportedMessageRepository.
  * Creates parent-child relationships based on message order.
  *
- * Note: System messages are filtered out because assistant-ui's
- * `fromThreadMessageLike` doesn't support them in the exported format.
+ * Note: system, developer, and tool messages are filtered out. assistant-ui's
+ * exported format only models user/assistant turns; system/developer rows are
+ * pre-prompt instructions the UI doesn't render, and tool rows are folded into
+ * the preceding assistant message as `tool-call` parts via `tool_calls`.
  */
 export function convertGramMessagesToExported(
   messages: GramChatMessage[],
@@ -294,8 +331,11 @@ export function convertGramMessagesToExported(
   let prevId: string | null = null;
 
   for (const msg of messages) {
-    // Skip system messages - they're not supported in the exported message format
-    if (msg.role === "system") {
+    if (
+      msg.role === "system" ||
+      msg.role === "developer" ||
+      msg.role === "tool"
+    ) {
       continue;
     }
 
@@ -322,17 +362,17 @@ export function convertGramMessagesToUIMessages(messages: GramChatMessage[]): {
     return { messages: [], headId: null };
   }
 
-  const toolCallResults = new Map<string, ToolResponseMessage>();
+  const toolCallResults = new Map<string, GramChatMessage>();
   for (const msg of messages) {
     if (msg.role !== "tool") {
       continue;
     }
-    const id = (msg as any).tool_call_id;
+    const id = msg.tool_call_id;
     if (typeof id !== "string") {
       continue;
     }
 
-    toolCallResults.set(id, msg as ToolResponseMessage);
+    toolCallResults.set(id, msg);
   }
 
   const uiMessages: { parentId: string | null; message: UIMessage }[] = [];
@@ -415,9 +455,19 @@ export function convertGramMessagesToUIMessages(messages: GramChatMessage[]): {
   };
 }
 
+/**
+ * Parsed shape of a single entry inside an assistant message's `tool_calls`
+ * JSON string. Mirrors the OpenAI/OpenRouter tool-call wire format.
+ */
+interface GramToolCall {
+  id: string;
+  type?: "function";
+  function?: { name?: string; arguments?: string | Record<string, unknown> };
+}
+
 export function convertGramMessagePartsToUIMessageParts(
-  msg: UserMessage | AssistantMessage,
-  toolResults: Map<string, ToolResponseMessage>,
+  msg: GramChatMessage,
+  toolResults: Map<string, GramChatMessage>,
   seenToolCallIds?: Set<string>,
 ): UIMessage["parts"] {
   const uiparts: UIMessage["parts"] = [];
@@ -440,10 +490,7 @@ export function convertGramMessagePartsToUIMessageParts(
         break;
       }
       case "image_url": {
-        const url = (p as any).image_url?.url as FIXME<
-          string | undefined,
-          "Fixed by switching to Gram TS SDK."
-        >;
+        const url = p.image_url?.url;
         if (!url) {
           break;
         }
@@ -456,10 +503,7 @@ export function convertGramMessagePartsToUIMessageParts(
         break;
       }
       case "input_audio": {
-        const url = (p as any).input_audio?.data as FIXME<
-          string | undefined,
-          "Fixed by switching to Gram TS SDK."
-        >;
+        const url = p.input_audio?.data;
         if (!url) {
           break;
         }
@@ -481,14 +525,8 @@ export function convertGramMessagePartsToUIMessageParts(
     });
   }
 
-  if (msg.role === "assistant" && (msg as any).tool_calls) {
-    const toolCallsJSON = (msg as any).tool_calls as FIXME<
-      string,
-      "Fixed by switching to Gram TS SDK."
-    >;
-    let toolCalls = tryParseJSON<AssistantMessage["toolCalls"]>(
-      toolCallsJSON || "[]",
-    );
+  if (msg.role === "assistant" && msg.tool_calls) {
+    let toolCalls = tryParseJSON<GramToolCall[]>(msg.tool_calls || "[]");
     if (!Array.isArray(toolCalls)) {
       console.warn("Invalid tool_calls format, expected an array.");
       toolCalls = [];