agent0-js 0.0.6 → 0.0.8

package/README.md

@@ -98,6 +98,24 @@ interface ModelOverrides {
   maxOutputTokens?: number;    // Override max output tokens
   temperature?: number;        // Override temperature
   maxStepCount?: number;       // Override max step count
+  providerOptions?: ProviderOptions; // Provider-specific reasoning options
+}
+
+interface ProviderOptions {
+  openai?: {
+    reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high';
+    reasoningSummary?: 'auto' | 'detailed';
+  };
+  xai?: {
+    reasoningEffort?: 'low' | 'medium' | 'high';
+  };
+  google?: {
+    thinkingConfig?: {
+      thinkingBudget?: number;
+      thinkingLevel?: 'low' | 'medium' | 'high';
+      includeThoughts?: boolean;
+    };
+  };
 }
 ```
 
@@ -152,8 +170,148 @@ for await (const chunk of stream) {
 }
 ```
 
+### `embed(options: EmbedOptions): Promise<EmbedResponse>`
+
+Generate an embedding for a single text value.
+
+**Parameters:**
+
+Extends Vercel AI SDK's `embed` parameters. Only the `model` property is different:
+
+```typescript
+// All options from Vercel AI SDK's embed() are supported
+// Only the model property uses Agent0's format:
+type EmbedOptions = Omit<VercelEmbedOptions, 'model'> & {
+  model: {
+    provider_id: string;  // The provider ID (from your Agent0 providers)
+    name: string;         // The embedding model name (e.g., 'text-embedding-3-small')
+  };
+};
+
+// Common options include:
+// - value: string           // The text to embed
+// - maxRetries?: number     // Maximum number of retries
+// - headers?: Record<string, string>
+// - providerOptions?: {...} // Provider-specific options
+// - experimental_telemetry?: {...}
+// Plus any future options added to Vercel AI SDK!
+```
+
+**Returns:**
+
+```typescript
+interface EmbedResponse {
+  embedding: number[];    // The embedding vector
+}
+```
+
+**Example:**
+
+```typescript
+const result = await client.embed({
+  model: {
+    provider_id: 'your-openai-provider-id',
+    name: 'text-embedding-3-small'
+  },
+  value: 'Hello, world!'
+});
+
+console.log('Embedding vector length:', result.embedding.length);
+// Store or use the embedding for similarity search, etc.
+```
+
+### `embedMany(options: EmbedManyOptions): Promise<EmbedManyResponse>`
+
+Generate embeddings for multiple text values in a single request.
+
+**Parameters:**
+
+Extends Vercel AI SDK's `embedMany` parameters. Only the `model` property is different:
+
+```typescript
+// All options from Vercel AI SDK's embedMany() are supported
+// Only the model property uses Agent0's format:
+type EmbedManyOptions = Omit<VercelEmbedManyOptions, 'model'> & {
+  model: {
+    provider_id: string;  // The provider ID (from your Agent0 providers)
+    name: string;         // The embedding model name
+  };
+};
+
+// Common options include:
+// - values: string[]        // The texts to embed
+// - maxRetries?: number     // Maximum number of retries
+// - headers?: Record<string, string>
+// - providerOptions?: {...} // Provider-specific options
+// Plus any future options added to Vercel AI SDK!
+```
+
+**Returns:**
+
+```typescript
+interface EmbedManyResponse {
+  embeddings: number[][]; // Array of embedding vectors (one per input value)
+}
+```
+
+**Example:**
+
+```typescript
+const result = await client.embedMany({
+  model: {
+    provider_id: 'your-openai-provider-id',
+    name: 'text-embedding-3-small'
+  },
+  values: [
+    'First document to embed',
+    'Second document to embed',
+    'Third document to embed'
+  ]
+});
+
+console.log('Number of embeddings:', result.embeddings.length);
+result.embeddings.forEach((embedding, i) => {
+  console.log(`Embedding ${i} length:`, embedding.length);
+});
+```
+
+**Using Provider Options:**
+
+Provider-specific options can be passed to customize embedding behavior:
+
+```typescript
+// Example: OpenAI with custom dimensions
+const result = await client.embed({
+  model: {
+    provider_id: 'your-openai-provider-id',
+    name: 'text-embedding-3-small'
+  },
+  value: 'Hello, world!',
+  providerOptions: {
+    openai: {
+      dimensions: 256  // Reduce dimensions for smaller vectors
+    }
+  }
+});
+
+// Example: Google with task type
+const googleResult = await client.embed({
+  model: {
+    provider_id: 'your-google-provider-id',
+    name: 'text-embedding-004'
+  },
+  value: 'Search query text',
+  providerOptions: {
+    google: {
+      taskType: 'RETRIEVAL_QUERY'  // Optimize for search queries
+    }
+  }
+});
+```
+
 ## Examples
 
