@robota-sdk/agent-provider 3.0.0-beta.64

package/dist/node/index-B7UvPJcI.d.ts

@@ -0,0 +1,315 @@
+import { AbstractAIProvider, IChatOptions, IExecutor, ILogger, IProviderCapabilities, IProviderDefinition, IProviderModelCatalog, IProviderProfileConfig, TProviderOptionValueBase, TTextDeltaCallback, TUniversalMessage } from "@robota-sdk/agent-core";
+import OpenAI from "openai";
+
+//#region src/openai/types/api-types.d.ts
+/**
+ * Payload logging data structure
+ */
+interface IOpenAILogData {
+  model: string;
+  messagesCount: number;
+  hasTools: boolean;
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  timestamp: string;
+  requestId?: string | undefined;
+}
+//#endregion
+//#region src/openai/interfaces/payload-logger.d.ts
+/**
+ * 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;
+}
+//#endregion
+//#region src/openai/types.d.ts
+type TOpenAIApiSurface = 'responses' | 'chat-completions';
+interface IOpenAIJsonSchemaDefinition {
+  name: string;
+  description?: string;
+  schema?: Record<string, TOpenAIProviderOptionValue>;
+  strict?: boolean;
+}
+interface IOpenAIResponsesReasoningOptions {
+  effort?: 'low' | 'medium' | 'high';
+  summary?: 'auto' | 'concise' | 'detailed';
+}
+interface IOpenAINativeWebToolsOptions {
+  webSearch?: boolean;
+  webFetch?: boolean;
+}
+/**
+ * Valid provider option value types
+ */
+type TOpenAIProviderOptionValue = string | number | boolean | undefined | null | IOpenAIJsonSchemaDefinition | IOpenAINativeWebToolsOptions | IOpenAIResponsesReasoningOptions | 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;
+  /**
+   * Default model used when chat options do not provide a model.
+   */
+  defaultModel?: string;
+  /**
+   * API surface to use for direct OpenAI calls.
+   *
+   * Defaults to Responses for official OpenAI calls. Profiles with baseURL use
+   * Chat Completions by default for OpenAI-compatible endpoint compatibility.
+   */
+  apiSurface?: TOpenAIApiSurface;
+  /**
+   * 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?: IOpenAIJsonSchemaDefinition;
+  /**
+   * Responses API reasoning controls. Hidden reasoning is never exposed in message
+   * content; only explicit summaries/encrypted items requested here are represented.
+   */
+  reasoning?: IOpenAIResponsesReasoningOptions;
+  /**
+   * Whether OpenAI should store Responses API results. Defaults to OpenAI API behavior.
+   */
+  store?: boolean;
+  /**
+   * Include encrypted reasoning items for stateless reasoning continuation.
+   */
+  includeEncryptedReasoning?: boolean;
+  /**
+   * Opt into strict custom function parameter validation where supported.
+   */
+  strictTools?: boolean;
+  /**
+   * Provider-native hosted web tool request from provider profile options.
+   *
+   * OpenAI-compatible Chat Completions endpoints do not support this Robota
+   * native web contract. The provider rejects unsupported configurations before
+   * any model request is sent.
+   */
+  nativeWebTools?: IOpenAINativeWebToolsOptions;
+  /**
+   * 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';
+   * const provider = new OpenAIProvider({
+   *   client: openaiClient,
+   *   payloadLogger: new FilePayloadLogger({ logDir: './logs/openai' })
+   * });
+   *
+   * // Browser
+   * import { ConsolePayloadLogger } from '@robota-sdk/agent-provider/openai/loggers';
+   * 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;
+}
+//#endregion
+//#region src/openai/provider.d.ts
+/**
+ * OpenAI provider implementation for Robota
+ *
+ * Provides integration with OpenAI models through the Robota provider contract.
+ * 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 apiSurface;
+  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>;
+  chatStream(messages: TUniversalMessage[], options?: IChatOptions): AsyncIterable<TUniversalMessage>;
+  supportsTools(): boolean;
+  getCapabilities(): IProviderCapabilities;
+  validateConfig(): boolean;
+  dispose(): Promise<void>;
+  protected validateMessages(messages: TUniversalMessage[]): void;
+}
+//#endregion
+//#region src/openai/adapter.d.ts
+/**
+ * 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[];
+}
+//#endregion
+//#region src/openai/model-catalog-refresh.d.ts
+interface IOpenAIModelCatalogResponse {
+  data?: readonly IOpenAIModelCatalogResource[];
+}
+interface IOpenAIModelCatalogResource {
+  id?: string;
+}
+interface IOpenAIModelCatalogFetchInit {
+  headers: Record<string, string>;
+}
+interface IOpenAIModelCatalogFetchResponse {
+  ok: boolean;
+  status: number;
+  statusText?: string;
+  json: () => Promise<IOpenAIModelCatalogResponse>;
+}
+type TOpenAIModelCatalogFetch = (url: string, init: IOpenAIModelCatalogFetchInit) => Promise<IOpenAIModelCatalogFetchResponse>;
+interface IRefreshOpenAIModelCatalogOptions {
+  fetcher?: TOpenAIModelCatalogFetch;
+  now?: () => Date;
+}
+declare function refreshOpenAIModelCatalog(profile: IProviderProfileConfig, options?: IRefreshOpenAIModelCatalogOptions): Promise<IProviderModelCatalog>;
+//#endregion
+//#region src/openai/provider-definition.d.ts
+declare const DEFAULT_OPENAI_PROVIDER_MODEL: string | undefined;
+declare const DEFAULT_OPENAI_PROVIDER_API_KEY_REFERENCE = "$ENV:OPENAI_API_KEY";
+declare function createOpenAIProviderDefinition(): IProviderDefinition;
+//#endregion
+export { TOpenAIApiSurface as _, IOpenAIModelCatalogFetchResponse as a, IPayloadLoggerOptions as b, IRefreshOpenAIModelCatalogOptions as c, OpenAIConversationAdapter as d, OpenAIProvider as f, IOpenAIResponsesReasoningOptions as g, IOpenAIProviderOptions as h, IOpenAIModelCatalogFetchInit as i, TOpenAIModelCatalogFetch as l, IOpenAINativeWebToolsOptions as m, DEFAULT_OPENAI_PROVIDER_MODEL as n, IOpenAIModelCatalogResource as o, IOpenAIJsonSchemaDefinition as p, createOpenAIProviderDefinition as r, IOpenAIModelCatalogResponse as s, DEFAULT_OPENAI_PROVIDER_API_KEY_REFERENCE as t, refreshOpenAIModelCatalog as u, TOpenAIProviderOptionValue as v, IPayloadLogger as y };
+//# sourceMappingURL=index-B7UvPJcI.d.ts.map

package/dist/node/index-B7UvPJcI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-B7UvPJcI.d.ts","names":[],"sources":["../../src/openai/types/api-types.ts","../../src/openai/interfaces/payload-logger.ts","../../src/openai/types.ts","../../src/openai/provider.ts","../../src/openai/adapter.ts","../../src/openai/model-catalog-refresh.ts","../../src/openai/provider-definition.ts"],"mappings":"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"}

package/dist/node/index-BLPOTNb5.d.ts

@@ -0,0 +1,98 @@
+import { AbstractAIProvider, IChatOptions, IExecutor, ILogger, IProviderCapabilities, IProviderDefinition, IProviderProfileConfig, IToolCall, IToolSchema, TProviderOptionValueBase, TTextDeltaCallback, TUniversalMessage } from "@robota-sdk/agent-core";
+import OpenAI from "openai";
+
+//#region src/gemma/types.d.ts
+type TGemmaProviderOptionValue = string | number | boolean | undefined | null | OpenAI | ILogger | IExecutor | TProviderOptionValueBase | TGemmaProviderOptionValue[] | {
+  [key: string]: TGemmaProviderOptionValue;
+};
+interface IGemmaProviderOptions {
+  [key: string]: TGemmaProviderOptionValue;
+  apiKey?: string;
+  baseURL?: string;
+  timeout?: number;
+  defaultModel?: string;
+  client?: OpenAI;
+  executor?: IExecutor;
+  logger?: ILogger;
+}
+//#endregion
+//#region src/gemma/reasoning-projector.d.ts
+interface IGemmaReasoningProjection {
+  rawText: string;
+  visibleText: string;
+  removedReasoning: boolean;
+}
+declare function projectGemmaReasoningText(rawText: string): IGemmaReasoningProjection;
+declare class GemmaReasoningProjector {
+  private buffer;
+  private emittedVisibleText;
+  private hasRemovedReasoning;
+  get rawText(): string;
+  get removedReasoning(): boolean;
+  project(delta: string): string;
+  flush(): string;
+  private projectVisibleText;
+}
+//#endregion
+//#region src/shared/openai-compatible/types.d.ts
+interface IOpenAICompatibleToolCallTextProjection {
+  visibleText: string;
+  toolCalls: IToolCall[];
+  removedToolCallText: boolean;
+  rawToolCallText?: string | undefined;
+}
+interface IOpenAICompatibleToolCallTextProjector {
+  project(text: string): IOpenAICompatibleToolCallTextProjection;
+  flush(): IOpenAICompatibleToolCallTextProjection;
+}
+//#endregion
+//#region src/gemma/tool-call-projector.d.ts
+interface IGemmaToolCallProjectorOptions {
+  toolNames: readonly string[];
+  callIdPrefix?: string;
+}
+interface IGemmaToolCallProjection extends IOpenAICompatibleToolCallTextProjection {
+  rawText: string;
+}
+declare function createGemmaToolCallProjector(tools: readonly IToolSchema[] | undefined): GemmaToolCallProjector | undefined;
+declare function projectGemmaToolCallText(rawText: string, options: IGemmaToolCallProjectorOptions): IGemmaToolCallProjection;
+declare class GemmaToolCallProjector implements IOpenAICompatibleToolCallTextProjector {
+  private readonly options;
+  private buffer;
+  private emittedVisibleText;
+  private emittedRawToolCallText;
+  private readonly emittedToolCallIds;
+  constructor(options: IGemmaToolCallProjectorOptions);
+  project(delta: string): IOpenAICompatibleToolCallTextProjection;
+  flush(): IOpenAICompatibleToolCallTextProjection;
+  private projectVisibleText;
+}
+//#endregion
+//#region src/gemma/provider.d.ts
+declare class GemmaProvider extends AbstractAIProvider {
+  readonly name = "gemma";
+  readonly version = "1.0.0";
+  private readonly client?;
+  private readonly options;
+  onTextDelta?: TTextDeltaCallback;
+  constructor(options: IGemmaProviderOptions);
+  chat(messages: TUniversalMessage[], options?: IChatOptions): Promise<TUniversalMessage>;
+  chatStream(messages: TUniversalMessage[], options?: IChatOptions): AsyncIterable<TUniversalMessage>;
+  supportsTools(): boolean;
+  getCapabilities(): IProviderCapabilities;
+  validateConfig(): boolean;
+  dispose(): Promise<void>;
+  protected validateMessages(messages: TUniversalMessage[]): void;
+  private buildRequestParams;
+  private buildStreamingRequestParams;
+  private chatWithStreamingAssembly;
+}
+//#endregion
+//#region src/gemma/provider-definition.d.ts
+declare const DEFAULT_GEMMA_PROVIDER_MODEL = "supergemma4-26b-uncensored-v2";
+declare const DEFAULT_GEMMA_PROVIDER_API_KEY = "lm-studio";
+declare const DEFAULT_GEMMA_PROVIDER_BASE_URL = "http://localhost:1234/v1";
+declare function createGemmaProviderDefinition(): IProviderDefinition;
+//#endregion
+export { GemmaProvider as a, IGemmaToolCallProjectorOptions as c, GemmaReasoningProjector as d, IGemmaReasoningProjection as f, TGemmaProviderOptionValue as h, createGemmaProviderDefinition as i, createGemmaToolCallProjector as l, IGemmaProviderOptions as m, DEFAULT_GEMMA_PROVIDER_BASE_URL as n, GemmaToolCallProjector as o, projectGemmaReasoningText as p, DEFAULT_GEMMA_PROVIDER_MODEL as r, IGemmaToolCallProjection as s, DEFAULT_GEMMA_PROVIDER_API_KEY as t, projectGemmaToolCallText as u };
+//# sourceMappingURL=index-BLPOTNb5.d.ts.map

package/dist/node/index-BLPOTNb5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BLPOTNb5.d.ts","names":[],"sources":["../../src/gemma/types.ts","../../src/gemma/reasoning-projector.ts","../../src/shared/openai-compatible/types.ts","../../src/gemma/tool-call-projector.ts","../../src/gemma/provider.ts","../../src/gemma/provider-definition.ts"],"mappings":";;;;KAGY,yBAAA,kDAMR,MAAA,GACA,OAAA,GACA,SAAA,GACA,wBAAA,GACA,yBAAA;EAAA,CACG,GAAA,WAAc,yBAAA;AAAA;AAAA,UAEJ,qBAAA;EAAA,CACd,GAAA,WAAc,yBAAA;EAEf,MAAA;EACA,OAAA;EACA,OAAA;EACA,YAAA;EACA,MAAA,GAAS,MAAA;EACT,QAAA,GAAW,SAAA;EACX,MAAA,GAAS,OAAA;AAAA;;;UCrBM,yBAAA;EACf,OAAA;EACA,WAAA;EACA,gBAAA;AAAA;AAAA,iBAYc,yBAAA,CAA0B,OAAA,WAAkB,yBAAyB;AAAA,cASxE,uBAAA;EAAA,QACH,MAAA;EAAA,QACA,kBAAA;EAAA,QACA,mBAAA;EAAA,IAEJ,OAAA,CAAA;EAAA,IAIA,gBAAA,CAAA;EAIJ,OAAA,CAAQ,KAAA;EASR,KAAA,CAAA;EAAA,QAIQ,kBAAA;AAAA;;;UChBO,uCAAA;EACf,WAAA;EACA,SAAA,EAAW,SAAS;EACpB,mBAAA;EACA,eAAA;AAAA;AAAA,UAGe,sCAAA;EACf,OAAA,CAAQ,IAAA,WAAe,uCAAA;EACvB,KAAA,IAAS,uCAAuC;AAAA;;;UClCjC,8BAAA;EACf,SAAA;EACA,YAAY;AAAA;AAAA,UAGG,wBAAA,SAAiC,uCAAuC;EACvF,OAAO;AAAA;AAAA,iBAcO,4BAAA,CACd,KAAA,WAAgB,WAAA,iBACf,sBAAsB;AAAA,iBAOT,wBAAA,CACd,OAAA,UACA,OAAA,EAAS,8BAAA,GACR,wBAAwB;AAAA,cAKd,sBAAA,YAAkC,sCAAA;EAAA,iBAMhB,OAAA;EAAA,QALrB,MAAA;EAAA,QACA,kBAAA;EAAA,QACA,sBAAA;EAAA,iBACS,kBAAA;cAEY,OAAA,EAAS,8BAAA;EAEtC,OAAA,CAAQ,KAAA,WAAgB,uCAAA;EASxB,KAAA,CAAA,GAAS,uCAAA;EAAA,QAID,kBAAA;AAAA;;;cC7CG,aAAA,SAAsB,kBAAA;EAAA,SACf,IAAA;EAAA,SACA,OAAA;EAAA,iBAED,MAAA;EAAA,iBACA,OAAA;EAEjB,WAAA,GAAc,kBAAA;cAEF,OAAA,EAAS,qBAAA;EAuBN,IAAA,CACb,QAAA,EAAU,iBAAA,IACV,OAAA,GAAU,YAAA,GACT,OAAA,CAAQ,iBAAA;EA2DK,UAAA,CACd,QAAA,EAAU,iBAAA,IACV,OAAA,GAAU,YAAA,GACT,aAAA,CAAc,iBAAA;EAwDR,aAAA,CAAA;EAIA,eAAA,CAAA,GAAmB,qBAAA;EAsBnB,cAAA,CAAA;EAIM,OAAA,CAAA,GAAW,OAAA;EAAA,UAIP,gBAAA,CAAiB,QAAA,EAAU,iBAAA;EAAA,QAiBtC,kBAAA;EAAA,QAyBA,2BAAA;EAAA,QAUM,yBAAA;AAAA;;;cCrQH,4BAAA;AAAA,cACA,8BAAA;AAAA,cACA,+BAAA;AAAA,iBA8BG,6BAAA,CAAA,GAAiC,mBAAmB"}

package/dist/node/index-BqixM_XD.d.ts

@@ -0,0 +1,231 @@
+import { AbstractAIProvider, IChatOptions, IExecutor, ILogger, IProviderDefinition, IProviderModelCatalog, IProviderProfileConfig, IToolSchema, TProviderOptionValueBase, TTextDeltaCallback, TUniversalMessage } from "@robota-sdk/agent-core";
+import OpenAI from "openai";
+
+//#region src/qwen/defaults.d.ts
+declare const QWEN_PROVIDER_BASE_URLS: {
+  readonly singapore: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
+  readonly usVirginia: "https://dashscope-us.aliyuncs.com/compatible-mode/v1";
+  readonly beijing: "https://dashscope.aliyuncs.com/compatible-mode/v1";
+  readonly hongKong: "https://cn-hongkong.dashscope.aliyuncs.com/compatible-mode/v1";
+};
+type TQwenProviderRegion = keyof typeof QWEN_PROVIDER_BASE_URLS;
+declare const QWEN_PROVIDER_RESPONSES_BASE_URLS: {
+  readonly singapore: "https://dashscope-intl.aliyuncs.com/api/v2/apps/protocols/compatible-mode/v1";
+  readonly usVirginia: "https://dashscope-us.aliyuncs.com/api/v2/apps/protocols/compatible-mode/v1";
+  readonly beijing: "https://dashscope.aliyuncs.com/api/v2/apps/protocols/compatible-mode/v1";
+};
+type TQwenProviderResponsesRegion = keyof typeof QWEN_PROVIDER_RESPONSES_BASE_URLS;
+declare const DEFAULT_QWEN_PROVIDER_MODEL = "qwen-plus";
+declare const DEFAULT_QWEN_PROVIDER_API_KEY_ENV = "DASHSCOPE_API_KEY";
+declare const DEFAULT_QWEN_PROVIDER_API_KEY_REFERENCE = "$ENV:DASHSCOPE_API_KEY";
+declare const DEFAULT_QWEN_PROVIDER_BASE_URL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
+declare const DEFAULT_QWEN_PROVIDER_RESPONSES_BASE_URL: "https://dashscope-intl.aliyuncs.com/api/v2/apps/protocols/compatible-mode/v1";
+declare const QWEN_MODEL_SOURCE_URL = "https://www.alibabacloud.com/help/en/model-studio/compatibility-of-openai-with-dashscope";
+declare const QWEN_MODEL_LAST_VERIFIED_AT = "2026-05-04";
+//#endregion
+//#region src/qwen/types.d.ts
+type TQwenBuiltInWebToolName = 'web_search' | 'web_extractor';
+interface IQwenBuiltInWebToolsOptions {
+  webSearch?: boolean;
+  webFetch?: boolean;
+  enableThinking?: boolean;
+}
+interface IQwenResponsesWebSearchTool {
+  type: 'web_search';
+}
+interface IQwenResponsesWebExtractorTool {
+  type: 'web_extractor';
+}
+interface IQwenResponsesFunctionTool {
+  type: 'function';
+  name: string;
+  description?: string;
+  parameters: IToolSchema['parameters'];
+}
+type TQwenResponsesTool = IQwenResponsesWebSearchTool | IQwenResponsesWebExtractorTool | IQwenResponsesFunctionTool;
+interface IQwenResponsesMessageInput {
+  type?: 'message';
+  role: 'user' | 'assistant' | 'system' | 'developer';
+  content: string;
+}
+interface IQwenResponsesFunctionCallInput {
+  type: 'function_call';
+  call_id: string;
+  name: string;
+  arguments: string;
+}
+interface IQwenResponsesFunctionCallOutputInput {
+  type: 'function_call_output';
+  call_id: string;
+  output: string;
+}
+type TQwenResponsesInputItem = IQwenResponsesMessageInput | IQwenResponsesFunctionCallInput | IQwenResponsesFunctionCallOutputInput;
+interface IQwenResponsesRequestBase {
+  model: string;
+  input: TQwenResponsesInputItem[];
+  tools?: TQwenResponsesTool[];
+  temperature?: number;
+  max_output_tokens?: number;
+  enable_thinking?: boolean;
+}
+interface IQwenResponsesRequestNonStreaming extends IQwenResponsesRequestBase {
+  stream?: false;
+}
+interface IQwenResponsesRequestStreaming extends IQwenResponsesRequestBase {
+  stream: true;
+}
+interface IQwenResponsesTextContent {
+  type: 'output_text' | 'text' | 'input_text';
+  text: string;
+}
+interface IQwenResponsesMessageOutputItem {
+  type: 'message';
+  content: IQwenResponsesTextContent[];
+}
+interface IQwenResponsesFunctionCallOutputItem {
+  type: 'function_call';
+  call_id: string;
+  name: string;
+  arguments: string;
+  id?: string;
+  status?: string;
+}
+interface IQwenResponsesWebSearchAction {
+  query?: string;
+}
+interface IQwenResponsesWebSearchOutputItem {
+  type: 'web_search_call';
+  id?: string;
+  status?: string;
+  action?: IQwenResponsesWebSearchAction;
+}
+interface IQwenResponsesWebExtractorOutputItem {
+  type: 'web_extractor_call';
+  id?: string;
+  status?: string;
+  goal?: string;
+  output?: string;
+}
+interface IQwenResponsesGenericOutputItem {
+  type: string;
+  id?: string;
+  status?: string;
+}
+type TQwenResponsesOutputItem = IQwenResponsesMessageOutputItem | IQwenResponsesFunctionCallOutputItem | IQwenResponsesWebSearchOutputItem | IQwenResponsesWebExtractorOutputItem | IQwenResponsesGenericOutputItem;
+interface IQwenResponsesToolUsageCount {
+  count?: number;
+}
+interface IQwenResponsesUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+  total_tokens?: number;
+  x_tools?: Record<string, IQwenResponsesToolUsageCount>;
+}
+interface IQwenResponsesResponse {
+  id?: string;
+  model?: string;
+  output_text?: string;
+  output?: TQwenResponsesOutputItem[];
+  usage?: IQwenResponsesUsage;
+  status?: string;
+}
+interface IQwenResponsesTextDeltaEvent {
+  type: 'response.output_text.delta';
+  delta: string;
+}
+interface IQwenResponsesCompletedEvent {
+  type: 'response.completed';
+  response: IQwenResponsesResponse;
+}
+interface IQwenResponsesOutputItemDoneEvent {
+  type: 'response.output_item.done';
+  item: TQwenResponsesOutputItem;
+}
+interface IQwenResponsesErrorEvent {
+  type: 'response.error' | 'response.failed';
+  message?: string;
+  error?: {
+    message?: string;
+  };
+  response?: {
+    error?: {
+      message?: string;
+    };
+  };
+}
+interface IQwenResponsesWebSearchEvent {
+  type: 'response.web_search_call.in_progress' | 'response.web_search_call.searching' | 'response.web_search_call.completed';
+}
+interface IQwenResponsesGenericEvent {
+  type: string;
+  item?: TQwenResponsesOutputItem;
+  response?: IQwenResponsesResponse;
+}
+type TQwenResponsesStreamEvent = IQwenResponsesTextDeltaEvent | IQwenResponsesCompletedEvent | IQwenResponsesOutputItemDoneEvent | IQwenResponsesErrorEvent | IQwenResponsesWebSearchEvent;
+type TQwenMessagesToResponsesInput = (messages: TUniversalMessage[]) => TQwenResponsesInputItem[];
+type TQwenProviderOptionValue = string | number | boolean | undefined | null | IQwenBuiltInWebToolsOptions | OpenAI | ILogger | IExecutor | TProviderOptionValueBase | TQwenProviderOptionValue[] | {
+  [key: string]: TQwenProviderOptionValue;
+};
+interface IQwenProviderOptions {
+  [key: string]: TQwenProviderOptionValue;
+  apiKey?: string;
+  baseURL?: string;
+  responsesBaseURL?: string;
+  timeout?: number;
+  defaultModel?: string;
+  builtInWebTools?: IQwenBuiltInWebToolsOptions;
+  client?: OpenAI;
+  executor?: IExecutor;
+  logger?: ILogger;
+}
+//#endregion
+//#region src/qwen/provider.d.ts
+declare class QwenProvider extends AbstractAIProvider {
+  readonly name = "qwen";
+  readonly version = "1.0.0";
+  private readonly client?;
+  private readonly responsesClient?;
+  private readonly options;
+  private readonly responseParser;
+  onTextDelta?: TTextDeltaCallback;
+  constructor(options: IQwenProviderOptions);
+  chat(messages: TUniversalMessage[], options?: IChatOptions): Promise<TUniversalMessage>;
+  private chatViaExecutor;
+  private chatViaResponsesApi;
+  private chatViaChatCompletions;
+  chatStream(messages: TUniversalMessage[], options?: IChatOptions): AsyncIterable<TUniversalMessage>;
+  supportsTools(): boolean;
+  getCapabilities(): import("@robota-sdk/agent-core").IProviderCapabilities;
+  validateConfig(): boolean;
+  dispose(): Promise<void>;
+  private buildRequestParams;
+  private buildStreamingRequestParams;
+  private shouldUseResponsesApi;
+  private getClient;
+  private getResponsesClient;
+}
+//#endregion
+//#region src/qwen/provider-definition.d.ts
+declare function createQwenProviderDefinition(): IProviderDefinition;
+//#endregion
+//#region src/qwen/model-catalog-refresh.d.ts
+interface IQwenModelsResponse {
+  data?: Array<{
+    id?: string;
+    object?: string;
+    owned_by?: string;
+  }>;
+}
+interface IQwenFetchInit {
+  headers?: Record<string, string>;
+}
+interface IQwenFetchResponse {
+  ok: boolean;
+  status: number;
+  json: () => Promise<IQwenModelsResponse>;
+}
+type TQwenFetch = (url: string, init?: IQwenFetchInit) => Promise<IQwenFetchResponse>;
+declare function refreshQwenModelCatalog(profile: IProviderProfileConfig, fetcher?: TQwenFetch): Promise<IProviderModelCatalog>;
+//#endregion
+export { IQwenResponsesWebExtractorTool as A, TQwenResponsesStreamEvent as B, IQwenResponsesRequestStreaming as C, IQwenResponsesToolUsageCount as D, IQwenResponsesTextDeltaEvent as E, TQwenBuiltInWebToolName as F, DEFAULT_QWEN_PROVIDER_MODEL as G, DEFAULT_QWEN_PROVIDER_API_KEY_ENV as H, TQwenMessagesToResponsesInput as I, QWEN_MODEL_SOURCE_URL as J, DEFAULT_QWEN_PROVIDER_RESPONSES_BASE_URL as K, TQwenProviderOptionValue as L, IQwenResponsesWebSearchEvent as M, IQwenResponsesWebSearchOutputItem as N, IQwenResponsesUsage as O, IQwenResponsesWebSearchTool as P, TQwenProviderResponsesRegion as Q, TQwenResponsesInputItem as R, IQwenResponsesRequestNonStreaming as S, IQwenResponsesTextContent as T, DEFAULT_QWEN_PROVIDER_API_KEY_REFERENCE as U, TQwenResponsesTool as V, DEFAULT_QWEN_PROVIDER_BASE_URL as W, QWEN_PROVIDER_RESPONSES_BASE_URLS as X, QWEN_PROVIDER_BASE_URLS as Y, TQwenProviderRegion as Z, IQwenResponsesGenericOutputItem as _, refreshQwenModelCatalog as a, IQwenResponsesOutputItemDoneEvent as b, IQwenBuiltInWebToolsOptions as c, IQwenResponsesErrorEvent as d, IQwenResponsesFunctionCallInput as f, IQwenResponsesGenericEvent as g, IQwenResponsesFunctionTool as h, TQwenFetch as i, IQwenResponsesWebSearchAction as j, IQwenResponsesWebExtractorOutputItem as k, IQwenProviderOptions as l, IQwenResponsesFunctionCallOutputItem as m, IQwenFetchResponse as n, createQwenProviderDefinition as o, IQwenResponsesFunctionCallOutputInput as p, QWEN_MODEL_LAST_VERIFIED_AT as q, IQwenModelsResponse as r, QwenProvider as s, IQwenFetchInit as t, IQwenResponsesCompletedEvent as u, IQwenResponsesMessageInput as v, IQwenResponsesResponse as w, IQwenResponsesRequestBase as x, IQwenResponsesMessageOutputItem as y, TQwenResponsesOutputItem as z };
+//# sourceMappingURL=index-BqixM_XD.d.ts.map

package/dist/node/index-BqixM_XD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BqixM_XD.d.ts","names":[],"sources":["../../src/qwen/defaults.ts","../../src/qwen/types.ts","../../src/qwen/provider.ts","../../src/qwen/provider-definition.ts","../../src/qwen/model-catalog-refresh.ts"],"mappings":"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"}