@warlock.js/ai-openai 5.30.0 → 5.32.0

package/esm/config.type.d.mts

@@ -1,6 +1,5 @@
 import OpenAI, { ClientOptions } from "openai";
 import { EmbedderConfig, ImageModelConfig, ModelConfig, ModelPricing, SpeechModelConfig, TranscriptionModelConfig } from "@warlock.js/ai";
-
 //#region ../../packages/ai-openai/src/config.type.d.ts
 /**
  * Configuration for the OpenAI SDK adapter.
@@ -32,7 +31,7 @@ import { EmbedderConfig, ImageModelConfig, ModelConfig, ModelPricing, SpeechMode
  *   },
  * });
  */
-type OpenAISDKConfig = Omit<ClientOptions, "provider"> & {
+export type OpenAISDKConfig = Omit<ClientOptions, "provider"> & {
   /**
    * Free-form upstream label. `ClientOptions.provider` is omitted above
    * on purpose: openai v7 added its own `provider?: Provider` key (an
@@ -63,7 +62,7 @@ type OpenAISDKConfig = Omit<ClientOptions, "provider"> & {
  * // Route through OpenRouter to a model that rejects strict json_schema:
  * openai.model({ name: "some-legacy-model", responseFormat: "json_object" });
  */
-type OpenAIResponseFormat = "json_schema" | "json_object" | "text";
+export type OpenAIResponseFormat = "json_schema" | "json_object" | "text";
 /**
  * Which OpenAI endpoint a model speaks.
  *
@@ -75,7 +74,7 @@ type OpenAIResponseFormat = "json_schema" | "json_object" | "text";
  *   only: `OpenAISDK.model()` throws for any other provider label, so the
  *   wrapper packages (deepseek, groq, xai, mistral) can never reach it.
  */
-type OpenAIApi = "chat" | "responses";
+export type OpenAIApi = "chat" | "responses";
 /**
  * Per-model configuration for `OpenAISDK.model()`. Extends the neutral
  * `ModelConfig` with OpenAI-specific capability overrides.
@@ -88,7 +87,7 @@ type OpenAIApi = "chat" | "responses";
  * // Reasoning model + tools on the Responses API (direct OpenAI only):
  * openai.model({ name: "gpt-5.6", api: "responses" });
  */
-type OpenAIModelConfig = ModelConfig & {
+export type OpenAIModelConfig = ModelConfig & {
   /**
    * Wire API to use. Default `"chat"` (Chat Completions). `"responses"`
    * selects the stateless Responses adapter and is accepted only on the
@@ -138,9 +137,11 @@ type OpenAIModelConfig = ModelConfig & {
    */
   reasoning?: boolean;
   /**
-   * Stable request bucket used by OpenAI to improve prompt-cache matching.
-   * Sent only by models whose SDK provider label is `"openai"`; compatible
-   * wrapper endpoints deliberately never receive this OpenAI-only field.
+   * Stable request bucket used to improve prompt-cache matching, sent as
+   * `prompt_cache_key`. Sent when the SDK provider label is `"openai"`,
+   * `"xai"` or `"mistral"` — the endpoints that document the field. Other
+   * labels (Groq and DeepSeek cache automatically; custom gateways) never
+   * receive it.
    */
   promptCacheKey?: string;
   /**
@@ -177,7 +178,7 @@ type OpenAIModelConfig = ModelConfig & {
  * openai.embedder({ name: "text-embedding-3-small" });
  * openai.embedder({ name: "text-embedding-3-large", dimensions: 256 });
  */
-type OpenAIEmbedderConfig = EmbedderConfig;
+export type OpenAIEmbedderConfig = EmbedderConfig;
 /**
  * Per-model configuration for `OpenAISDK.image()`. Mirrors the neutral
  * {@link ImageModelConfig} — `name` is the image model id, passed
@@ -190,7 +191,7 @@ type OpenAIEmbedderConfig = EmbedderConfig;
  * openai.image({ name: "gpt-image-1" });
  * openai.image({ name: "dall-e-3", pricing: { perImage: 0.04 } });
  */
-type OpenAIImageConfig = ImageModelConfig;
+export type OpenAIImageConfig = ImageModelConfig;
 /**
  * Per-model configuration for `OpenAISDK.speech()`. Mirrors the neutral
  * {@link SpeechModelConfig} — `name` is the TTS model id, passed
@@ -202,7 +203,7 @@ type OpenAIImageConfig = ImageModelConfig;
  * @example
  * openai.speech({ name: "tts-1", voice: "alloy", pricing: { perMillionCharacters: 15 } });
  */
-type OpenAISpeechConfig = SpeechModelConfig;
+export type OpenAISpeechConfig = SpeechModelConfig;
 /**
  * Per-model configuration for `OpenAISDK.transcribe()`. Mirrors the
  * neutral {@link TranscriptionModelConfig} — `name` is the STT model
@@ -214,7 +215,6 @@ type OpenAISpeechConfig = SpeechModelConfig;
  * @example
  * openai.transcribe({ name: "whisper-1", pricing: { perMinute: 0.006 } });
  */
-type OpenAITranscriptionConfig = TranscriptionModelConfig;
+export type OpenAITranscriptionConfig = TranscriptionModelConfig;
 //#endregion
-export { OpenAIEmbedderConfig, OpenAIImageConfig, OpenAIModelConfig, OpenAISDKConfig, OpenAISpeechConfig, OpenAITranscriptionConfig };
 //# sourceMappingURL=config.type.d.mts.map

package/esm/config.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/config.type.ts"],"mappings":";;;;;AAyCA;;;;;;;;;;;;;;;;AAeuC;AAiBvC;;;;AAAgC;AAahC;;;;AAAqB;AAcrB;;KA3DY,eAAA,GAAkB,IAAA,CAAK,aAAA;EA2DH;;;;;;;;EAlD9B,QAAA;EAwDM;;;;;EAlDN,OAAA,GAAU,MAAA,SAAe,YAAA;AAAA;;;;;;;;;;AA4HpB;AAaP;;;;KAxHY,oBAAA;AAsIZ;;;;AAAgD;AAahD;;;;AAAkD;AAalD;AA1BA,KAzHY,SAAA;;;AAmJoD;;;;;;;;;;KArIpD,iBAAA,GAAoB,WAAA;;;;;;EAM9B,GAAA,GAAM,SAAA;;;;;;;;EAQN,MAAA;;;;;;;;;;;;;;EAcA,cAAA,GAAiB,oBAAA;;;;;;;;;EASjB,gBAAA;;;;;;;;;;;EAWA,SAAA;;;;;;EAMA,cAAA;;;;;;EAMA,oBAAA,GAAuB,OAAA,CACrB,MAAA,CAAO,IAAA,CAAK,WAAA,CAAY,0BAAA;;;;;;;;;EAW1B,GAAA;;;;;;;;EAQA,KAAA;AAAA;;;;;;;;;;;KAaU,oBAAA,GAAuB,cAAc;;;;;;;;;;;;;KAcrC,iBAAA,GAAoB,gBAAgB;;;;;;;;;;;;KAapC,kBAAA,GAAqB,iBAAiB;;;;;;;;;;;;KAatC,yBAAA,GAA4B,wBAAwB"}
+{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/config.type.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAyCY,kBAAkB,KAAK;;;;;;;;;EASjC;;;;;;EAMA,UAAU,eAAe;;;;;;;;;;;;;;;;YAiBf;;;;;;;;;;;;YAaA;;;;;;;;;;;;;YAcA,oBAAoB;;;;;;EAM9B,MAAM;;;;;;;;EAQN;;;;;;;;;;;;;;EAcA,iBAAiB;;;;;;;;;EASjB;;;;;;;;;;;EAWA;;;;;;;;EAQA;;;;;;EAMA,uBAAuB,QACrB,OAAO,KAAK,YAAY;;;;;;;;;EAW1B;;;;;;;;EAQA;;;;;;;;;;;;YAaU,uBAAuB;;;;;;;;;;;;;YAcvB,oBAAoB;;;;;;;;;;;;YAapB,qBAAqB;;;;;;;;;;;;YAarB,4BAA4B"}

package/esm/embedder.d.mts

@@ -1,7 +1,6 @@
 import { OpenAIEmbedderConfig } from "./config.type.mjs";
 import OpenAI from "openai";
 import { EmbedderContract, EmbeddingBatchResult, EmbeddingResult } from "@warlock.js/ai";
-
 //#region ../../packages/ai-openai/src/embedder.d.ts
 /**
  * OpenAI-backed implementation of `EmbedderContract`.
@@ -28,7 +27,7 @@ import { EmbedderContract, EmbeddingBatchResult, EmbeddingResult } from "@warloc
  * const { vector, dimensions, usage } = await embedder.embed("Hello world");
  * const { vectors } = await embedder.embedMany(["doc 1", "doc 2"]);
  */
-declare class OpenAIEmbedder implements EmbedderContract {
+export declare class OpenAIEmbedder implements EmbedderContract {
   readonly name: string;
   readonly provider = "openai";
   dimensions: number;
@@ -52,5 +51,4 @@ declare class OpenAIEmbedder implements EmbedderContract {
   private request;
 }
 //#endregion
-export { OpenAIEmbedder };
 //# sourceMappingURL=embedder.d.mts.map

package/esm/embedder.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"embedder.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/embedder.ts"],"mappings":";;;;;;;AA2CA;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,YAA0B,gBAAA;EAAA,SACrB,IAAA;EAAA,SACA,QAAA;EACT,UAAA;EAAA,iBAEU,MAAA;EA8CJ;;;;;EAAA,iBAvCI,oBAAA;EAAA,iBACA,MAAA;cAEE,MAAA,EAAQ,MAAA,EAAQ,MAAA,EAAQ,oBAAA;EAO9B,KAAA,CAAM,KAAA,WAAgB,OAAA,CAAQ,eAAA;EA6B9B,SAAA,CAAU,MAAA,aAAmB,OAAA,CAAQ,oBAAA;;;;;;;UAgBpC,OAAA;AAAA"}
+{"version":3,"file":"embedder.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/embedder.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyCa,0BAA0B;WACrB;WACA;EACT;mBAEU;;;;;;mBAOA;mBACA;EAEjB,YAAmB,QAAQ,QAAQ,QAAQ;EAO9B,MAAM,gBAAgB,QAAQ;EA6B9B,UAAU,mBAAmB,QAAQ;;;;;;;UAgBpC"}

package/esm/embedder.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"embedder.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/embedder.ts"],"sourcesContent":["import {\n  EmbeddingVectorCountMismatchError,\n  type EmbeddingBatchResult,\n  type EmbeddingResult,\n  type EmbeddingUsage,\n  type EmbedderContract,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAIEmbedderConfig } from \"./config.type\";\nimport { wrapOpenAIError } from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\ntype EmbeddingsResponse = Awaited<\n  ReturnType<OpenAI[\"embeddings\"][\"create\"]>\n>;\n\n/**\n * OpenAI-backed implementation of `EmbedderContract`.\n *\n * **Role.** Converts text (or a batch of texts) into floating-point\n * vectors via OpenAI's Embeddings API. Standalone primitive — no\n * relationship to chat completions, tools, or the agent loop.\n *\n * **Dimensions.** When no `dimensions` override is supplied in config,\n * `this.dimensions` starts at `0` and is populated from the first\n * response's vector length, then cached for all subsequent calls —\n * even if a later response were to return a different length, the\n * first value wins so batches stay dimensionally consistent. Passing\n * `dimensions` in config both forwards the truncation hint to the API\n * (for models like `text-embedding-3-*`) and sets the initial value.\n *\n * **Error handling.** Raw OpenAI SDK errors are wrapped into the\n * typed `@warlock.js/ai` `AIError` hierarchy via `wrapOpenAIError` —\n * callers catch `AIError` subclasses (`ProviderRateLimitError`,\n * `ProviderAuthError`, etc.) instead of OpenAI's own classes.\n *\n * @example\n * const embedder = new OpenAIEmbedder(client, { name: \"text-embedding-3-small\" });\n * const { vector, dimensions, usage } = await embedder.embed(\"Hello world\");\n * const { vectors } = await embedder.embedMany([\"doc 1\", \"doc 2\"]);\n */\nexport class OpenAIEmbedder implements EmbedderContract {\n  public readonly name: string;\n  public readonly provider = \"openai\";\n  public dimensions: number;\n\n  private readonly client: OpenAI;\n\n  /**\n   * User-specified truncation hint, or `undefined` if omitted.\n   * Forwarded to the API on every call so OpenAI can truncate the\n   * embedding server-side for models that support it.\n   */\n  private readonly configuredDimensions: number | undefined;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAIEmbedderConfig) {\n    this.client = client;\n    this.name = config.name;\n    this.configuredDimensions = config.dimensions;\n    this.dimensions = config.dimensions ?? 0;\n  }\n\n  public async embed(input: string): Promise<EmbeddingResult> {\n    const { response, usage } = await this.request(input);\n\n    const [first] = response.data;\n\n    if (first === undefined) {\n      // A 200 whose `data` array is empty. Before this guard the next line\n      // read `.embedding` off `undefined` and the caller got a bare\n      // `TypeError: Cannot read properties of undefined`, naming neither the\n      // provider nor what it actually returned.\n      //\n      // Same typed error the RAG and skill-catalog paths raise for this\n      // contract violation, so one shortfall has one name wherever it\n      // surfaces. Expected 1, received 0.\n      throw new EmbeddingVectorCountMismatchError({\n        provider: this.provider,\n        expectedCount: 1,\n        receivedCount: response.data.length,\n        record: input,\n      });\n    }\n\n    return {\n      vector: first.embedding,\n      dimensions: this.dimensions,\n      usage,\n    };\n  }\n\n  public async embedMany(inputs: string[]): Promise<EmbeddingBatchResult> {\n    const { response, usage } = await this.request(inputs);\n\n    return {\n      vectors: response.data.map((d) => d.embedding),\n      dimensions: this.dimensions,\n      usage,\n    };\n  }\n\n  /**\n   * Shared transport for both `embed()` and `embedMany()` — issues the\n   * `embeddings.create` call, wraps provider errors, caches dimensions\n   * on the first successful response, and returns the raw response\n   * plus a camelCase usage object for the caller to shape.\n   */\n  private async request(input: string | string[]): Promise<{\n    response: EmbeddingsResponse;\n    usage: EmbeddingUsage;\n  }> {\n    this.logger.debug(LOG_MODULE, \"embedder.request\", \"embeddings.create\", {\n      model: this.name,\n      batch: Array.isArray(input),\n      count: Array.isArray(input) ? input.length : 1,\n    });\n\n    let response: EmbeddingsResponse;\n\n    try {\n      response = await this.client.embeddings.create({\n        model: this.name,\n        input,\n        ...(this.configuredDimensions !== undefined\n          ? { dimensions: this.configuredDimensions }\n          : {}),\n      });\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"embedder.error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    this.logger.debug(LOG_MODULE, \"embedder.response\", \"embeddings.create returned\", {\n      dimensions: response.data[0]?.embedding.length,\n      usage: {\n        promptTokens: response.usage.prompt_tokens,\n        totalTokens: response.usage.total_tokens,\n      },\n    });\n\n    // Cache dimensions on the first response. Once set, stays set —\n    // we trust the first call to define the shape for this embedder.\n    //\n    // Reads the first entry optionally rather than asserting it: this runs for\n    // BOTH embed() and embedMany(), and an empty `data` array is a real\n    // provider response, not an impossible one. Leaving `dimensions` at 0 for\n    // an empty response is correct — the callers each raise their own typed\n    // error about the shortfall, and cacheing a dimension off a response that\n    // carried no vectors would be inventing a shape from nothing.\n    if (this.dimensions === 0) {\n      const firstEmbedding = response.data[0]?.embedding;\n\n      if (firstEmbedding !== undefined) {\n        this.dimensions = firstEmbedding.length;\n      }\n    }\n\n    const usage: EmbeddingUsage = {\n      promptTokens: response.usage.prompt_tokens,\n      totalTokens: response.usage.total_tokens,\n    };\n\n    return { response, usage };\n  }\n}\n"],"mappings":";;;;;;AAYA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BnB,IAAa,iBAAb,MAAwD;CAetD,AAAO,YAAY,QAAgB,QAA8B;kBAbtC;gBAWO;EAGhC,KAAK,SAAS;EACd,KAAK,OAAO,OAAO;EACnB,KAAK,uBAAuB,OAAO;EACnC,KAAK,aAAa,OAAO,cAAc;CACzC;CAEA,MAAa,MAAM,OAAyC;EAC1D,MAAM,EAAE,UAAU,UAAU,MAAM,KAAK,QAAQ,KAAK;EAEpD,MAAM,CAAC,SAAS,SAAS;EAEzB,IAAI,UAAU,QASZ,MAAM,IAAI,kCAAkC;GAC1C,UAAU,KAAK;GACf,eAAe;GACf,eAAe,SAAS,KAAK;GAC7B,QAAQ;EACV,CAAC;EAGH,OAAO;GACL,QAAQ,MAAM;GACd,YAAY,KAAK;GACjB;EACF;CACF;CAEA,MAAa,UAAU,QAAiD;EACtE,MAAM,EAAE,UAAU,UAAU,MAAM,KAAK,QAAQ,MAAM;EAErD,OAAO;GACL,SAAS,SAAS,KAAK,KAAK,MAAM,EAAE,SAAS;GAC7C,YAAY,KAAK;GACjB;EACF;CACF;;;;;;;CAQA,MAAc,QAAQ,OAGnB;EACD,KAAK,OAAO,MAAM,YAAY,oBAAoB,qBAAqB;GACrE,OAAO,KAAK;GACZ,OAAO,MAAM,QAAQ,KAAK;GAC1B,OAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,SAAS;EAC/C,CAAC;EAED,IAAI;EAEJ,IAAI;GACF,WAAW,MAAM,KAAK,OAAO,WAAW,OAAO;IAC7C,OAAO,KAAK;IACZ;IACA,GAAI,KAAK,yBAAyB,SAC9B,EAAE,YAAY,KAAK,qBAAqB,IACxC,CAAC;GACP,CAAC;EACH,SAAS,QAAQ;GACf,MAAM,UAAU,gBAAgB,MAAM;GAEtC,KAAK,OAAO,MAAM,YAAY,kBAAkB,QAAQ,SAAS;IAC/D,MAAM,QAAQ;IACd,SAAS,QAAQ;GACnB,CAAC;GAED,MAAM;EACR;EAEA,KAAK,OAAO,MAAM,YAAY,qBAAqB,8BAA8B;GAC/E,YAAY,SAAS,KAAK,EAAE,EAAE,UAAU;GACxC,OAAO;IACL,cAAc,SAAS,MAAM;IAC7B,aAAa,SAAS,MAAM;GAC9B;EACF,CAAC;EAWD,IAAI,KAAK,eAAe,GAAG;GACzB,MAAM,iBAAiB,SAAS,KAAK,EAAE,EAAE;GAEzC,IAAI,mBAAmB,QACrB,KAAK,aAAa,eAAe;EAErC;EAEA,MAAM,QAAwB;GAC5B,cAAc,SAAS,MAAM;GAC7B,aAAa,SAAS,MAAM;EAC9B;EAEA,OAAO;GAAE;GAAU;EAAM;CAC3B;AACF"}
+{"version":3,"file":"embedder.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/embedder.ts"],"sourcesContent":["import {\n  EmbeddingVectorCountMismatchError,\n  type EmbeddingBatchResult,\n  type EmbeddingResult,\n  type EmbeddingUsage,\n  type EmbedderContract,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAIEmbedderConfig } from \"./config.type\";\nimport { wrapOpenAIError } from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\ntype EmbeddingsResponse = Awaited<ReturnType<OpenAI[\"embeddings\"][\"create\"]>>;\n\n/**\n * OpenAI-backed implementation of `EmbedderContract`.\n *\n * **Role.** Converts text (or a batch of texts) into floating-point\n * vectors via OpenAI's Embeddings API. Standalone primitive — no\n * relationship to chat completions, tools, or the agent loop.\n *\n * **Dimensions.** When no `dimensions` override is supplied in config,\n * `this.dimensions` starts at `0` and is populated from the first\n * response's vector length, then cached for all subsequent calls —\n * even if a later response were to return a different length, the\n * first value wins so batches stay dimensionally consistent. Passing\n * `dimensions` in config both forwards the truncation hint to the API\n * (for models like `text-embedding-3-*`) and sets the initial value.\n *\n * **Error handling.** Raw OpenAI SDK errors are wrapped into the\n * typed `@warlock.js/ai` `AIError` hierarchy via `wrapOpenAIError` —\n * callers catch `AIError` subclasses (`ProviderRateLimitError`,\n * `ProviderAuthError`, etc.) instead of OpenAI's own classes.\n *\n * @example\n * const embedder = new OpenAIEmbedder(client, { name: \"text-embedding-3-small\" });\n * const { vector, dimensions, usage } = await embedder.embed(\"Hello world\");\n * const { vectors } = await embedder.embedMany([\"doc 1\", \"doc 2\"]);\n */\nexport class OpenAIEmbedder implements EmbedderContract {\n  public readonly name: string;\n  public readonly provider = \"openai\";\n  public dimensions: number;\n\n  private readonly client: OpenAI;\n\n  /**\n   * User-specified truncation hint, or `undefined` if omitted.\n   * Forwarded to the API on every call so OpenAI can truncate the\n   * embedding server-side for models that support it.\n   */\n  private readonly configuredDimensions: number | undefined;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAIEmbedderConfig) {\n    this.client = client;\n    this.name = config.name;\n    this.configuredDimensions = config.dimensions;\n    this.dimensions = config.dimensions ?? 0;\n  }\n\n  public async embed(input: string): Promise<EmbeddingResult> {\n    const { response, usage } = await this.request(input);\n\n    const [first] = response.data;\n\n    if (first === undefined) {\n      // A 200 whose `data` array is empty. Before this guard the next line\n      // read `.embedding` off `undefined` and the caller got a bare\n      // `TypeError: Cannot read properties of undefined`, naming neither the\n      // provider nor what it actually returned.\n      //\n      // Same typed error the RAG and skill-catalog paths raise for this\n      // contract violation, so one shortfall has one name wherever it\n      // surfaces. Expected 1, received 0.\n      throw new EmbeddingVectorCountMismatchError({\n        provider: this.provider,\n        expectedCount: 1,\n        receivedCount: response.data.length,\n        record: input,\n      });\n    }\n\n    return {\n      vector: first.embedding,\n      dimensions: this.dimensions,\n      usage,\n    };\n  }\n\n  public async embedMany(inputs: string[]): Promise<EmbeddingBatchResult> {\n    const { response, usage } = await this.request(inputs);\n\n    return {\n      vectors: response.data.map((d) => d.embedding),\n      dimensions: this.dimensions,\n      usage,\n    };\n  }\n\n  /**\n   * Shared transport for both `embed()` and `embedMany()` — issues the\n   * `embeddings.create` call, wraps provider errors, caches dimensions\n   * on the first successful response, and returns the raw response\n   * plus a camelCase usage object for the caller to shape.\n   */\n  private async request(input: string | string[]): Promise<{\n    response: EmbeddingsResponse;\n    usage: EmbeddingUsage;\n  }> {\n    this.logger.debug(LOG_MODULE, \"embedder.request\", \"embeddings.create\", {\n      model: this.name,\n      batch: Array.isArray(input),\n      count: Array.isArray(input) ? input.length : 1,\n    });\n\n    let response: EmbeddingsResponse;\n\n    try {\n      response = await this.client.embeddings.create({\n        model: this.name,\n        input,\n        ...(this.configuredDimensions !== undefined\n          ? { dimensions: this.configuredDimensions }\n          : {}),\n      });\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"embedder.error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    this.logger.debug(LOG_MODULE, \"embedder.response\", \"embeddings.create returned\", {\n      dimensions: response.data[0]?.embedding.length,\n      usage: {\n        promptTokens: response.usage.prompt_tokens,\n        totalTokens: response.usage.total_tokens,\n      },\n    });\n\n    // Cache dimensions on the first response. Once set, stays set —\n    // we trust the first call to define the shape for this embedder.\n    //\n    // Reads the first entry optionally rather than asserting it: this runs for\n    // BOTH embed() and embedMany(), and an empty `data` array is a real\n    // provider response, not an impossible one. Leaving `dimensions` at 0 for\n    // an empty response is correct — the callers each raise their own typed\n    // error about the shortfall, and cacheing a dimension off a response that\n    // carried no vectors would be inventing a shape from nothing.\n    if (this.dimensions === 0) {\n      const firstEmbedding = response.data[0]?.embedding;\n\n      if (firstEmbedding !== undefined) {\n        this.dimensions = firstEmbedding.length;\n      }\n    }\n\n    const usage: EmbeddingUsage = {\n      promptTokens: response.usage.prompt_tokens,\n      totalTokens: response.usage.total_tokens,\n    };\n\n    return { response, usage };\n  }\n}\n"],"mappings":";;;;;;AAYA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BnB,IAAa,iBAAb,MAAwD;CAetD,AAAO,YAAY,QAAgB,QAA8B;kBAbtC;gBAWO;EAGhC,KAAK,SAAS;EACd,KAAK,OAAO,OAAO;EACnB,KAAK,uBAAuB,OAAO;EACnC,KAAK,aAAa,OAAO,cAAc;CACzC;CAEA,MAAa,MAAM,OAAyC;EAC1D,MAAM,EAAE,UAAU,UAAU,MAAM,KAAK,QAAQ,KAAK;EAEpD,MAAM,CAAC,SAAS,SAAS;EAEzB,IAAI,UAAU,QASZ,MAAM,IAAI,kCAAkC;GAC1C,UAAU,KAAK;GACf,eAAe;GACf,eAAe,SAAS,KAAK;GAC7B,QAAQ;EACV,CAAC;EAGH,OAAO;GACL,QAAQ,MAAM;GACd,YAAY,KAAK;GACjB;EACF;CACF;CAEA,MAAa,UAAU,QAAiD;EACtE,MAAM,EAAE,UAAU,UAAU,MAAM,KAAK,QAAQ,MAAM;EAErD,OAAO;GACL,SAAS,SAAS,KAAK,KAAK,MAAM,EAAE,SAAS;GAC7C,YAAY,KAAK;GACjB;EACF;CACF;;;;;;;CAQA,MAAc,QAAQ,OAGnB;EACD,KAAK,OAAO,MAAM,YAAY,oBAAoB,qBAAqB;GACrE,OAAO,KAAK;GACZ,OAAO,MAAM,QAAQ,KAAK;GAC1B,OAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,SAAS;EAC/C,CAAC;EAED,IAAI;EAEJ,IAAI;GACF,WAAW,MAAM,KAAK,OAAO,WAAW,OAAO;IAC7C,OAAO,KAAK;IACZ;IACA,GAAI,KAAK,yBAAyB,SAC9B,EAAE,YAAY,KAAK,qBAAqB,IACxC,CAAC;GACP,CAAC;EACH,SAAS,QAAQ;GACf,MAAM,UAAU,gBAAgB,MAAM;GAEtC,KAAK,OAAO,MAAM,YAAY,kBAAkB,QAAQ,SAAS;IAC/D,MAAM,QAAQ;IACd,SAAS,QAAQ;GACnB,CAAC;GAED,MAAM;EACR;EAEA,KAAK,OAAO,MAAM,YAAY,qBAAqB,8BAA8B;GAC/E,YAAY,SAAS,KAAK,EAAE,EAAE,UAAU;GACxC,OAAO;IACL,cAAc,SAAS,MAAM;IAC7B,aAAa,SAAS,MAAM;GAC9B;EACF,CAAC;EAWD,IAAI,KAAK,eAAe,GAAG;GACzB,MAAM,iBAAiB,SAAS,KAAK,EAAE,EAAE;GAEzC,IAAI,mBAAmB,QACrB,KAAK,aAAa,eAAe;EAErC;EAEA,MAAM,QAAwB;GAC5B,cAAc,SAAS,MAAM;GAC7B,aAAa,SAAS,MAAM;EAC9B;EAEA,OAAO;GAAE;GAAU;EAAM;CAC3B;AACF"}

package/esm/image.d.mts

@@ -1,7 +1,6 @@
 import { OpenAIImageConfig } from "./config.type.mjs";
 import OpenAI from "openai";
 import { ImageGenerationOptions, ImageGenerationResponse, ImageModelContract, ImageModelPricing } from "@warlock.js/ai";
-
 //#region ../../packages/ai-openai/src/image.d.ts
 /**
  * OpenAI-backed implementation of `ImageModelContract`.
@@ -31,7 +30,7 @@ import { ImageGenerationOptions, ImageGenerationResponse, ImageModelContract, Im
  * const model = new OpenAIImageModel(client, { name: "gpt-image-1" }, "openai");
  * const { images, usage } = await model.generate("a teal ceramic mug, studio light");
  */
-declare class OpenAIImageModel implements ImageModelContract {
+export declare class OpenAIImageModel implements ImageModelContract {
   readonly name: string;
   readonly provider: string;
   readonly pricing?: ImageModelPricing;
@@ -49,5 +48,4 @@ declare class OpenAIImageModel implements ImageModelContract {
   private toGeneratedImage;
 }
 //#endregion
-export { OpenAIImageModel };
 //# sourceMappingURL=image.d.mts.map

package/esm/image.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/image.ts"],"mappings":";;;;;;;AAwDA;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,gBAAA,YAA4B,kBAAA;EAAA,SACvB,IAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA,GAAU,iBAAA;EAAA,iBAET,MAAA;EAAA,iBACA,MAAA;cAEE,MAAA,EAAQ,MAAA,EAAQ,MAAA,EAAQ,iBAAA,EAAmB,QAAA;EAOjD,QAAA,CACX,MAAA,UACA,OAAA,GAAU,sBAAA,GACT,OAAA,CAAQ,uBAAA;;;;;;;;UA+EH,gBAAA;AAAA"}
+{"version":3,"file":"image.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/image.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwDa,4BAA4B;WACvB;WACA;WACA,UAAU;mBAET;mBACA;EAEjB,YAAmB,QAAQ,QAAQ,QAAQ,mBAAmB;EAOjD,SACX,gBACA,UAAU,yBACT,QAAQ;;;;;;;;UA+EH"}

package/esm/index.d.mts

@@ -1,7 +1,10 @@
 import { OpenAIEmbedderConfig, OpenAIImageConfig, OpenAISDKConfig, OpenAISpeechConfig, OpenAITranscriptionConfig } from "./config.type.mjs";
 import { OpenAISDK } from "./sdk.mjs";
+import { OPENAI_MODEL_PRICING, OPENAI_SERVER_TOOL_PRICING, openAIPricingFor } from "./known-pricing.mjs";
 import { OpenAIEmbedder } from "./embedder.mjs";
 import { OpenAIImageModel } from "./image.mjs";
 import { OpenAISpeechModel } from "./speech.mjs";
 import { OpenAITranscriptionModel } from "./transcription.mjs";
-export { OpenAIEmbedder, type OpenAIEmbedderConfig, type OpenAIImageConfig, OpenAIImageModel, OpenAISDK, type OpenAISDKConfig, type OpenAISpeechConfig, OpenAISpeechModel, type OpenAITranscriptionConfig, OpenAITranscriptionModel };
+import { OpenAICallOptions, QwenCallOptions } from "./provider-options.mjs";
+import { KIMI_SERVER_TOOL_PRICING, KimiFetchOutput, KimiSearchOutput, KimiSearchResult, KimiSearchToolOptions, KimiToolOptions, kimiFetchTool, kimiSearchTool } from "./kimi-tools.mjs";
+export { KIMI_SERVER_TOOL_PRICING, type KimiFetchOutput, type KimiSearchOutput, type KimiSearchResult, type KimiSearchToolOptions, type KimiToolOptions, OPENAI_MODEL_PRICING, OPENAI_SERVER_TOOL_PRICING, type OpenAICallOptions, OpenAIEmbedder, type OpenAIEmbedderConfig, type OpenAIImageConfig, OpenAIImageModel, OpenAISDK, type OpenAISDKConfig, type OpenAISpeechConfig, OpenAISpeechModel, type OpenAITranscriptionConfig, OpenAITranscriptionModel, type QwenCallOptions, kimiFetchTool, kimiSearchTool, openAIPricingFor };

package/esm/index.mjs

@@ -1,7 +1,9 @@
+import { OPENAI_MODEL_PRICING, OPENAI_SERVER_TOOL_PRICING, openAIPricingFor } from "./known-pricing.mjs";
 import { OpenAIEmbedder } from "./embedder.mjs";
 import { OpenAIImageModel } from "./image.mjs";
 import { OpenAISpeechModel } from "./speech.mjs";
 import { OpenAITranscriptionModel } from "./transcription.mjs";
 import { OpenAISDK } from "./sdk.mjs";
+import { KIMI_SERVER_TOOL_PRICING, kimiFetchTool, kimiSearchTool } from "./kimi-tools.mjs";
 
-export { OpenAIEmbedder, OpenAIImageModel, OpenAISDK, OpenAISpeechModel, OpenAITranscriptionModel };
+export { KIMI_SERVER_TOOL_PRICING, OPENAI_MODEL_PRICING, OPENAI_SERVER_TOOL_PRICING, OpenAIEmbedder, OpenAIImageModel, OpenAISDK, OpenAISpeechModel, OpenAITranscriptionModel, kimiFetchTool, kimiSearchTool, openAIPricingFor };

package/esm/kimi-tools.d.mts

@@ -0,0 +1,69 @@
+import { ClientOptions } from "openai";
+import { ServerToolPricing, ToolContract } from "@warlock.js/ai";
+//#region ../../packages/ai-openai/src/kimi-tools.d.ts
+/** USD per billable REST request, verified 2026-10-18:
+ * https://platform.kimi.ai/docs/pricing/websearch
+ * HTTP 200 + nonempty search_results / nonblank markdown only. Taxes excluded.
+ * Namespaced rates avoid charging the generic counters a second time. */
+export declare const KIMI_SERVER_TOOL_PRICING: Readonly<ServerToolPricing>;
+export type KimiToolOptions = Pick<ClientOptions, "baseURL" | "fetch" | "timeout" | "defaultHeaders"> & {
+  apiKey: NonNullable<ClientOptions["apiKey"]>;
+  /** Total snippet / page / chunk characters returned to the model. Default 12,000. */
+  maxContentChars?: number;
+  /** Per-request USD rates keyed like KIMI_SERVER_TOOL_PRICING. {} leaves calls unpriced. */
+  pricing?: ServerToolPricing;
+};
+export type KimiSearchToolOptions = KimiToolOptions & {
+  /** Default "basic". Pro returns ranked passages and supports site/date constraints. */
+  mode?: "basic" | "pro";
+  /** 1–20, default 5. */
+  limit?: number;
+  /** 1–60 seconds, default 30. */
+  timeoutSeconds?: number;
+  /** Basic only; default false. */
+  includeContent?: boolean;
+  /** Pro only; at most five sites, combined with OR. */
+  sites?: string[];
+  /** Pro only; dates accept YYYY, YYYY-MM or YYYY-MM-DD (validated by Kimi). */
+  timeWindow?: {
+    start?: string;
+    end?: string;
+  };
+};
+export type KimiSearchResult = {
+  title: string;
+  url: string;
+  snippet: string;
+  siteName: string;
+  date: string;
+  authority: string;
+  text?: string;
+  chunks?: {
+    text: string;
+    score: number;
+  }[];
+};
+export type KimiSearchOutput = {
+  results: KimiSearchResult[];
+  truncated: boolean;
+};
+export type KimiFetchOutput = {
+  url: string;
+  title: string;
+  markdown: string;
+  truncated: boolean;
+};
+/** Standalone first-party REST search, registered as an ordinary client function tool.
+ * Wire contract: https://platform.kimi.ai/docs/api/tools-search and tools-search-pro.
+ * Reuse the API key / baseURL configuration passed to OpenAISDK; the default URL
+ * here is Moonshot, independent of the model used by the agent. */
+export declare function kimiSearchTool(options: KimiSearchToolOptions): ToolContract<{
+  query: string;
+}, KimiSearchOutput>;
+/** First-party URL-to-Markdown REST tool.
+ * https://platform.kimi.ai/docs/api/tools-fetch — only http/https inputs. */
+export declare function kimiFetchTool(options: KimiToolOptions): ToolContract<{
+  url: string;
+}, KimiFetchOutput>;
+//#endregion
+//# sourceMappingURL=kimi-tools.d.mts.map

package/esm/kimi-tools.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kimi-tools.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/kimi-tools.ts"],"mappings":";;;;;;;qBAuBa,0BAA0B,SAAS;YAMpC,kBAAkB,KAC5B;EAGA,QAAQ,YAAY;;EAEpB;;EAEA,UAAU;;YAGA,wBAAwB;;EAElC;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;IAAe;IAAgB;;;YAGrB;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;IAAW;IAAc;;;YAEf;EAAqB,SAAS;EAAoB;;YAClD;EAAoB;EAAa;EAAe;EAAkB;;;;;;wBAQ9D,eACd,SAAS,wBACR;EAAe;GAAiB;;;wBA2FnB,cACd,SAAS,kBACR;EAAe;GAAe"}

package/esm/kimi-tools.mjs

@@ -0,0 +1,256 @@
+import { wrapOpenAIError } from "./utils/wrap-openai-error.mjs";
+import OpenAI, { APIError } from "openai";
+import { AgentCancelledError, InvalidRequestError, ProviderAuthError, ProviderError, ProviderRateLimitError, ProviderTimeoutError, computeCost, tool } from "@warlock.js/ai";
+
+//#region ../../packages/ai-openai/src/kimi-tools.ts
+/** USD per billable REST request, verified 2026-10-18:
+* https://platform.kimi.ai/docs/pricing/websearch
+* HTTP 200 + nonempty search_results / nonblank markdown only. Taxes excluded.
+* Namespaced rates avoid charging the generic counters a second time. */
+const KIMI_SERVER_TOOL_PRICING = Object.freeze({
+	kimiSearchRequests: .002,
+	kimiSearchProRequests: .003,
+	kimiFetchRequests: .002
+});
+/** Standalone first-party REST search, registered as an ordinary client function tool.
+* Wire contract: https://platform.kimi.ai/docs/api/tools-search and tools-search-pro.
+* Reuse the API key / baseURL configuration passed to OpenAISDK; the default URL
+* here is Moonshot, independent of the model used by the agent. */
+function kimiSearchTool(options) {
+	const mode = options.mode ?? "basic";
+	if (mode !== "basic" && mode !== "pro") throw new InvalidRequestError("Invalid Kimi search mode.");
+	const limit = integer(options.limit ?? 5, 1, 20, "limit");
+	const timeout = integer(options.timeoutSeconds ?? 30, 1, 60, "timeoutSeconds");
+	if (mode === "basic" && (options.sites !== void 0 || options.timeWindow !== void 0)) throw new InvalidRequestError("Kimi sites and timeWindow require mode: pro.");
+	if (mode === "pro" && options.includeContent !== void 0) throw new InvalidRequestError("Kimi includeContent is available only in basic mode.");
+	if (options.sites && (options.sites.length > 5 || options.sites.some((site) => !site || /[\s()]/u.test(site)))) throw new InvalidRequestError("Kimi sites accepts at most five nonempty sites without whitespace or parentheses.");
+	const maxChars = contentLimit(options);
+	const client = createClient(options);
+	const counter = mode === "pro" ? "kimiSearchProRequests" : "kimiSearchRequests";
+	return meteredTool({
+		name: mode === "pro" ? "kimi_search_pro" : "kimi_search",
+		description: "Search the web with Kimi and return cited sources and relevant text.",
+		input: stringInput("query"),
+		async execute({ query }, ctx, record) {
+			const body = {
+				text_query: query,
+				limit,
+				timeout_seconds: timeout,
+				...mode === "basic" ? { include_content: options.includeContent ?? false } : {
+					...options.sites !== void 0 ? { sites: options.sites } : {},
+					...options.timeWindow !== void 0 ? { time_window: options.timeWindow } : {}
+				}
+			};
+			const raw = await request(client, mode === "pro" ? "/tools/search_pro" : "/tools/search", body, ctx);
+			if (!isObject(raw.data) || !Array.isArray(raw.data.search_results)) throw new ProviderError("Kimi returned invalid search_results.");
+			record(raw.status === 200 && raw.data.search_results.length > 0);
+			const budget = textBudget(maxChars);
+			return {
+				results: raw.data.search_results.slice(0, limit).map((value) => {
+					if (!isObject(value)) throw new ProviderError("Kimi returned an invalid search result.");
+					const result = {
+						title: stringValue(value.title),
+						url: stringValue(value.url),
+						snippet: budget.take(stringValue(value.snippet)),
+						siteName: stringValue(value.site_name),
+						date: stringValue(value.date),
+						authority: stringValue(value.authority)
+					};
+					if (mode === "basic" && options.includeContent) result.text = budget.take(stringValue(value.text));
+					if (mode === "pro") {
+						if (!Array.isArray(value.chunks)) throw new ProviderError("Kimi returned invalid search chunks.");
+						result.chunks = value.chunks.map((chunk) => {
+							if (!isObject(chunk) || typeof chunk.score !== "number" || !Number.isFinite(chunk.score)) throw new ProviderError("Kimi returned an invalid search chunk.");
+							return {
+								text: budget.take(stringValue(chunk.text)),
+								score: chunk.score
+							};
+						}).filter((chunk) => chunk.text.length > 0);
+					}
+					return result;
+				}),
+				truncated: budget.truncated || raw.data.search_results.length > limit
+			};
+		}
+	}, counter, options.pricing);
+}
+/** First-party URL-to-Markdown REST tool.
+* https://platform.kimi.ai/docs/api/tools-fetch — only http/https inputs. */
+function kimiFetchTool(options) {
+	const client = createClient(options);
+	const maxChars = contentLimit(options);
+	return meteredTool({
+		name: "kimi_fetch",
+		description: "Read a web page with Kimi and return its title, URL and Markdown body.",
+		input: stringInput("url"),
+		async execute({ url }, ctx, record) {
+			let parsed;
+			try {
+				parsed = new URL(url);
+			} catch {
+				throw new InvalidRequestError("Kimi fetch requires an http/https URL.");
+			}
+			if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new InvalidRequestError("Kimi fetch requires an http/https URL.");
+			const raw = await request(client, "/tools/fetch", { url }, ctx);
+			if (!isObject(raw.data) || typeof raw.data.markdown !== "string") throw new ProviderError("Kimi returned invalid fetch content.");
+			record(raw.status === 200 && raw.data.markdown.trim().length > 0);
+			return {
+				url: stringValue(raw.data.url),
+				title: stringValue(raw.data.title),
+				markdown: raw.data.markdown.slice(0, maxChars),
+				truncated: raw.data.markdown.length > maxChars
+			};
+		}
+	}, "kimiFetchRequests", options.pricing);
+}
+function createClient(options) {
+	const { apiKey, baseURL, fetch, timeout, defaultHeaders } = options;
+	if (!apiKey) throw new ProviderAuthError("Kimi tools require an explicitly configured API key.");
+	return new OpenAI({
+		apiKey,
+		baseURL: baseURL ?? "https://api.moonshot.ai/v1",
+		fetch,
+		timeout,
+		defaultHeaders,
+		maxRetries: 0
+	});
+}
+async function request(client, path, body, ctx) {
+	try {
+		ctx?.signal?.throwIfAborted();
+		const response = await client.post(path, {
+			body,
+			signal: ctx?.signal
+		}).withResponse();
+		return {
+			data: response.data,
+			status: response.response.status
+		};
+	} catch (thrown) {
+		if (ctx?.signal?.aborted) throw new AgentCancelledError("Kimi tool request cancelled.", { cause: thrown });
+		if (thrown instanceof APIError) {
+			const context = {
+				status: thrown.status,
+				type: thrown.type,
+				requestId: thrown.headers?.get("x-msh-track-id")
+			};
+			if (thrown.status === 408 || thrown.status === 504) throw new ProviderTimeoutError(thrown.message, {
+				cause: thrown,
+				context
+			});
+			if (thrown.status === 429) {
+				const retry = Number(thrown.headers?.get("retry-after") ?? NaN);
+				throw new ProviderRateLimitError(thrown.message, {
+					cause: thrown,
+					context,
+					retryAfter: Number.isFinite(retry) && retry >= 0 ? retry * 1e3 : void 0
+				});
+			}
+			if (thrown.status === 403 && !thrown.type) throw new ProviderAuthError(thrown.message, {
+				cause: thrown,
+				context
+			});
+		}
+		throw wrapOpenAIError(thrown);
+	}
+}
+/** Each invoke owns its ledger, including concurrent calls and post-response failures.
+* ToolContract.invoke is the existing accounting boundary used by agents/reports. */
+function meteredTool(config, counter, prices = KIMI_SERVER_TOOL_PRICING) {
+	const rate = prices[counter];
+	if (rate !== void 0 && (!Number.isFinite(rate) || rate < 0)) throw new InvalidRequestError("Kimi per-call pricing must be finite and nonnegative.");
+	return {
+		...tool({
+			...config,
+			execute: (input, ctx) => config.execute(input, ctx, () => {})
+		}),
+		async invoke(input, ctx) {
+			let usage = {
+				input: 0,
+				output: 0,
+				total: 0
+			};
+			const result = await tool({
+				...config,
+				execute: (validated, context) => config.execute(validated, context, (billable) => {
+					const count = billable ? 1 : 0;
+					usage = {
+						input: 0,
+						output: 0,
+						total: 0,
+						serverToolUse: {
+							[counter]: count,
+							[counter === "kimiFetchRequests" ? "webFetchRequests" : "webSearchRequests"]: count
+						}
+					};
+					if (rate !== void 0) usage.cost = computeCost(usage, {
+						input: 0,
+						output: 0,
+						serverTools: { [counter]: rate }
+					});
+				})
+			}).invoke(input, ctx);
+			return {
+				...result,
+				usage,
+				report: {
+					...result.report,
+					usage
+				}
+			};
+		}
+	};
+}
+function integer(value, min, max, name) {
+	if (!Number.isInteger(value) || value < min || value > max) throw new InvalidRequestError(`Kimi ${name} must be an integer from ${min} to ${max}.`);
+	return value;
+}
+function contentLimit(options) {
+	return integer(options.maxContentChars ?? 12e3, 1, Number.MAX_SAFE_INTEGER, "maxContentChars");
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+	if (typeof value !== "string") throw new ProviderError("Kimi returned an invalid text field.");
+	return value;
+}
+function textBudget(max) {
+	return {
+		truncated: false,
+		take(text) {
+			const result = text.slice(0, max);
+			if (text.length > max) this.truncated = true;
+			max -= result.length;
+			return result;
+		}
+	};
+}
+function stringInput(key) {
+	return {
+		jsonSchema: {
+			type: "object",
+			properties: { [key]: {
+				type: "string",
+				minLength: 1
+			} },
+			required: [key],
+			additionalProperties: false
+		},
+		"~standard": {
+			version: 1,
+			vendor: "kimi",
+			validate(value) {
+				if (!isObject(value) || typeof value[key] !== "string" || !value[key].trim()) return { issues: [{
+					message: `${key} must be a nonempty string`,
+					path: [key]
+				}] };
+				return { value: { [key]: value[key] } };
+			}
+		}
+	};
+}
+
+//#endregion
+export { KIMI_SERVER_TOOL_PRICING, kimiFetchTool, kimiSearchTool };
+//# sourceMappingURL=kimi-tools.mjs.map

package/esm/kimi-tools.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kimi-tools.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/kimi-tools.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport {\n  AgentCancelledError,\n  InvalidRequestError,\n  ProviderAuthError,\n  ProviderError,\n  ProviderRateLimitError,\n  ProviderTimeoutError,\n  computeCost,\n  tool,\n  type ServerToolPricing,\n  type ToolConfig,\n  type ToolContext,\n  type ToolContract,\n  type Usage,\n} from \"@warlock.js/ai\";\nimport OpenAI, { APIError, type ClientOptions } from \"openai\";\nimport { wrapOpenAIError } from \"./utils/wrap-openai-error\";\n\n/** USD per billable REST request, verified 2026-10-18:\n * https://platform.kimi.ai/docs/pricing/websearch\n * HTTP 200 + nonempty search_results / nonblank markdown only. Taxes excluded.\n * Namespaced rates avoid charging the generic counters a second time. */\nexport const KIMI_SERVER_TOOL_PRICING: Readonly<ServerToolPricing> = Object.freeze({\n  kimiSearchRequests: 0.002,\n  kimiSearchProRequests: 0.003,\n  kimiFetchRequests: 0.002,\n});\n\nexport type KimiToolOptions = Pick<\n  ClientOptions,\n  \"baseURL\" | \"fetch\" | \"timeout\" | \"defaultHeaders\"\n> & {\n  apiKey: NonNullable<ClientOptions[\"apiKey\"]>;\n  /** Total snippet / page / chunk characters returned to the model. Default 12,000. */\n  maxContentChars?: number;\n  /** Per-request USD rates keyed like KIMI_SERVER_TOOL_PRICING. {} leaves calls unpriced. */\n  pricing?: ServerToolPricing;\n};\n\nexport type KimiSearchToolOptions = KimiToolOptions & {\n  /** Default \"basic\". Pro returns ranked passages and supports site/date constraints. */\n  mode?: \"basic\" | \"pro\";\n  /** 1–20, default 5. */\n  limit?: number;\n  /** 1–60 seconds, default 30. */\n  timeoutSeconds?: number;\n  /** Basic only; default false. */\n  includeContent?: boolean;\n  /** Pro only; at most five sites, combined with OR. */\n  sites?: string[];\n  /** Pro only; dates accept YYYY, YYYY-MM or YYYY-MM-DD (validated by Kimi). */\n  timeWindow?: { start?: string; end?: string };\n};\n\nexport type KimiSearchResult = {\n  title: string;\n  url: string;\n  snippet: string;\n  siteName: string;\n  date: string;\n  authority: string;\n  text?: string;\n  chunks?: { text: string; score: number }[];\n};\nexport type KimiSearchOutput = { results: KimiSearchResult[]; truncated: boolean };\nexport type KimiFetchOutput = { url: string; title: string; markdown: string; truncated: boolean };\n\ntype Counter = \"kimiSearchRequests\" | \"kimiSearchProRequests\" | \"kimiFetchRequests\";\n\n/** Standalone first-party REST search, registered as an ordinary client function tool.\n * Wire contract: https://platform.kimi.ai/docs/api/tools-search and tools-search-pro.\n * Reuse the API key / baseURL configuration passed to OpenAISDK; the default URL\n * here is Moonshot, independent of the model used by the agent. */\nexport function kimiSearchTool(\n  options: KimiSearchToolOptions,\n): ToolContract<{ query: string }, KimiSearchOutput> {\n  const mode = options.mode ?? \"basic\";\n  if (mode !== \"basic\" && mode !== \"pro\")\n    throw new InvalidRequestError(\"Invalid Kimi search mode.\");\n  const limit = integer(options.limit ?? 5, 1, 20, \"limit\");\n  const timeout = integer(options.timeoutSeconds ?? 30, 1, 60, \"timeoutSeconds\");\n  if (mode === \"basic\" && (options.sites !== undefined || options.timeWindow !== undefined)) {\n    throw new InvalidRequestError(\"Kimi sites and timeWindow require mode: pro.\");\n  }\n  if (mode === \"pro\" && options.includeContent !== undefined) {\n    throw new InvalidRequestError(\"Kimi includeContent is available only in basic mode.\");\n  }\n  if (\n    options.sites &&\n    (options.sites.length > 5 || options.sites.some((site) => !site || /[\\s()]/u.test(site)))\n  ) {\n    throw new InvalidRequestError(\n      \"Kimi sites accepts at most five nonempty sites without whitespace or parentheses.\",\n    );\n  }\n  const maxChars = contentLimit(options);\n  const client = createClient(options);\n  const counter = mode === \"pro\" ? \"kimiSearchProRequests\" : \"kimiSearchRequests\";\n  return meteredTool(\n    {\n      name: mode === \"pro\" ? \"kimi_search_pro\" : \"kimi_search\",\n      description: \"Search the web with Kimi and return cited sources and relevant text.\",\n      input: stringInput(\"query\"),\n      async execute({ query }, ctx, record) {\n        const body = {\n          text_query: query,\n          limit,\n          timeout_seconds: timeout,\n          ...(mode === \"basic\"\n            ? { include_content: options.includeContent ?? false }\n            : {\n                ...(options.sites !== undefined ? { sites: options.sites } : {}),\n                ...(options.timeWindow !== undefined ? { time_window: options.timeWindow } : {}),\n              }),\n        };\n        const raw = await request(\n          client,\n          mode === \"pro\" ? \"/tools/search_pro\" : \"/tools/search\",\n          body,\n          ctx,\n        );\n        if (!isObject(raw.data) || !Array.isArray(raw.data.search_results)) {\n          throw new ProviderError(\"Kimi returned invalid search_results.\");\n        }\n        record(raw.status === 200 && raw.data.search_results.length > 0);\n        const budget = textBudget(maxChars);\n        const results = raw.data.search_results.slice(0, limit).map((value): KimiSearchResult => {\n          if (!isObject(value)) throw new ProviderError(\"Kimi returned an invalid search result.\");\n          const result: KimiSearchResult = {\n            title: stringValue(value.title),\n            url: stringValue(value.url),\n            snippet: budget.take(stringValue(value.snippet)),\n            siteName: stringValue(value.site_name),\n            date: stringValue(value.date),\n            authority: stringValue(value.authority),\n          };\n          if (mode === \"basic\" && options.includeContent)\n            result.text = budget.take(stringValue(value.text));\n          if (mode === \"pro\") {\n            if (!Array.isArray(value.chunks))\n              throw new ProviderError(\"Kimi returned invalid search chunks.\");\n            result.chunks = value.chunks\n              .map((chunk) => {\n                if (\n                  !isObject(chunk) ||\n                  typeof chunk.score !== \"number\" ||\n                  !Number.isFinite(chunk.score)\n                ) {\n                  throw new ProviderError(\"Kimi returned an invalid search chunk.\");\n                }\n                return { text: budget.take(stringValue(chunk.text)), score: chunk.score };\n              })\n              .filter((chunk) => chunk.text.length > 0);\n          }\n          return result;\n        });\n        return { results, truncated: budget.truncated || raw.data.search_results.length > limit };\n      },\n    },\n    counter,\n    options.pricing,\n  );\n}\n\n/** First-party URL-to-Markdown REST tool.\n * https://platform.kimi.ai/docs/api/tools-fetch — only http/https inputs. */\nexport function kimiFetchTool(\n  options: KimiToolOptions,\n): ToolContract<{ url: string }, KimiFetchOutput> {\n  const client = createClient(options);\n  const maxChars = contentLimit(options);\n  return meteredTool(\n    {\n      name: \"kimi_fetch\",\n      description: \"Read a web page with Kimi and return its title, URL and Markdown body.\",\n      input: stringInput(\"url\"),\n      async execute({ url }, ctx, record) {\n        let parsed: URL;\n        try {\n          parsed = new URL(url);\n        } catch {\n          throw new InvalidRequestError(\"Kimi fetch requires an http/https URL.\");\n        }\n        if (parsed.protocol !== \"http:\" && parsed.protocol !== \"https:\") {\n          throw new InvalidRequestError(\"Kimi fetch requires an http/https URL.\");\n        }\n        const raw = await request(client, \"/tools/fetch\", { url }, ctx);\n        if (!isObject(raw.data) || typeof raw.data.markdown !== \"string\") {\n          throw new ProviderError(\"Kimi returned invalid fetch content.\");\n        }\n        record(raw.status === 200 && raw.data.markdown.trim().length > 0);\n        return {\n          url: stringValue(raw.data.url),\n          title: stringValue(raw.data.title),\n          markdown: raw.data.markdown.slice(0, maxChars),\n          truncated: raw.data.markdown.length > maxChars,\n        };\n      },\n    },\n    \"kimiFetchRequests\",\n    options.pricing,\n  );\n}\n\nfunction createClient(options: KimiToolOptions): OpenAI {\n  const { apiKey, baseURL, fetch, timeout, defaultHeaders } = options;\n  if (!apiKey) throw new ProviderAuthError(\"Kimi tools require an explicitly configured API key.\");\n  return new OpenAI({\n    apiKey,\n    baseURL: baseURL ?? \"https://api.moonshot.ai/v1\",\n    fetch,\n    timeout,\n    defaultHeaders,\n    maxRetries: 0,\n  });\n}\n\nasync function request(client: OpenAI, path: string, body: object, ctx?: ToolContext) {\n  try {\n    ctx?.signal?.throwIfAborted();\n    // No automatic retries: a lost response does not prove the vendor did not bill it.\n    const response = await client.post<unknown>(path, { body, signal: ctx?.signal }).withResponse();\n    return { data: response.data, status: response.response.status };\n  } catch (thrown) {\n    if (ctx?.signal?.aborted) {\n      throw new AgentCancelledError(\"Kimi tool request cancelled.\", { cause: thrown });\n    }\n    if (thrown instanceof APIError) {\n      const context = {\n        status: thrown.status,\n        type: thrown.type,\n        requestId: thrown.headers?.get(\"x-msh-track-id\"),\n      };\n      if (thrown.status === 408 || thrown.status === 504)\n        throw new ProviderTimeoutError(thrown.message, { cause: thrown, context });\n      if (thrown.status === 429) {\n        const retry = Number(thrown.headers?.get(\"retry-after\") ?? Number.NaN);\n        throw new ProviderRateLimitError(thrown.message, {\n          cause: thrown,\n          context,\n          retryAfter: Number.isFinite(retry) && retry >= 0 ? retry * 1000 : undefined,\n        });\n      }\n      if (thrown.status === 403 && !thrown.type)\n        throw new ProviderAuthError(thrown.message, { cause: thrown, context });\n    }\n    throw wrapOpenAIError(thrown);\n  }\n}\n\n/** Each invoke owns its ledger, including concurrent calls and post-response failures.\n * ToolContract.invoke is the existing accounting boundary used by agents/reports. */\nfunction meteredTool<TInput, TOutput>(\n  config: Omit<ToolConfig<TInput, TOutput>, \"execute\"> & {\n    execute(\n      input: TInput,\n      ctx: ToolContext | undefined,\n      record: (billable: boolean) => void,\n    ): Promise<TOutput>;\n  },\n  counter: Counter,\n  prices: ServerToolPricing = KIMI_SERVER_TOOL_PRICING,\n): ToolContract<TInput, TOutput> {\n  const rate = prices[counter];\n  if (rate !== undefined && (!Number.isFinite(rate) || rate < 0))\n    throw new InvalidRequestError(\"Kimi per-call pricing must be finite and nonnegative.\");\n  const base = tool({\n    ...config,\n    execute: (input: TInput, ctx?: ToolContext) => config.execute(input, ctx, () => {}),\n  });\n  return {\n    ...base,\n    async invoke(input, ctx) {\n      let usage: Usage = { input: 0, output: 0, total: 0 };\n      const invocation = tool({\n        ...config,\n        execute: (validated: TInput, context?: ToolContext) =>\n          config.execute(validated, context, (billable) => {\n            const count = billable ? 1 : 0;\n            usage = {\n              input: 0,\n              output: 0,\n              total: 0,\n              serverToolUse: {\n                [counter]: count,\n                [counter === \"kimiFetchRequests\" ? \"webFetchRequests\" : \"webSearchRequests\"]: count,\n              },\n            };\n            if (rate !== undefined)\n              usage.cost = computeCost(usage, {\n                input: 0,\n                output: 0,\n                serverTools: { [counter]: rate },\n              });\n          }),\n      });\n      const result = await invocation.invoke(input, ctx);\n      return { ...result, usage, report: { ...result.report, usage } };\n    },\n  };\n}\n\nfunction integer(value: number, min: number, max: number, name: string): number {\n  if (!Number.isInteger(value) || value < min || value > max)\n    throw new InvalidRequestError(`Kimi ${name} must be an integer from ${min} to ${max}.`);\n  return value;\n}\nfunction contentLimit(options: KimiToolOptions): number {\n  return integer(options.maxContentChars ?? 12_000, 1, Number.MAX_SAFE_INTEGER, \"maxContentChars\");\n}\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\nfunction stringValue(value: unknown): string {\n  if (typeof value !== \"string\") throw new ProviderError(\"Kimi returned an invalid text field.\");\n  return value;\n}\nfunction textBudget(max: number) {\n  return {\n    truncated: false,\n    take(text: string) {\n      const result = text.slice(0, max);\n      if (text.length > max) this.truncated = true;\n      max -= result.length;\n      return result;\n    },\n  };\n}\nfunction stringInput<K extends string>(\n  key: K,\n): StandardSchemaV1<Record<K, string>> & { jsonSchema: Record<string, unknown> } {\n  return {\n    jsonSchema: {\n      type: \"object\",\n      properties: { [key]: { type: \"string\", minLength: 1 } },\n      required: [key],\n      additionalProperties: false,\n    },\n    \"~standard\": {\n      version: 1,\n      vendor: \"kimi\",\n      validate(value) {\n        if (!isObject(value) || typeof value[key] !== \"string\" || !value[key].trim()) {\n          return { issues: [{ message: `${key} must be a nonempty string`, path: [key] }] };\n        }\n        return { value: { [key]: value[key] } as Record<K, string> };\n      },\n    },\n  };\n}\n"],"mappings":"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"}

package/esm/known-pricing.d.mts

@@ -0,0 +1,39 @@
+import { ModelPricing } from "@warlock.js/ai";
+//#region ../../packages/ai-openai/src/known-pricing.d.ts
+/**
+ * Built-in OpenAI API list prices, USD per 1,000,000 tokens, keyed by
+ * exact model id. `cachedInput` is the cached-input rate. None of these
+ * models charges for cache writes.
+ *
+ * Source: https://developers.openai.com/api/docs/pricing (the target of
+ * platform.openai.com/docs/pricing), Standard tier, fetched 2026-10-17.
+ *
+ * Applied only when the SDK's provider label is `"openai"`, and only on
+ * an exact id match — dated snapshots can carry other prices. Left out on
+ * purpose, so pass `pricing` yourself for them:
+ *
+ * - Models priced by prompt length (a higher rate above 272K input
+ *   tokens): the gpt-6 / gpt-5.6 / gpt-5.5 / gpt-5.4 families and the
+ *   `-pro` models. A flat `ModelPricing` cannot express the tiers.
+ * - Promotional, Batch, Flex and Priority pricing, and the regional
+ *   (data-residency) uplift.
+ */
+export declare const OPENAI_MODEL_PRICING: Readonly<Record<string, ModelPricing>>;
+/**
+ * Look up the built-in list price for an OpenAI model id (exact match).
+ * Returns `undefined` for unknown ids, so cost stays unknown rather than
+ * wrong.
+ *
+ * @example
+ * openAIPricingFor("gpt-4o-mini"); // { input: 0.15, output: 0.6, cachedInput: 0.075 }
+ * openAIPricingFor("gpt-5.5"); // undefined — priced by prompt length
+ */
+export declare function openAIPricingFor(modelName: string): ModelPricing | undefined;
+/** USD per request for web_search (NOT non-reasoning web_search_preview).
+ * Search content tokens are additional; preview variants can have other rates.
+ * https://developers.openai.com/api/docs/pricing#built-in-tools — verified 2026-10-18. */
+export declare const OPENAI_SERVER_TOOL_PRICING: {
+  webSearch: number;
+};
+//#endregion
+//# sourceMappingURL=known-pricing.d.mts.map

package/esm/known-pricing.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-pricing.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/known-pricing.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAoBa,sBAAsB,SAAS,eAAe;;;;;;;;;;wBA4B3C,iBAAiB,oBAAoB;;;;qBAOxC;EAA+B"}