@warlock.js/ai-openai 5.28.0 → 5.30.0

package/esm/config.type.d.mts

@@ -1,7 +1,7 @@
 import OpenAI, { ClientOptions } from "openai";
 import { EmbedderConfig, ImageModelConfig, ModelConfig, ModelPricing, SpeechModelConfig, TranscriptionModelConfig } from "@warlock.js/ai";
 
-//#region ../ai-openai/src/config.type.d.ts
+//#region ../../packages/ai-openai/src/config.type.d.ts
 /**
  * Configuration for the OpenAI SDK adapter.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"config.type.d.mts","names":[],"sources":["../../../../../../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":";;;;;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"}

package/esm/embedder.d.mts

@@ -2,7 +2,7 @@ import { OpenAIEmbedderConfig } from "./config.type.mjs";
 import OpenAI from "openai";
 import { EmbedderContract, EmbeddingBatchResult, EmbeddingResult } from "@warlock.js/ai";
 
-//#region ../ai-openai/src/embedder.d.ts
+//#region ../../packages/ai-openai/src/embedder.d.ts
 /**
  * OpenAI-backed implementation of `EmbedderContract`.
  *

package/esm/embedder.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"embedder.d.mts","names":[],"sources":["../../../../../../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":";;;;;;;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"}

package/esm/embedder.mjs

@@ -3,7 +3,7 @@ import "./utils/index.mjs";
 import { EmbeddingVectorCountMismatchError } from "@warlock.js/ai";
 import { log } from "@warlock.js/logger";
 
-//#region ../ai-openai/src/embedder.ts
+//#region ../../packages/ai-openai/src/embedder.ts
 const LOG_MODULE = "ai.openai";
 /**
 * OpenAI-backed implementation of `EmbedderContract`.

package/esm/embedder.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"embedder.mjs","names":[],"sources":["../../../../../../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<\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"}

package/esm/image.d.mts

@@ -2,7 +2,7 @@ import { OpenAIImageConfig } from "./config.type.mjs";
 import OpenAI from "openai";
 import { ImageGenerationOptions, ImageGenerationResponse, ImageModelContract, ImageModelPricing } from "@warlock.js/ai";
 
-//#region ../ai-openai/src/image.d.ts
+//#region ../../packages/ai-openai/src/image.d.ts
 /**
  * OpenAI-backed implementation of `ImageModelContract`.
  *

package/esm/image.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.mts","names":[],"sources":["../../../../../../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":";;;;;;;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"}

package/esm/image.mjs

@@ -3,7 +3,7 @@ import "./utils/index.mjs";
 import { ProviderError } from "@warlock.js/ai";
 import { log } from "@warlock.js/logger";
 
-//#region ../ai-openai/src/image.ts
+//#region ../../packages/ai-openai/src/image.ts
 const LOG_MODULE = "ai.openai";
 /** Map a neutral output container to its IANA media type. */
 function mediaTypeFor(format) {

package/esm/image.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"image.mjs","names":[],"sources":["../../../../../../ai-openai/src/image.ts"],"sourcesContent":["import {\n  ProviderError,\n  type GeneratedImage,\n  type ImageGenerationOptions,\n  type ImageGenerationResponse,\n  type ImageModelContract,\n  type ImageModelPricing,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAIImageConfig } from \"./config.type\";\nimport { wrapOpenAIError } from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\n/** Map a neutral output container to its IANA media type. */\nfunction mediaTypeFor(format: string | undefined): string {\n  switch (format) {\n    case \"jpeg\":\n    case \"jpg\":\n      return \"image/jpeg\";\n    case \"webp\":\n      return \"image/webp\";\n    default:\n      return \"image/png\";\n  }\n}\n\n/**\n * OpenAI-backed implementation of `ImageModelContract`.\n *\n * **Role.** Bridges the vendor-neutral `ai.image()` verb to OpenAI's\n * **Images** API. Metering follows the family the id belongs to: the\n * token-metered `gpt-image-*` models (always return base64 bytes) and\n * the per-image-metered `dall-e-*` models (URL or base64). Like\n * `OpenAIEmbedder`, it's a standalone primitive — no relationship to\n * chat completions, tools, or the agent loop.\n *\n * **No model-id validation.** `config.name` is forwarded to\n * `client.images.generate` exactly as given — the constructor never\n * inspects it. OpenAI adds and retires image model ids on its own\n * schedule, so an id this adapter does not recognize is not the\n * adapter's call to refuse; an unsupported id surfaces as a provider\n * error from OpenAI (wrapped into the typed `AIError` hierarchy by\n * `generate()`), not as a local one.\n *\n * **Error handling.** Raw OpenAI SDK errors are wrapped into the typed\n * `@warlock.js/ai` `AIError` hierarchy via `wrapOpenAIError`, so a\n * caller catches `ProviderRateLimitError` / `ContentFilterError` /\n * `ProviderAuthError` rather than OpenAI's own classes. `ai.image()`\n * turns those throws into `result.error`.\n *\n * @example\n * const model = new OpenAIImageModel(client, { name: \"gpt-image-1\" }, \"openai\");\n * const { images, usage } = await model.generate(\"a teal ceramic mug, studio light\");\n */\nexport class OpenAIImageModel implements ImageModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly pricing?: ImageModelPricing;\n\n  private readonly client: OpenAI;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAIImageConfig, provider: string = \"openai\") {\n    this.client = client;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n  }\n\n  public async generate(\n    prompt: string,\n    options?: ImageGenerationOptions,\n  ): Promise<ImageGenerationResponse> {\n    const isGptImage = this.name.startsWith(\"gpt-image\");\n    // gpt-image always returns base64 bytes (no `response_format` knob);\n    // DALL·E defaults to self-contained base64 here (URLs expire in ~60\n    // min), but the caller can ask for a URL via `options.responseFormat`.\n    const responseFormat =\n      (options?.responseFormat as \"url\" | \"b64_json\" | undefined) ??\n      (isGptImage ? undefined : \"b64_json\");\n\n    const body: OpenAI.Images.ImageGenerateParamsNonStreaming = {\n      model: this.name,\n      prompt,\n    };\n\n    if (options?.count !== undefined) body.n = options.count;\n    if (options?.size !== undefined) body.size = options.size;\n    if (options?.quality !== undefined) {\n      body.quality = options.quality as OpenAI.Images.ImageGenerateParamsNonStreaming[\"quality\"];\n    }\n    if (!isGptImage && responseFormat) body.response_format = responseFormat;\n    if (isGptImage && options?.format !== undefined) {\n      body.output_format =\n        options.format as OpenAI.Images.ImageGenerateParamsNonStreaming[\"output_format\"];\n    }\n    if (options?.background !== undefined) {\n      body.background =\n        options.background as OpenAI.Images.ImageGenerateParamsNonStreaming[\"background\"];\n    }\n\n    this.logger.debug(LOG_MODULE, \"image.request\", \"images.generate\", {\n      model: this.name,\n      count: options?.count ?? 1,\n    });\n\n    let response: OpenAI.Images.ImagesResponse;\n\n    try {\n      response = await this.client.images.generate(\n        body,\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"image.error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    const images = (response.data ?? []).map((image) =>\n      this.toGeneratedImage(image, options?.format),\n    );\n\n    const usage = response.usage\n      ? {\n          input: response.usage.input_tokens,\n          output: response.usage.output_tokens,\n          total: response.usage.total_tokens,\n        }\n      : { input: 0, output: 0, total: 0 };\n\n    this.logger.debug(LOG_MODULE, \"image.response\", \"images.generate succeeded\", {\n      images: images.length,\n      usage,\n    });\n\n    return { images, usage };\n  }\n\n  /**\n   * Normalize one OpenAI `Image` into the neutral discriminated shape.\n   * Base64 wins when present (gpt-image, and DALL·E in b64 mode);\n   * otherwise a hosted URL. A response carrying neither is a provider\n   * contract violation — surface it as a typed `ProviderError` rather\n   * than emitting a half-formed part.\n   */\n  private toGeneratedImage(image: OpenAI.Images.Image, format: string | undefined): GeneratedImage {\n    if (image.b64_json) {\n      return {\n        type: \"base64\",\n        base64: image.b64_json,\n        mediaType: mediaTypeFor(format),\n        ...(image.revised_prompt ? { revisedPrompt: image.revised_prompt } : {}),\n      };\n    }\n\n    if (image.url) {\n      return {\n        type: \"url\",\n        url: image.url,\n        ...(image.revised_prompt ? { revisedPrompt: image.revised_prompt } : {}),\n      };\n    }\n\n    throw new ProviderError(\"OpenAI image response contained neither base64 bytes nor a URL.\");\n  }\n}\n"],"mappings":";;;;;;AAaA,MAAM,aAAa;;AAGnB,SAAS,aAAa,QAAoC;CACxD,QAAQ,QAAR;EACE,KAAK;EACL,KAAK,OACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,SACE,OAAO;CACX;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,mBAAb,MAA4D;CAQ1D,AAAO,YAAY,QAAgB,QAA2B,WAAmB,UAAU;gBAFzD;EAGhC,KAAK,SAAS;EACd,KAAK,OAAO,OAAO;EACnB,KAAK,WAAW;EAChB,KAAK,UAAU,OAAO;CACxB;CAEA,MAAa,SACX,QACA,SACkC;EAClC,MAAM,aAAa,KAAK,KAAK,WAAW,WAAW;EAInD,MAAM,iBACH,SAAS,mBACT,aAAa,SAAY;EAE5B,MAAM,OAAsD;GAC1D,OAAO,KAAK;GACZ;EACF;EAEA,IAAI,SAAS,UAAU,QAAW,KAAK,IAAI,QAAQ;EACnD,IAAI,SAAS,SAAS,QAAW,KAAK,OAAO,QAAQ;EACrD,IAAI,SAAS,YAAY,QACvB,KAAK,UAAU,QAAQ;EAEzB,IAAI,CAAC,cAAc,gBAAgB,KAAK,kBAAkB;EAC1D,IAAI,cAAc,SAAS,WAAW,QACpC,KAAK,gBACH,QAAQ;EAEZ,IAAI,SAAS,eAAe,QAC1B,KAAK,aACH,QAAQ;EAGZ,KAAK,OAAO,MAAM,YAAY,iBAAiB,mBAAmB;GAChE,OAAO,KAAK;GACZ,OAAO,SAAS,SAAS;EAC3B,CAAC;EAED,IAAI;EAEJ,IAAI;GACF,WAAW,MAAM,KAAK,OAAO,OAAO,SAClC,MACA,SAAS,SAAS,EAAE,QAAQ,QAAQ,OAAO,IAAI,MACjD;EACF,SAAS,QAAQ;GACf,MAAM,UAAU,gBAAgB,MAAM;GAEtC,KAAK,OAAO,MAAM,YAAY,eAAe,QAAQ,SAAS;IAC5D,MAAM,QAAQ;IACd,SAAS,QAAQ;GACnB,CAAC;GAED,MAAM;EACR;EAEA,MAAM,UAAU,SAAS,QAAQ,CAAC,EAAC,CAAE,KAAK,UACxC,KAAK,iBAAiB,OAAO,SAAS,MAAM,CAC9C;EAEA,MAAM,QAAQ,SAAS,QACnB;GACE,OAAO,SAAS,MAAM;GACtB,QAAQ,SAAS,MAAM;GACvB,OAAO,SAAS,MAAM;EACxB,IACA;GAAE,OAAO;GAAG,QAAQ;GAAG,OAAO;EAAE;EAEpC,KAAK,OAAO,MAAM,YAAY,kBAAkB,6BAA6B;GAC3E,QAAQ,OAAO;GACf;EACF,CAAC;EAED,OAAO;GAAE;GAAQ;EAAM;CACzB;;;;;;;;CASA,AAAQ,iBAAiB,OAA4B,QAA4C;EAC/F,IAAI,MAAM,UACR,OAAO;GACL,MAAM;GACN,QAAQ,MAAM;GACd,WAAW,aAAa,MAAM;GAC9B,GAAI,MAAM,iBAAiB,EAAE,eAAe,MAAM,eAAe,IAAI,CAAC;EACxE;EAGF,IAAI,MAAM,KACR,OAAO;GACL,MAAM;GACN,KAAK,MAAM;GACX,GAAI,MAAM,iBAAiB,EAAE,eAAe,MAAM,eAAe,IAAI,CAAC;EACxE;EAGF,MAAM,IAAI,cAAc,iEAAiE;CAC3F;AACF"}
+{"version":3,"file":"image.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/image.ts"],"sourcesContent":["import {\n  ProviderError,\n  type GeneratedImage,\n  type ImageGenerationOptions,\n  type ImageGenerationResponse,\n  type ImageModelContract,\n  type ImageModelPricing,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAIImageConfig } from \"./config.type\";\nimport { wrapOpenAIError } from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\n/** Map a neutral output container to its IANA media type. */\nfunction mediaTypeFor(format: string | undefined): string {\n  switch (format) {\n    case \"jpeg\":\n    case \"jpg\":\n      return \"image/jpeg\";\n    case \"webp\":\n      return \"image/webp\";\n    default:\n      return \"image/png\";\n  }\n}\n\n/**\n * OpenAI-backed implementation of `ImageModelContract`.\n *\n * **Role.** Bridges the vendor-neutral `ai.image()` verb to OpenAI's\n * **Images** API. Metering follows the family the id belongs to: the\n * token-metered `gpt-image-*` models (always return base64 bytes) and\n * the per-image-metered `dall-e-*` models (URL or base64). Like\n * `OpenAIEmbedder`, it's a standalone primitive — no relationship to\n * chat completions, tools, or the agent loop.\n *\n * **No model-id validation.** `config.name` is forwarded to\n * `client.images.generate` exactly as given — the constructor never\n * inspects it. OpenAI adds and retires image model ids on its own\n * schedule, so an id this adapter does not recognize is not the\n * adapter's call to refuse; an unsupported id surfaces as a provider\n * error from OpenAI (wrapped into the typed `AIError` hierarchy by\n * `generate()`), not as a local one.\n *\n * **Error handling.** Raw OpenAI SDK errors are wrapped into the typed\n * `@warlock.js/ai` `AIError` hierarchy via `wrapOpenAIError`, so a\n * caller catches `ProviderRateLimitError` / `ContentFilterError` /\n * `ProviderAuthError` rather than OpenAI's own classes. `ai.image()`\n * turns those throws into `result.error`.\n *\n * @example\n * const model = new OpenAIImageModel(client, { name: \"gpt-image-1\" }, \"openai\");\n * const { images, usage } = await model.generate(\"a teal ceramic mug, studio light\");\n */\nexport class OpenAIImageModel implements ImageModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly pricing?: ImageModelPricing;\n\n  private readonly client: OpenAI;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAIImageConfig, provider: string = \"openai\") {\n    this.client = client;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n  }\n\n  public async generate(\n    prompt: string,\n    options?: ImageGenerationOptions,\n  ): Promise<ImageGenerationResponse> {\n    const isGptImage = this.name.startsWith(\"gpt-image\");\n    // gpt-image always returns base64 bytes (no `response_format` knob);\n    // DALL·E defaults to self-contained base64 here (URLs expire in ~60\n    // min), but the caller can ask for a URL via `options.responseFormat`.\n    const responseFormat =\n      (options?.responseFormat as \"url\" | \"b64_json\" | undefined) ??\n      (isGptImage ? undefined : \"b64_json\");\n\n    const body: OpenAI.Images.ImageGenerateParamsNonStreaming = {\n      model: this.name,\n      prompt,\n    };\n\n    if (options?.count !== undefined) body.n = options.count;\n    if (options?.size !== undefined) body.size = options.size;\n    if (options?.quality !== undefined) {\n      body.quality = options.quality as OpenAI.Images.ImageGenerateParamsNonStreaming[\"quality\"];\n    }\n    if (!isGptImage && responseFormat) body.response_format = responseFormat;\n    if (isGptImage && options?.format !== undefined) {\n      body.output_format =\n        options.format as OpenAI.Images.ImageGenerateParamsNonStreaming[\"output_format\"];\n    }\n    if (options?.background !== undefined) {\n      body.background =\n        options.background as OpenAI.Images.ImageGenerateParamsNonStreaming[\"background\"];\n    }\n\n    this.logger.debug(LOG_MODULE, \"image.request\", \"images.generate\", {\n      model: this.name,\n      count: options?.count ?? 1,\n    });\n\n    let response: OpenAI.Images.ImagesResponse;\n\n    try {\n      response = await this.client.images.generate(\n        body,\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"image.error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    const images = (response.data ?? []).map((image) =>\n      this.toGeneratedImage(image, options?.format),\n    );\n\n    const usage = response.usage\n      ? {\n          input: response.usage.input_tokens,\n          output: response.usage.output_tokens,\n          total: response.usage.total_tokens,\n        }\n      : { input: 0, output: 0, total: 0 };\n\n    this.logger.debug(LOG_MODULE, \"image.response\", \"images.generate succeeded\", {\n      images: images.length,\n      usage,\n    });\n\n    return { images, usage };\n  }\n\n  /**\n   * Normalize one OpenAI `Image` into the neutral discriminated shape.\n   * Base64 wins when present (gpt-image, and DALL·E in b64 mode);\n   * otherwise a hosted URL. A response carrying neither is a provider\n   * contract violation — surface it as a typed `ProviderError` rather\n   * than emitting a half-formed part.\n   */\n  private toGeneratedImage(image: OpenAI.Images.Image, format: string | undefined): GeneratedImage {\n    if (image.b64_json) {\n      return {\n        type: \"base64\",\n        base64: image.b64_json,\n        mediaType: mediaTypeFor(format),\n        ...(image.revised_prompt ? { revisedPrompt: image.revised_prompt } : {}),\n      };\n    }\n\n    if (image.url) {\n      return {\n        type: \"url\",\n        url: image.url,\n        ...(image.revised_prompt ? { revisedPrompt: image.revised_prompt } : {}),\n      };\n    }\n\n    throw new ProviderError(\"OpenAI image response contained neither base64 bytes nor a URL.\");\n  }\n}\n"],"mappings":";;;;;;AAaA,MAAM,aAAa;;AAGnB,SAAS,aAAa,QAAoC;CACxD,QAAQ,QAAR;EACE,KAAK;EACL,KAAK,OACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,SACE,OAAO;CACX;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,mBAAb,MAA4D;CAQ1D,AAAO,YAAY,QAAgB,QAA2B,WAAmB,UAAU;gBAFzD;EAGhC,KAAK,SAAS;EACd,KAAK,OAAO,OAAO;EACnB,KAAK,WAAW;EAChB,KAAK,UAAU,OAAO;CACxB;CAEA,MAAa,SACX,QACA,SACkC;EAClC,MAAM,aAAa,KAAK,KAAK,WAAW,WAAW;EAInD,MAAM,iBACH,SAAS,mBACT,aAAa,SAAY;EAE5B,MAAM,OAAsD;GAC1D,OAAO,KAAK;GACZ;EACF;EAEA,IAAI,SAAS,UAAU,QAAW,KAAK,IAAI,QAAQ;EACnD,IAAI,SAAS,SAAS,QAAW,KAAK,OAAO,QAAQ;EACrD,IAAI,SAAS,YAAY,QACvB,KAAK,UAAU,QAAQ;EAEzB,IAAI,CAAC,cAAc,gBAAgB,KAAK,kBAAkB;EAC1D,IAAI,cAAc,SAAS,WAAW,QACpC,KAAK,gBACH,QAAQ;EAEZ,IAAI,SAAS,eAAe,QAC1B,KAAK,aACH,QAAQ;EAGZ,KAAK,OAAO,MAAM,YAAY,iBAAiB,mBAAmB;GAChE,OAAO,KAAK;GACZ,OAAO,SAAS,SAAS;EAC3B,CAAC;EAED,IAAI;EAEJ,IAAI;GACF,WAAW,MAAM,KAAK,OAAO,OAAO,SAClC,MACA,SAAS,SAAS,EAAE,QAAQ,QAAQ,OAAO,IAAI,MACjD;EACF,SAAS,QAAQ;GACf,MAAM,UAAU,gBAAgB,MAAM;GAEtC,KAAK,OAAO,MAAM,YAAY,eAAe,QAAQ,SAAS;IAC5D,MAAM,QAAQ;IACd,SAAS,QAAQ;GACnB,CAAC;GAED,MAAM;EACR;EAEA,MAAM,UAAU,SAAS,QAAQ,CAAC,EAAC,CAAE,KAAK,UACxC,KAAK,iBAAiB,OAAO,SAAS,MAAM,CAC9C;EAEA,MAAM,QAAQ,SAAS,QACnB;GACE,OAAO,SAAS,MAAM;GACtB,QAAQ,SAAS,MAAM;GACvB,OAAO,SAAS,MAAM;EACxB,IACA;GAAE,OAAO;GAAG,QAAQ;GAAG,OAAO;EAAE;EAEpC,KAAK,OAAO,MAAM,YAAY,kBAAkB,6BAA6B;GAC3E,QAAQ,OAAO;GACf;EACF,CAAC;EAED,OAAO;GAAE;GAAQ;EAAM;CACzB;;;;;;;;CASA,AAAQ,iBAAiB,OAA4B,QAA4C;EAC/F,IAAI,MAAM,UACR,OAAO;GACL,MAAM;GACN,QAAQ,MAAM;GACd,WAAW,aAAa,MAAM;GAC9B,GAAI,MAAM,iBAAiB,EAAE,eAAe,MAAM,eAAe,IAAI,CAAC;EACxE;EAGF,IAAI,MAAM,KACR,OAAO;GACL,MAAM;GACN,KAAK,MAAM;GACX,GAAI,MAAM,iBAAiB,EAAE,eAAe,MAAM,eAAe,IAAI,CAAC;EACxE;EAGF,MAAM,IAAI,cAAc,iEAAiE;CAC3F;AACF"}

package/esm/known-reasoning-models.mjs

@@ -1,4 +1,4 @@
-//#region ../ai-openai/src/known-reasoning-models.ts
+//#region ../../packages/ai-openai/src/known-reasoning-models.ts
 /**
 * Model-name prefixes for OpenAI families that expose internal
 * reasoning / thinking tokens and accept the `reasoning_effort`

package/esm/known-reasoning-models.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"known-reasoning-models.mjs","names":[],"sources":["../../../../../../ai-openai/src/known-reasoning-models.ts"],"sourcesContent":["/**\n * Model-name prefixes for OpenAI families that expose internal\n * reasoning / thinking tokens and accept the `reasoning_effort`\n * request parameter on the Chat Completions API.\n *\n * Matched as a prefix so dated variants (`o3-2025-04-16`) and\n * `-mini` / `-pro` suffixes (`o4-mini`, `gpt-5-pro`) are covered\n * without listing every release tag explicitly.\n *\n * Maintenance: append a new prefix when OpenAI ships a reasoning\n * model family that doesn't already match. Devs can always override\n * per-model via `openai.model({ name, reasoning: true | false })` —\n * explicit config wins over inference in either direction.\n */\nconst REASONING_CAPABLE_PREFIXES = [\"o1\", \"o3\", \"o4\", \"gpt-5\", \"gpt-6\"];\n\n/**\n * Infer whether a given OpenAI model name is a reasoning model (o-series\n * and the gpt-5 / gpt-6 families) based on the known-prefix list. Unknown models\n * default to `false` so the adapter never forwards an unsupported\n * `reasoning_effort` param to a non-reasoning model (which would 400).\n *\n * @example\n * inferReasoningCapability(\"o3-mini\");          // → true\n * inferReasoningCapability(\"o4-mini\");          // → true\n * inferReasoningCapability(\"gpt-5-pro\");        // → true\n * inferReasoningCapability(\"gpt-6-astra\");      // → true\n * inferReasoningCapability(\"gpt-4o\");           // → false\n * inferReasoningCapability(\"custom-llm\");       // → false\n */\nexport function inferReasoningCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return REASONING_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAM,6BAA6B;CAAC;CAAM;CAAM;CAAM;CAAS;AAAO;;;;;;;;;;;;;;;AAgBtE,SAAgB,yBAAyB,WAA4B;CACnE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,2BAA2B,MAAM,WAAW,WAAW,WAAW,MAAM,CAAC;AAClF"}
+{"version":3,"file":"known-reasoning-models.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/known-reasoning-models.ts"],"sourcesContent":["/**\n * Model-name prefixes for OpenAI families that expose internal\n * reasoning / thinking tokens and accept the `reasoning_effort`\n * request parameter on the Chat Completions API.\n *\n * Matched as a prefix so dated variants (`o3-2025-04-16`) and\n * `-mini` / `-pro` suffixes (`o4-mini`, `gpt-5-pro`) are covered\n * without listing every release tag explicitly.\n *\n * Maintenance: append a new prefix when OpenAI ships a reasoning\n * model family that doesn't already match. Devs can always override\n * per-model via `openai.model({ name, reasoning: true | false })` —\n * explicit config wins over inference in either direction.\n */\nconst REASONING_CAPABLE_PREFIXES = [\"o1\", \"o3\", \"o4\", \"gpt-5\", \"gpt-6\"];\n\n/**\n * Infer whether a given OpenAI model name is a reasoning model (o-series\n * and the gpt-5 / gpt-6 families) based on the known-prefix list. Unknown models\n * default to `false` so the adapter never forwards an unsupported\n * `reasoning_effort` param to a non-reasoning model (which would 400).\n *\n * @example\n * inferReasoningCapability(\"o3-mini\");          // → true\n * inferReasoningCapability(\"o4-mini\");          // → true\n * inferReasoningCapability(\"gpt-5-pro\");        // → true\n * inferReasoningCapability(\"gpt-6-astra\");      // → true\n * inferReasoningCapability(\"gpt-4o\");           // → false\n * inferReasoningCapability(\"custom-llm\");       // → false\n */\nexport function inferReasoningCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return REASONING_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAM,6BAA6B;CAAC;CAAM;CAAM;CAAM;CAAS;AAAO;;;;;;;;;;;;;;;AAgBtE,SAAgB,yBAAyB,WAA4B;CACnE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,2BAA2B,MAAM,WAAW,WAAW,WAAW,MAAM,CAAC;AAClF"}

package/esm/known-vision-models.mjs

@@ -1,4 +1,4 @@
-//#region ../ai-openai/src/known-vision-models.ts
+//#region ../../packages/ai-openai/src/known-vision-models.ts
 /**
 * Model-name prefixes for OpenAI families that support vision input
 * (image attachments) on the Chat Completions API.

package/esm/known-vision-models.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"known-vision-models.mjs","names":[],"sources":["../../../../../../ai-openai/src/known-vision-models.ts"],"sourcesContent":["/**\n * Model-name prefixes for OpenAI families that support vision input\n * (image attachments) on the Chat Completions API.\n *\n * Matched as a prefix so dated variants (`gpt-4o-2024-08-06`) and\n * `-mini` / `-preview` suffixes (`gpt-4o-mini`, `gpt-4-turbo-preview`)\n * are covered without listing every release tag explicitly.\n *\n * Maintenance: append a new prefix when OpenAI ships a vision-capable\n * model family that doesn't already match. Devs can always override\n * per-model via `openai.model({ name, vision: true | false })` —\n * explicit config wins over inference in either direction.\n */\nconst VISION_CAPABLE_PREFIXES = [\n  \"gpt-4o\",\n  \"gpt-4-turbo\",\n  \"gpt-4.1\",\n  \"gpt-5\",\n  \"gpt-6\",\n  \"o1\",\n  \"o3\",\n  \"o4\",\n  \"chatgpt-4o\",\n];\n\n/**\n * Infer whether a given OpenAI model name supports vision based on the\n * known-prefix list. Unknown models default to `false` so that passing\n * an image attachment to an unsupported model surfaces a clear,\n * agent-side capability error instead of an opaque OpenAI 400.\n *\n * @example\n * inferVisionCapability(\"gpt-4o-mini\");          // → true\n * inferVisionCapability(\"gpt-4o-2024-08-06\");    // → true\n * inferVisionCapability(\"gpt-3.5-turbo\");        // → false\n * inferVisionCapability(\"custom-llm\");           // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAM,0BAA0B;CAC9B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;AAcA,SAAgB,sBAAsB,WAA4B;CAChE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,wBAAwB,MAAM,WAAW,WAAW,WAAW,MAAM,CAAC;AAC/E"}
+{"version":3,"file":"known-vision-models.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/known-vision-models.ts"],"sourcesContent":["/**\n * Model-name prefixes for OpenAI families that support vision input\n * (image attachments) on the Chat Completions API.\n *\n * Matched as a prefix so dated variants (`gpt-4o-2024-08-06`) and\n * `-mini` / `-preview` suffixes (`gpt-4o-mini`, `gpt-4-turbo-preview`)\n * are covered without listing every release tag explicitly.\n *\n * Maintenance: append a new prefix when OpenAI ships a vision-capable\n * model family that doesn't already match. Devs can always override\n * per-model via `openai.model({ name, vision: true | false })` —\n * explicit config wins over inference in either direction.\n */\nconst VISION_CAPABLE_PREFIXES = [\n  \"gpt-4o\",\n  \"gpt-4-turbo\",\n  \"gpt-4.1\",\n  \"gpt-5\",\n  \"gpt-6\",\n  \"o1\",\n  \"o3\",\n  \"o4\",\n  \"chatgpt-4o\",\n];\n\n/**\n * Infer whether a given OpenAI model name supports vision based on the\n * known-prefix list. Unknown models default to `false` so that passing\n * an image attachment to an unsupported model surfaces a clear,\n * agent-side capability error instead of an opaque OpenAI 400.\n *\n * @example\n * inferVisionCapability(\"gpt-4o-mini\");          // → true\n * inferVisionCapability(\"gpt-4o-2024-08-06\");    // → true\n * inferVisionCapability(\"gpt-3.5-turbo\");        // → false\n * inferVisionCapability(\"custom-llm\");           // → false\n */\nexport function inferVisionCapability(modelName: string): boolean {\n  const normalized = modelName.toLowerCase();\n\n  return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAM,0BAA0B;CAC9B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;AAcA,SAAgB,sBAAsB,WAA4B;CAChE,MAAM,aAAa,UAAU,YAAY;CAEzC,OAAO,wBAAwB,MAAM,WAAW,WAAW,WAAW,MAAM,CAAC;AAC/E"}

package/esm/model.mjs

@@ -12,7 +12,7 @@ import { inferVisionCapability } from "./known-vision-models.mjs";
 import { InvalidRequestError, ProviderError, safeJsonParse } from "@warlock.js/ai";
 import { log } from "@warlock.js/logger";
 
-//#region ../ai-openai/src/model.ts
+//#region ../../packages/ai-openai/src/model.ts
 const LOG_MODULE = "ai.openai";
 /**
 * OpenAI-backed implementation of `ModelContract`.

package/esm/model.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"model.mjs","names":[],"sources":["../../../../../../ai-openai/src/model.ts"],"sourcesContent":["import {\n  InvalidRequestError,\n  ProviderError,\n  safeJsonParse,\n  type Message,\n  type ModelCallOptions,\n  type ModelCapabilities,\n  type ModelContract,\n  type ModelPricing,\n  type ModelResponse,\n  type ModelStreamChunk,\n  type ModelToolCallRequest,\n  type Usage,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAIModelConfig } from \"./config.type\";\nimport { inferReasoningCapability } from \"./known-reasoning-models\";\nimport { inferVisionCapability } from \"./known-vision-models\";\nimport {\n  buildPromptCacheParams,\n  buildUsage,\n  inferStructuredOutput,\n  mapFinishReason,\n  planStructuredOutput,\n  toOpenAIMessages,\n  toOpenAIReasoningEffort,\n  toOpenAITools,\n  wrapOpenAIError,\n} from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\n/**\n * OpenAI-backed implementation of `ModelContract`.\n *\n * **Role.** The provider-facing bridge between the vendor-neutral\n * `@warlock.js/ai` agent runtime and the official `openai` SDK. Agents,\n * workflows, and supervisors never talk to OpenAI directly — they hold a\n * `ModelContract`, and this class is what makes that contract concrete for\n * any OpenAI-compatible endpoint (OpenAI, Azure OpenAI, OpenRouter, local\n * gateways that speak the Chat Completions protocol).\n *\n * **Responsibility.**\n * - Owns: a long-lived `OpenAI` client + frozen `ModelConfig` (name,\n *   temperature, maxTokens) used as defaults for every call.\n * - Owns: translating vendor-neutral `Message[]` and\n *   `ToolContract[]` into OpenAI wire shapes on the way out, and\n *   translating OpenAI's response (content, finish reason, tool calls,\n *   usage) back into the neutral shapes on the way in.\n * - Does NOT own: dispatching tools, deciding whether to loop, tracking\n *   conversation history, or retrying on failure — those are agent\n *   concerns. The model is a stateless (per-call) protocol adapter.\n *\n * Because it holds a live client and shared defaults, it is modeled as a\n * class (see §4.2 of code-style.md — \"long-lived state across calls\").\n *\n * @example\n * import OpenAI from \"openai\";\n * const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });\n * const model = new OpenAIModel(client, { name: \"gpt-4o\", temperature: 0.3 });\n *\n * const myAgent = agent({\n *   model,\n *   systemPrompt: \"You are a helpful assistant.\",\n *   tools: [searchTool],\n * });\n *\n * const result = await myAgent.execute(\"Summarize today's news.\");\n */\nexport class OpenAIModel implements ModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly capabilities: ModelCapabilities;\n  public readonly pricing?: ModelPricing;\n\n  private readonly client: OpenAI;\n  private readonly config: OpenAIModelConfig;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAIModelConfig, provider: string = \"openai\") {\n    // `api: \"responses\"` belongs to `OpenAIResponsesModel`, which only the\n    // `OpenAISDK.model()` factory constructs. This class speaks Chat\n    // Completions only; accepting the flag here would silently ignore it.\n    if (config.api === \"responses\") {\n      throw new InvalidRequestError(\n        'OpenAIModel speaks Chat Completions only and cannot serve api: \"responses\". Use OpenAISDK.model({ api: \"responses\" }) on the direct OpenAI provider.',\n        { context: { provider, model: config.name, api: config.api } },\n      );\n    }\n\n    this.client = client;\n    this.config = config;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n    this.capabilities = {\n      structuredOutput: config.structuredOutput ?? inferStructuredOutput(config.responseFormat),\n      vision: config.vision ?? inferVisionCapability(config.name),\n      // o-series + gpt-5 / gpt-6 models surface a reasoning channel and accept\n      // the `reasoning_effort` param. Explicit config wins over the\n      // name-prefix inference.\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      // Direct OpenAI requests support automatic cache hits and explicit\n      // content-part breakpoints. Wrapper endpoints have distinct provider\n      // labels and may reject these OpenAI-only request fields.\n      promptCaching: this.provider === \"openai\",\n      // PDF + audio INPUT are off by default — OpenAI accepts `file`\n      // (PDF) and `input_audio` parts only on specific models, so the\n      // flags are conservative/honest and opt-in via config rather than\n      // name-inferred. When set, the agent admits the attachments and\n      // `toOpenAIMessages` maps them to the real wire parts.\n      pdf: config.pdf ?? false,\n      audio: config.audio ?? false,\n    };\n  }\n\n  /**\n   * Single-shot completion. Sends the full message list to the Chat\n   * Completions endpoint, waits for the terminal response, and reshapes it\n   * into a vendor-neutral `ModelResponse`. Per-call `options` override the\n   * instance's `ModelConfig` defaults for this call only.\n   */\n  public async complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse> {\n    // Per-call request/response logs are hot-path in production agents\n    // — keep them at `debug` so `info` stays reserved for lifecycle\n    // events (agent starting/completed, etc.). Operators who need to\n    // audit every LLM call can raise log-level at runtime.\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting call to chat.completions\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: false,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let response: OpenAI.Chat.Completions.ChatCompletion;\n\n    try {\n      response = await this.client.chat.completions.create(\n        {\n          model: this.name,\n          messages: toOpenAIMessages(messages, this.promptCacheBreakpoints(options)),\n          ...this.buildSamplingParams(options),\n          ...buildPromptCacheParams(this.provider, this.config),\n          tools: toOpenAITools(options?.tools),\n          ...this.buildResponseFormat(options?.responseSchema),\n          ...this.buildReasoningParams(options?.reasoning, Boolean(options?.tools?.length)),\n        },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    const [choice] = response.choices;\n\n    if (choice === undefined) {\n      // A 200 carrying an empty `choices` array. Every line below reads off\n      // `choice`, so without this the caller got a bare `TypeError: Cannot\n      // read properties of undefined` — no provider, no model, no hint that\n      // the response itself was the problem rather than our handling of it.\n      //\n      // `ProviderError` because that is what this is: the provider answered\n      // successfully and returned nothing usable. Callers already branch on\n      // `instanceof ProviderError` for any provider-side failure.\n      throw new ProviderError(\"OpenAI returned a response with no choices.\", {\n        context: { provider: \"openai\", model: this.name, choices: response.choices.length },\n      });\n    }\n\n    const finishReason = mapFinishReason(choice.finish_reason);\n    const usage = this.extractUsage(response.usage);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"call to chat.completions succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    return {\n      content: choice.message.content ?? \"\",\n      finishReason,\n      usage,\n      toolCalls: this.extractToolCalls(choice.message.tool_calls),\n    };\n  }\n\n  /**\n   * Incremental streaming completion. Yields neutral `ModelStreamChunk`s —\n   * `delta` for text tokens, `tool-call` when the model requests a tool,\n   * and a terminal `done` carrying the final finish reason + usage totals.\n   * Callers consume it with `for await`.\n   */\n  public async *stream(\n    messages: Message[],\n    options?: ModelCallOptions,\n  ): AsyncIterable<ModelStreamChunk> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting streaming call to chat.completions\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: true,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let stream: Awaited<ReturnType<typeof this.client.chat.completions.create>>;\n\n    try {\n      stream = await this.client.chat.completions.create(\n        {\n          model: this.name,\n          messages: toOpenAIMessages(messages, this.promptCacheBreakpoints(options)),\n          ...this.buildSamplingParams(options),\n          ...buildPromptCacheParams(this.provider, this.config),\n          tools: toOpenAITools(options?.tools),\n          stream: true,\n          stream_options: { include_usage: true },\n          ...this.buildResponseFormat(options?.responseSchema),\n          ...this.buildReasoningParams(options?.reasoning, Boolean(options?.tools?.length)),\n        },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    let rawFinishReason: string = \"stop\";\n    const usage: Usage = { input: 0, output: 0, total: 0 };\n    const toolCallAccum = new Map<number, { id: string; name: string; arguments: string }>();\n\n    try {\n      for await (const chunk of stream as AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>) {\n        const delta = chunk.choices[0]?.delta;\n        const finish = chunk.choices[0]?.finish_reason;\n\n        if (delta?.content) {\n          yield { type: \"delta\", content: delta.content };\n        }\n\n        if (delta?.tool_calls) {\n          for (const toolCall of delta.tool_calls) {\n            const idx = toolCall.index ?? 0;\n            if (!toolCallAccum.has(idx)) {\n              toolCallAccum.set(idx, { id: \"\", name: \"\", arguments: \"\" });\n            }\n            const acc = toolCallAccum.get(idx)!;\n            if (toolCall.id) acc.id = toolCall.id;\n            if (toolCall.function?.name) acc.name = toolCall.function.name;\n            if (toolCall.function?.arguments) acc.arguments += toolCall.function.arguments;\n          }\n        }\n\n        if (finish) {\n          rawFinishReason = finish;\n        }\n\n        if (chunk.usage) {\n          usage.input = chunk.usage.prompt_tokens ?? 0;\n          usage.output = chunk.usage.completion_tokens ?? 0;\n          usage.total = chunk.usage.total_tokens ?? 0;\n          const cached = chunk.usage.prompt_tokens_details?.cached_tokens;\n          if (cached !== undefined && cached > 0) {\n            usage.cachedTokens = cached;\n          }\n          const reasoning = chunk.usage.completion_tokens_details?.reasoning_tokens;\n          if (reasoning !== undefined && reasoning > 0) {\n            usage.reasoningTokens = reasoning;\n          }\n        }\n      }\n\n      for (const acc of toolCallAccum.values()) {\n        // Skip accumulators that never received a function name — those\n        // are partial fragments the model started but never identified\n        // (e.g. arguments-only deltas with no originating `id`/`name`).\n        // Yielding them produces nameless tool-calls the agent runtime\n        // can't dispatch and would mis-attribute as a registered tool.\n        if (!acc.name) continue;\n\n        yield {\n          type: \"tool-call\",\n          id: acc.id,\n          name: acc.name,\n          input: safeJsonParse<Record<string, unknown>>(acc.arguments, {}),\n        };\n      }\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    const finishReason = mapFinishReason(rawFinishReason);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"Streaming call to chat.completions succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    yield { type: \"done\", finishReason, usage };\n  }\n\n  /** Map the neutral cache hint only for the direct OpenAI provider. */\n  private promptCacheBreakpoints(options: ModelCallOptions | undefined): number {\n    return this.provider === \"openai\" ? (options?.cacheControl?.breakpoints ?? 0) : 0;\n  }\n\n  /**\n   * Translate the neutral `responseSchema` option into OpenAI's\n   * `response_format` parameter. The mode decision (override handling,\n   * strict-compatibility downgrade to `json_object`) lives in\n   * `planStructuredOutput`, shared with the Responses adapter.\n   *\n   * Returns an empty spread when no schema was supplied, so the caller\n   * can unconditionally `...buildResponseFormat(...)` into the request.\n   */\n  private buildResponseFormat(responseSchema: Record<string, unknown> | undefined): {\n    response_format?: OpenAI.Chat.Completions.ChatCompletionCreateParams[\"response_format\"];\n  } {\n    const plan = planStructuredOutput(responseSchema, this.config.responseFormat);\n\n    if (plan.mode === \"json_schema\") {\n      return {\n        response_format: {\n          type: \"json_schema\",\n          json_schema: { name: \"response\", schema: plan.schema, strict: true },\n        },\n      };\n    }\n\n    if (plan.mode === \"json_object\") {\n      return { response_format: { type: \"json_object\" } };\n    }\n\n    return {};\n  }\n\n  /**\n   * Normalize OpenAI's `usage` block (which may be absent on some responses\n   * or partials) into the neutral `Usage` shape. Missing usage collapses to\n   * zeros rather than propagating `undefined`, so downstream aggregation\n   * math stays safe.\n   *\n   * `cachedTokens` mirrors `prompt_tokens_details.cached_tokens` (the\n   * subset of the prompt served from OpenAI's automatic prompt cache);\n   * `reasoningTokens` mirrors `completion_tokens_details.reasoning_tokens`\n   * (the hidden reasoning channel on o-series / gpt-5 models, already\n   * counted within `output`). Both are emitted only when the provider\n   * reports a positive value, so non-reasoning / uncached calls keep the\n   * lean `{ input, output, total }` shape.\n   */\n  private extractUsage(raw: OpenAI.Completions.CompletionUsage | undefined): Usage {\n    if (!raw) {\n      return { input: 0, output: 0, total: 0 };\n    }\n\n    return buildUsage({\n      input: raw.prompt_tokens,\n      output: raw.completion_tokens,\n      total: raw.total_tokens,\n      cachedTokens: raw.prompt_tokens_details?.cached_tokens,\n      reasoningTokens: raw.completion_tokens_details?.reasoning_tokens,\n    });\n  }\n\n  /**\n   * Translate the neutral `ModelCallOptions.reasoning` hint into OpenAI's\n   * `reasoning_effort` request param. Only `effort` maps — OpenAI's Chat\n   * Completions API exposes a discrete effort knob, not a token budget,\n   * so `reasoning.maxTokens` (the Anthropic extended-thinking cap) has no\n   * wire equivalent here and is silently ignored.\n   *\n   * The neutral `ReasoningEffort` (`\"low\" | \"medium\" | \"high\" | \"none\"`)\n   * is a subset of OpenAI's accepted values, so it forwards verbatim —\n   * `\"none\"` included. `\"none\"` is load-bearing: gpt-5 / o-series models\n   * **reject function tools** on Chat Completions while reasoning is\n   * active, and the endpoint accepts tools only when `reasoning_effort`\n   * is `\"none\"` (the alternative is the Responses API). This is why the\n   * param is EMITTED for `\"none\"` rather than omitted — omitting it\n   * leaves the model reasoning server-side by default, so tools would\n   * still be rejected.\n   *\n   * No-ops when the model is not reasoning-capable\n   * (`capabilities.reasoning` is false — e.g. `gpt-4o`, which 400s on any\n   * `reasoning_effort`).\n   *\n   * When the caller gave no explicit `effort`: defaults to `\"none\"` IF\n   * `hasTools` is true, else omits the param (provider default — the\n   * pre-existing behavior for a tool-less call). The default exists\n   * because, on a reasoning-capable model, there is no working alternative\n   * to `\"none\"` when tools are attached — omitting `reasoning_effort`\n   * leaves reasoning on server-side, which Chat Completions rejects tools\n   * for (empty replies on some model generations, a hard 400 — \"Function\n   * tools with reasoning_effort are not supported ... in\n   * /v1/chat/completions\" — on newer ones). An explicit `effort` from the\n   * caller always wins over this default, in either direction.\n   *\n   * Returns an empty spread when nothing applies, so the caller can\n   * unconditionally `...buildReasoningParams(...)` into the request.\n   */\n  /**\n   * Output-length and sampling params, in current Chat Completions shapes only.\n   *\n   * - `max_completion_tokens`, never the legacy `max_tokens`: current\n   *   models (the gpt-5 family and later) answer `400 unsupported_parameter`\n   *   to `max_tokens`, and `max_completion_tokens` is accepted everywhere.\n   * - No `temperature` for a reasoning-capable model: those accept only the\n   *   default value and reject any other with a 400.\n   */\n  private buildSamplingParams(options: ModelCallOptions | undefined): {\n    max_completion_tokens?: number;\n    temperature?: number;\n  } {\n    const maxTokens = options?.maxTokens ?? this.config.maxTokens;\n    const temperature = options?.temperature ?? this.config.temperature;\n\n    return {\n      max_completion_tokens: maxTokens,\n      ...(!this.capabilities.reasoning && { temperature }),\n    };\n  }\n\n  private buildReasoningParams(\n    reasoning: ModelCallOptions[\"reasoning\"],\n    hasTools: boolean,\n  ): {\n    reasoning_effort?: OpenAI.Chat.Completions.ChatCompletionCreateParams[\"reasoning_effort\"];\n  } {\n    if (!this.capabilities.reasoning) {\n      return {};\n    }\n\n    if (!reasoning?.effort) {\n      return hasTools ? { reasoning_effort: \"none\" } : {};\n    }\n\n    return { reasoning_effort: toOpenAIReasoningEffort(reasoning.effort) };\n  }\n\n  /**\n   * Reshape OpenAI's `tool_calls` array into the neutral\n   * `ModelToolCallRequest[]`. The raw `arguments` field is a JSON string\n   * per OpenAI's protocol — we parse it defensively via `safeJsonParse` so\n   * malformed or empty arguments yield an empty object instead of crashing\n   * the trip. Returns `undefined` when no tools were requested so callers\n   * can branch on presence.\n   */\n  private extractToolCalls(\n    rawToolCalls: OpenAI.Chat.Completions.ChatCompletionMessageToolCall[] | undefined,\n  ): ModelToolCallRequest[] | undefined {\n    if (!rawToolCalls || rawToolCalls.length === 0) {\n      return undefined;\n    }\n\n    return rawToolCalls.map((toolCall) => ({\n      id: toolCall.id,\n      name: (toolCall as any).function.name,\n      input: safeJsonParse<Record<string, unknown>>((toolCall as any).function.arguments, {}),\n    }));\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"model.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/model.ts"],"sourcesContent":["import {\n  InvalidRequestError,\n  ProviderError,\n  safeJsonParse,\n  type Message,\n  type ModelCallOptions,\n  type ModelCapabilities,\n  type ModelContract,\n  type ModelPricing,\n  type ModelResponse,\n  type ModelStreamChunk,\n  type ModelToolCallRequest,\n  type Usage,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAIModelConfig } from \"./config.type\";\nimport { inferReasoningCapability } from \"./known-reasoning-models\";\nimport { inferVisionCapability } from \"./known-vision-models\";\nimport {\n  buildPromptCacheParams,\n  buildUsage,\n  inferStructuredOutput,\n  mapFinishReason,\n  planStructuredOutput,\n  toOpenAIMessages,\n  toOpenAIReasoningEffort,\n  toOpenAITools,\n  wrapOpenAIError,\n} from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\n/**\n * OpenAI-backed implementation of `ModelContract`.\n *\n * **Role.** The provider-facing bridge between the vendor-neutral\n * `@warlock.js/ai` agent runtime and the official `openai` SDK. Agents,\n * workflows, and supervisors never talk to OpenAI directly — they hold a\n * `ModelContract`, and this class is what makes that contract concrete for\n * any OpenAI-compatible endpoint (OpenAI, Azure OpenAI, OpenRouter, local\n * gateways that speak the Chat Completions protocol).\n *\n * **Responsibility.**\n * - Owns: a long-lived `OpenAI` client + frozen `ModelConfig` (name,\n *   temperature, maxTokens) used as defaults for every call.\n * - Owns: translating vendor-neutral `Message[]` and\n *   `ToolContract[]` into OpenAI wire shapes on the way out, and\n *   translating OpenAI's response (content, finish reason, tool calls,\n *   usage) back into the neutral shapes on the way in.\n * - Does NOT own: dispatching tools, deciding whether to loop, tracking\n *   conversation history, or retrying on failure — those are agent\n *   concerns. The model is a stateless (per-call) protocol adapter.\n *\n * Because it holds a live client and shared defaults, it is modeled as a\n * class (see §4.2 of code-style.md — \"long-lived state across calls\").\n *\n * @example\n * import OpenAI from \"openai\";\n * const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });\n * const model = new OpenAIModel(client, { name: \"gpt-4o\", temperature: 0.3 });\n *\n * const myAgent = agent({\n *   model,\n *   systemPrompt: \"You are a helpful assistant.\",\n *   tools: [searchTool],\n * });\n *\n * const result = await myAgent.execute(\"Summarize today's news.\");\n */\nexport class OpenAIModel implements ModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly capabilities: ModelCapabilities;\n  public readonly pricing?: ModelPricing;\n\n  private readonly client: OpenAI;\n  private readonly config: OpenAIModelConfig;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAIModelConfig, provider: string = \"openai\") {\n    // `api: \"responses\"` belongs to `OpenAIResponsesModel`, which only the\n    // `OpenAISDK.model()` factory constructs. This class speaks Chat\n    // Completions only; accepting the flag here would silently ignore it.\n    if (config.api === \"responses\") {\n      throw new InvalidRequestError(\n        'OpenAIModel speaks Chat Completions only and cannot serve api: \"responses\". Use OpenAISDK.model({ api: \"responses\" }) on the direct OpenAI provider.',\n        { context: { provider, model: config.name, api: config.api } },\n      );\n    }\n\n    this.client = client;\n    this.config = config;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n    this.capabilities = {\n      structuredOutput: config.structuredOutput ?? inferStructuredOutput(config.responseFormat),\n      vision: config.vision ?? inferVisionCapability(config.name),\n      // o-series + gpt-5 / gpt-6 models surface a reasoning channel and accept\n      // the `reasoning_effort` param. Explicit config wins over the\n      // name-prefix inference.\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      // Direct OpenAI requests support automatic cache hits and explicit\n      // content-part breakpoints. Wrapper endpoints have distinct provider\n      // labels and may reject these OpenAI-only request fields.\n      promptCaching: this.provider === \"openai\",\n      // PDF + audio INPUT are off by default — OpenAI accepts `file`\n      // (PDF) and `input_audio` parts only on specific models, so the\n      // flags are conservative/honest and opt-in via config rather than\n      // name-inferred. When set, the agent admits the attachments and\n      // `toOpenAIMessages` maps them to the real wire parts.\n      pdf: config.pdf ?? false,\n      audio: config.audio ?? false,\n    };\n  }\n\n  /**\n   * Single-shot completion. Sends the full message list to the Chat\n   * Completions endpoint, waits for the terminal response, and reshapes it\n   * into a vendor-neutral `ModelResponse`. Per-call `options` override the\n   * instance's `ModelConfig` defaults for this call only.\n   */\n  public async complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse> {\n    // Per-call request/response logs are hot-path in production agents\n    // — keep them at `debug` so `info` stays reserved for lifecycle\n    // events (agent starting/completed, etc.). Operators who need to\n    // audit every LLM call can raise log-level at runtime.\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting call to chat.completions\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: false,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let response: OpenAI.Chat.Completions.ChatCompletion;\n\n    try {\n      response = await this.client.chat.completions.create(\n        {\n          model: this.name,\n          messages: toOpenAIMessages(messages, this.promptCacheBreakpoints(options)),\n          ...this.buildSamplingParams(options),\n          ...buildPromptCacheParams(this.provider, this.config),\n          tools: toOpenAITools(options?.tools),\n          ...this.buildResponseFormat(options?.responseSchema),\n          ...this.buildReasoningParams(options?.reasoning, Boolean(options?.tools?.length)),\n        },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    const [choice] = response.choices;\n\n    if (choice === undefined) {\n      // A 200 carrying an empty `choices` array. Every line below reads off\n      // `choice`, so without this the caller got a bare `TypeError: Cannot\n      // read properties of undefined` — no provider, no model, no hint that\n      // the response itself was the problem rather than our handling of it.\n      //\n      // `ProviderError` because that is what this is: the provider answered\n      // successfully and returned nothing usable. Callers already branch on\n      // `instanceof ProviderError` for any provider-side failure.\n      throw new ProviderError(\"OpenAI returned a response with no choices.\", {\n        context: { provider: \"openai\", model: this.name, choices: response.choices.length },\n      });\n    }\n\n    const finishReason = mapFinishReason(choice.finish_reason);\n    const usage = this.extractUsage(response.usage);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"call to chat.completions succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    return {\n      content: choice.message.content ?? \"\",\n      finishReason,\n      usage,\n      toolCalls: this.extractToolCalls(choice.message.tool_calls),\n    };\n  }\n\n  /**\n   * Incremental streaming completion. Yields neutral `ModelStreamChunk`s —\n   * `delta` for text tokens, `tool-call` when the model requests a tool,\n   * and a terminal `done` carrying the final finish reason + usage totals.\n   * Callers consume it with `for await`.\n   */\n  public async *stream(\n    messages: Message[],\n    options?: ModelCallOptions,\n  ): AsyncIterable<ModelStreamChunk> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting streaming call to chat.completions\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: true,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let stream: Awaited<ReturnType<typeof this.client.chat.completions.create>>;\n\n    try {\n      stream = await this.client.chat.completions.create(\n        {\n          model: this.name,\n          messages: toOpenAIMessages(messages, this.promptCacheBreakpoints(options)),\n          ...this.buildSamplingParams(options),\n          ...buildPromptCacheParams(this.provider, this.config),\n          tools: toOpenAITools(options?.tools),\n          stream: true,\n          stream_options: { include_usage: true },\n          ...this.buildResponseFormat(options?.responseSchema),\n          ...this.buildReasoningParams(options?.reasoning, Boolean(options?.tools?.length)),\n        },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    let rawFinishReason: string = \"stop\";\n    const usage: Usage = { input: 0, output: 0, total: 0 };\n    const toolCallAccum = new Map<number, { id: string; name: string; arguments: string }>();\n\n    try {\n      for await (const chunk of stream as AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>) {\n        const delta = chunk.choices[0]?.delta;\n        const finish = chunk.choices[0]?.finish_reason;\n\n        if (delta?.content) {\n          yield { type: \"delta\", content: delta.content };\n        }\n\n        if (delta?.tool_calls) {\n          for (const toolCall of delta.tool_calls) {\n            const idx = toolCall.index ?? 0;\n            if (!toolCallAccum.has(idx)) {\n              toolCallAccum.set(idx, { id: \"\", name: \"\", arguments: \"\" });\n            }\n            const acc = toolCallAccum.get(idx)!;\n            if (toolCall.id) acc.id = toolCall.id;\n            if (toolCall.function?.name) acc.name = toolCall.function.name;\n            if (toolCall.function?.arguments) acc.arguments += toolCall.function.arguments;\n          }\n        }\n\n        if (finish) {\n          rawFinishReason = finish;\n        }\n\n        if (chunk.usage) {\n          usage.input = chunk.usage.prompt_tokens ?? 0;\n          usage.output = chunk.usage.completion_tokens ?? 0;\n          usage.total = chunk.usage.total_tokens ?? 0;\n          const cached = chunk.usage.prompt_tokens_details?.cached_tokens;\n          if (cached !== undefined && cached > 0) {\n            usage.cachedTokens = cached;\n          }\n          const reasoning = chunk.usage.completion_tokens_details?.reasoning_tokens;\n          if (reasoning !== undefined && reasoning > 0) {\n            usage.reasoningTokens = reasoning;\n          }\n        }\n      }\n\n      for (const acc of toolCallAccum.values()) {\n        // Skip accumulators that never received a function name — those\n        // are partial fragments the model started but never identified\n        // (e.g. arguments-only deltas with no originating `id`/`name`).\n        // Yielding them produces nameless tool-calls the agent runtime\n        // can't dispatch and would mis-attribute as a registered tool.\n        if (!acc.name) continue;\n\n        yield {\n          type: \"tool-call\",\n          id: acc.id,\n          name: acc.name,\n          input: safeJsonParse<Record<string, unknown>>(acc.arguments, {}),\n        };\n      }\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n\n      this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n\n      throw wrapped;\n    }\n\n    const finishReason = mapFinishReason(rawFinishReason);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"Streaming call to chat.completions succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    yield { type: \"done\", finishReason, usage };\n  }\n\n  /** Map the neutral cache hint only for the direct OpenAI provider. */\n  private promptCacheBreakpoints(options: ModelCallOptions | undefined): number {\n    return this.provider === \"openai\" ? (options?.cacheControl?.breakpoints ?? 0) : 0;\n  }\n\n  /**\n   * Translate the neutral `responseSchema` option into OpenAI's\n   * `response_format` parameter. The mode decision (override handling,\n   * strict-compatibility downgrade to `json_object`) lives in\n   * `planStructuredOutput`, shared with the Responses adapter.\n   *\n   * Returns an empty spread when no schema was supplied, so the caller\n   * can unconditionally `...buildResponseFormat(...)` into the request.\n   */\n  private buildResponseFormat(responseSchema: Record<string, unknown> | undefined): {\n    response_format?: OpenAI.Chat.Completions.ChatCompletionCreateParams[\"response_format\"];\n  } {\n    const plan = planStructuredOutput(responseSchema, this.config.responseFormat);\n\n    if (plan.mode === \"json_schema\") {\n      return {\n        response_format: {\n          type: \"json_schema\",\n          json_schema: { name: \"response\", schema: plan.schema, strict: true },\n        },\n      };\n    }\n\n    if (plan.mode === \"json_object\") {\n      return { response_format: { type: \"json_object\" } };\n    }\n\n    return {};\n  }\n\n  /**\n   * Normalize OpenAI's `usage` block (which may be absent on some responses\n   * or partials) into the neutral `Usage` shape. Missing usage collapses to\n   * zeros rather than propagating `undefined`, so downstream aggregation\n   * math stays safe.\n   *\n   * `cachedTokens` mirrors `prompt_tokens_details.cached_tokens` (the\n   * subset of the prompt served from OpenAI's automatic prompt cache);\n   * `reasoningTokens` mirrors `completion_tokens_details.reasoning_tokens`\n   * (the hidden reasoning channel on o-series / gpt-5 models, already\n   * counted within `output`). Both are emitted only when the provider\n   * reports a positive value, so non-reasoning / uncached calls keep the\n   * lean `{ input, output, total }` shape.\n   */\n  private extractUsage(raw: OpenAI.Completions.CompletionUsage | undefined): Usage {\n    if (!raw) {\n      return { input: 0, output: 0, total: 0 };\n    }\n\n    return buildUsage({\n      input: raw.prompt_tokens,\n      output: raw.completion_tokens,\n      total: raw.total_tokens,\n      cachedTokens: raw.prompt_tokens_details?.cached_tokens,\n      reasoningTokens: raw.completion_tokens_details?.reasoning_tokens,\n    });\n  }\n\n  /**\n   * Translate the neutral `ModelCallOptions.reasoning` hint into OpenAI's\n   * `reasoning_effort` request param. Only `effort` maps — OpenAI's Chat\n   * Completions API exposes a discrete effort knob, not a token budget,\n   * so `reasoning.maxTokens` (the Anthropic extended-thinking cap) has no\n   * wire equivalent here and is silently ignored.\n   *\n   * The neutral `ReasoningEffort` (`\"low\" | \"medium\" | \"high\" | \"none\"`)\n   * is a subset of OpenAI's accepted values, so it forwards verbatim —\n   * `\"none\"` included. `\"none\"` is load-bearing: gpt-5 / o-series models\n   * **reject function tools** on Chat Completions while reasoning is\n   * active, and the endpoint accepts tools only when `reasoning_effort`\n   * is `\"none\"` (the alternative is the Responses API). This is why the\n   * param is EMITTED for `\"none\"` rather than omitted — omitting it\n   * leaves the model reasoning server-side by default, so tools would\n   * still be rejected.\n   *\n   * No-ops when the model is not reasoning-capable\n   * (`capabilities.reasoning` is false — e.g. `gpt-4o`, which 400s on any\n   * `reasoning_effort`).\n   *\n   * When the caller gave no explicit `effort`: defaults to `\"none\"` IF\n   * `hasTools` is true, else omits the param (provider default — the\n   * pre-existing behavior for a tool-less call). The default exists\n   * because, on a reasoning-capable model, there is no working alternative\n   * to `\"none\"` when tools are attached — omitting `reasoning_effort`\n   * leaves reasoning on server-side, which Chat Completions rejects tools\n   * for (empty replies on some model generations, a hard 400 — \"Function\n   * tools with reasoning_effort are not supported ... in\n   * /v1/chat/completions\" — on newer ones). An explicit `effort` from the\n   * caller always wins over this default, in either direction.\n   *\n   * Returns an empty spread when nothing applies, so the caller can\n   * unconditionally `...buildReasoningParams(...)` into the request.\n   */\n  /**\n   * Output-length and sampling params, in current Chat Completions shapes only.\n   *\n   * - `max_completion_tokens`, never the legacy `max_tokens`: current\n   *   models (the gpt-5 family and later) answer `400 unsupported_parameter`\n   *   to `max_tokens`, and `max_completion_tokens` is accepted everywhere.\n   * - No `temperature` for a reasoning-capable model: those accept only the\n   *   default value and reject any other with a 400.\n   */\n  private buildSamplingParams(options: ModelCallOptions | undefined): {\n    max_completion_tokens?: number;\n    temperature?: number;\n  } {\n    const maxTokens = options?.maxTokens ?? this.config.maxTokens;\n    const temperature = options?.temperature ?? this.config.temperature;\n\n    return {\n      max_completion_tokens: maxTokens,\n      ...(!this.capabilities.reasoning && { temperature }),\n    };\n  }\n\n  private buildReasoningParams(\n    reasoning: ModelCallOptions[\"reasoning\"],\n    hasTools: boolean,\n  ): {\n    reasoning_effort?: OpenAI.Chat.Completions.ChatCompletionCreateParams[\"reasoning_effort\"];\n  } {\n    if (!this.capabilities.reasoning) {\n      return {};\n    }\n\n    if (!reasoning?.effort) {\n      return hasTools ? { reasoning_effort: \"none\" } : {};\n    }\n\n    return { reasoning_effort: toOpenAIReasoningEffort(reasoning.effort) };\n  }\n\n  /**\n   * Reshape OpenAI's `tool_calls` array into the neutral\n   * `ModelToolCallRequest[]`. The raw `arguments` field is a JSON string\n   * per OpenAI's protocol — we parse it defensively via `safeJsonParse` so\n   * malformed or empty arguments yield an empty object instead of crashing\n   * the trip. Returns `undefined` when no tools were requested so callers\n   * can branch on presence.\n   */\n  private extractToolCalls(\n    rawToolCalls: OpenAI.Chat.Completions.ChatCompletionMessageToolCall[] | undefined,\n  ): ModelToolCallRequest[] | undefined {\n    if (!rawToolCalls || rawToolCalls.length === 0) {\n      return undefined;\n    }\n\n    return rawToolCalls.map((toolCall) => ({\n      id: toolCall.id,\n      name: (toolCall as any).function.name,\n      input: safeJsonParse<Record<string, unknown>>((toolCall as any).function.arguments, {}),\n    }));\n  }\n}\n"],"mappings":"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"}

package/esm/responses-model.mjs

@@ -13,7 +13,7 @@ import { inferVisionCapability } from "./known-vision-models.mjs";
 import { InvalidRequestError, ProviderError, safeJsonParse } from "@warlock.js/ai";
 import { log } from "@warlock.js/logger";
 
-//#region ../ai-openai/src/responses-model.ts
+//#region ../../packages/ai-openai/src/responses-model.ts
 const LOG_MODULE = "ai.openai";
 /**
 * OpenAI Responses API implementation of `ModelContract` (`api: "responses"`).

package/esm/responses-model.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"responses-model.mjs","names":[],"sources":["../../../../../../ai-openai/src/responses-model.ts"],"sourcesContent":["import {\n  InvalidRequestError,\n  ProviderError,\n  safeJsonParse,\n  type Message,\n  type ModelCallOptions,\n  type ModelCapabilities,\n  type ModelContract,\n  type ModelPricing,\n  type ModelResponse,\n  type ModelStreamChunk,\n  type ModelToolCallRequest,\n  type Usage,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAIModelConfig } from \"./config.type\";\nimport { inferReasoningCapability } from \"./known-reasoning-models\";\nimport { inferVisionCapability } from \"./known-vision-models\";\nimport {\n  attachReasoningReplay,\n  buildPromptCacheParams,\n  buildUsage,\n  inferStructuredOutput,\n  mapResponsesFinishReason,\n  planStructuredOutput,\n  toOpenAIReasoningEffort,\n  toResponseFailure,\n  toResponsesInput,\n  toResponsesToolChoice,\n  toResponsesTools,\n  wrapOpenAIError,\n} from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\n/**\n * OpenAI Responses API implementation of `ModelContract` (`api: \"responses\"`).\n *\n * **Role.** A sibling of `OpenAIModel` that speaks `POST /v1/responses`\n * instead of Chat Completions. Its point is letting a tool-using agent run a\n * reasoning model with reasoning ON: the Chat path has to force\n * `reasoning_effort: \"none\"` whenever tools are attached, Responses does not.\n *\n * **Why a separate class.** Only `OpenAISDK.model()` constructs it, and only\n * for the direct `\"openai\"` provider. The wrapper packages (deepseek, groq,\n * xai, mistral) build `OpenAIModel` and cannot reach this class, so an\n * endpoint that does not implement `/v1/responses` is never sent there. The\n * constructor re-checks the provider label as a second lock.\n *\n * **Stateless.** Every request sends `store: false`; nothing is kept on the\n * server and no `previous_response_id` is used. Full history is re-sent each\n * call, exactly like the Chat path.\n *\n * **Reasoning replay.** Every request asks for\n * `include: [\"reasoning.encrypted_content\"]`. The `reasoning` items of a\n * tool-calling turn are stored on the FIRST tool call as\n * `providerMetadata.openaiResponses = { model, reasoningItems }` and sent back\n * before that turn's `function_call` items on the next request (only when the\n * stored model equals the current one). Text-only turns are not replayed.\n *\n * **Streaming.** `stream()` uses `responses.create({ stream: true })` and yields\n * the same chunk sequence as the Chat path: text `delta`s, then the\n * `tool-call`s, then one `done`.\n */\nexport class OpenAIResponsesModel implements ModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly capabilities: ModelCapabilities;\n  public readonly pricing?: ModelPricing;\n\n  private readonly client: OpenAI;\n  private readonly config: OpenAIModelConfig;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAIModelConfig, provider: string = \"openai\") {\n    if (provider !== \"openai\") {\n      throw new InvalidRequestError(\n        `api: \"responses\" is supported only on the direct \"openai\" provider; got provider \"${provider}\".`,\n        { context: { provider, model: config.name, api: \"responses\" } },\n      );\n    }\n\n    this.client = client;\n    this.config = config;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n    this.capabilities = {\n      structuredOutput: config.structuredOutput ?? inferStructuredOutput(config.responseFormat),\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      // Read-side cache accounting (`cachedTokens`, `cacheWriteTokens`) works\n      // and `prompt_cache_key` is forwarded. Explicit write breakpoints are not\n      // mapped onto Responses yet, so a `cacheControl.breakpoints` hint is\n      // ignored rather than rejected.\n      promptCaching: true,\n      // PDF and audio input are off under Responses in this adapter: the\n      // `input_file` / `input_audio` field-level mapping is unverified. The\n      // `pdf` / `audio` config flags are deliberately NOT honoured here.\n      pdf: false,\n      audio: false,\n    };\n  }\n\n  /**\n   * Single-shot completion against `client.responses.create`. Sends the full\n   * history as Responses `input` items, walks `response.output`, and reshapes\n   * it into a vendor-neutral `ModelResponse`. Per-call `options` override the\n   * instance defaults for this call only.\n   */\n  public async complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting call to responses.create\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: false,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let response: OpenAI.Responses.Response;\n\n    try {\n      response = await this.client.responses.create(\n        this.buildRequest(messages, options),\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    if (response.status === \"failed\") {\n      throw this.logAndWrap(toResponseFailure(response, this.name));\n    }\n\n    const output = Array.isArray(response.output) ? response.output : [];\n    const { content, toolCalls } = this.readOutput(output);\n    const finishReason = mapResponsesFinishReason({\n      status: response.status,\n      incomplete_details: response.incomplete_details,\n      hasToolCalls: toolCalls !== undefined,\n    });\n    const usage = this.extractUsage(response.usage);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"call to responses.create succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    return { content, finishReason, usage, ...(toolCalls ? { toolCalls } : {}) };\n  }\n\n  /**\n   * Incremental streaming completion via `responses.create({ stream: true })`\n   * (the SDK's `Stream<ResponseStreamEvent>`, `responses.d.ts:55`). Yields the\n   * same neutral `ModelStreamChunk` sequence as the Chat path:\n   *\n   * - `response.output_text.delta` / `response.refusal.delta` -> `delta`.\n   * - `response.output_item.done` with a completed `function_call` item ->\n   *   buffered; `reasoning` items are captured for replay. The `done` copy is\n   *   used because the `added` copy may be incomplete (`responses.d.ts:5711`).\n   * - After the loop: the buffered `tool-call`s (the first carries the\n   *   replay metadata), then a single `done` with the finish reason and usage\n   *   from `response.completed` / `response.incomplete`.\n   * - `response.failed` and `error` events throw a typed `AIError`; a stream\n   *   that ends with no terminal event throws `ProviderError`.\n   * - Abort goes through the request `signal`; the SDK rejects the read and\n   *   the error is wrapped like any other.\n   */\n  public async *stream(\n    messages: Message[],\n    options?: ModelCallOptions,\n  ): AsyncIterable<ModelStreamChunk> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting streaming call to responses.create\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: true,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let events: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>;\n\n    try {\n      events = await this.client.responses.create(\n        { ...this.buildRequest(messages, options), stream: true },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    const toolCalls: ModelToolCallRequest[] = [];\n    const reasoningItems: OpenAI.Responses.ResponseReasoningItem[] = [];\n    let terminal: OpenAI.Responses.Response | undefined;\n\n    try {\n      for await (const event of events) {\n        if (event.type === \"response.output_text.delta\" || event.type === \"response.refusal.delta\") {\n          if (event.delta) {\n            yield { type: \"delta\", content: event.delta };\n          }\n\n          continue;\n        }\n\n        if (event.type === \"response.output_item.done\") {\n          const { item } = event;\n\n          if (item.type === \"reasoning\") {\n            reasoningItems.push(item);\n          } else if (item.type === \"function_call\" && item.status !== \"incomplete\") {\n            toolCalls.push(this.toToolCall(item));\n          }\n\n          continue;\n        }\n\n        if (event.type === \"response.completed\" || event.type === \"response.incomplete\") {\n          terminal = event.response;\n          continue;\n        }\n\n        if (event.type === \"response.failed\") {\n          throw toResponseFailure(event.response, this.name);\n        }\n\n        if (event.type === \"error\") {\n          throw wrapOpenAIError({ code: event.code, message: event.message, param: event.param });\n        }\n      }\n\n      if (terminal === undefined) {\n        throw new ProviderError(\"OpenAI Responses stream ended before response.completed.\", {\n          context: { provider: this.provider, model: this.name },\n        });\n      }\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    for (const call of attachReasoningReplay(toolCalls, this.name, reasoningItems)) {\n      yield {\n        type: \"tool-call\",\n        id: call.id,\n        name: call.name,\n        input: call.input,\n        ...(call.providerMetadata ? { providerMetadata: call.providerMetadata } : {}),\n      };\n    }\n\n    const finishReason = mapResponsesFinishReason({\n      status: terminal.status,\n      incomplete_details: terminal.incomplete_details,\n      hasToolCalls: toolCalls.length > 0,\n    });\n    const usage = this.extractUsage(terminal.usage);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"Streaming call to responses.create succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    yield { type: \"done\", finishReason, usage };\n  }\n\n  /**\n   * Assemble the `responses.create` body.\n   *\n   * - System prompt -> `instructions`; history -> `input` items.\n   * - `store: false` always (the API default is `true` when omitted), plus\n   *   `include: [\"reasoning.encrypted_content\"]` for stateless reasoning replay.\n   * - `max_output_tokens` caps reasoning and visible output together.\n   * - `temperature` only for non-reasoning models (same rule as Chat).\n   * - `tools` flat with `strict: false`; `tool_choice` only with tools.\n   * - `reasoning.effort` only when the caller gave one, through the same\n   *   clamp table as Chat. With no explicit effort the provider default\n   *   applies EVEN with tools attached - that is the point of this API.\n   */\n  private buildRequest(\n    messages: Message[],\n    options: ModelCallOptions | undefined,\n  ): OpenAI.Responses.ResponseCreateParamsNonStreaming {\n    const { instructions, input } = toResponsesInput(messages, this.name);\n    const tools = toResponsesTools(options?.tools);\n    const toolChoice = tools ? toResponsesToolChoice(options?.toolChoice) : undefined;\n    const maxTokens = options?.maxTokens ?? this.config.maxTokens;\n    const temperature = options?.temperature ?? this.config.temperature;\n\n    return {\n      model: this.name,\n      ...(instructions !== undefined ? { instructions } : {}),\n      input,\n      store: false,\n      // Stateless replay: ask for the encrypted reasoning blobs so they can be\n      // sent back on the next tool turn (decision 3).\n      include: [\"reasoning.encrypted_content\"],\n      ...(maxTokens !== undefined ? { max_output_tokens: maxTokens } : {}),\n      ...(!this.capabilities.reasoning && temperature !== undefined ? { temperature } : {}),\n      ...(tools ? { tools } : {}),\n      ...(toolChoice !== undefined ? { tool_choice: toolChoice } : {}),\n      ...this.buildTextFormat(options?.responseSchema),\n      ...this.buildReasoningParams(options?.reasoning),\n      ...buildPromptCacheParams(this.provider, this.config),\n    };\n  }\n\n  /**\n   * Structured output on Responses lives in `text.format`, and `name` /\n   * `schema` / `strict` sit directly on the format object (Chat nests them\n   * under `json_schema`). The strict-or-downgrade decision is the shared\n   * `planStructuredOutput`.\n   */\n  private buildTextFormat(responseSchema: Record<string, unknown> | undefined): {\n    text?: OpenAI.Responses.ResponseTextConfig;\n  } {\n    const plan = planStructuredOutput(responseSchema, this.config.responseFormat);\n\n    if (plan.mode === \"json_schema\") {\n      return {\n        text: { format: { type: \"json_schema\", name: \"response\", schema: plan.schema, strict: true } },\n      };\n    }\n\n    if (plan.mode === \"json_object\") {\n      return { text: { format: { type: \"json_object\" } } };\n    }\n\n    return {};\n  }\n\n  /** `reasoning.effort` for reasoning-capable models, only when the caller set one. */\n  private buildReasoningParams(reasoning: ModelCallOptions[\"reasoning\"]): {\n    reasoning?: { effort: ReturnType<typeof toOpenAIReasoningEffort> };\n  } {\n    if (!this.capabilities.reasoning || !reasoning?.effort) {\n      return {};\n    }\n\n    return { reasoning: { effort: toOpenAIReasoningEffort(reasoning.effort) } };\n  }\n\n  /**\n   * Walk `response.output`: `message` items contribute their `output_text`\n   * text and any `refusal` text (surfaced as ordinary content, decision 5);\n   * each completed `function_call` item becomes one tool call with\n   * `id = call_id`. `reasoning` items carry no visible content and are\n   * not content. A `function_call` the API marked `incomplete` (truncated\n   * arguments) is skipped rather than dispatched with empty input.\n   * `reasoning` items are captured and attached to the first tool call for\n   * replay (see `attachReasoningReplay`).\n   */\n  private readOutput(output: OpenAI.Responses.ResponseOutputItem[]): {\n    content: string;\n    toolCalls: ModelToolCallRequest[] | undefined;\n  } {\n    let content = \"\";\n    const toolCalls: ModelToolCallRequest[] = [];\n    const reasoningItems: OpenAI.Responses.ResponseReasoningItem[] = [];\n\n    for (const item of output) {\n      if (item.type === \"reasoning\") {\n        reasoningItems.push(item);\n        continue;\n      }\n\n      if (item.type === \"message\") {\n        for (const part of item.content) {\n          content += part.type === \"refusal\" ? part.refusal : part.text;\n        }\n\n        continue;\n      }\n\n      if (item.type === \"function_call\" && item.status !== \"incomplete\") {\n        toolCalls.push(this.toToolCall(item));\n      }\n    }\n\n    return {\n      content,\n      toolCalls:\n        toolCalls.length > 0\n          ? attachReasoningReplay(toolCalls, this.name, reasoningItems)\n          : undefined,\n    };\n  }\n\n  /** One completed `function_call` item as a neutral tool call (`call_id` -> `id`). */\n  private toToolCall(item: OpenAI.Responses.ResponseFunctionToolCall): ModelToolCallRequest {\n    return {\n      id: item.call_id,\n      name: item.name,\n      input: safeJsonParse<Record<string, unknown>>(item.arguments, {}),\n    };\n  }\n\n  /**\n   * Normalize `usage` (absent on some partials) into the neutral `Usage`.\n   * `input_tokens_details.cached_tokens` -> `cachedTokens`,\n   * `cache_write_tokens` -> `cacheWriteTokens`,\n   * `output_tokens_details.reasoning_tokens` -> `reasoningTokens`. The\n   * detail blocks are typed non-optional but read defensively.\n   */\n  private extractUsage(raw: OpenAI.Responses.ResponseUsage | undefined): Usage {\n    if (!raw) {\n      return { input: 0, output: 0, total: 0 };\n    }\n\n    return buildUsage({\n      input: raw.input_tokens,\n      output: raw.output_tokens,\n      total: raw.total_tokens,\n      cachedTokens: raw.input_tokens_details?.cached_tokens,\n      cacheWriteTokens: raw.input_tokens_details?.cache_write_tokens,\n      reasoningTokens: raw.output_tokens_details?.reasoning_tokens,\n    });\n  }\n\n  /** Wrap (idempotently), log and return a failure for the caller to throw. */\n  private logAndWrap(thrown: unknown): ReturnType<typeof wrapOpenAIError> {\n    const wrapped = wrapOpenAIError(thrown);\n\n    this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n      code: wrapped.code,\n      context: wrapped.context,\n    });\n\n    return wrapped;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"responses-model.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/responses-model.ts"],"sourcesContent":["import {\n  InvalidRequestError,\n  ProviderError,\n  safeJsonParse,\n  type Message,\n  type ModelCallOptions,\n  type ModelCapabilities,\n  type ModelContract,\n  type ModelPricing,\n  type ModelResponse,\n  type ModelStreamChunk,\n  type ModelToolCallRequest,\n  type Usage,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAIModelConfig } from \"./config.type\";\nimport { inferReasoningCapability } from \"./known-reasoning-models\";\nimport { inferVisionCapability } from \"./known-vision-models\";\nimport {\n  attachReasoningReplay,\n  buildPromptCacheParams,\n  buildUsage,\n  inferStructuredOutput,\n  mapResponsesFinishReason,\n  planStructuredOutput,\n  toOpenAIReasoningEffort,\n  toResponseFailure,\n  toResponsesInput,\n  toResponsesToolChoice,\n  toResponsesTools,\n  wrapOpenAIError,\n} from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\n/**\n * OpenAI Responses API implementation of `ModelContract` (`api: \"responses\"`).\n *\n * **Role.** A sibling of `OpenAIModel` that speaks `POST /v1/responses`\n * instead of Chat Completions. Its point is letting a tool-using agent run a\n * reasoning model with reasoning ON: the Chat path has to force\n * `reasoning_effort: \"none\"` whenever tools are attached, Responses does not.\n *\n * **Why a separate class.** Only `OpenAISDK.model()` constructs it, and only\n * for the direct `\"openai\"` provider. The wrapper packages (deepseek, groq,\n * xai, mistral) build `OpenAIModel` and cannot reach this class, so an\n * endpoint that does not implement `/v1/responses` is never sent there. The\n * constructor re-checks the provider label as a second lock.\n *\n * **Stateless.** Every request sends `store: false`; nothing is kept on the\n * server and no `previous_response_id` is used. Full history is re-sent each\n * call, exactly like the Chat path.\n *\n * **Reasoning replay.** Every request asks for\n * `include: [\"reasoning.encrypted_content\"]`. The `reasoning` items of a\n * tool-calling turn are stored on the FIRST tool call as\n * `providerMetadata.openaiResponses = { model, reasoningItems }` and sent back\n * before that turn's `function_call` items on the next request (only when the\n * stored model equals the current one). Text-only turns are not replayed.\n *\n * **Streaming.** `stream()` uses `responses.create({ stream: true })` and yields\n * the same chunk sequence as the Chat path: text `delta`s, then the\n * `tool-call`s, then one `done`.\n */\nexport class OpenAIResponsesModel implements ModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly capabilities: ModelCapabilities;\n  public readonly pricing?: ModelPricing;\n\n  private readonly client: OpenAI;\n  private readonly config: OpenAIModelConfig;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAIModelConfig, provider: string = \"openai\") {\n    if (provider !== \"openai\") {\n      throw new InvalidRequestError(\n        `api: \"responses\" is supported only on the direct \"openai\" provider; got provider \"${provider}\".`,\n        { context: { provider, model: config.name, api: \"responses\" } },\n      );\n    }\n\n    this.client = client;\n    this.config = config;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n    this.capabilities = {\n      structuredOutput: config.structuredOutput ?? inferStructuredOutput(config.responseFormat),\n      vision: config.vision ?? inferVisionCapability(config.name),\n      reasoning: config.reasoning ?? inferReasoningCapability(config.name),\n      // Read-side cache accounting (`cachedTokens`, `cacheWriteTokens`) works\n      // and `prompt_cache_key` is forwarded. Explicit write breakpoints are not\n      // mapped onto Responses yet, so a `cacheControl.breakpoints` hint is\n      // ignored rather than rejected.\n      promptCaching: true,\n      // PDF and audio input are off under Responses in this adapter: the\n      // `input_file` / `input_audio` field-level mapping is unverified. The\n      // `pdf` / `audio` config flags are deliberately NOT honoured here.\n      pdf: false,\n      audio: false,\n    };\n  }\n\n  /**\n   * Single-shot completion against `client.responses.create`. Sends the full\n   * history as Responses `input` items, walks `response.output`, and reshapes\n   * it into a vendor-neutral `ModelResponse`. Per-call `options` override the\n   * instance defaults for this call only.\n   */\n  public async complete(messages: Message[], options?: ModelCallOptions): Promise<ModelResponse> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting call to responses.create\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: false,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let response: OpenAI.Responses.Response;\n\n    try {\n      response = await this.client.responses.create(\n        this.buildRequest(messages, options),\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    if (response.status === \"failed\") {\n      throw this.logAndWrap(toResponseFailure(response, this.name));\n    }\n\n    const output = Array.isArray(response.output) ? response.output : [];\n    const { content, toolCalls } = this.readOutput(output);\n    const finishReason = mapResponsesFinishReason({\n      status: response.status,\n      incomplete_details: response.incomplete_details,\n      hasToolCalls: toolCalls !== undefined,\n    });\n    const usage = this.extractUsage(response.usage);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"call to responses.create succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    return { content, finishReason, usage, ...(toolCalls ? { toolCalls } : {}) };\n  }\n\n  /**\n   * Incremental streaming completion via `responses.create({ stream: true })`\n   * (the SDK's `Stream<ResponseStreamEvent>`, `responses.d.ts:55`). Yields the\n   * same neutral `ModelStreamChunk` sequence as the Chat path:\n   *\n   * - `response.output_text.delta` / `response.refusal.delta` -> `delta`.\n   * - `response.output_item.done` with a completed `function_call` item ->\n   *   buffered; `reasoning` items are captured for replay. The `done` copy is\n   *   used because the `added` copy may be incomplete (`responses.d.ts:5711`).\n   * - After the loop: the buffered `tool-call`s (the first carries the\n   *   replay metadata), then a single `done` with the finish reason and usage\n   *   from `response.completed` / `response.incomplete`.\n   * - `response.failed` and `error` events throw a typed `AIError`; a stream\n   *   that ends with no terminal event throws `ProviderError`.\n   * - Abort goes through the request `signal`; the SDK rejects the read and\n   *   the error is wrapped like any other.\n   */\n  public async *stream(\n    messages: Message[],\n    options?: ModelCallOptions,\n  ): AsyncIterable<ModelStreamChunk> {\n    this.logger.debug(LOG_MODULE, \"request\", \"Starting streaming call to responses.create\", {\n      model: this.name,\n      messageCount: messages.length,\n      streaming: true,\n      toolCount: options?.tools?.length ?? 0,\n    });\n\n    let events: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>;\n\n    try {\n      events = await this.client.responses.create(\n        { ...this.buildRequest(messages, options), stream: true },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    const toolCalls: ModelToolCallRequest[] = [];\n    const reasoningItems: OpenAI.Responses.ResponseReasoningItem[] = [];\n    let terminal: OpenAI.Responses.Response | undefined;\n\n    try {\n      for await (const event of events) {\n        if (event.type === \"response.output_text.delta\" || event.type === \"response.refusal.delta\") {\n          if (event.delta) {\n            yield { type: \"delta\", content: event.delta };\n          }\n\n          continue;\n        }\n\n        if (event.type === \"response.output_item.done\") {\n          const { item } = event;\n\n          if (item.type === \"reasoning\") {\n            reasoningItems.push(item);\n          } else if (item.type === \"function_call\" && item.status !== \"incomplete\") {\n            toolCalls.push(this.toToolCall(item));\n          }\n\n          continue;\n        }\n\n        if (event.type === \"response.completed\" || event.type === \"response.incomplete\") {\n          terminal = event.response;\n          continue;\n        }\n\n        if (event.type === \"response.failed\") {\n          throw toResponseFailure(event.response, this.name);\n        }\n\n        if (event.type === \"error\") {\n          throw wrapOpenAIError({ code: event.code, message: event.message, param: event.param });\n        }\n      }\n\n      if (terminal === undefined) {\n        throw new ProviderError(\"OpenAI Responses stream ended before response.completed.\", {\n          context: { provider: this.provider, model: this.name },\n        });\n      }\n    } catch (thrown) {\n      throw this.logAndWrap(thrown);\n    }\n\n    for (const call of attachReasoningReplay(toolCalls, this.name, reasoningItems)) {\n      yield {\n        type: \"tool-call\",\n        id: call.id,\n        name: call.name,\n        input: call.input,\n        ...(call.providerMetadata ? { providerMetadata: call.providerMetadata } : {}),\n      };\n    }\n\n    const finishReason = mapResponsesFinishReason({\n      status: terminal.status,\n      incomplete_details: terminal.incomplete_details,\n      hasToolCalls: toolCalls.length > 0,\n    });\n    const usage = this.extractUsage(terminal.usage);\n\n    this.logger.debug(LOG_MODULE, \"response\", \"Streaming call to responses.create succeeded\", {\n      finishReason,\n      usage,\n    });\n\n    yield { type: \"done\", finishReason, usage };\n  }\n\n  /**\n   * Assemble the `responses.create` body.\n   *\n   * - System prompt -> `instructions`; history -> `input` items.\n   * - `store: false` always (the API default is `true` when omitted), plus\n   *   `include: [\"reasoning.encrypted_content\"]` for stateless reasoning replay.\n   * - `max_output_tokens` caps reasoning and visible output together.\n   * - `temperature` only for non-reasoning models (same rule as Chat).\n   * - `tools` flat with `strict: false`; `tool_choice` only with tools.\n   * - `reasoning.effort` only when the caller gave one, through the same\n   *   clamp table as Chat. With no explicit effort the provider default\n   *   applies EVEN with tools attached - that is the point of this API.\n   */\n  private buildRequest(\n    messages: Message[],\n    options: ModelCallOptions | undefined,\n  ): OpenAI.Responses.ResponseCreateParamsNonStreaming {\n    const { instructions, input } = toResponsesInput(messages, this.name);\n    const tools = toResponsesTools(options?.tools);\n    const toolChoice = tools ? toResponsesToolChoice(options?.toolChoice) : undefined;\n    const maxTokens = options?.maxTokens ?? this.config.maxTokens;\n    const temperature = options?.temperature ?? this.config.temperature;\n\n    return {\n      model: this.name,\n      ...(instructions !== undefined ? { instructions } : {}),\n      input,\n      store: false,\n      // Stateless replay: ask for the encrypted reasoning blobs so they can be\n      // sent back on the next tool turn (decision 3).\n      include: [\"reasoning.encrypted_content\"],\n      ...(maxTokens !== undefined ? { max_output_tokens: maxTokens } : {}),\n      ...(!this.capabilities.reasoning && temperature !== undefined ? { temperature } : {}),\n      ...(tools ? { tools } : {}),\n      ...(toolChoice !== undefined ? { tool_choice: toolChoice } : {}),\n      ...this.buildTextFormat(options?.responseSchema),\n      ...this.buildReasoningParams(options?.reasoning),\n      ...buildPromptCacheParams(this.provider, this.config),\n    };\n  }\n\n  /**\n   * Structured output on Responses lives in `text.format`, and `name` /\n   * `schema` / `strict` sit directly on the format object (Chat nests them\n   * under `json_schema`). The strict-or-downgrade decision is the shared\n   * `planStructuredOutput`.\n   */\n  private buildTextFormat(responseSchema: Record<string, unknown> | undefined): {\n    text?: OpenAI.Responses.ResponseTextConfig;\n  } {\n    const plan = planStructuredOutput(responseSchema, this.config.responseFormat);\n\n    if (plan.mode === \"json_schema\") {\n      return {\n        text: { format: { type: \"json_schema\", name: \"response\", schema: plan.schema, strict: true } },\n      };\n    }\n\n    if (plan.mode === \"json_object\") {\n      return { text: { format: { type: \"json_object\" } } };\n    }\n\n    return {};\n  }\n\n  /** `reasoning.effort` for reasoning-capable models, only when the caller set one. */\n  private buildReasoningParams(reasoning: ModelCallOptions[\"reasoning\"]): {\n    reasoning?: { effort: ReturnType<typeof toOpenAIReasoningEffort> };\n  } {\n    if (!this.capabilities.reasoning || !reasoning?.effort) {\n      return {};\n    }\n\n    return { reasoning: { effort: toOpenAIReasoningEffort(reasoning.effort) } };\n  }\n\n  /**\n   * Walk `response.output`: `message` items contribute their `output_text`\n   * text and any `refusal` text (surfaced as ordinary content, decision 5);\n   * each completed `function_call` item becomes one tool call with\n   * `id = call_id`. `reasoning` items carry no visible content and are\n   * not content. A `function_call` the API marked `incomplete` (truncated\n   * arguments) is skipped rather than dispatched with empty input.\n   * `reasoning` items are captured and attached to the first tool call for\n   * replay (see `attachReasoningReplay`).\n   */\n  private readOutput(output: OpenAI.Responses.ResponseOutputItem[]): {\n    content: string;\n    toolCalls: ModelToolCallRequest[] | undefined;\n  } {\n    let content = \"\";\n    const toolCalls: ModelToolCallRequest[] = [];\n    const reasoningItems: OpenAI.Responses.ResponseReasoningItem[] = [];\n\n    for (const item of output) {\n      if (item.type === \"reasoning\") {\n        reasoningItems.push(item);\n        continue;\n      }\n\n      if (item.type === \"message\") {\n        for (const part of item.content) {\n          content += part.type === \"refusal\" ? part.refusal : part.text;\n        }\n\n        continue;\n      }\n\n      if (item.type === \"function_call\" && item.status !== \"incomplete\") {\n        toolCalls.push(this.toToolCall(item));\n      }\n    }\n\n    return {\n      content,\n      toolCalls:\n        toolCalls.length > 0\n          ? attachReasoningReplay(toolCalls, this.name, reasoningItems)\n          : undefined,\n    };\n  }\n\n  /** One completed `function_call` item as a neutral tool call (`call_id` -> `id`). */\n  private toToolCall(item: OpenAI.Responses.ResponseFunctionToolCall): ModelToolCallRequest {\n    return {\n      id: item.call_id,\n      name: item.name,\n      input: safeJsonParse<Record<string, unknown>>(item.arguments, {}),\n    };\n  }\n\n  /**\n   * Normalize `usage` (absent on some partials) into the neutral `Usage`.\n   * `input_tokens_details.cached_tokens` -> `cachedTokens`,\n   * `cache_write_tokens` -> `cacheWriteTokens`,\n   * `output_tokens_details.reasoning_tokens` -> `reasoningTokens`. The\n   * detail blocks are typed non-optional but read defensively.\n   */\n  private extractUsage(raw: OpenAI.Responses.ResponseUsage | undefined): Usage {\n    if (!raw) {\n      return { input: 0, output: 0, total: 0 };\n    }\n\n    return buildUsage({\n      input: raw.input_tokens,\n      output: raw.output_tokens,\n      total: raw.total_tokens,\n      cachedTokens: raw.input_tokens_details?.cached_tokens,\n      cacheWriteTokens: raw.input_tokens_details?.cache_write_tokens,\n      reasoningTokens: raw.output_tokens_details?.reasoning_tokens,\n    });\n  }\n\n  /** Wrap (idempotently), log and return a failure for the caller to throw. */\n  private logAndWrap(thrown: unknown): ReturnType<typeof wrapOpenAIError> {\n    const wrapped = wrapOpenAIError(thrown);\n\n    this.logger.error(LOG_MODULE, \"error\", wrapped.message, {\n      code: wrapped.code,\n      context: wrapped.context,\n    });\n\n    return wrapped;\n  }\n}\n"],"mappings":"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"}

package/esm/sdk.d.mts

@@ -1,7 +1,7 @@
 import { OpenAIEmbedderConfig, OpenAIImageConfig, OpenAIModelConfig, OpenAISDKConfig, OpenAISpeechConfig, OpenAITranscriptionConfig } from "./config.type.mjs";
 import { EmbedderContract, ImageModelContract, ModelContract, SDKAdapterContract, SpeechModelContract, TranscriptionModelContract } from "@warlock.js/ai";
 
-//#region ../ai-openai/src/sdk.d.ts
+//#region ../../packages/ai-openai/src/sdk.d.ts
 /**
  * OpenAI-backed implementation of `SDKAdapterContract`.
  *

package/esm/sdk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../../ai-openai/src/sdk.ts"],"mappings":";;;;;;AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,SAAA,YAAqB,kBAAA;EAAA,iBACf,MAAA;EAAA,iBACA,QAAA;EAAA,iBACA,OAAA;cAEE,MAAA,EAAQ,eAAA;EAqGpB;;;;;;;;;;;;;AAkCyE;;;;;;EAxGzE,KAAA,CAAM,MAAA,EAAQ,iBAAA,GAAoB,aAAA;;;;;;;;EAmC5B,KAAA,CAAM,IAAA,UAAc,MAAA,YAAkB,OAAA;;;;;;;;;;;EAc5C,QAAA,CAAS,MAAA,EAAQ,oBAAA,GAAuB,gBAAA;;;;;;;;;;;;;;;;;;EAqBxC,KAAA,CAAM,MAAA,EAAQ,iBAAA,GAAoB,kBAAA;;;;;;;;;;;;EAmBlC,MAAA,CAAO,MAAA,EAAQ,kBAAA,GAAqB,mBAAA;;;;;;;;;;;;EAepC,UAAA,CAAW,MAAA,EAAQ,yBAAA,GAA4B,0BAAA;AAAA"}
+{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/sdk.ts"],"mappings":";;;;;;AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,SAAA,YAAqB,kBAAA;EAAA,iBACf,MAAA;EAAA,iBACA,QAAA;EAAA,iBACA,OAAA;cAEE,MAAA,EAAQ,eAAA;EAqGpB;;;;;;;;;;;;;AAkCyE;;;;;;EAxGzE,KAAA,CAAM,MAAA,EAAQ,iBAAA,GAAoB,aAAA;;;;;;;;EAmC5B,KAAA,CAAM,IAAA,UAAc,MAAA,YAAkB,OAAA;;;;;;;;;;;EAc5C,QAAA,CAAS,MAAA,EAAQ,oBAAA,GAAuB,gBAAA;;;;;;;;;;;;;;;;;;EAqBxC,KAAA,CAAM,MAAA,EAAQ,iBAAA,GAAoB,kBAAA;;;;;;;;;;;;EAmBlC,MAAA,CAAO,MAAA,EAAQ,kBAAA,GAAqB,mBAAA;;;;;;;;;;;;EAepC,UAAA,CAAW,MAAA,EAAQ,yBAAA,GAA4B,0BAAA;AAAA"}

package/esm/sdk.mjs

@@ -7,7 +7,7 @@ import { OpenAITranscriptionModel } from "./transcription.mjs";
 import OpenAI from "openai";
 import { InvalidRequestError, approximateTokenCount } from "@warlock.js/ai";
 
-//#region ../ai-openai/src/sdk.ts
+//#region ../../packages/ai-openai/src/sdk.ts
 /**
 * OpenAI-backed implementation of `SDKAdapterContract`.
 *

package/esm/sdk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../../ai-openai/src/sdk.ts"],"sourcesContent":["import OpenAI from \"openai\";\nimport type {\n  EmbedderContract,\n  ImageModelContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n  SpeechModelContract,\n  TranscriptionModelContract,\n} from \"@warlock.js/ai\";\nimport { InvalidRequestError, approximateTokenCount } from \"@warlock.js/ai\";\nimport type {\n  OpenAIEmbedderConfig,\n  OpenAIImageConfig,\n  OpenAIModelConfig,\n  OpenAISDKConfig,\n  OpenAISpeechConfig,\n  OpenAITranscriptionConfig,\n} from \"./config.type\";\nimport { OpenAIEmbedder } from \"./embedder\";\nimport { OpenAIImageModel } from \"./image\";\nimport { OpenAIModel } from \"./model\";\nimport { OpenAIResponsesModel } from \"./responses-model\";\nimport { OpenAISpeechModel } from \"./speech\";\nimport { OpenAITranscriptionModel } from \"./transcription\";\n\n/**\n * OpenAI-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for any OpenAI-compatible provider\n * (OpenAI, Azure OpenAI, OpenRouter, local gateways speaking the Chat\n * Completions protocol). A single `OpenAISDK` instance holds one live\n * `OpenAI` client, shared by every `ModelContract` it produces via\n * `model()`. Users construct one SDK per provider/account and reuse it\n * across all agents, workflows, and supervisors that target that\n * provider.\n *\n * **Responsibility.**\n * - Owns: a long-lived `OpenAI` client (authentication, base URL) and\n *   its lifetime scope. Factory for `OpenAIModel` instances — each\n *   model call gets a reference to the same client.\n * - Does NOT own: anything per-call (tool execution, message history,\n *   streaming loop) — those live in `OpenAIModel` and the agent runtime.\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"): the `OpenAI` client is heavy to construct and\n * designed to be reused; keeping it on `this` makes that reuse\n * explicit and aligns with the PascalCase naming convention readers\n * expect from a constructor.\n *\n * @example\n * const openai = new OpenAISDK({ apiKey: process.env.OPENAI_API_KEY! });\n * const model = openai.model({ name: \"gpt-4o\", temperature: 0.7 });\n * const tokens = await openai.count(\"Hello world\");\n *\n * @example\n * // Compose into an `ai.openai` namespace for ergonomic agent wiring\n * const ai = { agent, tool, systemPrompt, persona, instruction, openai: new OpenAISDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.openai.model({ name: \"gpt-4o-mini\" }) });\n */\nexport class OpenAISDK implements SDKAdapterContract {\n  private readonly client: OpenAI;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: OpenAISDKConfig) {\n    // Peel off the framework-only keys and forward every other upstream\n    // `ClientOptions` (timeout, maxRetries, defaultHeaders, fetch,\n    // organization, project, …) verbatim — they type-check, so dropping them\n    // is a silent footgun. Mirrors the Bedrock/Google/Ollama adapters.\n    const { provider, pricing, ...clientOptions } = config;\n\n    this.client = new OpenAI(clientOptions);\n    this.provider = provider ?? \"openai\";\n    this.pricing = pricing;\n  }\n\n  /**\n   * Build an `OpenAIModel` bound to this SDK's client. Each call returns\n   * a fresh model instance, but all instances share the underlying\n   * `OpenAI` client — connection pools, rate limits, and authentication\n   * state stay unified across every model produced here. The SDK's\n   * `provider` label is forwarded so every model self-identifies as\n   * coming from the same upstream.\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise the\n   * SDK-level registry entry keyed by `config.name`; otherwise\n   * `undefined` (no cost computed).\n   *\n   * `config.api` selects the wire API. Omitted or `\"chat\"` builds the Chat\n   * Completions `OpenAIModel`. `\"responses\"` builds `OpenAIResponsesModel`\n   * and is accepted ONLY when this SDK's provider label is `\"openai\"`: any\n   * other label (the wrapper packages deepseek / groq / xai / mistral, or a\n   * custom gateway label) throws, so an endpoint not known to implement\n   * `/v1/responses` is never sent there.\n   */\n  public model(config: OpenAIModelConfig): ModelContract {\n    const api: unknown = config.api;\n\n    if (api !== undefined && api !== \"chat\" && api !== \"responses\") {\n      throw new InvalidRequestError(\n        `Unknown OpenAI api \"${String(api)}\"; expected \"chat\" or \"responses\".`,\n        { context: { provider: this.provider, model: config.name, api } },\n      );\n    }\n\n    if (api === \"responses\" && this.provider !== \"openai\") {\n      throw new InvalidRequestError(\n        `api: \"responses\" is supported only on the direct \"openai\" provider; this SDK is labeled \"${this.provider}\". Use the default api: \"chat\".`,\n        { context: { provider: this.provider, model: config.name, api } },\n      );\n    }\n\n    const resolvedPricing = config.pricing ?? this.pricing?.[config.name];\n    const resolvedConfig: OpenAIModelConfig =\n      resolvedPricing === config.pricing ? config : { ...config, pricing: resolvedPricing };\n\n    if (api === \"responses\") {\n      return new OpenAIResponsesModel(this.client, resolvedConfig, this.provider);\n    }\n\n    return new OpenAIModel(this.client, resolvedConfig, this.provider);\n  }\n\n  /**\n   * Rough token-count estimate for a given text. Uses a\n   * character-heuristic (`approximateTokenCount`) from the core package\n   * — good enough for budgeting and quota guards, not for billing.\n   * Accepts an optional model id for future per-model tokenizer\n   * dispatch; currently ignored.\n   */\n  public async count(text: string, _model?: string): Promise<number> {\n    return approximateTokenCount(text);\n  }\n\n  /**\n   * Build an `OpenAIEmbedder` bound to this SDK's client. Each call\n   * returns a fresh embedder instance sharing the same underlying\n   * `OpenAI` client — connection pools and authentication stay unified\n   * across every embedder produced here.\n   *\n   * @example\n   * const embedder = openai.embedder({ name: \"text-embedding-3-small\" });\n   * const { vector } = await embedder.embed(\"Hello world\");\n   */\n  public embedder(config: OpenAIEmbedderConfig): EmbedderContract {\n    return new OpenAIEmbedder(this.client, config);\n  }\n\n  /**\n   * Build an `OpenAIImageModel` bound to this SDK's client for use with\n   * `ai.image({ model, prompt })`. `config.name` is passed through to\n   * `client.images.generate` as given — no id is rejected locally, so\n   * an unsupported model fails at OpenAI, not here. Metering follows\n   * the family: `gpt-image-*` is token-metered, `dall-e-*` per-image.\n   *\n   * Pricing resolution mirrors `model()`: per-model `config.pricing`\n   * wins, otherwise the SDK-level registry entry keyed by `config.name`,\n   * otherwise `undefined` (no cost computed). A token-priced\n   * `gpt-image-1` entry can live in the same SDK registry as the chat\n   * models.\n   *\n   * @example\n   * const model = openai.image({ name: \"gpt-image-1\" });\n   * const { data } = await ai.image({ model, prompt: \"a red bicycle\" });\n   */\n  public image(config: OpenAIImageConfig): ImageModelContract {\n    const resolvedPricing = config.pricing ?? this.pricing?.[config.name];\n    const resolvedConfig: OpenAIImageConfig =\n      resolvedPricing === config.pricing ? config : { ...config, pricing: resolvedPricing };\n\n    return new OpenAIImageModel(this.client, resolvedConfig, this.provider);\n  }\n\n  /**\n   * Build an `OpenAISpeechModel` (text-to-speech) bound to this SDK's\n   * client, for use with `ai.speech({ model, text })`. `config.name` is\n   * passed through to `audio.speech.create` as given — no id is\n   * rejected locally, so an unsupported model fails at OpenAI, not\n   * here.\n   *\n   * @example\n   * const tts = openai.speech({ name: \"tts-1\", voice: \"alloy\" });\n   * const { data } = await ai.speech({ model: tts, text: \"Hello\" });\n   */\n  public speech(config: OpenAISpeechConfig): SpeechModelContract {\n    return new OpenAISpeechModel(this.client, config, this.provider);\n  }\n\n  /**\n   * Build an `OpenAITranscriptionModel` (speech-to-text) bound to this\n   * SDK's client, for use with `ai.transcribe({ model, audio })`.\n   * `config.name` is passed through to `audio.transcriptions.create`\n   * as given — no id is rejected locally, so an unsupported model\n   * fails at OpenAI, not here.\n   *\n   * @example\n   * const stt = openai.transcribe({ name: \"whisper-1\" });\n   * const { data } = await ai.transcribe({ model: stt, audio });\n   */\n  public transcribe(config: OpenAITranscriptionConfig): TranscriptionModelContract {\n    return new OpenAITranscriptionModel(this.client, config, this.provider);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,IAAa,YAAb,MAAqD;CAKnD,AAAO,YAAY,QAAyB;EAK1C,MAAM,EAAE,UAAU,SAAS,GAAG,kBAAkB;EAEhD,KAAK,SAAS,IAAI,OAAO,aAAa;EACtC,KAAK,WAAW,YAAY;EAC5B,KAAK,UAAU;CACjB;;;;;;;;;;;;;;;;;;;;CAqBA,AAAO,MAAM,QAA0C;EACrD,MAAM,MAAe,OAAO;EAE5B,IAAI,QAAQ,UAAa,QAAQ,UAAU,QAAQ,aACjD,MAAM,IAAI,oBACR,uBAAuB,OAAO,GAAG,EAAE,qCACnC,EAAE,SAAS;GAAE,UAAU,KAAK;GAAU,OAAO,OAAO;GAAM;EAAI,EAAE,CAClE;EAGF,IAAI,QAAQ,eAAe,KAAK,aAAa,UAC3C,MAAM,IAAI,oBACR,4FAA4F,KAAK,SAAS,kCAC1G,EAAE,SAAS;GAAE,UAAU,KAAK;GAAU,OAAO,OAAO;GAAM;EAAI,EAAE,CAClE;EAGF,MAAM,kBAAkB,OAAO,WAAW,KAAK,UAAU,OAAO;EAChE,MAAM,iBACJ,oBAAoB,OAAO,UAAU,SAAS;GAAE,GAAG;GAAQ,SAAS;EAAgB;EAEtF,IAAI,QAAQ,aACV,OAAO,IAAI,qBAAqB,KAAK,QAAQ,gBAAgB,KAAK,QAAQ;EAG5E,OAAO,IAAI,YAAY,KAAK,QAAQ,gBAAgB,KAAK,QAAQ;CACnE;;;;;;;;CASA,MAAa,MAAM,MAAc,QAAkC;EACjE,OAAO,sBAAsB,IAAI;CACnC;;;;;;;;;;;CAYA,AAAO,SAAS,QAAgD;EAC9D,OAAO,IAAI,eAAe,KAAK,QAAQ,MAAM;CAC/C;;;;;;;;;;;;;;;;;;CAmBA,AAAO,MAAM,QAA+C;EAC1D,MAAM,kBAAkB,OAAO,WAAW,KAAK,UAAU,OAAO;EAChE,MAAM,iBACJ,oBAAoB,OAAO,UAAU,SAAS;GAAE,GAAG;GAAQ,SAAS;EAAgB;EAEtF,OAAO,IAAI,iBAAiB,KAAK,QAAQ,gBAAgB,KAAK,QAAQ;CACxE;;;;;;;;;;;;CAaA,AAAO,OAAO,QAAiD;EAC7D,OAAO,IAAI,kBAAkB,KAAK,QAAQ,QAAQ,KAAK,QAAQ;CACjE;;;;;;;;;;;;CAaA,AAAO,WAAW,QAA+D;EAC/E,OAAO,IAAI,yBAAyB,KAAK,QAAQ,QAAQ,KAAK,QAAQ;CACxE;AACF"}
+{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/sdk.ts"],"sourcesContent":["import OpenAI from \"openai\";\nimport type {\n  EmbedderContract,\n  ImageModelContract,\n  ModelContract,\n  ModelPricing,\n  SDKAdapterContract,\n  SpeechModelContract,\n  TranscriptionModelContract,\n} from \"@warlock.js/ai\";\nimport { InvalidRequestError, approximateTokenCount } from \"@warlock.js/ai\";\nimport type {\n  OpenAIEmbedderConfig,\n  OpenAIImageConfig,\n  OpenAIModelConfig,\n  OpenAISDKConfig,\n  OpenAISpeechConfig,\n  OpenAITranscriptionConfig,\n} from \"./config.type\";\nimport { OpenAIEmbedder } from \"./embedder\";\nimport { OpenAIImageModel } from \"./image\";\nimport { OpenAIModel } from \"./model\";\nimport { OpenAIResponsesModel } from \"./responses-model\";\nimport { OpenAISpeechModel } from \"./speech\";\nimport { OpenAITranscriptionModel } from \"./transcription\";\n\n/**\n * OpenAI-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for any OpenAI-compatible provider\n * (OpenAI, Azure OpenAI, OpenRouter, local gateways speaking the Chat\n * Completions protocol). A single `OpenAISDK` instance holds one live\n * `OpenAI` client, shared by every `ModelContract` it produces via\n * `model()`. Users construct one SDK per provider/account and reuse it\n * across all agents, workflows, and supervisors that target that\n * provider.\n *\n * **Responsibility.**\n * - Owns: a long-lived `OpenAI` client (authentication, base URL) and\n *   its lifetime scope. Factory for `OpenAIModel` instances — each\n *   model call gets a reference to the same client.\n * - Does NOT own: anything per-call (tool execution, message history,\n *   streaming loop) — those live in `OpenAIModel` and the agent runtime.\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"): the `OpenAI` client is heavy to construct and\n * designed to be reused; keeping it on `this` makes that reuse\n * explicit and aligns with the PascalCase naming convention readers\n * expect from a constructor.\n *\n * @example\n * const openai = new OpenAISDK({ apiKey: process.env.OPENAI_API_KEY! });\n * const model = openai.model({ name: \"gpt-4o\", temperature: 0.7 });\n * const tokens = await openai.count(\"Hello world\");\n *\n * @example\n * // Compose into an `ai.openai` namespace for ergonomic agent wiring\n * const ai = { agent, tool, systemPrompt, persona, instruction, openai: new OpenAISDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.openai.model({ name: \"gpt-4o-mini\" }) });\n */\nexport class OpenAISDK implements SDKAdapterContract {\n  private readonly client: OpenAI;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: OpenAISDKConfig) {\n    // Peel off the framework-only keys and forward every other upstream\n    // `ClientOptions` (timeout, maxRetries, defaultHeaders, fetch,\n    // organization, project, …) verbatim — they type-check, so dropping them\n    // is a silent footgun. Mirrors the Bedrock/Google/Ollama adapters.\n    const { provider, pricing, ...clientOptions } = config;\n\n    this.client = new OpenAI(clientOptions);\n    this.provider = provider ?? \"openai\";\n    this.pricing = pricing;\n  }\n\n  /**\n   * Build an `OpenAIModel` bound to this SDK's client. Each call returns\n   * a fresh model instance, but all instances share the underlying\n   * `OpenAI` client — connection pools, rate limits, and authentication\n   * state stay unified across every model produced here. The SDK's\n   * `provider` label is forwarded so every model self-identifies as\n   * coming from the same upstream.\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise the\n   * SDK-level registry entry keyed by `config.name`; otherwise\n   * `undefined` (no cost computed).\n   *\n   * `config.api` selects the wire API. Omitted or `\"chat\"` builds the Chat\n   * Completions `OpenAIModel`. `\"responses\"` builds `OpenAIResponsesModel`\n   * and is accepted ONLY when this SDK's provider label is `\"openai\"`: any\n   * other label (the wrapper packages deepseek / groq / xai / mistral, or a\n   * custom gateway label) throws, so an endpoint not known to implement\n   * `/v1/responses` is never sent there.\n   */\n  public model(config: OpenAIModelConfig): ModelContract {\n    const api: unknown = config.api;\n\n    if (api !== undefined && api !== \"chat\" && api !== \"responses\") {\n      throw new InvalidRequestError(\n        `Unknown OpenAI api \"${String(api)}\"; expected \"chat\" or \"responses\".`,\n        { context: { provider: this.provider, model: config.name, api } },\n      );\n    }\n\n    if (api === \"responses\" && this.provider !== \"openai\") {\n      throw new InvalidRequestError(\n        `api: \"responses\" is supported only on the direct \"openai\" provider; this SDK is labeled \"${this.provider}\". Use the default api: \"chat\".`,\n        { context: { provider: this.provider, model: config.name, api } },\n      );\n    }\n\n    const resolvedPricing = config.pricing ?? this.pricing?.[config.name];\n    const resolvedConfig: OpenAIModelConfig =\n      resolvedPricing === config.pricing ? config : { ...config, pricing: resolvedPricing };\n\n    if (api === \"responses\") {\n      return new OpenAIResponsesModel(this.client, resolvedConfig, this.provider);\n    }\n\n    return new OpenAIModel(this.client, resolvedConfig, this.provider);\n  }\n\n  /**\n   * Rough token-count estimate for a given text. Uses a\n   * character-heuristic (`approximateTokenCount`) from the core package\n   * — good enough for budgeting and quota guards, not for billing.\n   * Accepts an optional model id for future per-model tokenizer\n   * dispatch; currently ignored.\n   */\n  public async count(text: string, _model?: string): Promise<number> {\n    return approximateTokenCount(text);\n  }\n\n  /**\n   * Build an `OpenAIEmbedder` bound to this SDK's client. Each call\n   * returns a fresh embedder instance sharing the same underlying\n   * `OpenAI` client — connection pools and authentication stay unified\n   * across every embedder produced here.\n   *\n   * @example\n   * const embedder = openai.embedder({ name: \"text-embedding-3-small\" });\n   * const { vector } = await embedder.embed(\"Hello world\");\n   */\n  public embedder(config: OpenAIEmbedderConfig): EmbedderContract {\n    return new OpenAIEmbedder(this.client, config);\n  }\n\n  /**\n   * Build an `OpenAIImageModel` bound to this SDK's client for use with\n   * `ai.image({ model, prompt })`. `config.name` is passed through to\n   * `client.images.generate` as given — no id is rejected locally, so\n   * an unsupported model fails at OpenAI, not here. Metering follows\n   * the family: `gpt-image-*` is token-metered, `dall-e-*` per-image.\n   *\n   * Pricing resolution mirrors `model()`: per-model `config.pricing`\n   * wins, otherwise the SDK-level registry entry keyed by `config.name`,\n   * otherwise `undefined` (no cost computed). A token-priced\n   * `gpt-image-1` entry can live in the same SDK registry as the chat\n   * models.\n   *\n   * @example\n   * const model = openai.image({ name: \"gpt-image-1\" });\n   * const { data } = await ai.image({ model, prompt: \"a red bicycle\" });\n   */\n  public image(config: OpenAIImageConfig): ImageModelContract {\n    const resolvedPricing = config.pricing ?? this.pricing?.[config.name];\n    const resolvedConfig: OpenAIImageConfig =\n      resolvedPricing === config.pricing ? config : { ...config, pricing: resolvedPricing };\n\n    return new OpenAIImageModel(this.client, resolvedConfig, this.provider);\n  }\n\n  /**\n   * Build an `OpenAISpeechModel` (text-to-speech) bound to this SDK's\n   * client, for use with `ai.speech({ model, text })`. `config.name` is\n   * passed through to `audio.speech.create` as given — no id is\n   * rejected locally, so an unsupported model fails at OpenAI, not\n   * here.\n   *\n   * @example\n   * const tts = openai.speech({ name: \"tts-1\", voice: \"alloy\" });\n   * const { data } = await ai.speech({ model: tts, text: \"Hello\" });\n   */\n  public speech(config: OpenAISpeechConfig): SpeechModelContract {\n    return new OpenAISpeechModel(this.client, config, this.provider);\n  }\n\n  /**\n   * Build an `OpenAITranscriptionModel` (speech-to-text) bound to this\n   * SDK's client, for use with `ai.transcribe({ model, audio })`.\n   * `config.name` is passed through to `audio.transcriptions.create`\n   * as given — no id is rejected locally, so an unsupported model\n   * fails at OpenAI, not here.\n   *\n   * @example\n   * const stt = openai.transcribe({ name: \"whisper-1\" });\n   * const { data } = await ai.transcribe({ model: stt, audio });\n   */\n  public transcribe(config: OpenAITranscriptionConfig): TranscriptionModelContract {\n    return new OpenAITranscriptionModel(this.client, config, this.provider);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,IAAa,YAAb,MAAqD;CAKnD,AAAO,YAAY,QAAyB;EAK1C,MAAM,EAAE,UAAU,SAAS,GAAG,kBAAkB;EAEhD,KAAK,SAAS,IAAI,OAAO,aAAa;EACtC,KAAK,WAAW,YAAY;EAC5B,KAAK,UAAU;CACjB;;;;;;;;;;;;;;;;;;;;CAqBA,AAAO,MAAM,QAA0C;EACrD,MAAM,MAAe,OAAO;EAE5B,IAAI,QAAQ,UAAa,QAAQ,UAAU,QAAQ,aACjD,MAAM,IAAI,oBACR,uBAAuB,OAAO,GAAG,EAAE,qCACnC,EAAE,SAAS;GAAE,UAAU,KAAK;GAAU,OAAO,OAAO;GAAM;EAAI,EAAE,CAClE;EAGF,IAAI,QAAQ,eAAe,KAAK,aAAa,UAC3C,MAAM,IAAI,oBACR,4FAA4F,KAAK,SAAS,kCAC1G,EAAE,SAAS;GAAE,UAAU,KAAK;GAAU,OAAO,OAAO;GAAM;EAAI,EAAE,CAClE;EAGF,MAAM,kBAAkB,OAAO,WAAW,KAAK,UAAU,OAAO;EAChE,MAAM,iBACJ,oBAAoB,OAAO,UAAU,SAAS;GAAE,GAAG;GAAQ,SAAS;EAAgB;EAEtF,IAAI,QAAQ,aACV,OAAO,IAAI,qBAAqB,KAAK,QAAQ,gBAAgB,KAAK,QAAQ;EAG5E,OAAO,IAAI,YAAY,KAAK,QAAQ,gBAAgB,KAAK,QAAQ;CACnE;;;;;;;;CASA,MAAa,MAAM,MAAc,QAAkC;EACjE,OAAO,sBAAsB,IAAI;CACnC;;;;;;;;;;;CAYA,AAAO,SAAS,QAAgD;EAC9D,OAAO,IAAI,eAAe,KAAK,QAAQ,MAAM;CAC/C;;;;;;;;;;;;;;;;;;CAmBA,AAAO,MAAM,QAA+C;EAC1D,MAAM,kBAAkB,OAAO,WAAW,KAAK,UAAU,OAAO;EAChE,MAAM,iBACJ,oBAAoB,OAAO,UAAU,SAAS;GAAE,GAAG;GAAQ,SAAS;EAAgB;EAEtF,OAAO,IAAI,iBAAiB,KAAK,QAAQ,gBAAgB,KAAK,QAAQ;CACxE;;;;;;;;;;;;CAaA,AAAO,OAAO,QAAiD;EAC7D,OAAO,IAAI,kBAAkB,KAAK,QAAQ,QAAQ,KAAK,QAAQ;CACjE;;;;;;;;;;;;CAaA,AAAO,WAAW,QAA+D;EAC/E,OAAO,IAAI,yBAAyB,KAAK,QAAQ,QAAQ,KAAK,QAAQ;CACxE;AACF"}

package/esm/speech.d.mts

@@ -2,7 +2,7 @@ import { OpenAISpeechConfig } from "./config.type.mjs";
 import OpenAI from "openai";
 import { SpeechGenerationResponse, SpeechModelContract, SpeechModelPricing, SpeechOptions } from "@warlock.js/ai";
 
-//#region ../ai-openai/src/speech.d.ts
+//#region ../../packages/ai-openai/src/speech.d.ts
 /**
  * OpenAI-backed implementation of `SpeechModelContract` (text-to-speech)
  * via `audio.speech.create`. Standalone primitive — no relation to chat

package/esm/speech.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"speech.d.mts","names":[],"sources":["../../../../../../ai-openai/src/speech.ts"],"mappings":";;;;;;;AA8CA;;;;;;;;;;;;;cAAa,iBAAA,YAA6B,mBAAA;EAAA,SACxB,IAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA,GAAU,kBAAA;EAAA,iBAET,MAAA;EAAA,iBACA,YAAA;EAAA,iBACA,MAAA;cAEE,MAAA,EAAQ,MAAA,EAAQ,MAAA,EAAQ,kBAAA,EAAoB,QAAA;EAQlD,QAAA,CAAS,IAAA,UAAc,OAAA,GAAU,aAAA,GAAgB,OAAA,CAAQ,wBAAA;AAAA"}
+{"version":3,"file":"speech.d.mts","names":[],"sources":["../../../../../../../packages/ai-openai/src/speech.ts"],"mappings":";;;;;;;AA8CA;;;;;;;;;;;;;cAAa,iBAAA,YAA6B,mBAAA;EAAA,SACxB,IAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA,GAAU,kBAAA;EAAA,iBAET,MAAA;EAAA,iBACA,YAAA;EAAA,iBACA,MAAA;cAEE,MAAA,EAAQ,MAAA,EAAQ,MAAA,EAAQ,kBAAA,EAAoB,QAAA;EAQlD,QAAA,CAAS,IAAA,UAAc,OAAA,GAAU,aAAA,GAAgB,OAAA,CAAQ,wBAAA;AAAA"}

package/esm/speech.mjs

@@ -2,7 +2,7 @@ import { wrapOpenAIError } from "./utils/wrap-openai-error.mjs";
 import "./utils/index.mjs";
 import { log } from "@warlock.js/logger";
 
-//#region ../ai-openai/src/speech.ts
+//#region ../../packages/ai-openai/src/speech.ts
 const LOG_MODULE = "ai.openai";
 /** Map a neutral output container hint to its IANA audio media type. */
 function audioMediaType(format) {

package/esm/speech.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"speech.mjs","names":[],"sources":["../../../../../../ai-openai/src/speech.ts"],"sourcesContent":["import {\n  type SpeechGenerationResponse,\n  type SpeechModelContract,\n  type SpeechModelPricing,\n  type SpeechOptions,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAISpeechConfig } from \"./config.type\";\nimport { wrapOpenAIError } from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\n/** Map a neutral output container hint to its IANA audio media type. */\nfunction audioMediaType(format: string | undefined): string {\n  switch (format) {\n    case \"opus\":\n      return \"audio/opus\";\n    case \"aac\":\n      return \"audio/aac\";\n    case \"flac\":\n      return \"audio/flac\";\n    case \"wav\":\n      return \"audio/wav\";\n    case \"pcm\":\n      return \"audio/pcm\";\n    default:\n      return \"audio/mpeg\";\n  }\n}\n\n/**\n * OpenAI-backed implementation of `SpeechModelContract` (text-to-speech)\n * via `audio.speech.create`. Standalone primitive — no relation to chat\n * completions or the agent loop. Consumed by the `ai.speech()` verb.\n *\n * **No model-id validation.** `config.name` is forwarded to\n * `audio.speech.create` exactly as given — the constructor never\n * inspects it. OpenAI ships and retires TTS model ids on its own\n * schedule, so an unrecognized id fails at OpenAI (wrapped into the\n * typed `AIError` hierarchy by `generate()`), not here.\n *\n * @example\n * const tts = new OpenAISpeechModel(client, { name: \"tts-1\", voice: \"alloy\" }, \"openai\");\n * const { audio } = await tts.generate(\"Welcome aboard.\");\n */\nexport class OpenAISpeechModel implements SpeechModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly pricing?: SpeechModelPricing;\n\n  private readonly client: OpenAI;\n  private readonly defaultVoice?: string;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAISpeechConfig, provider: string = \"openai\") {\n    this.client = client;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n    this.defaultVoice = config.voice;\n  }\n\n  public async generate(text: string, options?: SpeechOptions): Promise<SpeechGenerationResponse> {\n    const format = options?.format ?? \"mp3\";\n\n    this.logger.debug(LOG_MODULE, \"speech.request\", \"audio.speech.create\", {\n      model: this.name,\n      characters: text.length,\n    });\n\n    let response: Response;\n\n    try {\n      response = await this.client.audio.speech.create(\n        {\n          model: this.name,\n          input: text,\n          voice: options?.voice ?? this.defaultVoice ?? \"alloy\",\n          response_format: format as OpenAI.Audio.SpeechCreateParams[\"response_format\"],\n          ...(options?.speed !== undefined ? { speed: options.speed } : {}),\n          ...(options?.instructions !== undefined ? { instructions: options.instructions } : {}),\n        },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n      this.logger.error(LOG_MODULE, \"speech.error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n      throw wrapped;\n    }\n\n    const base64 = Buffer.from(await response.arrayBuffer()).toString(\"base64\");\n\n    return {\n      audio: { type: \"base64\", base64, mediaType: audioMediaType(format) },\n      // The Speech API reports no token usage; spend is priced per\n      // character (or per token for gpt-4o-mini-tts) by `ai.speech()`.\n      usage: { input: 0, output: 0, total: 0 },\n      characters: text.length,\n    };\n  }\n}\n"],"mappings":";;;;;AAWA,MAAM,aAAa;;AAGnB,SAAS,eAAe,QAAoC;CAC1D,QAAQ,QAAR;EACE,KAAK,QACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,SACE,OAAO;CACX;AACF;;;;;;;;;;;;;;;;AAiBA,IAAa,oBAAb,MAA8D;CAS5D,AAAO,YAAY,QAAgB,QAA4B,WAAmB,UAAU;gBAF1D;EAGhC,KAAK,SAAS;EACd,KAAK,OAAO,OAAO;EACnB,KAAK,WAAW;EAChB,KAAK,UAAU,OAAO;EACtB,KAAK,eAAe,OAAO;CAC7B;CAEA,MAAa,SAAS,MAAc,SAA4D;EAC9F,MAAM,SAAS,SAAS,UAAU;EAElC,KAAK,OAAO,MAAM,YAAY,kBAAkB,uBAAuB;GACrE,OAAO,KAAK;GACZ,YAAY,KAAK;EACnB,CAAC;EAED,IAAI;EAEJ,IAAI;GACF,WAAW,MAAM,KAAK,OAAO,MAAM,OAAO,OACxC;IACE,OAAO,KAAK;IACZ,OAAO;IACP,OAAO,SAAS,SAAS,KAAK,gBAAgB;IAC9C,iBAAiB;IACjB,GAAI,SAAS,UAAU,SAAY,EAAE,OAAO,QAAQ,MAAM,IAAI,CAAC;IAC/D,GAAI,SAAS,iBAAiB,SAAY,EAAE,cAAc,QAAQ,aAAa,IAAI,CAAC;GACtF,GACA,SAAS,SAAS,EAAE,QAAQ,QAAQ,OAAO,IAAI,MACjD;EACF,SAAS,QAAQ;GACf,MAAM,UAAU,gBAAgB,MAAM;GACtC,KAAK,OAAO,MAAM,YAAY,gBAAgB,QAAQ,SAAS;IAC7D,MAAM,QAAQ;IACd,SAAS,QAAQ;GACnB,CAAC;GACD,MAAM;EACR;EAIA,OAAO;GACL,OAAO;IAAE,MAAM;IAAU,QAHZ,OAAO,KAAK,MAAM,SAAS,YAAY,CAAC,CAAC,CAAC,SAAS,QAGlC;IAAG,WAAW,eAAe,MAAM;GAAE;GAGnE,OAAO;IAAE,OAAO;IAAG,QAAQ;IAAG,OAAO;GAAE;GACvC,YAAY,KAAK;EACnB;CACF;AACF"}
+{"version":3,"file":"speech.mjs","names":[],"sources":["../../../../../../../packages/ai-openai/src/speech.ts"],"sourcesContent":["import {\n  type SpeechGenerationResponse,\n  type SpeechModelContract,\n  type SpeechModelPricing,\n  type SpeechOptions,\n} from \"@warlock.js/ai\";\nimport { log, type Logger } from \"@warlock.js/logger\";\nimport type OpenAI from \"openai\";\nimport type { OpenAISpeechConfig } from \"./config.type\";\nimport { wrapOpenAIError } from \"./utils\";\n\nconst LOG_MODULE = \"ai.openai\";\n\n/** Map a neutral output container hint to its IANA audio media type. */\nfunction audioMediaType(format: string | undefined): string {\n  switch (format) {\n    case \"opus\":\n      return \"audio/opus\";\n    case \"aac\":\n      return \"audio/aac\";\n    case \"flac\":\n      return \"audio/flac\";\n    case \"wav\":\n      return \"audio/wav\";\n    case \"pcm\":\n      return \"audio/pcm\";\n    default:\n      return \"audio/mpeg\";\n  }\n}\n\n/**\n * OpenAI-backed implementation of `SpeechModelContract` (text-to-speech)\n * via `audio.speech.create`. Standalone primitive — no relation to chat\n * completions or the agent loop. Consumed by the `ai.speech()` verb.\n *\n * **No model-id validation.** `config.name` is forwarded to\n * `audio.speech.create` exactly as given — the constructor never\n * inspects it. OpenAI ships and retires TTS model ids on its own\n * schedule, so an unrecognized id fails at OpenAI (wrapped into the\n * typed `AIError` hierarchy by `generate()`), not here.\n *\n * @example\n * const tts = new OpenAISpeechModel(client, { name: \"tts-1\", voice: \"alloy\" }, \"openai\");\n * const { audio } = await tts.generate(\"Welcome aboard.\");\n */\nexport class OpenAISpeechModel implements SpeechModelContract {\n  public readonly name: string;\n  public readonly provider: string;\n  public readonly pricing?: SpeechModelPricing;\n\n  private readonly client: OpenAI;\n  private readonly defaultVoice?: string;\n  private readonly logger: Logger = log;\n\n  public constructor(client: OpenAI, config: OpenAISpeechConfig, provider: string = \"openai\") {\n    this.client = client;\n    this.name = config.name;\n    this.provider = provider;\n    this.pricing = config.pricing;\n    this.defaultVoice = config.voice;\n  }\n\n  public async generate(text: string, options?: SpeechOptions): Promise<SpeechGenerationResponse> {\n    const format = options?.format ?? \"mp3\";\n\n    this.logger.debug(LOG_MODULE, \"speech.request\", \"audio.speech.create\", {\n      model: this.name,\n      characters: text.length,\n    });\n\n    let response: Response;\n\n    try {\n      response = await this.client.audio.speech.create(\n        {\n          model: this.name,\n          input: text,\n          voice: options?.voice ?? this.defaultVoice ?? \"alloy\",\n          response_format: format as OpenAI.Audio.SpeechCreateParams[\"response_format\"],\n          ...(options?.speed !== undefined ? { speed: options.speed } : {}),\n          ...(options?.instructions !== undefined ? { instructions: options.instructions } : {}),\n        },\n        options?.signal ? { signal: options.signal } : undefined,\n      );\n    } catch (thrown) {\n      const wrapped = wrapOpenAIError(thrown);\n      this.logger.error(LOG_MODULE, \"speech.error\", wrapped.message, {\n        code: wrapped.code,\n        context: wrapped.context,\n      });\n      throw wrapped;\n    }\n\n    const base64 = Buffer.from(await response.arrayBuffer()).toString(\"base64\");\n\n    return {\n      audio: { type: \"base64\", base64, mediaType: audioMediaType(format) },\n      // The Speech API reports no token usage; spend is priced per\n      // character (or per token for gpt-4o-mini-tts) by `ai.speech()`.\n      usage: { input: 0, output: 0, total: 0 },\n      characters: text.length,\n    };\n  }\n}\n"],"mappings":";;;;;AAWA,MAAM,aAAa;;AAGnB,SAAS,eAAe,QAAoC;CAC1D,QAAQ,QAAR;EACE,KAAK,QACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,KAAK,OACH,OAAO;EACT,SACE,OAAO;CACX;AACF;;;;;;;;;;;;;;;;AAiBA,IAAa,oBAAb,MAA8D;CAS5D,AAAO,YAAY,QAAgB,QAA4B,WAAmB,UAAU;gBAF1D;EAGhC,KAAK,SAAS;EACd,KAAK,OAAO,OAAO;EACnB,KAAK,WAAW;EAChB,KAAK,UAAU,OAAO;EACtB,KAAK,eAAe,OAAO;CAC7B;CAEA,MAAa,SAAS,MAAc,SAA4D;EAC9F,MAAM,SAAS,SAAS,UAAU;EAElC,KAAK,OAAO,MAAM,YAAY,kBAAkB,uBAAuB;GACrE,OAAO,KAAK;GACZ,YAAY,KAAK;EACnB,CAAC;EAED,IAAI;EAEJ,IAAI;GACF,WAAW,MAAM,KAAK,OAAO,MAAM,OAAO,OACxC;IACE,OAAO,KAAK;IACZ,OAAO;IACP,OAAO,SAAS,SAAS,KAAK,gBAAgB;IAC9C,iBAAiB;IACjB,GAAI,SAAS,UAAU,SAAY,EAAE,OAAO,QAAQ,MAAM,IAAI,CAAC;IAC/D,GAAI,SAAS,iBAAiB,SAAY,EAAE,cAAc,QAAQ,aAAa,IAAI,CAAC;GACtF,GACA,SAAS,SAAS,EAAE,QAAQ,QAAQ,OAAO,IAAI,MACjD;EACF,SAAS,QAAQ;GACf,MAAM,UAAU,gBAAgB,MAAM;GACtC,KAAK,OAAO,MAAM,YAAY,gBAAgB,QAAQ,SAAS;IAC7D,MAAM,QAAQ;IACd,SAAS,QAAQ;GACnB,CAAC;GACD,MAAM;EACR;EAIA,OAAO;GACL,OAAO;IAAE,MAAM;IAAU,QAHZ,OAAO,KAAK,MAAM,SAAS,YAAY,CAAC,CAAC,CAAC,SAAS,QAGlC;IAAG,WAAW,eAAe,MAAM;GAAE;GAGnE,OAAO;IAAE,OAAO;IAAG,QAAQ;IAAG,OAAO;GAAE;GACvC,YAAY,KAAK;EACnB;CACF;AACF"}