@ahoo-wang/fetcher-openai 2.9.8

package/dist/chat/chatClient.d.ts

@@ -0,0 +1,225 @@
+import { ApiMetadata, ApiMetadataCapable, ExecuteLifeCycle } from '@ahoo-wang/fetcher-decorator';
+import { JsonServerSentEventStream } from '@ahoo-wang/fetcher-eventstream';
+import { FetchExchange } from '@ahoo-wang/fetcher';
+import { ChatRequest, ChatResponse } from './types';
+/**
+ * OpenAI Chat API Client
+ *
+ * A comprehensive client for OpenAI's Chat Completions API that provides type-safe integration
+ * with both streaming and non-streaming chat completion endpoints. This client leverages the
+ * fetcher-decorator pattern to enable declarative API definitions and automatic request/response
+ * handling.
+ *
+ * Key Features:
+ * - Type-safe request/response handling with TypeScript generics
+ * - Automatic streaming response processing for server-sent events
+ * - Lifecycle hooks for request preprocessing and response transformation
+ * - Support for all OpenAI Chat Completion API parameters
+ * - Conditional return types based on streaming configuration
+ *
+ * @implements {ApiMetadataCapable} - Supports API metadata configuration
+ * @implements {ExecuteLifeCycle} - Provides lifecycle hooks for request processing
+ *
+ * @example
+ * ```typescript
+ * import { ChatClient } from '@ahoo-wang/fetcher-openai';
+ *
+ * const client = new ChatClient({
+ *   baseURL: 'https://api.openai.com/v1',
+ *   headers: {
+ *     'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`
+ *   }
+ * });
+ *
+ * // Non-streaming completion
+ * const response = await client.completions({
+ *   model: 'gpt-3.5-turbo',
+ *   messages: [{ role: 'user', content: 'Hello, world!' }]
+ * });
+ *
+ * // Streaming completion
+ * const stream = await client.completions({
+ *   model: 'gpt-3.5-turbo',
+ *   messages: [{ role: 'user', content: 'Tell me a story' }],
+ *   stream: true
+ * });
+ *
+ * for await (const chunk of stream) {
+ *   console.log(chunk.choices[0]?.delta?.content || '');
+ * }
+ * ```
+ */
+export declare class ChatClient implements ApiMetadataCapable, ExecuteLifeCycle {
+    readonly apiMetadata?: ApiMetadata | undefined;
+    /**
+     * Creates a new ChatClient instance with optional API configuration.
+     *
+     * The API metadata allows customization of request behavior such as base URLs,
+     * default headers, timeout settings, and other fetcher configuration options.
+     * This enables flexible deployment scenarios (e.g., custom API endpoints, proxy configurations).
+     *
+     * @param apiMetadata - Optional configuration object for customizing API behavior.
+     *                       Includes baseURL, headers, timeout, and other fetcher options.
+     *                       If not provided, uses default fetcher configuration.
+     *
+     * @example
+     * ```typescript
+     * // Basic usage with default configuration
+     * const client = new ChatClient();
+     *
+     * // With custom API endpoint and authentication
+     * const client = new ChatClient({
+     *   baseURL: 'https://api.openai.com/v1',
+     *   headers: {
+     *     'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
+     *     'Content-Type': 'application/json'
+     *   },
+     *   timeout: 30000
+     * });
+     *
+     * // With custom fetcher configuration
+     * const client = new ChatClient({
+     *   baseURL: 'https://custom-openai-proxy.com/api',
+     *   interceptors: [customAuthInterceptor]
+     * });
+     * ```
+     */
+    constructor(apiMetadata?: ApiMetadata | undefined);
+    /**
+     * Lifecycle hook executed before request processing.
+     *
+     * This method implements the ExecuteLifeCycle interface and is automatically called by the
+     * fetcher-decorator framework before each API request. It inspects the chat request to determine
+     * whether streaming is requested and configures the appropriate result extractor accordingly.
+     *
+     * The method performs dynamic result extractor assignment:
+     * - For streaming requests (`stream: true`): Assigns `CompletionStreamResultExtractor` to handle
+     *   server-sent event streams with automatic termination detection
+     * - For non-streaming requests (`stream: false` or undefined): Uses the default JSON extractor
+     *   for standard JSON response parsing
+     *
+     * This approach enables type-safe conditional return types while maintaining clean API design.
+     *
+     * @param exchange - The fetch exchange object containing request details, response information,
+     *                   and configuration that can be modified before execution
+     *
+     * @example
+     * ```typescript
+     * // This method is called automatically by the framework
+     * // No manual invocation needed - shown for illustration:
+     *
+     * const exchange = {
+     *   request: { body: { stream: true, messages: [...] } },
+     *   resultExtractor: undefined // Will be set by beforeExecute
+     * };
+     *
+     * client.beforeExecute(exchange);
+     * // exchange.resultExtractor is now CompletionStreamResultExtractor
+     * ```
+     */
+    beforeExecute(exchange: FetchExchange): void;
+    /**
+     * Creates a chat completion using OpenAI's Chat Completions API.
+     *
+     * This is the primary method for interacting with OpenAI's chat completion models.
+     * It supports both synchronous and streaming response modes, automatically handling
+     * the appropriate response processing based on the `stream` parameter.
+     *
+     * The method uses advanced TypeScript conditional types to provide type-safe return values:
+     * - When `stream: true`, returns a `JsonServerSentEventStream<ChatResponse>` for real-time streaming
+     * - When `stream: false` or omitted, returns a standard `ChatResponse` object
+     *
+     * Streaming responses automatically terminate when the API sends a '[DONE]' signal,
+     * eliminating the need for manual stream management.
+     *
+     * @template T - The chat request type, constrained to ChatRequest for type safety
+     * @param chatRequest - Complete chat request configuration including:
+     *                      - `model`: The model to use (e.g., 'gpt-3.5-turbo', 'gpt-4')
+     *                      - `messages`: Array of chat messages with role/content pairs
+     *                      - `stream`: Optional boolean to enable streaming responses
+     *                      - `temperature`: Optional creativity control (0.0 to 2.0)
+     *                      - `max_tokens`: Optional maximum response length
+     *                      - `top_p`: Optional nucleus sampling parameter
+     *                      - `frequency_penalty`: Optional repetition control (-2.0 to 2.0)
+     *                      - `presence_penalty`: Optional topic diversity control (-2.0 to 2.0)
+     *                      - `stop`: Optional stop sequences (string or string array)
+     *                      - Additional OpenAI API parameters as needed
+     * @returns Promise resolving to:
+     *          - `JsonServerSentEventStream<ChatResponse>` when `T['stream'] extends true`
+     *          - `ChatResponse` when streaming is disabled or undefined
+     * @throws {Error} Network errors, authentication failures, or API errors
+     * @throws {EventStreamConvertError} When streaming response cannot be processed
+     *
+     * @example
+     * ```typescript
+     * // Basic non-streaming completion
+     * const response = await client.completions({
+     *   model: 'gpt-3.5-turbo',
+     *   messages: [
+     *     { role: 'system', content: 'You are a helpful assistant.' },
+     *     { role: 'user', content: 'What is TypeScript?' }
+     *   ],
+     *   temperature: 0.7,
+     *   max_tokens: 150
+     * });
+     *
+     * console.log(response.choices[0].message.content);
+     * // Output: TypeScript is a programming language developed by Microsoft...
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Streaming completion with real-time output
+     * const stream = await client.completions({
+     *   model: 'gpt-4',
+     *   messages: [{ role: 'user', content: 'Write a short story' }],
+     *   stream: true,
+     *   temperature: 0.8
+     * });
+     *
+     * for await (const chunk of stream) {
+     *   const content = chunk.choices[0]?.delta?.content;
+     *   if (content) {
+     *     process.stdout.write(content); // Real-time streaming output
+     *   }
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Advanced configuration with multiple parameters
+     * const response = await client.completions({
+     *   model: 'gpt-3.5-turbo',
+     *   messages: [{ role: 'user', content: 'Explain quantum computing' }],
+     *   temperature: 0.3,        // Lower temperature for more focused responses
+     *   max_tokens: 500,         // Limit response length
+     *   top_p: 0.9,             // Nucleus sampling
+     *   frequency_penalty: 0.1,  // Reduce repetition
+     *   presence_penalty: 0.1,   // Encourage topic diversity
+     *   stop: ['###', 'END']     // Custom stop sequences
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Error handling
+     * try {
+     *   const response = await client.completions({
+     *     model: 'gpt-3.5-turbo',
+     *     messages: [{ role: 'user', content: 'Hello!' }]
+     *   });
+     *   console.log('Success:', response);
+     * } catch (error) {
+     *   if (error.response?.status === 401) {
+     *     console.error('Authentication failed - check API key');
+     *   } else if (error.response?.status === 429) {
+     *     console.error('Rate limit exceeded - retry later');
+     *   } else {
+     *     console.error('API error:', error.message);
+     *   }
+     * }
+     * ```
+     */
+    completions<T extends ChatRequest = ChatRequest>(chatRequest: T): Promise<T['stream'] extends true ? JsonServerSentEventStream<ChatResponse> : ChatResponse>;
+}
+//# sourceMappingURL=chatClient.d.ts.map

