@tanstack/ai-grok 0.0.1 → 0.1.0

package/dist/esm/model-meta.d.ts

@@ -0,0 +1,223 @@
+declare const GROK_4_1_FAST_REASONING: {
+    readonly name: "grok-4-1-fast-reasoning";
+    readonly context_window: 2000000;
+    readonly supports: {
+        readonly input: ["text", "image"];
+        readonly output: ["text"];
+        readonly capabilities: ["reasoning", "structured_outputs", "tool_calling"];
+    };
+    readonly pricing: {
+        readonly input: {
+            readonly normal: 0.2;
+            readonly cached: 0.05;
+        };
+        readonly output: {
+            readonly normal: 0.5;
+        };
+    };
+};
+declare const GROK_4_1_FAST_NON_REASONING: {
+    readonly name: "grok-4-1-fast-non-reasoning";
+    readonly context_window: 2000000;
+    readonly supports: {
+        readonly input: ["text", "image"];
+        readonly output: ["text"];
+        readonly capabilities: ["structured_outputs", "tool_calling"];
+    };
+    readonly pricing: {
+        readonly input: {
+            readonly normal: 0.2;
+            readonly cached: 0.05;
+        };
+        readonly output: {
+            readonly normal: 0.5;
+        };
+    };
+};
+declare const GROK_CODE_FAST_1: {
+    readonly name: "grok-code-fast-1";
+    readonly context_window: 256000;
+    readonly supports: {
+        readonly input: ["text"];
+        readonly output: ["text"];
+        readonly capabilities: ["reasoning", "structured_outputs", "tool_calling"];
+    };
+    readonly pricing: {
+        readonly input: {
+            readonly normal: 0.2;
+            readonly cached: 0.02;
+        };
+        readonly output: {
+            readonly normal: 1.5;
+        };
+    };
+};
+declare const GROK_4_FAST_REASONING: {
+    readonly name: "grok-4-fast-reasoning";
+    readonly context_window: 2000000;
+    readonly supports: {
+        readonly input: ["text", "image"];
+        readonly output: ["text"];
+        readonly capabilities: ["reasoning", "structured_outputs", "tool_calling"];
+    };
+    readonly pricing: {
+        readonly input: {
+            readonly normal: 0.2;
+            readonly cached: 0.05;
+        };
+        readonly output: {
+            readonly normal: 0.5;
+        };
+    };
+};
+declare const GROK_4_FAST_NON_REASONING: {
+    readonly name: "grok-4-fast-non-reasoning";
+    readonly context_window: 2000000;
+    readonly supports: {
+        readonly input: ["text", "image"];
+        readonly output: ["text"];
+        readonly capabilities: ["structured_outputs", "tool_calling"];
+    };
+    readonly pricing: {
+        readonly input: {
+            readonly normal: 0.2;
+            readonly cached: 0.05;
+        };
+        readonly output: {
+            readonly normal: 0.5;
+        };
+    };
+};
+declare const GROK_4: {
+    readonly name: "grok-4";
+    readonly context_window: 256000;
+    readonly supports: {
+        readonly input: ["text", "image"];
+        readonly output: ["text"];
+        readonly capabilities: ["reasoning", "structured_outputs", "tool_calling"];
+    };
+    readonly pricing: {
+        readonly input: {
+            readonly normal: 3;
+            readonly cached: 0.75;
+        };
+        readonly output: {
+            readonly normal: 15;
+        };
+    };
+};
+declare const GROK_3_MINI: {
+    readonly name: "grok-3-mini";
+    readonly context_window: 131072;
+    readonly supports: {
+        readonly input: ["text"];
+        readonly output: ["text"];
+        readonly capabilities: ["reasoning", "structured_outputs", "tool_calling"];
+    };
+    readonly pricing: {
+        readonly input: {
+            readonly normal: 0.3;
+            readonly cached: 0.075;
+        };
+        readonly output: {
+            readonly normal: 0.5;
+        };
+    };
+};
+declare const GROK_3: {
+    readonly name: "grok-3";
+    readonly context_window: 131072;
+    readonly supports: {
+        readonly input: ["text"];
+        readonly output: ["text"];
+        readonly capabilities: ["structured_outputs", "tool_calling"];
+    };
+    readonly pricing: {
+        readonly input: {
+            readonly normal: 3;
+            readonly cached: 0.75;
+        };
+        readonly output: {
+            readonly normal: 15;
+        };
+    };
+};
+declare const GROK_2_VISION: {
+    readonly name: "grok-2-vision-1212";
+    readonly context_window: 32768;
+    readonly supports: {
+        readonly input: ["text", "image"];
+        readonly output: ["text"];
+        readonly capabilities: ["structured_outputs", "tool_calling"];
+    };
+    readonly pricing: {
+        readonly input: {
+            readonly normal: 2;
+        };
+        readonly output: {
+            readonly normal: 10;
+        };
+    };
+};
+/**
+ * Grok Chat Models
+ * Based on xAI's available models as of 2025
+ */
+export declare const GROK_CHAT_MODELS: readonly ["grok-4-1-fast-reasoning", "grok-4-1-fast-non-reasoning", "grok-code-fast-1", "grok-4-fast-reasoning", "grok-4-fast-non-reasoning", "grok-4", "grok-3", "grok-3-mini", "grok-2-vision-1212"];
+/**
+ * Grok Image Generation Models
+ */
+export declare const GROK_IMAGE_MODELS: readonly ["grok-2-image-1212"];
+/**
+ * Type-only map from Grok chat model name to its supported input modalities.
+ * Used for type inference when constructing multimodal messages.
+ */
+export type GrokModelInputModalitiesByName = {
+    [GROK_4_1_FAST_REASONING.name]: typeof GROK_4_1_FAST_REASONING.supports.input;
+    [GROK_4_1_FAST_NON_REASONING.name]: typeof GROK_4_1_FAST_NON_REASONING.supports.input;
+    [GROK_CODE_FAST_1.name]: typeof GROK_CODE_FAST_1.supports.input;
+    [GROK_4_FAST_REASONING.name]: typeof GROK_4_FAST_REASONING.supports.input;
+    [GROK_4_FAST_NON_REASONING.name]: typeof GROK_4_FAST_NON_REASONING.supports.input;
+    [GROK_4.name]: typeof GROK_4.supports.input;
+    [GROK_3.name]: typeof GROK_3.supports.input;
+    [GROK_3_MINI.name]: typeof GROK_3_MINI.supports.input;
+    [GROK_2_VISION.name]: typeof GROK_2_VISION.supports.input;
+};
+/**
+ * Type-only map from Grok chat model name to its provider options type.
+ * Since Grok uses OpenAI-compatible API, we reuse OpenAI provider options.
+ */
+export type GrokChatModelProviderOptionsByName = {
+    [K in (typeof GROK_CHAT_MODELS)[number]]: GrokProviderOptions;
+};
+/**
+ * Grok-specific provider options
+ * Based on OpenAI-compatible API options
+ */
+export interface GrokProviderOptions {
+    /** Temperature for response generation (0-2) */
+    temperature?: number;
+    /** Maximum tokens in the response */
+    max_tokens?: number;
+    /** Top-p sampling parameter */
+    top_p?: number;
+    /** Frequency penalty (-2.0 to 2.0) */
+    frequency_penalty?: number;
+    /** Presence penalty (-2.0 to 2.0) */
+    presence_penalty?: number;
+    /** Stop sequences */
+    stop?: string | Array<string>;
+    /** A unique identifier representing your end-user */
+    user?: string;
+}
+/**
+ * Resolve provider options for a specific model.
+ * If the model has explicit options in the map, use those; otherwise use base options.
+ */
+export type ResolveProviderOptions<TModel extends string> = TModel extends keyof GrokChatModelProviderOptionsByName ? GrokChatModelProviderOptionsByName[TModel] : GrokProviderOptions;
+/**
+ * Resolve input modalities for a specific model.
+ * If the model has explicit modalities in the map, use those; otherwise use text only.
+ */
+export type ResolveInputModalities<TModel extends string> = TModel extends keyof GrokModelInputModalitiesByName ? GrokModelInputModalitiesByName[TModel] : readonly ['text'];
+export {};