+
 ### Basic Usage (Node.js)
 
 ```javascript
@@ -222,8 +380,59 @@ async function streamExample() {
 streamExample();
 ```
 
+### Embeddings for Semantic Search
+
+Generate embeddings to power semantic search, similarity matching, or RAG (Retrieval-Augmented Generation) applications.
+
+```typescript
+import { Agent0 } from 'agent0-js';
+
+const client = new Agent0({
+  apiKey: process.env.AGENT0_API_KEY!
+});
+
+// Embed documents for a knowledge base
+async function embedDocuments() {
+  const documents = [
+    'Machine learning is a subset of artificial intelligence.',
+    'Neural networks are inspired by the human brain.',
+    'Deep learning uses multiple layers of neural networks.',
+  ];
+
+  const result = await client.embedMany({
+    model: {
+      provider_id: 'your-openai-provider-id',
+      name: 'text-embedding-3-small'
+    },
+    values: documents
+  });
+
+  // Store embeddings in your vector database
+  result.embeddings.forEach((embedding, i) => {
+    console.log(`Document ${i}: ${embedding.length} dimensions`);
+    // vectorDB.insert({ text: documents[i], embedding });
+  });
+}
+
+// Query with semantic search
+async function semanticSearch(query: string) {
+  const queryEmbedding = await client.embed({
+    model: {
+      provider_id: 'your-openai-provider-id',
+      name: 'text-embedding-3-small'
+    },
+    value: query
+  });
+
+  // Use the embedding to find similar documents
+  // const results = await vectorDB.search(queryEmbedding.embedding, { limit: 5 });
+  console.log('Query embedding dimensions:', queryEmbedding.embedding.length);
+}
+```
+
 ### Using Variables
 
+
 Variables allow you to pass dynamic data to your agents. Any variables defined in your agent's prompts will be replaced with the values you provide.
 
 ```typescript
@@ -278,6 +487,79 @@ async function runWithFallback(agentId: string, variables: Record<string, string
 }
 ```
 