package/dist/chat/chatClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatClient.d.ts","sourceRoot":"","sources":["../../src/chat/chatClient.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,WAAW,EAChB,kBAAkB,EAGlB,gBAAgB,EAEjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBACa,UAAW,YAAW,kBAAkB,EAAE,gBAAgB;aAkCzC,WAAW,CAAC,EAAE,WAAW;IAjCrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;gBACyB,WAAW,CAAC,EAAE,WAAW,YAAA;IAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,aAAa,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAO5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqGG;IAEH,WAAW,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACrC,WAAW,EAAE,CAAC,GACrB,OAAO,CACR,CAAC,CAAC,QAAQ,CAAC,SAAS,IAAI,GACpB,yBAAyB,CAAC,YAAY,CAAC,GACvC,YAAY,CACjB;CAGF"}

package/dist/chat/completionStreamResultExtractor.d.ts

@@ -0,0 +1,67 @@
+import { ResultExtractor } from '@ahoo-wang/fetcher';
+import { JsonServerSentEventStream, TerminateDetector } from '@ahoo-wang/fetcher-eventstream';
+import { ChatResponse } from './types';
+/**
+ * A termination detector for OpenAI chat completion streams.
+ *
+ * This detector identifies when a chat completion stream has finished by checking
+ * if the server-sent event data equals '[DONE]'. This is the standard completion
+ * signal used by OpenAI's API for streaming chat completions.
+ *
+ * @param event - The server-sent event to evaluate for termination
+ * @returns true if the event indicates stream completion, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const event: ServerSentEvent = { data: '[DONE]', event: 'done' };
+ * const isDone = DoneDetector(event); // returns true
+ * ```
+ */
+export declare const DoneDetector: TerminateDetector;
+/**
+ * Result extractor for OpenAI chat completion streaming responses.
+ *
+ * This extractor processes HTTP responses from OpenAI's chat completion API endpoints
+ * that return streaming responses. It converts the response into a JSON server-sent
+ * event stream that automatically terminates when the completion is finished.
+ *
+ * The extractor uses the DoneDetector to identify completion signals and ensures
+ * the response is properly formatted as a server-sent event stream with JSON data.
+ *
+ * @param exchange - The fetch exchange containing the HTTP response from OpenAI's API
+ * @returns A JSON server-sent event stream of ChatResponse objects that terminates on completion
+ * @throws {EventStreamConvertError} If the response is not a valid event stream or has incorrect content type
+ *
+ * @example
+ * ```typescript
+ * import { fetcher } from '@ahoo-wang/fetcher';
+ * import { CompletionStreamResultExtractor } from '@ahoo-wang/fetcher-openai';
+ *
+ * const response = await fetcher.post('/chat/completions', {
+ *   model: 'gpt-3.5-turbo',
+ *   messages: [{ role: 'user', content: 'Hello!' }],
+ *   stream: true
+ * });
+ *
+ * const stream = CompletionStreamResultExtractor(response);
+ *
+ * for await (const event of stream) {
+ *   console.log('Received:', event.data);
+ *   // Stream automatically terminates when '[DONE]' is received
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with fetcher configuration
+ * const fetcherWithExtractor = fetcher.extend({
+ *   resultExtractor: CompletionStreamResultExtractor
+ * });
+ *
+ * const stream = await fetcherWithExtractor.post('/chat/completions', {
+ *   // ... request options
+ * });
+ * ```
+ */
+export declare const CompletionStreamResultExtractor: ResultExtractor<JsonServerSentEventStream<ChatResponse>>;
+//# sourceMappingURL=completionStreamResultExtractor.d.ts.map