package/dist/esm/model-meta.js

@@ -0,0 +1,47 @@
+const GROK_4_1_FAST_REASONING = {
+  name: "grok-4-1-fast-reasoning"
+};
+const GROK_4_1_FAST_NON_REASONING = {
+  name: "grok-4-1-fast-non-reasoning"
+};
+const GROK_CODE_FAST_1 = {
+  name: "grok-code-fast-1"
+};
+const GROK_4_FAST_REASONING = {
+  name: "grok-4-fast-reasoning"
+};
+const GROK_4_FAST_NON_REASONING = {
+  name: "grok-4-fast-non-reasoning"
+};
+const GROK_4 = {
+  name: "grok-4"
+};
+const GROK_3_MINI = {
+  name: "grok-3-mini"
+};
+const GROK_3 = {
+  name: "grok-3"
+};
+const GROK_2_VISION = {
+  name: "grok-2-vision-1212"
+};
+const GROK_2_IMAGE = {
+  name: "grok-2-image-1212"
+};
+const GROK_CHAT_MODELS = [
+  GROK_4_1_FAST_REASONING.name,
+  GROK_4_1_FAST_NON_REASONING.name,
+  GROK_CODE_FAST_1.name,
+  GROK_4_FAST_REASONING.name,
+  GROK_4_FAST_NON_REASONING.name,
+  GROK_4.name,
+  GROK_3.name,
+  GROK_3_MINI.name,
+  GROK_2_VISION.name
+];
+const GROK_IMAGE_MODELS = [GROK_2_IMAGE.name];
+export {
+  GROK_CHAT_MODELS,
+  GROK_IMAGE_MODELS
+};
+//# sourceMappingURL=model-meta.js.map

