@tanstack/ai-grok 0.7.0 → 0.7.2

package/src/utils/client.ts

@@ -1,46 +1,31 @@
-import OpenAI_SDK from 'openai'
-import type { ClientOptions } from 'openai'
+import { getApiKeyFromEnv } from '@tanstack/ai-utils'
+import type { OpenAICompatibleClientConfig } from '@tanstack/openai-base'
 
-export interface GrokClientConfig extends ClientOptions {
-  apiKey: string
-}
-
-/**
- * Creates a Grok SDK client instance using OpenAI SDK with xAI's base URL
- */
-export function createGrokClient(config: GrokClientConfig): OpenAI_SDK {
-  return new OpenAI_SDK({
-    ...config,
-    apiKey: config.apiKey,
-    baseURL: config.baseURL || 'https://api.x.ai/v1',
-  })
-}
+export interface GrokClientConfig extends OpenAICompatibleClientConfig {}
 
 /**
  * Gets Grok API key from environment variables
  * @throws Error if XAI_API_KEY is not found
  */
 export function getGrokApiKeyFromEnv(): string {
-  const env =
-    typeof globalThis !== 'undefined' && (globalThis as any).window?.env
-      ? (globalThis as any).window.env
-      : typeof process !== 'undefined'
-        ? process.env
-        : undefined
-  const key = env?.XAI_API_KEY
-
-  if (!key) {
+  try {
+    return getApiKeyFromEnv('XAI_API_KEY')
+  } catch {
     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
 }
 
 /**
- * Generates a unique ID with a prefix
+ * Returns a Grok client config with the default xAI base URL applied
+ * when not already set.
  */
-export function generateId(prefix: string): string {
-  return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`
+export function withGrokDefaults(
+  config: GrokClientConfig,
+): OpenAICompatibleClientConfig {
+  return {
+    ...config,
+    baseURL: config.baseURL || 'https://api.x.ai/v1',
+  }
 }

package/src/utils/index.ts

@@ -1,7 +1,7 @@
+export { generateId } from '@tanstack/ai-utils'
 export {
-  createGrokClient,
   getGrokApiKeyFromEnv,
-  generateId,
+  withGrokDefaults,
   type GrokClientConfig,
 } from './client'
 export {

package/src/utils/schema-converter.ts

@@ -1,110 +1,2 @@
-/**
- * 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 function transformNullsToUndefined<T>(obj: T): T {
-  if (obj === null) {
-    return undefined as unknown as T
-  }
-
-  if (Array.isArray(obj)) {
-    return obj.map((item) => transformNullsToUndefined(item)) as unknown as T
-  }
-
-  if (typeof obj === 'object') {
-    const result: Record<string, unknown> = {}
-    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-      const transformed = transformNullsToUndefined(value)
-      // Only include the key if the value is not undefined
-      // This makes { notes: null } become {} (field absent) instead of { notes: undefined }
-      if (transformed !== undefined) {
-        result[key] = transformed
-      }
-    }
-    return result as T
-  }
-
-  return obj
-}
-
-/**
- * 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 function makeGrokStructuredOutputCompatible(
-  schema: Record<string, any>,
-  originalRequired: Array<string> = [],
-): Record<string, any> {
-  const result = { ...schema }
-
-  // Handle object types
-  if (result.type === 'object' && result.properties) {
-    const properties = { ...result.properties }
-    const allPropertyNames = Object.keys(properties)
-
-    // Transform each property
-    for (const propName of allPropertyNames) {
-      const prop = properties[propName]
-      const wasOptional = !originalRequired.includes(propName)
-
-      // Recursively transform nested objects/arrays
-      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) {
-        // Make optional fields nullable by adding null to the type
-        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
-    // ALL properties must be required for Grok structured output
-    result.required = allPropertyNames
-    // additionalProperties must be false
-    result.additionalProperties = false
-  }
-
-  // Handle array types with object items
-  if (result.type === 'array' && result.items) {
-    result.items = makeGrokStructuredOutputCompatible(
-      result.items,
-      result.items.required || [],
-    )
-  }
-
-  return result
-}
+export { transformNullsToUndefined } from '@tanstack/ai-utils'
+export { makeStructuredOutputCompatible as makeGrokStructuredOutputCompatible } from '@tanstack/openai-base'

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

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,15 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/tool-converter.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/schema-converter.js

@@ -1,71 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;"}

package/src/tools/function-tool.ts

@@ -1,45 +0,0 @@
-import { makeGrokStructuredOutputCompatible } from '../utils/schema-converter'
-import type { JSONSchema, Tool } from '@tanstack/ai'
-import type OpenAI from 'openai'
-
-// Use Chat Completions API tool format (not Responses API)
-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 function convertFunctionToolToAdapterFormat(tool: Tool): FunctionTool {
-  // Tool schemas are already converted to JSON Schema in the ai layer
-  // Apply Grok-specific transformations for strict mode
-  const inputSchema = (tool.inputSchema ?? {
-    type: 'object',
-    properties: {},
-    required: [],
-  }) as JSONSchema
-
-  const jsonSchema = makeGrokStructuredOutputCompatible(
-    inputSchema,
-    inputSchema.required || [],
-  )
-
-  // Ensure additionalProperties is false for strict mode
-  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
-    },
-  } satisfies FunctionTool
-}

package/src/tools/tool-converter.ts

@@ -1,17 +0,0 @@
-import { convertFunctionToolToAdapterFormat } from './function-tool'
-import type { FunctionTool } from './function-tool'
-import type { 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 function convertToolsToProviderFormat(
-  tools: Array<Tool>,
-): Array<FunctionTool> {
-  return tools.map((tool) => {
-    // For Grok, all tools are converted as function tools
-    // Grok uses OpenAI-compatible API which primarily supports function tools
-    return convertFunctionToolToAdapterFormat(tool)
-  })
-}