package/dist/chat/completionStreamResultExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completionStreamResultExtractor.d.ts","sourceRoot":"","sources":["../../src/chat/completionStreamResultExtractor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAiB,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,gCAAgC,CAAC;AACxC,OAAO,EACL,yBAAyB,EAEzB,iBAAiB,EAClB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,EAAE,iBAE1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,+BAA+B,EAAE,eAAe,CAC3D,yBAAyB,CAAC,YAAY,CAAC,CAGxC,CAAC"}

package/dist/chat/index.d.ts

@@ -0,0 +1,4 @@
+export * from './chatClient';
+export * from './completionStreamResultExtractor';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/chat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/chat/index.ts"],"names":[],"mappings":"AAaA,cAAc,cAAc,CAAC;AAC7B,cAAc,mCAAmC,CAAC;AAClD,cAAc,SAAS,CAAC"}

package/dist/chat/types.d.ts

@@ -0,0 +1,114 @@
+export interface ChatRequest {
+    /**
+     * 默认为 0 -2.0 到 2.0 之间的数字。正值根据文本目前的存在频率惩罚新标记,降低模型重复相同行的可能性。  有关频率和存在惩罚的更多信息。
+     */
+    frequency_penalty?: number;
+    /**
+     * 修改指定标记出现在补全中的可能性。
+     *
+     * 接受一个 JSON 对象,该对象将标记(由标记器指定的标记 ID)映射到相关的偏差值(-100 到 100)。从数学上讲,偏差在对模型进行采样之前添加到模型生成的 logit
+     * 中。确切效果因模型而异,但-1 和 1 之间的值应减少或增加相关标记的选择可能性;如-100 或 100 这样的值应导致相关标记的禁用或独占选择。
+     */
+    logit_bias?: null;
+    /**
+     * 默认为 inf
+     * 在聊天补全中生成的最大标记数。
+     *
+     * 输入标记和生成标记的总长度受模型的上下文长度限制。计算标记的 Python 代码示例。
+     */
+    max_tokens?: number;
+    /**
+     * 至今为止对话所包含的消息列表。Python 代码示例。
+     */
+    messages: Message[];
+    /**
+     * 要使用的模型的 ID。有关哪些模型可与聊天 API 一起使用的详细信息,请参阅模型端点兼容性表。
+     */
+    model?: string;
+    /**
+     * 默认为 1
+     * 为每个输入消息生成多少个聊天补全选择。
+     */
+    n?: number;
+    /**
+     * -2.0 和 2.0 之间的数字。正值会根据到目前为止是否出现在文本中来惩罚新标记，从而增加模型谈论新主题的可能性。
+     * [查看有关频率和存在惩罚的更多信息。](https://platform.openai.com/docs/api-reference/parameter-details)
+     */
+    presence_penalty?: number;
+    /**
+     * 指定模型必须输出的格式的对象。  将 { "type": "json_object" } 启用 JSON 模式,这可以确保模型生成的消息是有效的 JSON。  重要提示:使用
+     * JSON 模式时,还必须通过系统或用户消息指示模型生成
+     * JSON。如果不这样做,模型可能会生成无休止的空白流,直到生成达到令牌限制,从而导致延迟增加和请求“卡住”的外观。另请注意,如果
+     * finish_reason="length",则消息内容可能会被部分切断,这表示生成超过了 max_tokens 或对话超过了最大上下文长度。  显示属性
+     */
+    response_format?: {
+        [key: string]: any;
+    };
+    /**
+     * 此功能处于测试阶段。如果指定,我们的系统将尽最大努力确定性地进行采样,以便使用相同的种子和参数进行重复请求应返回相同的结果。不能保证确定性,您应该参考
+     * system_fingerprint 响应参数来监控后端的更改。
+     */
+    seen?: number;
+    /**
+     * 默认为 null 最多 4 个序列,API 将停止进一步生成标记。
+     */
+    stop?: string;
+    /**
+     * 默认为 false 如果设置,则像在 ChatGPT 中一样会发送部分消息增量。标记将以仅数据的服务器发送事件的形式发送,这些事件在可用时,并在 data: [DONE]
+     * 消息终止流。Python 代码示例。
+     */
+    stream?: boolean;
+    /**
+     * 使用什么采样温度，介于 0 和 2 之间。较高的值（如 0.8）将使输出更加随机，而较低的值（如 0.2）将使输出更加集中和确定。
+     * 我们通常建议改变这个或`top_p`但不是两者。
+     */
+    temperature?: number;
+    /**
+     * 控制模型调用哪个函数(如果有的话)。none 表示模型不会调用函数,而是生成消息。auto 表示模型可以在生成消息和调用函数之间进行选择。通过 {"type":
+     * "function", "function": {"name": "my_function"}} 强制模型调用该函数。  如果没有函数存在,默认为
+     * none。如果有函数存在,默认为 auto。  显示可能的类型
+     */
+    tool_choice?: {
+        [key: string]: any;
+    };
+    /**
+     * 模型可以调用的一组工具列表。目前,只支持作为工具的函数。使用此功能来提供模型可以为之生成 JSON 输入的函数列表。
+     */
+    tools?: string[];
+    /**
+     * 一种替代温度采样的方法，称为核采样，其中模型考虑具有 top_p 概率质量的标记的结果。所以 0.1 意味着只考虑构成前 10% 概率质量的标记。
+     * 我们通常建议改变这个或`temperature`但不是两者。
+     */
+    top_p?: number;
+    /**
+     * 代表您的最终用户的唯一标识符，可以帮助 OpenAI
+     * 监控和检测滥用行为。[了解更多](https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids)。
+     */
+    user?: string;
+}
+export interface Message {
+    content?: string;
+    role?: string;
+    [property: string]: any;
+}
+export interface ChatResponse {
+    choices: Choice[];
+    created: number;
+    id: string;
+    object: string;
+    usage: Usage;
+    [property: string]: any;
+}
+export interface Choice {
+    finish_reason?: string;
+    index?: number;
+    message?: Message;
+    [property: string]: any;
+}
+export interface Usage {
+    completion_tokens: number;
+    prompt_tokens: number;
+    total_tokens: number;
+    [property: string]: any;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/chat/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/chat/types.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,CAAC,CAAC,EAAE,MAAM,CAAC;IACX;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,eAAe,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;IACzC;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,WAAW,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;IACrC;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IAEb,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC;CACzB;AAED,MAAM,WAAW,MAAM;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC;CACzB;AAED,MAAM,WAAW,KAAK;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IAErB,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC;CACzB"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './chat';
+export * from './openai';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

package/dist/index.es.js

@@ -0,0 +1,128 @@
+import { post as i, body as h, api as u, autoGeneratedError as l } from "@ahoo-wang/fetcher-decorator";
+import "@ahoo-wang/fetcher-eventstream";
+import { Fetcher as m } from "@ahoo-wang/fetcher";
+const f = (e) => e.data === "[DONE]", v = (e) => e.requiredResponse.requiredJsonEventStream(f);
+var _ = Object.defineProperty, b = Object.getOwnPropertyDescriptor, p = (e, t, s, o) => {
+  for (var r = o > 1 ? void 0 : o ? b(t, s) : t, c = e.length - 1, n; c >= 0; c--)
+    (n = e[c]) && (r = (o ? n(t, s, r) : n(r)) || r);
+  return o && r && _(t, s, r), r;
+}, d = (e, t) => (s, o) => t(s, o, e);
+let a = class {
+  /**
+   * Creates a new ChatClient instance with optional API configuration.
+   *
+   * The API metadata allows customization of request behavior such as base URLs,
+   * default headers, timeout settings, and other fetcher configuration options.
+   * This enables flexible deployment scenarios (e.g., custom API endpoints, proxy configurations).
+   *
+   * @param apiMetadata - Optional configuration object for customizing API behavior.
+   *                       Includes baseURL, headers, timeout, and other fetcher options.
+   *                       If not provided, uses default fetcher configuration.
+   *
+   * @example
+   * ```typescript
+   * // Basic usage with default configuration
+   * const client = new ChatClient();
+   *
+   * // With custom API endpoint and authentication
+   * const client = new ChatClient({
+   *   baseURL: 'https://api.openai.com/v1',
+   *   headers: {
+   *     'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
+   *     'Content-Type': 'application/json'
+   *   },
+   *   timeout: 30000
+   * });
+   *
+   * // With custom fetcher configuration
+   * const client = new ChatClient({
+   *   baseURL: 'https://custom-openai-proxy.com/api',
+   *   interceptors: [customAuthInterceptor]
+   * });
+   * ```
+   */
+  constructor(e) {
+    this.apiMetadata = e;
+  }
+  /**
+   * Lifecycle hook executed before request processing.
+   *
+   * This method implements the ExecuteLifeCycle interface and is automatically called by the
+   * fetcher-decorator framework before each API request. It inspects the chat request to determine
+   * whether streaming is requested and configures the appropriate result extractor accordingly.
+   *
+   * The method performs dynamic result extractor assignment:
+   * - For streaming requests (`stream: true`): Assigns `CompletionStreamResultExtractor` to handle
+   *   server-sent event streams with automatic termination detection
+   * - For non-streaming requests (`stream: false` or undefined): Uses the default JSON extractor
+   *   for standard JSON response parsing
+   *
+   * This approach enables type-safe conditional return types while maintaining clean API design.
+   *
+   * @param exchange - The fetch exchange object containing request details, response information,
+   *                   and configuration that can be modified before execution
+   *
+   * @example
+   * ```typescript
+   * // This method is called automatically by the framework
+   * // No manual invocation needed - shown for illustration:
+   *
+   * const exchange = {
+   *   request: { body: { stream: true, messages: [...] } },
+   *   resultExtractor: undefined // Will be set by beforeExecute
+   * };
+   *
+   * client.beforeExecute(exchange);
+   * // exchange.resultExtractor is now CompletionStreamResultExtractor
+   * ```
+   */
+  beforeExecute(e) {
+    e.request.body.stream && (e.resultExtractor = v);
+  }
+  completions(e) {
+    throw l(e);
+  }
+};
+p([
+  i("/completions"),
+  d(0, h())
+], a.prototype, "completions", 1);
+a = p([
+  u("chat")
+], a);
+class q {
+  /**
+   * Creates an instance of the OpenAI client.
+   *
+   * Initializes the client with the provided configuration options, setting up the
+   * HTTP client with proper authentication and creating specialized sub-clients
+   * for different API features.
+   *
+   * @param options - Configuration options for the OpenAI client.
+   * @throws {Error} If the provided options are invalid or missing required fields.
+   * @throws {TypeError} If the apiKey or baseURL are not strings.
+   *
+   * @example
+   * ```typescript
+   * const openai = new OpenAI({
+   *   baseURL: 'https://api.openai.com/v1',
+   *   apiKey: process.env.OPENAI_API_KEY!
+   * });
+   * ```
+   */
+  constructor(t) {
+    this.fetcher = new m({
+      baseURL: t.baseURL,
+      headers: {
+        Authorization: `Bearer ${t.apiKey}`
+      }
+    }), this.chat = new a({ fetcher: this.fetcher });
+  }
+}
+export {
+  a as ChatClient,
+  v as CompletionStreamResultExtractor,
+  f as DoneDetector,
+  q as OpenAI
+};
+//# sourceMappingURL=index.es.js.map

package/dist/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../src/chat/completionStreamResultExtractor.ts","../src/chat/chatClient.ts","../src/openai.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FetchExchange, ResultExtractor } from '@ahoo-wang/fetcher';\nimport '@ahoo-wang/fetcher-eventstream';\nimport {\n  JsonServerSentEventStream,\n  ServerSentEvent,\n  TerminateDetector,\n} from '@ahoo-wang/fetcher-eventstream';\nimport { ChatResponse } from './types';\n\n/**\n * A termination detector for OpenAI chat completion streams.\n *\n * This detector identifies when a chat completion stream has finished by checking\n * if the server-sent event data equals '[DONE]'. This is the standard completion\n * signal used by OpenAI's API for streaming chat completions.\n *\n * @param event - The server-sent event to evaluate for termination\n * @returns true if the event indicates stream completion, false otherwise\n *\n * @example\n * ```typescript\n * const event: ServerSentEvent = { data: '[DONE]', event: 'done' };\n * const isDone = DoneDetector(event); // returns true\n * ```\n */\nexport const DoneDetector: TerminateDetector = (event: ServerSentEvent) => {\n  return event.data === '[DONE]';\n};\n\n/**\n * Result extractor for OpenAI chat completion streaming responses.\n *\n * This extractor processes HTTP responses from OpenAI's chat completion API endpoints\n * that return streaming responses. It converts the response into a JSON server-sent\n * event stream that automatically terminates when the completion is finished.\n *\n * The extractor uses the DoneDetector to identify completion signals and ensures\n * the response is properly formatted as a server-sent event stream with JSON data.\n *\n * @param exchange - The fetch exchange containing the HTTP response from OpenAI's API\n * @returns A JSON server-sent event stream of ChatResponse objects that terminates on completion\n * @throws {EventStreamConvertError} If the response is not a valid event stream or has incorrect content type\n *\n * @example\n * ```typescript\n * import { fetcher } from '@ahoo-wang/fetcher';\n * import { CompletionStreamResultExtractor } from '@ahoo-wang/fetcher-openai';\n *\n * const response = await fetcher.post('/chat/completions', {\n *   model: 'gpt-3.5-turbo',\n *   messages: [{ role: 'user', content: 'Hello!' }],\n *   stream: true\n * });\n *\n * const stream = CompletionStreamResultExtractor(response);\n *\n * for await (const event of stream) {\n *   console.log('Received:', event.data);\n *   // Stream automatically terminates when '[DONE]' is received\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Using with fetcher configuration\n * const fetcherWithExtractor = fetcher.extend({\n *   resultExtractor: CompletionStreamResultExtractor\n * });\n *\n * const stream = await fetcherWithExtractor.post('/chat/completions', {\n *   // ... request options\n * });\n * ```\n */\nexport const CompletionStreamResultExtractor: ResultExtractor<\n  JsonServerSentEventStream<ChatResponse>\n> = (exchange: FetchExchange) => {\n  return exchange.requiredResponse.requiredJsonEventStream(DoneDetector);\n};\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  api,\n  type ApiMetadata,\n  ApiMetadataCapable,\n  autoGeneratedError,\n  body,\n  ExecuteLifeCycle,\n  post,\n} from '@ahoo-wang/fetcher-decorator';\nimport { JsonServerSentEventStream } from '@ahoo-wang/fetcher-eventstream';\nimport { FetchExchange } from '@ahoo-wang/fetcher';\nimport { ChatRequest, ChatResponse } from './types';\nimport { CompletionStreamResultExtractor } from './completionStreamResultExtractor';\n\n/**\n * OpenAI Chat API Client\n *\n * A comprehensive client for OpenAI's Chat Completions API that provides type-safe integration\n * with both streaming and non-streaming chat completion endpoints. This client leverages the\n * fetcher-decorator pattern to enable declarative API definitions and automatic request/response\n * handling.\n *\n * Key Features:\n * - Type-safe request/response handling with TypeScript generics\n * - Automatic streaming response processing for server-sent events\n * - Lifecycle hooks for request preprocessing and response transformation\n * - Support for all OpenAI Chat Completion API parameters\n * - Conditional return types based on streaming configuration\n *\n * @implements {ApiMetadataCapable} - Supports API metadata configuration\n * @implements {ExecuteLifeCycle} - Provides lifecycle hooks for request processing\n *\n * @example\n * ```typescript\n * import { ChatClient } from '@ahoo-wang/fetcher-openai';\n *\n * const client = new ChatClient({\n *   baseURL: 'https://api.openai.com/v1',\n *   headers: {\n *     'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`\n *   }\n * });\n *\n * // Non-streaming completion\n * const response = await client.completions({\n *   model: 'gpt-3.5-turbo',\n *   messages: [{ role: 'user', content: 'Hello, world!' }]\n * });\n *\n * // Streaming completion\n * const stream = await client.completions({\n *   model: 'gpt-3.5-turbo',\n *   messages: [{ role: 'user', content: 'Tell me a story' }],\n *   stream: true\n * });\n *\n * for await (const chunk of stream) {\n *   console.log(chunk.choices[0]?.delta?.content || '');\n * }\n * ```\n */\n@api('chat')\nexport class ChatClient implements ApiMetadataCapable, ExecuteLifeCycle {\n  /**\n   * Creates a new ChatClient instance with optional API configuration.\n   *\n   * The API metadata allows customization of request behavior such as base URLs,\n   * default headers, timeout settings, and other fetcher configuration options.\n   * This enables flexible deployment scenarios (e.g., custom API endpoints, proxy configurations).\n   *\n   * @param apiMetadata - Optional configuration object for customizing API behavior.\n   *                       Includes baseURL, headers, timeout, and other fetcher options.\n   *                       If not provided, uses default fetcher configuration.\n   *\n   * @example\n   * ```typescript\n   * // Basic usage with default configuration\n   * const client = new ChatClient();\n   *\n   * // With custom API endpoint and authentication\n   * const client = new ChatClient({\n   *   baseURL: 'https://api.openai.com/v1',\n   *   headers: {\n   *     'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,\n   *     'Content-Type': 'application/json'\n   *   },\n   *   timeout: 30000\n   * });\n   *\n   * // With custom fetcher configuration\n   * const client = new ChatClient({\n   *   baseURL: 'https://custom-openai-proxy.com/api',\n   *   interceptors: [customAuthInterceptor]\n   * });\n   * ```\n   */\n  constructor(public readonly apiMetadata?: ApiMetadata) {}\n\n  /**\n   * Lifecycle hook executed before request processing.\n   *\n   * This method implements the ExecuteLifeCycle interface and is automatically called by the\n   * fetcher-decorator framework before each API request. It inspects the chat request to determine\n   * whether streaming is requested and configures the appropriate result extractor accordingly.\n   *\n   * The method performs dynamic result extractor assignment:\n   * - For streaming requests (`stream: true`): Assigns `CompletionStreamResultExtractor` to handle\n   *   server-sent event streams with automatic termination detection\n   * - For non-streaming requests (`stream: false` or undefined): Uses the default JSON extractor\n   *   for standard JSON response parsing\n   *\n   * This approach enables type-safe conditional return types while maintaining clean API design.\n   *\n   * @param exchange - The fetch exchange object containing request details, response information,\n   *                   and configuration that can be modified before execution\n   *\n   * @example\n   * ```typescript\n   * // This method is called automatically by the framework\n   * // No manual invocation needed - shown for illustration:\n   *\n   * const exchange = {\n   *   request: { body: { stream: true, messages: [...] } },\n   *   resultExtractor: undefined // Will be set by beforeExecute\n   * };\n   *\n   * client.beforeExecute(exchange);\n   * // exchange.resultExtractor is now CompletionStreamResultExtractor\n   * ```\n   */\n  beforeExecute(exchange: FetchExchange): void {\n    const chatRequest = exchange.request.body as ChatRequest;\n    if (chatRequest.stream) {\n      exchange.resultExtractor = CompletionStreamResultExtractor;\n    }\n  }\n\n  /**\n   * Creates a chat completion using OpenAI's Chat Completions API.\n   *\n   * This is the primary method for interacting with OpenAI's chat completion models.\n   * It supports both synchronous and streaming response modes, automatically handling\n   * the appropriate response processing based on the `stream` parameter.\n   *\n   * The method uses advanced TypeScript conditional types to provide type-safe return values:\n   * - When `stream: true`, returns a `JsonServerSentEventStream<ChatResponse>` for real-time streaming\n   * - When `stream: false` or omitted, returns a standard `ChatResponse` object\n   *\n   * Streaming responses automatically terminate when the API sends a '[DONE]' signal,\n   * eliminating the need for manual stream management.\n   *\n   * @template T - The chat request type, constrained to ChatRequest for type safety\n   * @param chatRequest - Complete chat request configuration including:\n   *                      - `model`: The model to use (e.g., 'gpt-3.5-turbo', 'gpt-4')\n   *                      - `messages`: Array of chat messages with role/content pairs\n   *                      - `stream`: Optional boolean to enable streaming responses\n   *                      - `temperature`: Optional creativity control (0.0 to 2.0)\n   *                      - `max_tokens`: Optional maximum response length\n   *                      - `top_p`: Optional nucleus sampling parameter\n   *                      - `frequency_penalty`: Optional repetition control (-2.0 to 2.0)\n   *                      - `presence_penalty`: Optional topic diversity control (-2.0 to 2.0)\n   *                      - `stop`: Optional stop sequences (string or string array)\n   *                      - Additional OpenAI API parameters as needed\n   * @returns Promise resolving to:\n   *          - `JsonServerSentEventStream<ChatResponse>` when `T['stream'] extends true`\n   *          - `ChatResponse` when streaming is disabled or undefined\n   * @throws {Error} Network errors, authentication failures, or API errors\n   * @throws {EventStreamConvertError} When streaming response cannot be processed\n   *\n   * @example\n   * ```typescript\n   * // Basic non-streaming completion\n   * const response = await client.completions({\n   *   model: 'gpt-3.5-turbo',\n   *   messages: [\n   *     { role: 'system', content: 'You are a helpful assistant.' },\n   *     { role: 'user', content: 'What is TypeScript?' }\n   *   ],\n   *   temperature: 0.7,\n   *   max_tokens: 150\n   * });\n   *\n   * console.log(response.choices[0].message.content);\n   * // Output: TypeScript is a programming language developed by Microsoft...\n   * ```\n   *\n   * @example\n   * ```typescript\n   * // Streaming completion with real-time output\n   * const stream = await client.completions({\n   *   model: 'gpt-4',\n   *   messages: [{ role: 'user', content: 'Write a short story' }],\n   *   stream: true,\n   *   temperature: 0.8\n   * });\n   *\n   * for await (const chunk of stream) {\n   *   const content = chunk.choices[0]?.delta?.content;\n   *   if (content) {\n   *     process.stdout.write(content); // Real-time streaming output\n   *   }\n   * }\n   * ```\n   *\n   * @example\n   * ```typescript\n   * // Advanced configuration with multiple parameters\n   * const response = await client.completions({\n   *   model: 'gpt-3.5-turbo',\n   *   messages: [{ role: 'user', content: 'Explain quantum computing' }],\n   *   temperature: 0.3,        // Lower temperature for more focused responses\n   *   max_tokens: 500,         // Limit response length\n   *   top_p: 0.9,             // Nucleus sampling\n   *   frequency_penalty: 0.1,  // Reduce repetition\n   *   presence_penalty: 0.1,   // Encourage topic diversity\n   *   stop: ['###', 'END']     // Custom stop sequences\n   * });\n   * ```\n   *\n   * @example\n   * ```typescript\n   * // Error handling\n   * try {\n   *   const response = await client.completions({\n   *     model: 'gpt-3.5-turbo',\n   *     messages: [{ role: 'user', content: 'Hello!' }]\n   *   });\n   *   console.log('Success:', response);\n   * } catch (error) {\n   *   if (error.response?.status === 401) {\n   *     console.error('Authentication failed - check API key');\n   *   } else if (error.response?.status === 429) {\n   *     console.error('Rate limit exceeded - retry later');\n   *   } else {\n   *     console.error('API error:', error.message);\n   *   }\n   * }\n   * ```\n   */\n  @post('/completions')\n  completions<T extends ChatRequest = ChatRequest>(\n    @body() chatRequest: T,\n  ): Promise<\n    T['stream'] extends true\n      ? JsonServerSentEventStream<ChatResponse>\n      : ChatResponse\n  > {\n    throw autoGeneratedError(chatRequest);\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ChatClient } from './chat';\nimport { BaseURLCapable, Fetcher } from '@ahoo-wang/fetcher';\n\n/**\n * Configuration options for the OpenAI client.\n *\n * This interface defines the required settings to initialize an OpenAI client instance,\n * including the API endpoint and authentication credentials.\n */\nexport interface OpenAIOptions extends BaseURLCapable {\n  /**\n   * The base URL for the OpenAI API.\n   *\n   * This should be the root URL of the OpenAI API service (e.g., 'https://api.openai.com/v1').\n   * It is used as the base for all API requests made by the client.\n   */\n  baseURL: string;\n\n  /**\n   * The API key for authenticating requests to the OpenAI API.\n   *\n   * This key must be a valid OpenAI API key obtained from the OpenAI platform.\n   * It is included in the Authorization header as a Bearer token for all requests.\n   */\n  apiKey: string;\n}\n\n/**\n * OpenAI client class for interacting with the OpenAI API.\n *\n * This class provides a high-level interface to the OpenAI API, encapsulating HTTP client\n * functionality and specialized clients for different API features. It serves as the main entry\n * point for applications needing to integrate with OpenAI services.\n *\n * @example\n * ```typescript\n * const client = new OpenAI({\n *   baseURL: 'https://api.openai.com/v1',\n *   apiKey: 'your-api-key-here'\n * });\n *\n * // Use the chat client for completions\n * const response = await client.chat.completions.create({\n *   model: 'gpt-3.5-turbo',\n *   messages: [{ role: 'user', content: 'Hello!' }]\n * });\n * ```\n */\nexport class OpenAI {\n  /**\n   * HTTP client instance for making requests to the OpenAI API.\n   *\n   * This Fetcher instance is configured with the base URL and authentication headers\n   * provided during initialization. It handles all underlying HTTP communication.\n   */\n  public readonly fetcher: Fetcher;\n\n  /**\n   * Chat completion client for interacting with OpenAI's chat models.\n   *\n   * Provides methods to create chat completions, manage conversations, and handle\n   * streaming responses from chat-based models like GPT-3.5 and GPT-4.\n   */\n  public readonly chat: ChatClient;\n\n  /**\n   * Creates an instance of the OpenAI client.\n   *\n   * Initializes the client with the provided configuration options, setting up the\n   * HTTP client with proper authentication and creating specialized sub-clients\n   * for different API features.\n   *\n   * @param options - Configuration options for the OpenAI client.\n   * @throws {Error} If the provided options are invalid or missing required fields.\n   * @throws {TypeError} If the apiKey or baseURL are not strings.\n   *\n   * @example\n   * ```typescript\n   * const openai = new OpenAI({\n   *   baseURL: 'https://api.openai.com/v1',\n   *   apiKey: process.env.OPENAI_API_KEY!\n   * });\n   * ```\n   */\n  constructor(options: OpenAIOptions) {\n    this.fetcher = new Fetcher({\n      baseURL: options.baseURL,\n      headers: {\n        Authorization: `Bearer ${options.apiKey}`,\n      },\n    });\n    this.chat = new ChatClient({ fetcher: this.fetcher });\n  }\n}\n"],"names":["DoneDetector","event","CompletionStreamResultExtractor","exchange","ChatClient","apiMetadata","chatRequest","autoGeneratedError","__decorateClass","post","__decorateParam","body","api","OpenAI","options","Fetcher"],"mappings":";;;AAsCO,MAAMA,IAAkC,CAACC,MACvCA,EAAM,SAAS,UAgDXC,IAET,CAACC,MACIA,EAAS,iBAAiB,wBAAwBH,CAAY;;;;;;ACfhE,IAAMI,IAAN,MAAiE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkCtE,YAA4BC,GAA2B;AAA3B,SAAA,cAAAA;AAAA,EAA4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkCxD,cAAcF,GAA+B;AAE3C,IADoBA,EAAS,QAAQ,KACrB,WACdA,EAAS,kBAAkBD;AAAA,EAE/B;AAAA,EAyGA,YACUI,GAKR;AACA,UAAMC,EAAmBD,CAAW;AAAA,EACtC;AACF;AATEE,EAAA;AAAA,EADCC,EAAK,cAAc;AAAA,EAEjBC,EAAA,GAAAC,EAAA,CAAK;AAAA,GAnLGP,EAkLX,WAAA,eAAA,CAAA;AAlLWA,IAANI,EAAA;AAAA,EADNI,EAAI,MAAM;AAAA,GACER,CAAA;ACdN,MAAMS,EAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoClB,YAAYC,GAAwB;AAClC,SAAK,UAAU,IAAIC,EAAQ;AAAA,MACzB,SAASD,EAAQ;AAAA,MACjB,SAAS;AAAA,QACP,eAAe,UAAUA,EAAQ,MAAM;AAAA,MAAA;AAAA,IACzC,CACD,GACD,KAAK,OAAO,IAAIV,EAAW,EAAE,SAAS,KAAK,SAAS;AAAA,EACtD;AACF;"}

package/dist/index.umd.js

@@ -0,0 +1,2 @@
+(function(e,n){typeof exports=="object"&&typeof module<"u"?n(exports,require("@ahoo-wang/fetcher-decorator"),require("@ahoo-wang/fetcher-eventstream"),require("@ahoo-wang/fetcher")):typeof define=="function"&&define.amd?define(["exports","@ahoo-wang/fetcher-decorator","@ahoo-wang/fetcher-eventstream","@ahoo-wang/fetcher"],n):(e=typeof globalThis<"u"?globalThis:e||self,n(e.FetcherOpenAI={},e.FetcherDecorator,e.FetcherEventStream,e.Fetcher))})(this,(function(e,n,v,d){"use strict";const s=r=>r.data==="[DONE]",u=r=>r.requiredResponse.requiredJsonEventStream(s);var p=Object.defineProperty,l=Object.getOwnPropertyDescriptor,f=(r,t,a,c)=>{for(var o=c>1?void 0:c?l(t,a):t,i=r.length-1,h;i>=0;i--)(h=r[i])&&(o=(c?h(t,a,o):h(o))||o);return c&&o&&p(t,a,o),o},m=(r,t)=>(a,c)=>t(a,c,r);e.ChatClient=class{constructor(t){this.apiMetadata=t}beforeExecute(t){t.request.body.stream&&(t.resultExtractor=u)}completions(t){throw n.autoGeneratedError(t)}},f([n.post("/completions"),m(0,n.body())],e.ChatClient.prototype,"completions",1),e.ChatClient=f([n.api("chat")],e.ChatClient);class C{constructor(t){this.fetcher=new d.Fetcher({baseURL:t.baseURL,headers:{Authorization:`Bearer ${t.apiKey}`}}),this.chat=new e.ChatClient({fetcher:this.fetcher})}}e.CompletionStreamResultExtractor=u,e.DoneDetector=s,e.OpenAI=C,Object.defineProperty(e,Symbol.toStringTag,{value:"Module"})}));
+//# sourceMappingURL=index.umd.js.map