package/dist/esm/model-meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-meta.js","sources":["../../src/model-meta.ts"],"sourcesContent":["/**\n * Model metadata interface for documentation and type inference\n */\ninterface ModelMeta {\n  name: string\n  supports: {\n    input: Array<'text' | 'image' | 'audio' | 'video' | 'document'>\n    output: Array<'text' | 'image' | 'audio' | 'video'>\n    capabilities?: Array<'reasoning' | 'tool_calling' | 'structured_outputs'>\n  }\n  max_input_tokens?: number\n  max_output_tokens?: number\n  context_window?: number\n  knowledge_cutoff?: string\n  pricing?: {\n    input: {\n      normal: number\n      cached?: number\n    }\n    output: {\n      normal: number\n    }\n  }\n}\n\nconst GROK_4_1_FAST_REASONING = {\n  name: 'grok-4-1-fast-reasoning',\n  context_window: 2_000_000,\n  supports: {\n    input: ['text', 'image'],\n    output: ['text'],\n    capabilities: ['reasoning', 'structured_outputs', 'tool_calling'],\n  },\n  pricing: {\n    input: {\n      normal: 0.2,\n      cached: 0.05,\n    },\n    output: {\n      normal: 0.5,\n    },\n  },\n} as const satisfies ModelMeta\n\nconst GROK_4_1_FAST_NON_REASONING = {\n  name: 'grok-4-1-fast-non-reasoning',\n  context_window: 2_000_000,\n  supports: {\n    input: ['text', 'image'],\n    output: ['text'],\n    capabilities: ['structured_outputs', 'tool_calling'],\n  },\n  pricing: {\n    input: {\n      normal: 0.2,\n      cached: 0.05,\n    },\n    output: {\n      normal: 0.5,\n    },\n  },\n} as const satisfies ModelMeta\n\nconst GROK_CODE_FAST_1 = {\n  name: 'grok-code-fast-1',\n  context_window: 256_000,\n  supports: {\n    input: ['text'],\n    output: ['text'],\n    capabilities: ['reasoning', 'structured_outputs', 'tool_calling'],\n  },\n  pricing: {\n    input: {\n      normal: 0.2,\n      cached: 0.02,\n    },\n    output: {\n      normal: 1.5,\n    },\n  },\n} as const satisfies ModelMeta\n\nconst GROK_4_FAST_REASONING = {\n  name: 'grok-4-fast-reasoning',\n  context_window: 2_000_000,\n  supports: {\n    input: ['text', 'image'],\n    output: ['text'],\n    capabilities: ['reasoning', 'structured_outputs', 'tool_calling'],\n  },\n  pricing: {\n    input: {\n      normal: 0.2,\n      cached: 0.05,\n    },\n    output: {\n      normal: 0.5,\n    },\n  },\n} as const satisfies ModelMeta\n\nconst GROK_4_FAST_NON_REASONING = {\n  name: 'grok-4-fast-non-reasoning',\n  context_window: 2_000_000,\n  supports: {\n    input: ['text', 'image'],\n    output: ['text'],\n    capabilities: ['structured_outputs', 'tool_calling'],\n  },\n  pricing: {\n    input: {\n      normal: 0.2,\n      cached: 0.05,\n    },\n    output: {\n      normal: 0.5,\n    },\n  },\n} as const satisfies ModelMeta\n\nconst GROK_4 = {\n  name: 'grok-4',\n  context_window: 256_000,\n  supports: {\n    input: ['text', 'image'],\n    output: ['text'],\n    capabilities: ['reasoning', 'structured_outputs', 'tool_calling'],\n  },\n  pricing: {\n    input: {\n      normal: 3,\n      cached: 0.75,\n    },\n    output: {\n      normal: 15,\n    },\n  },\n} as const satisfies ModelMeta\n\nconst GROK_3_MINI = {\n  name: 'grok-3-mini',\n  context_window: 131_072,\n  supports: {\n    input: ['text'],\n    output: ['text'],\n    capabilities: ['reasoning', 'structured_outputs', 'tool_calling'],\n  },\n  pricing: {\n    input: {\n      normal: 0.3,\n      cached: 0.075,\n    },\n    output: {\n      normal: 0.5,\n    },\n  },\n} as const satisfies ModelMeta\n\nconst GROK_3 = {\n  name: 'grok-3',\n  context_window: 131_072,\n  supports: {\n    input: ['text'],\n    output: ['text'],\n    capabilities: ['structured_outputs', 'tool_calling'],\n  },\n  pricing: {\n    input: {\n      normal: 3,\n      cached: 0.75,\n    },\n    output: {\n      normal: 15,\n    },\n  },\n} as const satisfies ModelMeta\n\nconst GROK_2_VISION = {\n  name: 'grok-2-vision-1212',\n  context_window: 32_768,\n  supports: {\n    input: ['text', 'image'],\n    output: ['text'],\n    capabilities: ['structured_outputs', 'tool_calling'],\n  },\n  pricing: {\n    input: {\n      normal: 2,\n    },\n    output: {\n      normal: 10,\n    },\n  },\n} as const satisfies ModelMeta\n\nconst GROK_2_IMAGE = {\n  name: 'grok-2-image-1212',\n  supports: {\n    input: ['text'],\n    output: ['image'],\n  },\n  pricing: {\n    input: {\n      normal: 0.07,\n    },\n    output: {\n      normal: 0.07,\n    },\n  },\n} as const satisfies ModelMeta\n\n/**\n * Grok Chat Models\n * Based on xAI's available models as of 2025\n */\nexport const GROK_CHAT_MODELS = [\n  GROK_4_1_FAST_REASONING.name,\n  GROK_4_1_FAST_NON_REASONING.name,\n  GROK_CODE_FAST_1.name,\n  GROK_4_FAST_REASONING.name,\n  GROK_4_FAST_NON_REASONING.name,\n  GROK_4.name,\n  GROK_3.name,\n  GROK_3_MINI.name,\n  GROK_2_VISION.name,\n] as const\n\n/**\n * Grok Image Generation Models\n */\nexport const GROK_IMAGE_MODELS = [GROK_2_IMAGE.name] as const\n\n/**\n * Type-only map from Grok chat model name to its supported input modalities.\n * Used for type inference when constructing multimodal messages.\n */\nexport type GrokModelInputModalitiesByName = {\n  [GROK_4_1_FAST_REASONING.name]: typeof GROK_4_1_FAST_REASONING.supports.input\n  [GROK_4_1_FAST_NON_REASONING.name]: typeof GROK_4_1_FAST_NON_REASONING.supports.input\n  [GROK_CODE_FAST_1.name]: typeof GROK_CODE_FAST_1.supports.input\n  [GROK_4_FAST_REASONING.name]: typeof GROK_4_FAST_REASONING.supports.input\n  [GROK_4_FAST_NON_REASONING.name]: typeof GROK_4_FAST_NON_REASONING.supports.input\n  [GROK_4.name]: typeof GROK_4.supports.input\n  [GROK_3.name]: typeof GROK_3.supports.input\n  [GROK_3_MINI.name]: typeof GROK_3_MINI.supports.input\n  [GROK_2_VISION.name]: typeof GROK_2_VISION.supports.input\n}\n\n/**\n * Type-only map from Grok chat model name to its provider options type.\n * Since Grok uses OpenAI-compatible API, we reuse OpenAI provider options.\n */\nexport type GrokChatModelProviderOptionsByName = {\n  [K in (typeof GROK_CHAT_MODELS)[number]]: GrokProviderOptions\n}\n\n/**\n * Grok-specific provider options\n * Based on OpenAI-compatible API options\n */\nexport interface GrokProviderOptions {\n  /** Temperature for response generation (0-2) */\n  temperature?: number\n  /** Maximum tokens in the response */\n  max_tokens?: number\n  /** Top-p sampling parameter */\n  top_p?: number\n  /** Frequency penalty (-2.0 to 2.0) */\n  frequency_penalty?: number\n  /** Presence penalty (-2.0 to 2.0) */\n  presence_penalty?: number\n  /** Stop sequences */\n  stop?: string | Array<string>\n  /** A unique identifier representing your end-user */\n  user?: string\n}\n\n// ===========================\n// Type Resolution Helpers\n// ===========================\n\n/**\n * Resolve provider options for a specific model.\n * If the model has explicit options in the map, use those; otherwise use base options.\n */\nexport type ResolveProviderOptions<TModel extends string> =\n  TModel extends keyof GrokChatModelProviderOptionsByName\n    ? GrokChatModelProviderOptionsByName[TModel]\n    : GrokProviderOptions\n\n/**\n * Resolve input modalities for a specific model.\n * If the model has explicit modalities in the map, use those; otherwise use text only.\n */\nexport type ResolveInputModalities<TModel extends string> =\n  TModel extends keyof GrokModelInputModalitiesByName\n    ? GrokModelInputModalitiesByName[TModel]\n    : readonly ['text']\n"],"names":[],"mappings":"AAyBA,MAAM,0BAA0B;AAAA,EAC9B,MAAM;AAgBR;AAEA,MAAM,8BAA8B;AAAA,EAClC,MAAM;AAgBR;AAEA,MAAM,mBAAmB;AAAA,EACvB,MAAM;AAgBR;AAEA,MAAM,wBAAwB;AAAA,EAC5B,MAAM;AAgBR;AAEA,MAAM,4BAA4B;AAAA,EAChC,MAAM;AAgBR;AAEA,MAAM,SAAS;AAAA,EACb,MAAM;AAgBR;AAEA,MAAM,cAAc;AAAA,EAClB,MAAM;AAgBR;AAEA,MAAM,SAAS;AAAA,EACb,MAAM;AAgBR;AAEA,MAAM,gBAAgB;AAAA,EACpB,MAAM;AAeR;AAEA,MAAM,eAAe;AAAA,EACnB,MAAM;AAaR;AAMO,MAAM,mBAAmB;AAAA,EAC9B,wBAAwB;AAAA,EACxB,4BAA4B;AAAA,EAC5B,iBAAiB;AAAA,EACjB,sBAAsB;AAAA,EACtB,0BAA0B;AAAA,EAC1B,OAAO;AAAA,EACP,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,cAAc;AAChB;AAKO,MAAM,oBAAoB,CAAC,aAAa,IAAI;"}

