@robota-sdk/agent-provider-openai 3.0.0-beta.55

package/README.md

@@ -0,0 +1,443 @@
+# @robota-sdk/agent-provider-openai
+
+OpenAI Provider for Robota SDK - Complete type-safe integration with OpenAI's GPT models, featuring function calling, streaming, and advanced AI capabilities.
+
+## 🚀 Features
+
+### Core Capabilities
+
+- **🎯 Type-Safe Integration**: Complete TypeScript support with zero `any` types
+- **🤖 GPT Model Support**: GPT-4, GPT-3.5 Turbo, OpenAI models, and OpenAI-compatible chat completion models
+- **⚡ Real-Time Streaming**: Asynchronous streaming responses with proper error handling
+- **🛠️ Function Calling**: Native OpenAI function calling with type validation
+- **🔄 Provider-Agnostic Design**: Seamless integration with other Robota providers
+- **📊 Payload Logging**: Optional API request/response logging for debugging
+
+### Architecture Highlights
+
+- **Generic Type Parameters**: Full `BaseAIProvider<TConfig, TMessage, TResponse>` implementation
+- **Facade Pattern**: Modular design with separated concerns
+- **Error Safety**: Comprehensive error handling without any-type compromises
+- **OpenAI SDK Compatibility**: Direct integration with official OpenAI SDK types
+
+## 📦 Installation
+
+```bash
+npm install @robota-sdk/agent-provider-openai @robota-sdk/agent-core openai
+```
+
+## 🔧 Basic Usage
+
+### Simple Chat Integration
+
+```typescript
+import { Robota } from '@robota-sdk/agent-core';
+import { OpenAIProvider } from '@robota-sdk/agent-provider-openai';
+
+// Create type-safe OpenAI provider
+const provider = new OpenAIProvider({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+// Create Robota agent with OpenAI provider
+const agent = new Robota({
+  name: 'MyAgent',
+  aiProviders: [provider],
+  defaultModel: {
+    provider: 'openai',
+    model: 'gpt-4',
+    temperature: 0.7,
+    systemMessage: 'You are a helpful AI assistant specialized in technical topics.',
+  },
+});
+
+// Execute conversation
+const response = await agent.run('Explain the benefits of TypeScript over JavaScript');
+console.log(response);
+
+// Clean up
+await agent.destroy();
+```
+
+### OpenAI-Compatible Endpoints
+
+Use `baseURL` to point the provider at an OpenAI-compatible Chat Completions endpoint. For LM Studio, the local API typically listens on `http://localhost:1234/v1` and accepts a local placeholder API key:
+
+```typescript
+import { OpenAIProvider } from '@robota-sdk/agent-provider-openai';
+
+const provider = new OpenAIProvider({
+  apiKey: 'lm-studio',
+  baseURL: 'http://localhost:1234/v1',
+  defaultModel: '<local-openai-compatible-model>',
+});
+```
+
+Gemma-family local models should use `@robota-sdk/agent-provider-gemma` instead of this
+OpenAI provider so Gemma chat-template channel markers are projected out of user-facing
+streamed text.
+
+### Streaming Responses
+
+```typescript
+// Real-time streaming for immediate feedback
+const stream = await agent.runStream('Write a detailed explanation of machine learning');
+
+for await (const chunk of stream) {
+  if (chunk.content) {
+    process.stdout.write(chunk.content);
+  }
+
+  // Handle streaming metadata
+  if (chunk.metadata?.isComplete) {
+    console.log('\n✓ Stream completed');
+  }
+}
+```
+
+When `chat()` receives an `onTextDelta` callback, the provider uses the streaming Chat Completions path internally, forwards text deltas to the callback, assembles streamed tool-call chunks, and returns the final assistant message.
+
+## 🛠️ Function Calling
+
+OpenAI Provider supports type-safe function calling with automatic parameter validation:
+
+```typescript
+import { FunctionTool } from '@robota-sdk/agent-core';
+import { z } from 'zod';
+
+// Define type-safe function tools
+const weatherTool = new FunctionTool({
+  name: 'getWeather',
+  description: 'Get current weather information for a location',
+  parameters: z.object({
+    location: z.string().describe('City name'),
+    unit: z.enum(['celsius', 'fahrenheit']).default('celsius'),
+  }),
+  handler: async ({ location, unit }) => {
+    // Type-safe handler implementation
+    const weatherData = await fetchWeatherAPI(location, unit);
+    return {
+      temperature: weatherData.temp,
+      condition: weatherData.condition,
+      location,
+      unit,
+    };
+  },
+});
+
+const calculatorTool = new FunctionTool({
+  name: 'calculate',
+  description: 'Perform mathematical operations',
+  parameters: z.object({
+    operation: z.enum(['add', 'subtract', 'multiply', 'divide']),
+    a: z.number(),
+    b: z.number(),
+  }),
+  handler: async ({ operation, a, b }) => {
+    const operations = {
+      add: a + b,
+      subtract: a - b,
+      multiply: a * b,
+      divide: a / b,
+    };
+    return { result: operations[operation] };
+  },
+});
+
+// Register tools with the agent
+agent.registerTool(weatherTool);
+agent.registerTool(calculatorTool);
+
+// Execute with function calling
+const result = await agent.run("What's the weather in Tokyo and what's 25 * 4?");
+```
+
+## 🔄 Multi-Provider Architecture
+
+Seamlessly integrate with other providers:
+
+```typescript
+import { AnthropicProvider } from '@robota-sdk/agent-provider-anthropic';
+import { GoogleProvider } from '@robota-sdk/agent-provider-google';
+
+const openaiProvider = new OpenAIProvider({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+const anthropicProvider = new AnthropicProvider({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+});
+
+const googleProvider = new GoogleProvider({
+  apiKey: process.env.GOOGLE_AI_API_KEY,
+});
+
+const agent = new Robota({
+  name: 'MultiProviderAgent',
+  aiProviders: [openaiProvider, anthropicProvider, googleProvider],
+  defaultModel: {
+    provider: 'openai',
+    model: 'gpt-4',
+  },
+});
+
+// Dynamic provider switching
+const openaiResponse = await agent.run('Respond using GPT-4');
+
+agent.setModel({ provider: 'anthropic', model: 'claude-3-sonnet-20240229' });
+const claudeResponse = await agent.run('Respond using Claude');
+```
+
+## ⚙️ Configuration Options
+
+```typescript
+interface IOpenAIProviderOptions {
+  // Required
+  client: OpenAI; // OpenAI SDK client instance
+
+  // Model Configuration
+  model?: string; // Default: 'gpt-4'
+  temperature?: number; // 0-1, default: 0.7
+  maxTokens?: number; // Maximum tokens to generate
+
+  // API Configuration
+  apiKey?: string; // API key (if not set in client)
+  organization?: string; // OpenAI organization ID
+  timeout?: number; // Request timeout (ms)
+  baseURL?: string; // Custom API base URL
+
+  // Response Configuration
+  responseFormat?: 'text' | 'json_object' | 'json_schema';
+  jsonSchema?: {
+    // For structured outputs
+    name: string;
+    description?: string;
+    schema?: Record<string, string | number | boolean | object>;
+    strict?: boolean;
+  };
+
+  // Debugging & Logging
+  payloadLogger?: IPayloadLogger; // Environment-specific payload logger
+
+  // Interface-based logger implementations:
+  // - FilePayloadLogger: Node.js file-based logging
+  // - ConsolePayloadLogger: Browser console-based logging
+  // - Custom: Implement IPayloadLogger interface
+}
+```
+
+## 📋 Supported Models
+
+| Model                  | Description          | Use Cases                                   |
+| ---------------------- | -------------------- | ------------------------------------------- |
+| `gpt-4`                | Most capable model   | Complex reasoning, analysis, creative tasks |
+| `gpt-4-turbo`          | Faster GPT-4 variant | Balanced performance and cost               |
+| `gpt-3.5-turbo`        | Fast and efficient   | Simple conversations, basic tasks           |
+| `gpt-4-vision-preview` | Vision capabilities  | Image analysis and understanding            |
+
+## 🔍 API Reference
+
+### OpenAIProvider Class
+
+```typescript
+class OpenAIProvider extends BaseAIProvider<
+  IOpenAIProviderOptions,
+  UniversalMessage,
+  UniversalMessage
+> {
+  // Core methods
+  async chat(messages: UniversalMessage[], options?: ChatOptions): Promise<UniversalMessage>;
+  async chatStream(
+    messages: UniversalMessage[],
+    options?: ChatOptions,
+  ): AsyncIterable<UniversalMessage>;
+
+  // Provider information
+  readonly name: string = 'openai';
+  readonly version: string = '1.0.0';
+
+  // Utility methods
+  supportsTools(): boolean;
+  validateConfig(): boolean;
+  async dispose(): Promise<void>;
+}
+```
+
+### Type Definitions
+
+```typescript
+// Chat Options
+interface ChatOptions {
+  tools?: ToolSchema[];
+  maxTokens?: number;
+  temperature?: number;
+  model?: string;
+}
+
+// OpenAI-specific types
+interface OpenAIToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+interface OpenAILogData {
+  model: string;
+  messagesCount: number;
+  hasTools: boolean;
+  temperature?: number;
+  maxTokens?: number;
+  timestamp: string;
+  requestId?: string;
+}
+```
+
+## 🐛 Debugging & Logging
+
+### Environment-Specific Payload Logging
+
+The OpenAI Provider supports environment-specific payload logging through interface-based dependency injection:
+
+#### Node.js Environment (File-Based Logging)
+
+```typescript
+import { OpenAIProvider } from '@robota-sdk/agent-provider-openai';
+import { FilePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers/file';
+
+const provider = new OpenAIProvider({
+  client: openaiClient,
+  model: 'gpt-4',
+  payloadLogger: new FilePayloadLogger({
+    logDir: './logs/openai-api',
+    enabled: true,
+    includeTimestamp: true,
+  }),
+});
+```
+
+#### Browser Environment (Console-Based Logging)
+
+```typescript
+import { OpenAIProvider } from '@robota-sdk/agent-provider-openai';
+import { ConsolePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers/console';
+
+const provider = new OpenAIProvider({
+  client: openaiClient,
+  model: 'gpt-4',
+  payloadLogger: new ConsolePayloadLogger({
+    enabled: true,
+    includeTimestamp: true,
+  }),
+});
+```
+
+#### No Logging (Both Environments)
+
+```typescript
+const provider = new OpenAIProvider({
+  client: openaiClient,
+  model: 'gpt-4',
+  // payloadLogger: undefined (default - no logging)
+});
+```
+
+### Custom Logger Implementation
+
+You can create custom logger implementations by implementing the IPayloadLogger interface:
+
+```typescript
+import type { IPayloadLogger, OpenAILogData } from '@robota-sdk/agent-provider-openai';
+
+class CustomPayloadLogger implements IPayloadLogger {
+  isEnabled(): boolean {
+    return true;
+  }
+
+  async logPayload(payload: OpenAILogData, type: 'chat' | 'stream'): Promise<void> {
+    // Custom logging implementation
+    console.log(`[Custom Logger] ${type}:`, payload);
+  }
+}
+
+const provider = new OpenAIProvider({
+  client: openaiClient,
+  payloadLogger: new CustomPayloadLogger(),
+});
+```
+
+This creates detailed logs of all API requests and responses for debugging purposes.
+
+## 🔒 Security Best Practices
+
+### API Key Management
+
+```typescript
+// ✅ Good: Use environment variables
+const client = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+// ❌ Bad: Hardcoded keys
+const client = new OpenAI({
+  apiKey: 'sk-...', // Never do this!
+});
+```
+
+### Error Handling
+
+```typescript
+try {
+  const response = await agent.run('Your query');
+} catch (error) {
+  if (error instanceof Error) {
+    console.error('AI Error:', error.message);
+  }
+  // Handle specific OpenAI errors
+}
+```
+
+## 📊 Performance Optimization
+
+### Token Management
+
+```typescript
+const provider = new OpenAIProvider({
+  client: openaiClient,
+  model: 'gpt-4',
+  maxTokens: 1000, // Limit response length
+  temperature: 0.3, // More deterministic responses
+});
+```
+
+### Model Selection Strategy
+
+- Use `gpt-3.5-turbo` for simple tasks
+- Use `gpt-4` for complex reasoning
+- Use `gpt-4-turbo` for balanced performance
+
+## 🤝 Contributing
+
+This package follows strict type safety guidelines:
+
+- Zero `any` or `unknown` types allowed
+- Complete TypeScript coverage
+- Comprehensive error handling
+- Provider-agnostic design principles
+
+## 📄 License
+
+MIT License - see LICENSE file for details.
+
+## 🔗 Related Packages
+
+- **[@robota-sdk/agent-core](../agents/)**: Core agent framework
+- **[@robota-sdk/agent-provider-anthropic](../anthropic/)**: Anthropic Claude provider
+- **[@robota-sdk/agent-provider-google](../google/)**: Google AI provider
+- **[@robota-sdk/agent-team](../team/)**: assignTask MCP tool collection (team creation removed)
+
+---
+
+For complete documentation and examples, visit the [Robota SDK Documentation](https://robota.io).

package/dist/browser/index.d.ts

@@ -0,0 +1,239 @@
+import OpenAI from 'openai';
+import { ILogger, IExecutor, TProviderOptionValueBase, AbstractAIProvider, TTextDeltaCallback, TUniversalMessage, IChatOptions, IProviderDefinition } from '@robota-sdk/agent-core';
+
+/**
+ * Payload logging data structure
+ */
+interface IOpenAILogData {
+    model: string;
+    messagesCount: number;
+    hasTools: boolean;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    timestamp: string;
+    requestId?: string | undefined;
+}
+
+/**
+ * IPayloadLogger interface for logging OpenAI API payloads
+ *
+ * This interface provides a contract for different logging implementations:
+ * - FilePayloadLogger: Node.js file-based logging
+ * - ConsolePayloadLogger: Browser console-based logging
+ * - Custom implementations: User-defined loggers
+ */
+interface IPayloadLogger {
+    /**
+     * Check if logging is enabled
+     * @returns true if logging is active, false otherwise
+     */
+    isEnabled(): boolean;
+    /**
+     * Log API payload data
+     * @param payload - The API request/response payload data
+     * @param type - Type of operation ('chat' or 'stream')
+     */
+    logPayload(payload: IOpenAILogData, type: 'chat' | 'stream'): Promise<void>;
+}
+/**
+ * Configuration options for payload loggers
+ */
+interface IPayloadLoggerOptions {
+    /**
+     * Whether logging is enabled
+     * @defaultValue true
+     */
+    enabled?: boolean;
+    /**
+     * Include timestamp in log entries
+     * @defaultValue true
+     */
+    includeTimestamp?: boolean;
+    /**
+     * Logger instance for console output
+     * @defaultValue SilentLogger
+     */
+    logger?: ILogger;
+}
+
+/**
+ * Valid provider option value types
+ */
+type TOpenAIProviderOptionValue = string | number | boolean | undefined | null | OpenAI | IPayloadLogger | ILogger | IExecutor | TProviderOptionValueBase | TOpenAIProviderOptionValue[] | {
+    [key: string]: TOpenAIProviderOptionValue;
+};
+/**
+ * OpenAI provider options
+ */
+interface IOpenAIProviderOptions {
+    /**
+     * Additional provider-specific options
+     */
+    [key: string]: TOpenAIProviderOptionValue;
+    /**
+     * OpenAI API key (required when client is not provided)
+     */
+    apiKey?: string;
+    /**
+     * OpenAI organization ID (optional)
+     */
+    organization?: string;
+    /**
+     * API request timeout (milliseconds)
+     */
+    timeout?: number;
+    /**
+     * API base URL (default: 'https://api.openai.com/v1')
+     */
+    baseURL?: string;
+    /**
+     * Response format (default: 'text')
+     * - 'text': Plain text response
+     * - 'json_object': JSON object mode (requires system message)
+     * - 'json_schema': Structured Outputs with schema validation
+     */
+    responseFormat?: 'text' | 'json_object' | 'json_schema';
+    /**
+     * JSON schema for structured outputs (required when responseFormat is 'json_schema')
+     */
+    jsonSchema?: {
+        name: string;
+        description?: string;
+        schema?: Record<string, TOpenAIProviderOptionValue>;
+        strict?: boolean;
+    };
+    /**
+     * OpenAI client instance (optional: will be created from apiKey if not provided)
+     */
+    client?: OpenAI;
+    /**
+     * Payload logger instance for debugging API requests/responses
+     *
+     * Use different implementations based on your environment:
+     * - FilePayloadLogger: Node.js file-based logging
+     * - ConsolePayloadLogger: Browser console-based logging
+     * - Custom: Implement IPayloadLogger interface
+     *
+     * @example
+     * ```typescript
+     * // Node.js
+     * import { FilePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers/file';
+     * const provider = new OpenAIProvider({
+     *   client: openaiClient,
+     *   payloadLogger: new FilePayloadLogger({ logDir: './logs/openai' })
+     * });
+     *
+     * // Browser
+     * import { ConsolePayloadLogger } from '@robota-sdk/agent-provider-openai/loggers/console';
+     * const provider = new OpenAIProvider({
+     *   client: openaiClient,
+     *   payloadLogger: new ConsolePayloadLogger()
+     * });
+     * ```
+     */
+    payloadLogger?: IPayloadLogger;
+    /**
+     * Optional executor for handling AI requests
+     *
+     * When provided, the provider will delegate all chat operations to this executor
+     * instead of making direct API calls. This enables remote execution capabilities.
+     *
+     * @example
+     * ```typescript
+     * import { LocalExecutor, RemoteExecutor } from '@robota-sdk/agent-core';
+     *
+     * // Local execution (registers this provider)
+     * const localExecutor = new LocalExecutor();
+     * localExecutor.registerProvider('openai', new OpenAIProvider({ apiKey: 'sk-...' }));
+     *
+     * // Remote execution
+     * const remoteExecutor = new RemoteExecutor({
+     *   serverUrl: 'https://api.robota.io',
+     *   userApiKey: 'user-token-123'
+     * });
+     *
+     * const provider = new OpenAIProvider({
+     *   executor: remoteExecutor // No direct API key needed
+     * });
+     * ```
+     */
+    executor?: IExecutor;
+    /**
+     * Logger instance for internal OpenAI provider logging
+     * @defaultValue SilentLogger
+     */
+    logger?: ILogger;
+}
+
+/**
+ * OpenAI provider implementation for Robota
+ *
+ * Provides integration with OpenAI's GPT models following BaseAIProvider guidelines.
+ * Uses OpenAI SDK native types internally for optimal performance and feature support.
+ *
+ * @public
+ */
+declare class OpenAIProvider extends AbstractAIProvider {
+    readonly name = "openai";
+    readonly version = "1.0.0";
+    private readonly client?;
+    private readonly options;
+    private readonly payloadLogger;
+    private readonly responseParser;
+    /**
+     * Optional callback for text deltas during streaming.
+     * Set by the consumer (e.g., Session) to receive real-time text chunks.
+     * When set, chat() uses streaming internally while still returning
+     * the complete assembled message.
+     */
+    onTextDelta?: TTextDeltaCallback;
+    constructor(options: IOpenAIProviderOptions);
+    chat(messages: TUniversalMessage[], options?: IChatOptions): Promise<TUniversalMessage>;
+    private chatWithStreamingAssembly;
+    chatStream(messages: TUniversalMessage[], options?: IChatOptions): AsyncIterable<TUniversalMessage>;
+    supportsTools(): boolean;
+    validateConfig(): boolean;
+    dispose(): Promise<void>;
+    protected validateMessages(messages: TUniversalMessage[]): void;
+}
+
+/**
+ * OpenAI Conversation Adapter
+ *
+ * Converts between TUniversalMessage format and OpenAI native types.
+ * Provides bidirectional conversion for seamless integration.
+ *
+ * @public
+ */
+declare class OpenAIConversationAdapter {
+    /**
+     * Filter messages for OpenAI compatibility
+     *
+     * OpenAI has specific requirements:
+     * - Tool messages must have valid toolCallId
+     * - Messages must be in proper sequence
+     * - Tool messages without toolCallId should be excluded
+     */
+    static filterMessagesForOpenAI(messages: TUniversalMessage[]): TUniversalMessage[];
+    /**
+     * Convert TUniversalMessage array to OpenAI message format
+     * Now properly handles tool messages for OpenAI's tool calling feature
+     */
+    static toOpenAIFormat(messages: TUniversalMessage[]): OpenAI.Chat.ChatCompletionMessageParam[];
+    /**
+     * Convert a single TUniversalMessage to OpenAI format
+     * Handles all message types including tool messages
+     */
+    static convertMessage(msg: TUniversalMessage): OpenAI.Chat.ChatCompletionMessageParam;
+    /**
+     * Add system prompt to message array if needed
+     */
+    static addSystemPromptIfNeeded(messages: OpenAI.Chat.ChatCompletionMessageParam[], systemPrompt?: string): OpenAI.Chat.ChatCompletionMessageParam[];
+}
+
+declare const DEFAULT_OPENAI_PROVIDER_MODEL: string | undefined;
+declare const DEFAULT_OPENAI_COMPATIBLE_PROVIDER_API_KEY = "lm-studio";
+declare const DEFAULT_OPENAI_COMPATIBLE_PROVIDER_BASE_URL = "http://localhost:1234/v1";
+declare function createOpenAIProviderDefinition(): IProviderDefinition;
+
+export { DEFAULT_OPENAI_COMPATIBLE_PROVIDER_API_KEY, DEFAULT_OPENAI_COMPATIBLE_PROVIDER_BASE_URL, DEFAULT_OPENAI_PROVIDER_MODEL, type IOpenAIProviderOptions, type IPayloadLogger, type IPayloadLoggerOptions, OpenAIConversationAdapter, OpenAIProvider, type TOpenAIProviderOptionValue, createOpenAIProviderDefinition };

package/dist/browser/index.js

@@ -0,0 +1,2 @@
+import C from'openai';import {AbstractAIProvider,SilentLogger}from'@robota-sdk/agent-core';import {assembleOpenAICompatibleStream,probeOpenAICompatibleProfile,OpenAICompatibleResponseParser,convertToOpenAICompatibleMessages,convertToOpenAICompatibleTools}from'@robota-sdk/agent-provider-openai-compatible';var p=class{parser;constructor(e){this.parser=new OpenAICompatibleResponseParser({logger:e});}parseResponse(e){try{return this.parser.parseResponse(e)}catch(t){let r=d(t instanceof Error?t.message:"OpenAI response parsing failed");throw new Error(`OpenAI response parsing failed: ${r}`)}}parseStreamingChunk(e){try{return this.parser.parseStreamingChunk(e)}catch(t){let r=d(t instanceof Error?t.message:"OpenAI chunk parsing failed");throw new Error(`OpenAI chunk parsing failed: ${r}`)}}};function d(a){return a.replace(/^OpenAI-compatible response parsing failed: /,"").replace(/^OpenAI-compatible chunk parsing failed: /,"").replace("OpenAI-compatible response","OpenAI response")}function c(a){return convertToOpenAICompatibleMessages(a)}function m(a){return convertToOpenAICompatibleTools(a)}var i=class extends AbstractAIProvider{name="openai";version="1.0.0";client;options;payloadLogger;responseParser;onTextDelta;constructor(e){if(super(e.logger||SilentLogger),this.options=e,e.executor&&(this.executor=e.executor),!this.executor)if(e.client)this.client=e.client;else if(e.apiKey)this.client=new C({apiKey:e.apiKey,...e.organization&&{organization:e.organization},...e.timeout&&{timeout:e.timeout},...e.baseURL&&{baseURL:e.baseURL}});else throw new Error("Either OpenAI client, apiKey, or executor is required");this.responseParser=new p(this.logger),this.payloadLogger=e.payloadLogger;}async chat(e,t){if(this.validateMessages(e),this.executor)try{return await this.executeViaExecutorOrDirect(e,t)}catch(r){throw this.logger.error("OpenAI Provider executor chat error:",r instanceof Error?r.message:String(r)),r}if(!this.client)throw new Error("OpenAI client not available. Either provide a client/apiKey or use an executor.");try{let r=c(e),o=t;if(!o?.model)throw new Error("Model is required in chat options. Please specify a model in defaultModel configuration.");let s={model:o.model,messages:r,...o.temperature!==void 0&&{temperature:o.temperature},...o.maxTokens&&{max_tokens:o.maxTokens},...o.tools&&{tools:m(o.tools),tool_choice:"auto"}},n=o.onTextDelta??this.onTextDelta;if(n)return await this.chatWithStreamingAssembly({...s,stream:!0},{...o,onTextDelta:n});if(this.payloadLogger?.isEnabled()){let I={model:s.model,messagesCount:r.length,hasTools:!!s.tools,temperature:s.temperature??void 0,maxTokens:s.max_tokens??void 0,timestamp:new Date().toISOString()};await this.payloadLogger.logPayload(I,"chat");}let l=await this.client.chat.completions.create(s);return this.responseParser.parseResponse(l)}catch(r){let s=r.message||"OpenAI API request failed";throw new Error(`OpenAI chat failed: ${s}`)}}async chatWithStreamingAssembly(e,t){if(!this.client)throw new Error("OpenAI client not available. Either provide a client/apiKey or use an executor.");try{if(this.payloadLogger?.isEnabled()){let o={model:e.model,messagesCount:e.messages.length,hasTools:!!e.tools,temperature:e.temperature??void 0,maxTokens:e.max_tokens??void 0,timestamp:new Date().toISOString()};await this.payloadLogger.logPayload(o,"stream");}let r=await this.client.chat.completions.create(e,t.signal?{signal:t.signal}:void 0);return assembleOpenAICompatibleStream({stream:r,onTextDelta:t.onTextDelta,signal:t.signal})}catch(r){let s=r.message||"OpenAI streaming request failed";throw new Error(`OpenAI stream failed: ${s}`)}}async*chatStream(e,t){if(this.executor)try{yield*this.executeStreamViaExecutorOrDirect(e,t);return}catch(r){throw this.logger.error("OpenAI Provider executor stream error:",r instanceof Error?r.message:String(r)),r}if(!this.client)throw new Error("OpenAI client not available. Either provide a client/apiKey or use an executor.");try{let r=c(e);if(!t?.model)throw new Error("Model is required in chat options. Please specify a model in defaultModel configuration.");let o={model:t.model,messages:r,stream:!0,...t?.temperature!==void 0&&{temperature:t.temperature},...t?.maxTokens&&{max_tokens:t.maxTokens},...t?.tools&&{tools:m(t.tools),tool_choice:"auto"}};if(this.payloadLogger?.isEnabled()){let n={model:o.model,messagesCount:r.length,hasTools:!!o.tools,temperature:o.temperature??void 0,maxTokens:o.max_tokens??void 0,timestamp:new Date().toISOString()};await this.payloadLogger.logPayload(n,"stream");}let s=await this.client.chat.completions.create(o);for await(let n of s){let l=this.responseParser.parseStreamingChunk(n);l&&(yield l);}}catch(r){let s=r.message||"OpenAI API request failed";throw new Error(`OpenAI stream failed: ${s}`)}}supportsTools(){return  true}validateConfig(){return !!this.client&&!!this.options}async dispose(){}validateMessages(e){super.validateMessages(e);for(let t of e)if(t.role==="assistant"){let r=t;if(r.toolCalls&&r.toolCalls.length>0&&r.content==="")continue}}};var g=class{static filterMessagesForOpenAI(e){return e.filter(t=>t.role==="user"||t.role==="assistant"||t.role==="system"?true:t.role==="tool"?!!(t.toolCallId&&t.toolCallId.trim()!==""&&t.toolCallId!=="unknown"):false)}static toOpenAIFormat(e){return this.filterMessagesForOpenAI(e).map(r=>this.convertMessage(r))}static convertMessage(e){let t=e.role;if(t==="user")return {role:"user",content:e.content};if(t==="assistant"){let o=e;return o.toolCalls&&o.toolCalls.length>0?{role:"assistant",content:o.content===""?null:o.content||null,tool_calls:o.toolCalls.map(n=>({id:n.id,type:"function",function:{name:n.function.name,arguments:n.function.arguments}}))}:{role:"assistant",content:o.content===null||o.content===""?null:o.content||""}}if(t==="system")return {role:"system",content:e.content};if(t==="tool"){if(!e.toolCallId||e.toolCallId.trim()==="")throw new Error(`Tool message missing toolCallId: ${JSON.stringify(e)}`);return {role:"tool",content:e.content,tool_call_id:e.toolCallId}}let r=t;throw new Error(`Unsupported message role: ${r}`)}static addSystemPromptIfNeeded(e,t){return !t||e.some(o=>o.role==="system")?e:[{role:"system",content:t},...e]}};var N=void 0,h="lm-studio",f="http://localhost:1234/v1";function z(){return {type:"openai",defaults:{apiKey:h,baseURL:f},setupSteps:[{key:"baseURL",title:"OpenAI-compatible base URL",defaultValue:f},{key:"model",title:"OpenAI-compatible model",required:true},{key:"apiKey",title:"OpenAI-compatible API key",defaultValue:h,masked:true}],requiresApiKey:true,probeProfile:probeOpenAICompatibleProfile,createProvider:a=>new i({apiKey:x(a.apiKey),...a.baseURL!==void 0&&{baseURL:a.baseURL},...a.timeout!==void 0&&{timeout:a.timeout},defaultModel:a.model})}}function x(a){if(!a)throw new Error("Provider openai requires apiKey");return a}
+export{h as DEFAULT_OPENAI_COMPATIBLE_PROVIDER_API_KEY,f as DEFAULT_OPENAI_COMPATIBLE_PROVIDER_BASE_URL,N as DEFAULT_OPENAI_PROVIDER_MODEL,g as OpenAIConversationAdapter,i as OpenAIProvider,z as createOpenAIProviderDefinition};