+### Provider Options
+
+The `providerOptions` option allows you to configure provider-specific reasoning and thinking behavior. Different providers have different options:
+
+**OpenAI / Azure** - Use `reasoningEffort` to control how much reasoning the model does, and `reasoningSummary` to control whether the model returns its reasoning process:
+
+```typescript
+const response = await client.generate({
+  agentId: 'agent_123',
+  overrides: {
+    providerOptions: {
+      openai: {
+        reasoningEffort: 'high', // 'minimal' | 'low' | 'medium' | 'high'
+        reasoningSummary: 'auto' // 'auto' | 'detailed' - controls reasoning output
+      }
+    }
+  }
+});
+```
+
+- `reasoningSummary: 'auto'` - Returns a condensed summary of the reasoning process
+- `reasoningSummary: 'detailed'` - Returns more comprehensive reasoning
+- When enabled, reasoning summaries appear in the stream as events with type `'reasoning'` and in non-streaming responses within the `reasoning` field
+
+**xAI (Grok)** - Use `reasoningEffort` to control reasoning:
+
+```typescript
+const response = await client.generate({
+  agentId: 'agent_123',
+  overrides: {
+    providerOptions: {
+      xai: {
+        reasoningEffort: 'high' // 'low' | 'medium' | 'high'
+      }
+    }
+  }
+});
+```
+
+**Google Generative AI / Google Vertex** - Use `thinkingConfig` to control thinking (use either `thinkingLevel` or `thinkingBudget`, not both):
+
+```typescript
+// Using thinkingLevel (recommended for most cases)
+const response = await client.generate({
+  agentId: 'agent_123',
+  overrides: {
+    providerOptions: {
+      google: {
+        thinkingConfig: {
+          thinkingLevel: 'high',     // 'low' | 'medium' | 'high'
+          includeThoughts: true      // Include thinking in response
+        }
+      }
+    }
+  }
+});
+
+// OR using thinkingBudget (for fine-grained control)
+const response = await client.generate({
+  agentId: 'agent_123',
+  overrides: {
+    providerOptions: {
+      google: {
+        thinkingConfig: {
+          thinkingBudget: 8192,      // Number of thinking tokens
+          includeThoughts: true
+        }
+      }
+    }
+  }
+});
+```
+
 ### Extra Messages
 
 The `extraMessages` option allows you to programmatically append additional messages to the agent's prompt. These messages are used as-is without any variable substitution, making them ideal for:

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import type { TextStreamPart, ToolSet } from 'ai';
-import type { Agent0Config, GenerateResponse, RunOptions } from './types';
+import type { TextStreamPart, ToolSet } from "ai";
+import type { Agent0Config, EmbedManyOptions, EmbedManyResponse, EmbedOptions, EmbedResponse, GenerateResponse, RunOptions } from "./types";
 export declare class Agent0 {
     private apiKey;
     private baseUrl;
@@ -7,4 +7,21 @@ export declare class Agent0 {
     private fetchApi;
     generate(options: RunOptions): Promise<GenerateResponse>;
     stream(options: RunOptions): AsyncGenerator<TextStreamPart<ToolSet>, void, unknown>;
+    /**
+     * Generate an embedding for a single value using the specified model.
+     * Accepts all options from Vercel AI SDK's embed function.
+     *
+     * @param options - The embedding options (extends Vercel AI SDK's embed parameters)
+     * @returns The embedding vector
+     */
+    embed(options: EmbedOptions): Promise<EmbedResponse>;
+    /**
+     * Generate embeddings for multiple values using the specified model.
+     * Accepts all options from Vercel AI SDK's embedMany function.
+     *
+     * @param options - The embedding options (extends Vercel AI SDK's embedMany parameters)
+     * @returns The embedding vectors (one per input value)
+     */
+    embedMany(options: EmbedManyOptions): Promise<EmbedManyResponse>;
 }
+export type { Agent0Config, EmbedManyOptions, EmbedManyResponse, EmbedModel, EmbedOptions, EmbedResponse, GenerateResponse, ModelOverrides, ProviderOptions, RunOptions, } from "./types";

package/dist/index.js

@@ -4,16 +4,16 @@ exports.Agent0 = void 0;
 class Agent0 {
     constructor(config) {
         this.apiKey = config.apiKey;
-        this.baseUrl = config.baseUrl || 'https://app.agent0.com'; // Default URL, can be overridden
+        this.baseUrl = config.baseUrl || "https://app.agent0.com"; // Default URL, can be overridden
     }
     async fetchApi(endpoint, body) {
         const url = `${this.baseUrl}${endpoint}`;
         const headers = {
-            'Content-Type': 'application/json',
-            'x-api-key': this.apiKey,
+            "Content-Type": "application/json",
+            "x-api-key": this.apiKey,
         };
         const response = await fetch(url, {
-            method: 'POST',
+            method: "POST",
             headers,
             body: JSON.stringify(body),
         });
@@ -24,7 +24,7 @@ class Agent0 {
         return response;
     }
     async generate(options) {
-        const response = await this.fetchApi('/api/v1/run', {
+        const response = await this.fetchApi("/api/v1/run", {
             agent_id: options.agentId,
             variables: options.variables,
             overrides: options.overrides,
@@ -34,7 +34,7 @@ class Agent0 {
         return await response.json();
     }
     async *stream(options) {
-        const response = await this.fetchApi('/api/v1/run', {
+        const response = await this.fetchApi("/api/v1/run", {
             agent_id: options.agentId,
             variables: options.variables,
             overrides: options.overrides,
@@ -42,23 +42,23 @@ class Agent0 {
             stream: true,
         });
         if (!response.body) {
-            throw new Error('Response body is empty');
+            throw new Error("Response body is empty");
         }
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
-        let buffer = '';
+        let buffer = "";
         try {
             while (true) {
                 const { done, value } = await reader.read();
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n');
+                const lines = buffer.split("\n");
                 // Keep the last incomplete line in the buffer
-                buffer = lines.pop() || '';
+                buffer = lines.pop() || "";
                 for (const line of lines) {
                     const trimmedLine = line.trim();
-                    if (!trimmedLine || !trimmedLine.startsWith('data: '))
+                    if (!trimmedLine || !trimmedLine.startsWith("data: "))
                         continue;
                     const data = trimmedLine.slice(6);
                     try {
@@ -66,7 +66,7 @@ class Agent0 {
                         yield parsed;
                     }
                     catch (e) {
-                        console.warn('Failed to parse stream chunk:', data, e);
+                        console.warn("Failed to parse stream chunk:", data, e);
                     }
                 }
             }
@@ -75,5 +75,29 @@ class Agent0 {
             reader.releaseLock();
         }
     }
+    /**
+     * Generate an embedding for a single value using the specified model.
+     * Accepts all options from Vercel AI SDK's embed function.
+     *
+     * @param options - The embedding options (extends Vercel AI SDK's embed parameters)
+     * @returns The embedding vector
+     */
+    async embed(options) {
+        // Pass all options directly to the API
+        const response = await this.fetchApi("/api/v1/embed", options);
+        return await response.json();
+    }
+    /**
+     * Generate embeddings for multiple values using the specified model.
+     * Accepts all options from Vercel AI SDK's embedMany function.
+     *
+     * @param options - The embedding options (extends Vercel AI SDK's embedMany parameters)
+     * @returns The embedding vectors (one per input value)
+     */
+    async embedMany(options) {
+        // Pass all options directly to the API
+        const response = await this.fetchApi("/api/v1/embed-many", options);
+        return await response.json();
+    }
 }
 exports.Agent0 = Agent0;

package/dist/types.d.ts

@@ -1,8 +1,23 @@
-import type { ModelMessage } from "ai";
+import type { GoogleGenerativeAIProviderOptions } from "@ai-sdk/google";
+import type { OpenAIResponsesProviderOptions } from "@ai-sdk/openai";
+import type { XaiProviderOptions } from "@ai-sdk/xai";
+import type { embed, embedMany, ModelMessage } from "ai";
 export interface Agent0Config {
     apiKey: string;
     baseUrl?: string;
 }
+/**
+ * Provider-specific options for reasoning/thinking configuration.
+ * Each provider has its own format for controlling reasoning behavior.
+ */
+export interface ProviderOptions {
+    /** OpenAI reasoning effort options */
+    openai?: OpenAIResponsesProviderOptions;
+    /** xAI reasoning effort options */
+    xai?: XaiProviderOptions;
+    /** Google/Vertex thinking configuration */
+    google?: GoogleGenerativeAIProviderOptions;
+}
 /**
  * Model configuration overrides for runtime customization.
  * Allows downstream applications to implement load balancing, fallbacks, and dynamic model switching.
@@ -19,6 +34,8 @@ export interface ModelOverrides {
     temperature?: number;
     /** Override max step count */
     maxStepCount?: number;
+    /** Provider-specific options for reasoning/thinking configuration */
+    providerOptions?: ProviderOptions;
 }
 export interface RunOptions {
     agentId: string;
@@ -32,3 +49,43 @@ export interface GenerateResponse {
     messages: ModelMessage[];
     text: string;
 }
+/**
+ * Model specification for Agent0 embedding operations.
+ * Instead of passing an EmbeddingModel instance, pass the provider_id and model name.
+ */
+export interface EmbedModel {
+    /** The provider ID (from your Agent0 providers configuration) */
+    provider_id: string;
+    /** The embedding model name (e.g., 'text-embedding-3-small', 'text-embedding-ada-002') */
+    name: string;
+}
+/**
+ * Options for the embed function.
+ * Extends Vercel AI SDK's embed parameters, only modifying the `model` property
+ * to use Agent0's provider_id + name format instead of an EmbeddingModel instance.
+ */
+export type EmbedOptions = Omit<Parameters<typeof embed>[0], "model"> & {
+    model: EmbedModel;
+};
+/**
+ * Options for the embedMany function.
+ * Extends Vercel AI SDK's embedMany parameters, only modifying the `model` property
+ * to use Agent0's provider_id + name format instead of an EmbeddingModel instance.
+ */
+export type EmbedManyOptions = Omit<Parameters<typeof embedMany>[0], "model"> & {
+    model: EmbedModel;
+};
+/**
+ * Response from the embed function.
+ */
+export interface EmbedResponse {
+    /** The embedding vector */
+    embedding: number[];
+}
+/**
+ * Response from the embedMany function.
+ */
+export interface EmbedManyResponse {
+    /** The embedding vectors (one per input value) */
+    embeddings: number[][];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent0-js",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "TypeScript SDK for Agent0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,9 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
+    "@ai-sdk/google": "3.0.0-beta.69",
+    "@ai-sdk/openai": "3.0.0-beta.90",
+    "@ai-sdk/xai": "3.0.0-beta.54",
     "ai": "^5.0.98"
   },
   "scripts": {

package/src/index.ts

@@ -1,93 +1,145 @@
-import type { TextStreamPart, ToolSet } from 'ai';
-import type { Agent0Config, GenerateResponse, RunOptions } from './types';
+import type { TextStreamPart, ToolSet } from "ai";
+import type {
+	Agent0Config,
+	EmbedManyOptions,
+	EmbedManyResponse,
+	EmbedOptions,
+	EmbedResponse,
+	GenerateResponse,
+	RunOptions,
+} from "./types";
 
 export class Agent0 {
-    private apiKey: string;
-    private baseUrl: string;
-
-    constructor(config: Agent0Config) {
-        this.apiKey = config.apiKey;
-        this.baseUrl = config.baseUrl || 'https://app.agent0.com'; // Default URL, can be overridden
-    }
-
-    private async fetchApi(endpoint: string, body: unknown): Promise<Response> {
-        const url = `${this.baseUrl}${endpoint}`;
-
-        const headers = {
-            'Content-Type': 'application/json',
-            'x-api-key': this.apiKey,
-        };
-
-        const response = await fetch(url, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(body),
-        });
-
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorText}`);
-        }
-
-        return response;
-    }
-
-    async generate(options: RunOptions): Promise<GenerateResponse> {
-        const response = await this.fetchApi('/api/v1/run', {
-            agent_id: options.agentId,
-            variables: options.variables,
-            overrides: options.overrides,
-            extra_messages: options.extraMessages,
-            stream: false,
-        });
-
-        return await response.json();
-    }
-
-    async *stream(options: RunOptions): AsyncGenerator<TextStreamPart<ToolSet>, void, unknown> {
-        const response = await this.fetchApi('/api/v1/run', {
-            agent_id: options.agentId,
-            variables: options.variables,
-            overrides: options.overrides,
-            extra_messages: options.extraMessages,
-            stream: true,
-        });
-
-        if (!response.body) {
-            throw new Error('Response body is empty');
-        }
-
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-
-        let buffer = '';
-
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) break;
-
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n');
-
-                // Keep the last incomplete line in the buffer
-                buffer = lines.pop() || '';
-
-                for (const line of lines) {
-                    const trimmedLine = line.trim();
-                    if (!trimmedLine || !trimmedLine.startsWith('data: ')) continue;
-
-                    const data = trimmedLine.slice(6);
-                    try {
-                        const parsed = JSON.parse(data) as TextStreamPart<ToolSet>;
-                        yield parsed;
-                    } catch (e) {
-                        console.warn('Failed to parse stream chunk:', data, e);
-                    }
-                }
-            }
-        } finally {
-            reader.releaseLock();
-        }
-    }
+	private apiKey: string;
+	private baseUrl: string;
+
+	constructor(config: Agent0Config) {
+		this.apiKey = config.apiKey;
+		this.baseUrl = config.baseUrl || "https://app.agent0.com"; // Default URL, can be overridden
+	}
+
+	private async fetchApi(endpoint: string, body: unknown): Promise<Response> {
+		const url = `${this.baseUrl}${endpoint}`;
+
+		const headers = {
+			"Content-Type": "application/json",
+			"x-api-key": this.apiKey,
+		};
+
+		const response = await fetch(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+		});
+
+		if (!response.ok) {
+			const errorText = await response.text();
+			throw new Error(
+				`API request failed: ${response.status} ${response.statusText} - ${errorText}`,
+			);
+		}
+
+		return response;
+	}
+
+	async generate(options: RunOptions): Promise<GenerateResponse> {
+		const response = await this.fetchApi("/api/v1/run", {
+			agent_id: options.agentId,
+			variables: options.variables,
+			overrides: options.overrides,
+			extra_messages: options.extraMessages,
+			stream: false,
+		});
+
+		return await response.json();
+	}
+
+	async *stream(
+		options: RunOptions,
+	): AsyncGenerator<TextStreamPart<ToolSet>, void, unknown> {
+		const response = await this.fetchApi("/api/v1/run", {
+			agent_id: options.agentId,
+			variables: options.variables,
+			overrides: options.overrides,
+			extra_messages: options.extraMessages,
+			stream: true,
+		});
+
+		if (!response.body) {
+			throw new Error("Response body is empty");
+		}
+
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+
+		let buffer = "";
+
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+
+				// Keep the last incomplete line in the buffer
+				buffer = lines.pop() || "";
+
+				for (const line of lines) {
+					const trimmedLine = line.trim();
+					if (!trimmedLine || !trimmedLine.startsWith("data: ")) continue;
+
+					const data = trimmedLine.slice(6);
+					try {
+						const parsed = JSON.parse(data) as TextStreamPart<ToolSet>;
+						yield parsed;
+					} catch (e) {
+						console.warn("Failed to parse stream chunk:", data, e);
+					}
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+	}
+
+	/**
+	 * Generate an embedding for a single value using the specified model.
+	 * Accepts all options from Vercel AI SDK's embed function.
+	 *
+	 * @param options - The embedding options (extends Vercel AI SDK's embed parameters)
+	 * @returns The embedding vector
+	 */
+	async embed(options: EmbedOptions): Promise<EmbedResponse> {
+		// Pass all options directly to the API
+		const response = await this.fetchApi("/api/v1/embed", options);
+		return await response.json();
+	}
+
+	/**
+	 * Generate embeddings for multiple values using the specified model.
+	 * Accepts all options from Vercel AI SDK's embedMany function.
+	 *
+	 * @param options - The embedding options (extends Vercel AI SDK's embedMany parameters)
+	 * @returns The embedding vectors (one per input value)
+	 */
+	async embedMany(options: EmbedManyOptions): Promise<EmbedManyResponse> {
+		// Pass all options directly to the API
+		const response = await this.fetchApi("/api/v1/embed-many", options);
+		return await response.json();
+	}
 }
+
+// Re-export types for convenience
+export type {
+	Agent0Config,
+	EmbedManyOptions,
+	EmbedManyResponse,
+	EmbedModel,
+	EmbedOptions,
+	EmbedResponse,
+	GenerateResponse,
+	ModelOverrides,
+	ProviderOptions,
+	RunOptions,
+} from "./types";

package/src/types.ts

@@ -1,8 +1,24 @@
-import type { ModelMessage } from "ai";
+import type { GoogleGenerativeAIProviderOptions } from "@ai-sdk/google";
+import type { OpenAIResponsesProviderOptions } from "@ai-sdk/openai";
+import type { XaiProviderOptions } from "@ai-sdk/xai";
+import type { embed, embedMany, ModelMessage } from "ai";
 
 export interface Agent0Config {
-    apiKey: string;
-    baseUrl?: string;
+	apiKey: string;
+	baseUrl?: string;
+}
+
+/**
+ * Provider-specific options for reasoning/thinking configuration.
+ * Each provider has its own format for controlling reasoning behavior.
+ */
+export interface ProviderOptions {
+	/** OpenAI reasoning effort options */
+	openai?: OpenAIResponsesProviderOptions;
+	/** xAI reasoning effort options */
+	xai?: XaiProviderOptions;
+	/** Google/Vertex thinking configuration */
+	google?: GoogleGenerativeAIProviderOptions;
 }
 
 /**
@@ -10,29 +26,79 @@ export interface Agent0Config {
  * Allows downstream applications to implement load balancing, fallbacks, and dynamic model switching.
  */
 export interface ModelOverrides {
-    /** Override the model provider and name */
-    model?: {
-        provider_id?: string;
-        name?: string;
-    };
-    /** Override max output tokens */
-    maxOutputTokens?: number;
-    /** Override temperature */
-    temperature?: number;
-    /** Override max step count */
-    maxStepCount?: number;
+	/** Override the model provider and name */
+	model?: {
+		provider_id?: string;
+		name?: string;
+	};
+	/** Override max output tokens */
+	maxOutputTokens?: number;
+	/** Override temperature */
+	temperature?: number;
+	/** Override max step count */
+	maxStepCount?: number;
+	/** Provider-specific options for reasoning/thinking configuration */
+	providerOptions?: ProviderOptions;
 }
 
 export interface RunOptions {
-    agentId: string;
-    variables?: Record<string, string>;
-    /** Runtime model overrides for load balancing, fallbacks, etc. */
-    overrides?: ModelOverrides;
-    /** Extra messages to append to the agent's prompt (used as-is, no variable substitution) */
-    extraMessages?: ModelMessage[];
+	agentId: string;
+	variables?: Record<string, string>;
+	/** Runtime model overrides for load balancing, fallbacks, etc. */
+	overrides?: ModelOverrides;
+	/** Extra messages to append to the agent's prompt (used as-is, no variable substitution) */
+	extraMessages?: ModelMessage[];
 }
 
 export interface GenerateResponse {
-    messages: ModelMessage[];
-    text: string;
+	messages: ModelMessage[];
+	text: string;
+}
+
+/**
+ * Model specification for Agent0 embedding operations.
+ * Instead of passing an EmbeddingModel instance, pass the provider_id and model name.
+ */
+export interface EmbedModel {
+	/** The provider ID (from your Agent0 providers configuration) */
+	provider_id: string;
+	/** The embedding model name (e.g., 'text-embedding-3-small', 'text-embedding-ada-002') */
+	name: string;
+}
+
+/**
+ * Options for the embed function.
+ * Extends Vercel AI SDK's embed parameters, only modifying the `model` property
+ * to use Agent0's provider_id + name format instead of an EmbeddingModel instance.
+ */
+export type EmbedOptions = Omit<Parameters<typeof embed>[0], "model"> & {
+	model: EmbedModel;
+};
+
+/**
+ * Options for the embedMany function.
+ * Extends Vercel AI SDK's embedMany parameters, only modifying the `model` property
+ * to use Agent0's provider_id + name format instead of an EmbeddingModel instance.
+ */
+export type EmbedManyOptions = Omit<
+	Parameters<typeof embedMany>[0],
+	"model"
+> & {
+	model: EmbedModel;
+};
+
+/**
+ * Response from the embed function.
+ */
+export interface EmbedResponse {
+	/** The embedding vector */
+	embedding: number[];
+}
+
+/**
+ * Response from the embedMany function.
+ */
+export interface EmbedManyResponse {
+	/** The embedding vectors (one per input value) */
+	embeddings: number[][];
 }