package/dist/esm/text/text-provider-options.d.ts

@@ -0,0 +1,66 @@
+import { FunctionTool } from '../tools/function-tool.js';
+/**
+ * Grok Text Provider Options
+ *
+ * Grok uses an OpenAI-compatible Chat Completions API.
+ * However, not all OpenAI features may be supported by Grok.
+ */
+/**
+ * Base provider options for Grok text/chat models
+ */
+export interface GrokBaseOptions {
+    /**
+     * A unique identifier representing your end-user.
+     * Can help xAI to monitor and detect abuse.
+     */
+    user?: string;
+}
+/**
+ * Grok-specific provider options for text/chat
+ * Based on OpenAI-compatible API options
+ */
+export interface GrokTextProviderOptions extends GrokBaseOptions {
+    /**
+     * Temperature for response generation (0-2)
+     * Higher values make output more random, lower values more focused
+     */
+    temperature?: number;
+    /**
+     * Top-p sampling parameter (0-1)
+     * Alternative to temperature, nucleus sampling
+     */
+    top_p?: number;
+    /**
+     * Maximum tokens in the response
+     */
+    max_tokens?: number;
+    /**
+     * Frequency penalty (-2.0 to 2.0)
+     */
+    frequency_penalty?: number;
+    /**
+     * Presence penalty (-2.0 to 2.0)
+     */
+    presence_penalty?: number;
+    /**
+     * Stop sequences
+     */
+    stop?: string | Array<string>;
+}
+/**
+ * Internal options interface for validation
+ * Used internally by the adapter
+ */
+export interface InternalTextProviderOptions extends GrokTextProviderOptions {
+    model: string;
+    stream?: boolean;
+    tools?: Array<FunctionTool>;
+}
+/**
+ * External provider options (what users pass in)
+ */
+export type ExternalTextProviderOptions = GrokTextProviderOptions;
+/**
+ * Validates text provider options
+ */
+export declare function validateTextProviderOptions(_options: InternalTextProviderOptions): void;

package/dist/esm/text/text-provider-options.js

@@ -0,0 +1,6 @@
+function validateTextProviderOptions(_options) {
+}
+export {
+  validateTextProviderOptions
+};
+//# sourceMappingURL=text-provider-options.js.map

package/dist/esm/text/text-provider-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-provider-options.js","sources":["../../../src/text/text-provider-options.ts"],"sourcesContent":["import type { FunctionTool } from '../tools/function-tool'\n\n/**\n * Grok Text Provider Options\n *\n * Grok uses an OpenAI-compatible Chat Completions API.\n * However, not all OpenAI features may be supported by Grok.\n */\n\n/**\n * Base provider options for Grok text/chat models\n */\nexport interface GrokBaseOptions {\n  /**\n   * A unique identifier representing your end-user.\n   * Can help xAI to monitor and detect abuse.\n   */\n  user?: string\n}\n\n/**\n * Grok-specific provider options for text/chat\n * Based on OpenAI-compatible API options\n */\nexport interface GrokTextProviderOptions extends GrokBaseOptions {\n  /**\n   * Temperature for response generation (0-2)\n   * Higher values make output more random, lower values more focused\n   */\n  temperature?: number\n  /**\n   * Top-p sampling parameter (0-1)\n   * Alternative to temperature, nucleus sampling\n   */\n  top_p?: number\n  /**\n   * Maximum tokens in the response\n   */\n  max_tokens?: number\n  /**\n   * Frequency penalty (-2.0 to 2.0)\n   */\n  frequency_penalty?: number\n  /**\n   * Presence penalty (-2.0 to 2.0)\n   */\n  presence_penalty?: number\n  /**\n   * Stop sequences\n   */\n  stop?: string | Array<string>\n}\n\n/**\n * Internal options interface for validation\n * Used internally by the adapter\n */\nexport interface InternalTextProviderOptions extends GrokTextProviderOptions {\n  model: string\n  stream?: boolean\n  tools?: Array<FunctionTool>\n}\n\n/**\n * External provider options (what users pass in)\n */\nexport type ExternalTextProviderOptions = GrokTextProviderOptions\n\n/**\n * Validates text provider options\n */\nexport function validateTextProviderOptions(\n  _options: InternalTextProviderOptions,\n): void {\n  // Basic validation can be added here if needed\n  // For now, Grok API will handle validation\n}\n"],"names":[],"mappings":"AAuEO,SAAS,4BACd,UACM;AAGR;"}

package/dist/esm/tools/function-tool.d.ts

@@ -0,0 +1,15 @@
+import { Tool } from '@tanstack/ai';
+import { default as OpenAI } from 'openai';
+export type FunctionTool = OpenAI.Chat.Completions.ChatCompletionTool;
+/**
+ * Converts a standard Tool to Grok ChatCompletionTool format.
+ *
+ * Tool schemas are already converted to JSON Schema in the ai layer.
+ * We apply Grok-specific transformations for strict mode:
+ * - All properties in required array
+ * - Optional fields made nullable
+ * - additionalProperties: false
+ *
+ * This enables strict mode for all tools automatically.
+ */
+export declare function convertFunctionToolToAdapterFormat(tool: Tool): FunctionTool;

package/dist/esm/tools/function-tool.js

@@ -0,0 +1,27 @@
+import { makeGrokStructuredOutputCompatible } from "../utils/schema-converter.js";
+function convertFunctionToolToAdapterFormat(tool) {
+  const inputSchema = tool.inputSchema ?? {
+    type: "object",
+    properties: {},
+    required: []
+  };
+  const jsonSchema = makeGrokStructuredOutputCompatible(
+    inputSchema,
+    inputSchema.required || []
+  );
+  jsonSchema.additionalProperties = false;
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: jsonSchema,
+      strict: true
+      // Always use strict mode since our schema converter handles the requirements
+    }
+  };
+}
+export {
+  convertFunctionToolToAdapterFormat
+};
+//# sourceMappingURL=function-tool.js.map

package/dist/esm/tools/function-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-tool.js","sources":["../../../src/tools/function-tool.ts"],"sourcesContent":["import { makeGrokStructuredOutputCompatible } from '../utils/schema-converter'\nimport type { JSONSchema, Tool } from '@tanstack/ai'\nimport type OpenAI from 'openai'\n\n// Use Chat Completions API tool format (not Responses API)\nexport type FunctionTool = OpenAI.Chat.Completions.ChatCompletionTool\n\n/**\n * Converts a standard Tool to Grok ChatCompletionTool format.\n *\n * Tool schemas are already converted to JSON Schema in the ai layer.\n * We apply Grok-specific transformations for strict mode:\n * - All properties in required array\n * - Optional fields made nullable\n * - additionalProperties: false\n *\n * This enables strict mode for all tools automatically.\n */\nexport function convertFunctionToolToAdapterFormat(tool: Tool): FunctionTool {\n  // Tool schemas are already converted to JSON Schema in the ai layer\n  // Apply Grok-specific transformations for strict mode\n  const inputSchema = (tool.inputSchema ?? {\n    type: 'object',\n    properties: {},\n    required: [],\n  }) as JSONSchema\n\n  const jsonSchema = makeGrokStructuredOutputCompatible(\n    inputSchema,\n    inputSchema.required || [],\n  )\n\n  // Ensure additionalProperties is false for strict mode\n  jsonSchema.additionalProperties = false\n\n  return {\n    type: 'function',\n    function: {\n      name: tool.name,\n      description: tool.description,\n      parameters: jsonSchema,\n      strict: true, // Always use strict mode since our schema converter handles the requirements\n    },\n  } satisfies FunctionTool\n}\n"],"names":[],"mappings":";AAkBO,SAAS,mCAAmC,MAA0B;AAG3E,QAAM,cAAe,KAAK,eAAe;AAAA,IACvC,MAAM;AAAA,IACN,YAAY,CAAA;AAAA,IACZ,UAAU,CAAA;AAAA,EAAC;AAGb,QAAM,aAAa;AAAA,IACjB;AAAA,IACA,YAAY,YAAY,CAAA;AAAA,EAAC;AAI3B,aAAW,uBAAuB;AAElC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,UAAU;AAAA,MACR,MAAM,KAAK;AAAA,MACX,aAAa,KAAK;AAAA,MAClB,YAAY;AAAA,MACZ,QAAQ;AAAA;AAAA,IAAA;AAAA,EACV;AAEJ;"}

package/dist/esm/tools/index.d.ts

@@ -0,0 +1,2 @@
+export { convertFunctionToolToAdapterFormat, type FunctionTool, } from './function-tool.js';
+export { convertToolsToProviderFormat } from './tool-converter.js';

package/dist/esm/tools/tool-converter.d.ts

@@ -0,0 +1,7 @@
+import { FunctionTool } from './function-tool.js';
+import { Tool } from '@tanstack/ai';
+/**
+ * Converts an array of standard Tools to Grok-specific format
+ * Grok uses OpenAI-compatible API, so we primarily support function tools
+ */
+export declare function convertToolsToProviderFormat(tools: Array<Tool>): Array<FunctionTool>;

package/dist/esm/tools/tool-converter.js

@@ -0,0 +1,10 @@
+import { convertFunctionToolToAdapterFormat } from "./function-tool.js";
+function convertToolsToProviderFormat(tools) {
+  return tools.map((tool) => {
+    return convertFunctionToolToAdapterFormat(tool);
+  });
+}
+export {
+  convertToolsToProviderFormat
+};
+//# sourceMappingURL=tool-converter.js.map

package/dist/esm/tools/tool-converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-converter.js","sources":["../../../src/tools/tool-converter.ts"],"sourcesContent":["import { convertFunctionToolToAdapterFormat } from './function-tool'\nimport type { FunctionTool } from './function-tool'\nimport type { Tool } from '@tanstack/ai'\n\n/**\n * Converts an array of standard Tools to Grok-specific format\n * Grok uses OpenAI-compatible API, so we primarily support function tools\n */\nexport function convertToolsToProviderFormat(\n  tools: Array<Tool>,\n): Array<FunctionTool> {\n  return tools.map((tool) => {\n    // For Grok, all tools are converted as function tools\n    // Grok uses OpenAI-compatible API which primarily supports function tools\n    return convertFunctionToolToAdapterFormat(tool)\n  })\n}\n"],"names":[],"mappings":";AAQO,SAAS,6BACd,OACqB;AACrB,SAAO,MAAM,IAAI,CAAC,SAAS;AAGzB,WAAO,mCAAmC,IAAI;AAAA,EAChD,CAAC;AACH;"}

package/dist/esm/utils/client.d.ts

@@ -0,0 +1,18 @@
+import { default as OpenAI_SDK } from 'openai';
+export interface GrokClientConfig {
+    apiKey: string;
+    baseURL?: string;
+}
+/**
+ * Creates a Grok SDK client instance using OpenAI SDK with xAI's base URL
+ */
+export declare function createGrokClient(config: GrokClientConfig): OpenAI_SDK;
+/**
+ * Gets Grok API key from environment variables
+ * @throws Error if XAI_API_KEY is not found
+ */
+export declare function getGrokApiKeyFromEnv(): string;
+/**
+ * Generates a unique ID with a prefix
+ */
+export declare function generateId(prefix: string): string;

package/dist/esm/utils/client.js

@@ -0,0 +1,26 @@
+import OpenAI_SDK from "openai";
+function createGrokClient(config) {
+  return new OpenAI_SDK({
+    apiKey: config.apiKey,
+    baseURL: config.baseURL || "https://api.x.ai/v1"
+  });
+}
+function getGrokApiKeyFromEnv() {
+  const env = typeof globalThis !== "undefined" && globalThis.window?.env ? globalThis.window.env : typeof process !== "undefined" ? process.env : void 0;
+  const key = env?.XAI_API_KEY;
+  if (!key) {
+    throw new Error(
+      "XAI_API_KEY is required. Please set it in your environment variables or use the factory function with an explicit API key."
+    );
+  }
+  return key;
+}
+function generateId(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+}
+export {
+  createGrokClient,
+  generateId,
+  getGrokApiKeyFromEnv
+};
+//# sourceMappingURL=client.js.map

package/dist/esm/utils/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sources":["../../../src/utils/client.ts"],"sourcesContent":["import OpenAI_SDK from 'openai'\n\nexport interface GrokClientConfig {\n  apiKey: string\n  baseURL?: string\n}\n\n/**\n * Creates a Grok SDK client instance using OpenAI SDK with xAI's base URL\n */\nexport function createGrokClient(config: GrokClientConfig): OpenAI_SDK {\n  return new OpenAI_SDK({\n    apiKey: config.apiKey,\n    baseURL: config.baseURL || 'https://api.x.ai/v1',\n  })\n}\n\n/**\n * Gets Grok API key from environment variables\n * @throws Error if XAI_API_KEY is not found\n */\nexport function getGrokApiKeyFromEnv(): string {\n  const env =\n    typeof globalThis !== 'undefined' && (globalThis as any).window?.env\n      ? (globalThis as any).window.env\n      : typeof process !== 'undefined'\n        ? process.env\n        : undefined\n  const key = env?.XAI_API_KEY\n\n  if (!key) {\n    throw new Error(\n      'XAI_API_KEY is required. Please set it in your environment variables or use the factory function with an explicit API key.',\n    )\n  }\n\n  return key\n}\n\n/**\n * Generates a unique ID with a prefix\n */\nexport function generateId(prefix: string): string {\n  return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`\n}\n"],"names":[],"mappings":";AAUO,SAAS,iBAAiB,QAAsC;AACrE,SAAO,IAAI,WAAW;AAAA,IACpB,QAAQ,OAAO;AAAA,IACf,SAAS,OAAO,WAAW;AAAA,EAAA,CAC5B;AACH;AAMO,SAAS,uBAA+B;AAC7C,QAAM,MACJ,OAAO,eAAe,eAAgB,WAAmB,QAAQ,MAC5D,WAAmB,OAAO,MAC3B,OAAO,YAAY,cACjB,QAAQ,MACR;AACR,QAAM,MAAM,KAAK;AAEjB,MAAI,CAAC,KAAK;AACR,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AAEA,SAAO;AACT;AAKO,SAAS,WAAW,QAAwB;AACjD,SAAO,GAAG,MAAM,IAAI,KAAK,KAAK,IAAI,KAAK,OAAA,EAAS,SAAS,EAAE,EAAE,UAAU,CAAC,CAAC;AAC3E;"}

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { createGrokClient, getGrokApiKeyFromEnv, generateId, type GrokClientConfig, } from './client.js';
+export { makeGrokStructuredOutputCompatible, transformNullsToUndefined, } from './schema-converter.js';

package/dist/esm/utils/schema-converter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Recursively transform null values to undefined in an object.
+ *
+ * This is needed because Grok's structured output (via OpenAI-compatible API) requires all fields to be
+ * in the `required` array, with optional fields made nullable (type: ["string", "null"]).
+ * When Grok returns null for optional fields, we need to convert them back to
+ * undefined to match the original Zod schema expectations.
+ *
+ * @param obj - Object to transform
+ * @returns Object with nulls converted to undefined
+ */
+export declare function transformNullsToUndefined<T>(obj: T): T;
+/**
+ * Transform a JSON schema to be compatible with Grok's structured output requirements (OpenAI-compatible).
+ * Grok requires:
+ * - All properties must be in the `required` array
+ * - Optional fields should have null added to their type union
+ * - additionalProperties must be false for objects
+ *
+ * @param schema - JSON schema to transform
+ * @param originalRequired - Original required array (to know which fields were optional)
+ * @returns Transformed schema compatible with Grok structured output
+ */
+export declare function makeGrokStructuredOutputCompatible(schema: Record<string, any>, originalRequired?: Array<string>): Record<string, any>;

package/dist/esm/utils/schema-converter.js

@@ -0,0 +1,71 @@
+function transformNullsToUndefined(obj) {
+  if (obj === null) {
+    return void 0;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => transformNullsToUndefined(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const transformed = transformNullsToUndefined(value);
+      if (transformed !== void 0) {
+        result[key] = transformed;
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+function makeGrokStructuredOutputCompatible(schema, originalRequired = []) {
+  const result = { ...schema };
+  if (result.type === "object" && result.properties) {
+    const properties = { ...result.properties };
+    const allPropertyNames = Object.keys(properties);
+    for (const propName of allPropertyNames) {
+      const prop = properties[propName];
+      const wasOptional = !originalRequired.includes(propName);
+      if (prop.type === "object" && prop.properties) {
+        properties[propName] = makeGrokStructuredOutputCompatible(
+          prop,
+          prop.required || []
+        );
+      } else if (prop.type === "array" && prop.items) {
+        properties[propName] = {
+          ...prop,
+          items: makeGrokStructuredOutputCompatible(
+            prop.items,
+            prop.items.required || []
+          )
+        };
+      } else if (wasOptional) {
+        if (prop.type && !Array.isArray(prop.type)) {
+          properties[propName] = {
+            ...prop,
+            type: [prop.type, "null"]
+          };
+        } else if (Array.isArray(prop.type) && !prop.type.includes("null")) {
+          properties[propName] = {
+            ...prop,
+            type: [...prop.type, "null"]
+          };
+        }
+      }
+    }
+    result.properties = properties;
+    result.required = allPropertyNames;
+    result.additionalProperties = false;
+  }
+  if (result.type === "array" && result.items) {
+    result.items = makeGrokStructuredOutputCompatible(
+      result.items,
+      result.items.required || []
+    );
+  }
+  return result;
+}
+export {
+  makeGrokStructuredOutputCompatible,
+  transformNullsToUndefined
+};
+//# sourceMappingURL=schema-converter.js.map

package/dist/esm/utils/schema-converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-converter.js","sources":["../../../src/utils/schema-converter.ts"],"sourcesContent":["/**\n * Recursively transform null values to undefined in an object.\n *\n * This is needed because Grok's structured output (via OpenAI-compatible API) requires all fields to be\n * in the `required` array, with optional fields made nullable (type: [\"string\", \"null\"]).\n * When Grok returns null for optional fields, we need to convert them back to\n * undefined to match the original Zod schema expectations.\n *\n * @param obj - Object to transform\n * @returns Object with nulls converted to undefined\n */\nexport function transformNullsToUndefined<T>(obj: T): T {\n  if (obj === null) {\n    return undefined as unknown as T\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => transformNullsToUndefined(item)) as unknown as T\n  }\n\n  if (typeof obj === 'object') {\n    const result: Record<string, unknown> = {}\n    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {\n      const transformed = transformNullsToUndefined(value)\n      // Only include the key if the value is not undefined\n      // This makes { notes: null } become {} (field absent) instead of { notes: undefined }\n      if (transformed !== undefined) {\n        result[key] = transformed\n      }\n    }\n    return result as T\n  }\n\n  return obj\n}\n\n/**\n * Transform a JSON schema to be compatible with Grok's structured output requirements (OpenAI-compatible).\n * Grok requires:\n * - All properties must be in the `required` array\n * - Optional fields should have null added to their type union\n * - additionalProperties must be false for objects\n *\n * @param schema - JSON schema to transform\n * @param originalRequired - Original required array (to know which fields were optional)\n * @returns Transformed schema compatible with Grok structured output\n */\nexport function makeGrokStructuredOutputCompatible(\n  schema: Record<string, any>,\n  originalRequired: Array<string> = [],\n): Record<string, any> {\n  const result = { ...schema }\n\n  // Handle object types\n  if (result.type === 'object' && result.properties) {\n    const properties = { ...result.properties }\n    const allPropertyNames = Object.keys(properties)\n\n    // Transform each property\n    for (const propName of allPropertyNames) {\n      const prop = properties[propName]\n      const wasOptional = !originalRequired.includes(propName)\n\n      // Recursively transform nested objects/arrays\n      if (prop.type === 'object' && prop.properties) {\n        properties[propName] = makeGrokStructuredOutputCompatible(\n          prop,\n          prop.required || [],\n        )\n      } else if (prop.type === 'array' && prop.items) {\n        properties[propName] = {\n          ...prop,\n          items: makeGrokStructuredOutputCompatible(\n            prop.items,\n            prop.items.required || [],\n          ),\n        }\n      } else if (wasOptional) {\n        // Make optional fields nullable by adding null to the type\n        if (prop.type && !Array.isArray(prop.type)) {\n          properties[propName] = {\n            ...prop,\n            type: [prop.type, 'null'],\n          }\n        } else if (Array.isArray(prop.type) && !prop.type.includes('null')) {\n          properties[propName] = {\n            ...prop,\n            type: [...prop.type, 'null'],\n          }\n        }\n      }\n    }\n\n    result.properties = properties\n    // ALL properties must be required for Grok structured output\n    result.required = allPropertyNames\n    // additionalProperties must be false\n    result.additionalProperties = false\n  }\n\n  // Handle array types with object items\n  if (result.type === 'array' && result.items) {\n    result.items = makeGrokStructuredOutputCompatible(\n      result.items,\n      result.items.required || [],\n    )\n  }\n\n  return result\n}\n"],"names":[],"mappings":"AAWO,SAAS,0BAA6B,KAAW;AACtD,MAAI,QAAQ,MAAM;AAChB,WAAO;AAAA,EACT;AAEA,MAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,WAAO,IAAI,IAAI,CAAC,SAAS,0BAA0B,IAAI,CAAC;AAAA,EAC1D;AAEA,MAAI,OAAO,QAAQ,UAAU;AAC3B,UAAM,SAAkC,CAAA;AACxC,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAA8B,GAAG;AACzE,YAAM,cAAc,0BAA0B,KAAK;AAGnD,UAAI,gBAAgB,QAAW;AAC7B,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAaO,SAAS,mCACd,QACA,mBAAkC,IACb;AACrB,QAAM,SAAS,EAAE,GAAG,OAAA;AAGpB,MAAI,OAAO,SAAS,YAAY,OAAO,YAAY;AACjD,UAAM,aAAa,EAAE,GAAG,OAAO,WAAA;AAC/B,UAAM,mBAAmB,OAAO,KAAK,UAAU;AAG/C,eAAW,YAAY,kBAAkB;AACvC,YAAM,OAAO,WAAW,QAAQ;AAChC,YAAM,cAAc,CAAC,iBAAiB,SAAS,QAAQ;AAGvD,UAAI,KAAK,SAAS,YAAY,KAAK,YAAY;AAC7C,mBAAW,QAAQ,IAAI;AAAA,UACrB;AAAA,UACA,KAAK,YAAY,CAAA;AAAA,QAAC;AAAA,MAEtB,WAAW,KAAK,SAAS,WAAW,KAAK,OAAO;AAC9C,mBAAW,QAAQ,IAAI;AAAA,UACrB,GAAG;AAAA,UACH,OAAO;AAAA,YACL,KAAK;AAAA,YACL,KAAK,MAAM,YAAY,CAAA;AAAA,UAAC;AAAA,QAC1B;AAAA,MAEJ,WAAW,aAAa;AAEtB,YAAI,KAAK,QAAQ,CAAC,MAAM,QAAQ,KAAK,IAAI,GAAG;AAC1C,qBAAW,QAAQ,IAAI;AAAA,YACrB,GAAG;AAAA,YACH,MAAM,CAAC,KAAK,MAAM,MAAM;AAAA,UAAA;AAAA,QAE5B,WAAW,MAAM,QAAQ,KAAK,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,MAAM,GAAG;AAClE,qBAAW,QAAQ,IAAI;AAAA,YACrB,GAAG;AAAA,YACH,MAAM,CAAC,GAAG,KAAK,MAAM,MAAM;AAAA,UAAA;AAAA,QAE/B;AAAA,MACF;AAAA,IACF;AAEA,WAAO,aAAa;AAEpB,WAAO,WAAW;AAElB,WAAO,uBAAuB;AAAA,EAChC;AAGA,MAAI,OAAO,SAAS,WAAW,OAAO,OAAO;AAC3C,WAAO,QAAQ;AAAA,MACb,OAAO;AAAA,MACP,OAAO,MAAM,YAAY,CAAA;AAAA,IAAC;AAAA,EAE9B;AAEA,SAAO;AACT;"}