@warlock.js/ai-openai 5.26.0 → 5.28.0

package/esm/utils/reasoning-effort.mjs

@@ -0,0 +1,35 @@
+//#region ../ai-openai/src/utils/reasoning-effort.ts
+/**
+* The installed OpenAI SDK 7.23.0 declares `reasoning_effort` as
+* `none | minimal | low | medium | high | xhigh | max` in
+* `openai/src/resources/shared.ts:367`. Its type notes that model support
+* varies but does not provide a model-family-specific accepted set, so map by
+* that union alone. This exhaustive record makes a future core level a
+* typecheck failure until its OpenAI clamp is consciously selected.
+*
+* Both the Chat Completions adapter (`reasoning_effort`) and the Responses
+* adapter (`reasoning.effort`) read this one table, so the two can never
+* disagree on how a neutral level reaches the wire.
+*/
+const EFFORT_TO_OPENAI_EFFORT = {
+	none: "none",
+	minimal: "minimal",
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max"
+};
+/**
+* Map a neutral `ReasoningEffort` to the value OpenAI accepts.
+*
+* @example
+* toOpenAIReasoningEffort("high"); // "high"
+*/
+function toOpenAIReasoningEffort(effort) {
+	return EFFORT_TO_OPENAI_EFFORT[effort];
+}
+
+//#endregion
+export { toOpenAIReasoningEffort };
+//# sourceMappingURL=reasoning-effort.mjs.map

package/esm/utils/reasoning-effort.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-effort.mjs","names":[],"sources":["../../../../../../../ai-openai/src/utils/reasoning-effort.ts"],"sourcesContent":["import type { ReasoningEffort } from \"@warlock.js/ai\";\nimport type OpenAI from \"openai\";\n\n/** The effort strings the OpenAI wire accepts (shared by Chat Completions and Responses). */\nexport type OpenAIReasoningEffort = NonNullable<\n  OpenAI.Chat.Completions.ChatCompletionCreateParams[\"reasoning_effort\"]\n>;\n\n/**\n * The installed OpenAI SDK 7.23.0 declares `reasoning_effort` as\n * `none | minimal | low | medium | high | xhigh | max` in\n * `openai/src/resources/shared.ts:367`. Its type notes that model support\n * varies but does not provide a model-family-specific accepted set, so map by\n * that union alone. This exhaustive record makes a future core level a\n * typecheck failure until its OpenAI clamp is consciously selected.\n *\n * Both the Chat Completions adapter (`reasoning_effort`) and the Responses\n * adapter (`reasoning.effort`) read this one table, so the two can never\n * disagree on how a neutral level reaches the wire.\n */\nconst EFFORT_TO_OPENAI_EFFORT: Record<ReasoningEffort, OpenAIReasoningEffort> = {\n  none: \"none\",\n  minimal: \"minimal\",\n  low: \"low\",\n  medium: \"medium\",\n  high: \"high\",\n  xhigh: \"xhigh\",\n  max: \"max\",\n};\n\n/**\n * Map a neutral `ReasoningEffort` to the value OpenAI accepts.\n *\n * @example\n * toOpenAIReasoningEffort(\"high\"); // \"high\"\n */\nexport function toOpenAIReasoningEffort(effort: ReasoningEffort): OpenAIReasoningEffort {\n  return EFFORT_TO_OPENAI_EFFORT[effort];\n}\n"],"mappings":";;;;;;;;;;;;;AAoBA,MAAM,0BAA0E;CAC9E,MAAM;CACN,SAAS;CACT,KAAK;CACL,QAAQ;CACR,MAAM;CACN,OAAO;CACP,KAAK;AACP;;;;;;;AAQA,SAAgB,wBAAwB,QAAgD;CACtF,OAAO,wBAAwB;AACjC"}

package/esm/utils/reasoning-replay.mjs

@@ -0,0 +1,85 @@
+//#region ../ai-openai/src/utils/reasoning-replay.ts
+/**
+* Key under `ModelToolCallRequest.providerMetadata` owned by the Responses
+* adapter. This name and the shape below are PERSISTED in users' conversation
+* memory, so they are part of the public contract: do not rename.
+*/
+const RESPONSES_METADATA_KEY = "openaiResponses";
+/**
+* Keep only the reasoning items that can actually be replayed. With
+* `store: false` the server keeps nothing, so an item without
+* `encrypted_content` has nothing to restore and replaying its bare `id`
+* would be rejected as an unknown item.
+*/
+function pickReplayableReasoning(items) {
+	return items.filter((item) => typeof item.encrypted_content === "string" && item.encrypted_content !== "");
+}
+/**
+* Attach the turn's reasoning items to the FIRST tool call only (parallel
+* calls do not each repeat the blobs). Returns the calls unchanged when
+* there is nothing to replay or no tool call to ride on (a text-only turn is
+* deliberately not replayed, decision 2). Does not mutate its input.
+*/
+function attachReasoningReplay(toolCalls, model, reasoningItems) {
+	const replayable = pickReplayableReasoning(reasoningItems);
+	const [first, ...rest] = toolCalls;
+	if (first === void 0 || replayable.length === 0) return [...toolCalls];
+	const metadata = {
+		model,
+		reasoningItems: replayable
+	};
+	return [{
+		...first,
+		providerMetadata: {
+			...first.providerMetadata,
+			[RESPONSES_METADATA_KEY]: metadata
+		}
+	}, ...rest];
+}
+/**
+* Read the stored reasoning items off an assistant turn's tool calls, for
+* replay on `model`. Returns `[]` when the key is absent or malformed, or
+* when the stored `model` differs from `model` (encrypted blobs are not
+* portable across models, design section 4). De-duplicates by item `id`.
+*/
+function readReasoningReplay(toolCalls, model) {
+	const seen = /* @__PURE__ */ new Set();
+	const items = [];
+	for (const call of toolCalls) {
+		const stored = call.providerMetadata?.[RESPONSES_METADATA_KEY];
+		if (!isReplayMetadata(stored) || stored.model !== model) continue;
+		for (const item of stored.reasoningItems) {
+			if (item?.type !== "reasoning" || seen.has(item.id)) continue;
+			seen.add(item.id);
+			items.push(item);
+		}
+	}
+	return items;
+}
+/**
+* Shape a stored reasoning item for the next request. Sends the four fields
+* a stateless replay needs (`type`, `id`, `summary`, `encrypted_content`) and
+* drops the response-only `status` and the optional raw `content`.
+*
+* UNVERIFIED: the SDK types accept the full item as input (`ResponseInputItem`
+* includes `ResponseReasoningItem`) and do not say which fields the API
+* refuses on replay with `store: false`. This is the conservative guess; a
+* live probe settles it.
+*/
+function toReplayReasoningItem(item) {
+	return {
+		type: "reasoning",
+		id: item.id,
+		summary: Array.isArray(item.summary) ? item.summary : [],
+		encrypted_content: item.encrypted_content
+	};
+}
+function isReplayMetadata(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.model === "string" && Array.isArray(candidate.reasoningItems);
+}
+
+//#endregion
+export { RESPONSES_METADATA_KEY, attachReasoningReplay, pickReplayableReasoning, readReasoningReplay, toReplayReasoningItem };
+//# sourceMappingURL=reasoning-replay.mjs.map

package/esm/utils/reasoning-replay.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-replay.mjs","names":[],"sources":["../../../../../../../ai-openai/src/utils/reasoning-replay.ts"],"sourcesContent":["import type { ModelToolCallRequest } from \"@warlock.js/ai\";\nimport type OpenAI from \"openai\";\n\n/** A `reasoning` output item as the Responses API returns it. */\nexport type ResponsesReasoningItem = OpenAI.Responses.ResponseReasoningItem;\n\n/**\n * Key under `ModelToolCallRequest.providerMetadata` owned by the Responses\n * adapter. This name and the shape below are PERSISTED in users' conversation\n * memory, so they are part of the public contract: do not rename.\n */\nexport const RESPONSES_METADATA_KEY = \"openaiResponses\";\n\n/**\n * What the Responses adapter stores on the FIRST tool call of an assistant\n * turn so the next request can replay the model's reasoning (design\n * section 4, decisions 2 and 3).\n */\nexport type ResponsesReplayMetadata = {\n  /** Model the items were produced by; replay is skipped when it differs. */\n  model: string;\n  /** Reasoning items of the turn, in the order the API emitted them. */\n  reasoningItems: ResponsesReasoningItem[];\n};\n\n/**\n * Keep only the reasoning items that can actually be replayed. With\n * `store: false` the server keeps nothing, so an item without\n * `encrypted_content` has nothing to restore and replaying its bare `id`\n * would be rejected as an unknown item.\n */\nexport function pickReplayableReasoning(\n  items: readonly ResponsesReasoningItem[],\n): ResponsesReasoningItem[] {\n  return items.filter(\n    (item) => typeof item.encrypted_content === \"string\" && item.encrypted_content !== \"\",\n  );\n}\n\n/**\n * Attach the turn's reasoning items to the FIRST tool call only (parallel\n * calls do not each repeat the blobs). Returns the calls unchanged when\n * there is nothing to replay or no tool call to ride on (a text-only turn is\n * deliberately not replayed, decision 2). Does not mutate its input.\n */\nexport function attachReasoningReplay(\n  toolCalls: readonly ModelToolCallRequest[],\n  model: string,\n  reasoningItems: readonly ResponsesReasoningItem[],\n): ModelToolCallRequest[] {\n  const replayable = pickReplayableReasoning(reasoningItems);\n  const [first, ...rest] = toolCalls;\n\n  if (first === undefined || replayable.length === 0) {\n    return [...toolCalls];\n  }\n\n  const metadata: ResponsesReplayMetadata = { model, reasoningItems: replayable };\n\n  return [\n    { ...first, providerMetadata: { ...first.providerMetadata, [RESPONSES_METADATA_KEY]: metadata } },\n    ...rest,\n  ];\n}\n\n/**\n * Read the stored reasoning items off an assistant turn's tool calls, for\n * replay on `model`. Returns `[]` when the key is absent or malformed, or\n * when the stored `model` differs from `model` (encrypted blobs are not\n * portable across models, design section 4). De-duplicates by item `id`.\n */\nexport function readReasoningReplay(\n  toolCalls: readonly ModelToolCallRequest[],\n  model: string,\n): ResponsesReasoningItem[] {\n  const seen = new Set<string>();\n  const items: ResponsesReasoningItem[] = [];\n\n  for (const call of toolCalls) {\n    const stored = call.providerMetadata?.[RESPONSES_METADATA_KEY];\n\n    if (!isReplayMetadata(stored) || stored.model !== model) {\n      continue;\n    }\n\n    for (const item of stored.reasoningItems) {\n      if (item?.type !== \"reasoning\" || seen.has(item.id)) {\n        continue;\n      }\n\n      seen.add(item.id);\n      items.push(item);\n    }\n  }\n\n  return items;\n}\n\n/**\n * Shape a stored reasoning item for the next request. Sends the four fields\n * a stateless replay needs (`type`, `id`, `summary`, `encrypted_content`) and\n * drops the response-only `status` and the optional raw `content`.\n *\n * UNVERIFIED: the SDK types accept the full item as input (`ResponseInputItem`\n * includes `ResponseReasoningItem`) and do not say which fields the API\n * refuses on replay with `store: false`. This is the conservative guess; a\n * live probe settles it.\n */\nexport function toReplayReasoningItem(item: ResponsesReasoningItem): ResponsesReasoningItem {\n  return {\n    type: \"reasoning\",\n    id: item.id,\n    summary: Array.isArray(item.summary) ? item.summary : [],\n    encrypted_content: item.encrypted_content,\n  };\n}\n\nfunction isReplayMetadata(value: unknown): value is ResponsesReplayMetadata {\n  if (typeof value !== \"object\" || value === null) {\n    return false;\n  }\n\n  const candidate = value as Partial<ResponsesReplayMetadata>;\n\n  return typeof candidate.model === \"string\" && Array.isArray(candidate.reasoningItems);\n}\n"],"mappings":";;;;;;AAWA,MAAa,yBAAyB;;;;;;;AAoBtC,SAAgB,wBACd,OAC0B;CAC1B,OAAO,MAAM,QACV,SAAS,OAAO,KAAK,sBAAsB,YAAY,KAAK,sBAAsB,EACrF;AACF;;;;;;;AAQA,SAAgB,sBACd,WACA,OACA,gBACwB;CACxB,MAAM,aAAa,wBAAwB,cAAc;CACzD,MAAM,CAAC,OAAO,GAAG,QAAQ;CAEzB,IAAI,UAAU,UAAa,WAAW,WAAW,GAC/C,OAAO,CAAC,GAAG,SAAS;CAGtB,MAAM,WAAoC;EAAE;EAAO,gBAAgB;CAAW;CAE9E,OAAO,CACL;EAAE,GAAG;EAAO,kBAAkB;GAAE,GAAG,MAAM;IAAmB,yBAAyB;EAAS;CAAE,GAChG,GAAG,IACL;AACF;;;;;;;AAQA,SAAgB,oBACd,WACA,OAC0B;CAC1B,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,QAAkC,CAAC;CAEzC,KAAK,MAAM,QAAQ,WAAW;EAC5B,MAAM,SAAS,KAAK,mBAAmB;EAEvC,IAAI,CAAC,iBAAiB,MAAM,KAAK,OAAO,UAAU,OAChD;EAGF,KAAK,MAAM,QAAQ,OAAO,gBAAgB;GACxC,IAAI,MAAM,SAAS,eAAe,KAAK,IAAI,KAAK,EAAE,GAChD;GAGF,KAAK,IAAI,KAAK,EAAE;GAChB,MAAM,KAAK,IAAI;EACjB;CACF;CAEA,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,sBAAsB,MAAsD;CAC1F,OAAO;EACL,MAAM;EACN,IAAI,KAAK;EACT,SAAS,MAAM,QAAQ,KAAK,OAAO,IAAI,KAAK,UAAU,CAAC;EACvD,mBAAmB,KAAK;CAC1B;AACF;AAEA,SAAS,iBAAiB,OAAkD;CAC1E,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;CAGT,MAAM,YAAY;CAElB,OAAO,OAAO,UAAU,UAAU,YAAY,MAAM,QAAQ,UAAU,cAAc;AACtF"}

package/esm/utils/structured-output.mjs

@@ -0,0 +1,84 @@
+//#region ../ai-openai/src/utils/structured-output.ts
+/**
+* Map an explicit `responseFormat` override to the default
+* `structuredOutput` capability. Loose wire modes (`"json_object"`,
+* `"text"`) don't enforce shape, so the agent needs to see the soft
+* schema hint in the system prompt — that only happens when the
+* capability is `false`. Default (no override) stays `true` to
+* preserve the prior assumption that OpenAI models support strict
+* structured output.
+*/
+function inferStructuredOutput(responseFormat) {
+	if (responseFormat === "json_object" || responseFormat === "text") return false;
+	return true;
+}
+/**
+* Decide the structured-output mode for a call.
+*
+* When `override` (the `responseFormat` config) is set, it wins: `"text"`
+* emits nothing, `"json_object"` always picks the loose mode, and
+* `"json_schema"` picks strict mode (with the same strict-compatibility
+* safety check - a malformed schema still degrades to `json_object` rather
+* than 400). The override exists because some targets (older OpenAI models,
+* OpenRouter routes, Ollama OpenAI-compat) reject strict `json_schema`
+* outright.
+*
+* When the override is omitted, strict `json_schema` mode (token-level
+* enforcement) is used only when the schema is a proper root-object JSON
+* Schema whose every object lists all of its properties in `required`. For
+* anything else it falls back to loose `json_object` mode. Client-side
+* Standard Schema `validate()` still enforces the full shape.
+*/
+function planStructuredOutput(responseSchema, override) {
+	if (!responseSchema || override === "text") return { mode: "none" };
+	if (override === "json_object") return { mode: "json_object" };
+	if (isStrictCompatible(responseSchema)) return {
+		mode: "json_schema",
+		schema: responseSchema
+	};
+	return { mode: "json_object" };
+}
+/**
+* OpenAI strict `json_schema` mode requires the root to be a JSON Schema
+* object type (`{ type: "object", properties: ... }`). Anything else
+* (top-level arrays, primitives, unknown shapes) is rejected with a 400
+* before a token is sampled. Checked structurally here so the first call
+* doesn't crash on a malformed extraction.
+*/
+function isStrictCompatible(schema) {
+	return schema.type === "object" && typeof schema.properties === "object" && schema.properties !== null && isStrictSafeNode(schema);
+}
+/**
+* Recursively check the one strict-mode rule schemas most often trip on:
+* every object must list ALL of its `properties` in `required` (OpenAI
+* strict has no notion of optional - optional fields must be expressed as
+* nullable, e.g. `type: ["string", "null"]`, and still appear in
+* `required`). A schema that violates this anywhere in the tree is NOT sent
+* in strict mode, so a hand-built or optional-bearing schema can't 400 the
+* call ("'required' ... must include every key in properties").
+*/
+function isStrictSafeNode(node) {
+	if (!node || typeof node !== "object") return true;
+	const record = node;
+	if (record.type === "object" && record.properties && typeof record.properties === "object") {
+		const properties = record.properties;
+		const keys = Object.keys(properties);
+		const required = Array.isArray(record.required) ? record.required : [];
+		if (keys.some((key) => !required.includes(key))) return false;
+		for (const key of keys) if (!isStrictSafeNode(properties[key])) return false;
+	}
+	if (record.items !== void 0 && !isStrictSafeNode(record.items)) return false;
+	for (const branch of [
+		"anyOf",
+		"allOf",
+		"oneOf"
+	]) {
+		const value = record[branch];
+		if (Array.isArray(value) && value.some((sub) => !isStrictSafeNode(sub))) return false;
+	}
+	return true;
+}
+
+//#endregion
+export { inferStructuredOutput, planStructuredOutput };
+//# sourceMappingURL=structured-output.mjs.map

package/esm/utils/structured-output.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-output.mjs","names":[],"sources":["../../../../../../../ai-openai/src/utils/structured-output.ts"],"sourcesContent":["import type { OpenAIResponseFormat } from \"../config.type\";\n\n/**\n * How a `responseSchema` should reach the wire, decided once for both the\n * Chat Completions adapter (`response_format`) and the Responses adapter\n * (`text.format`). Only the wire location differs between the two.\n */\nexport type StructuredOutputPlan =\n  | { mode: \"none\" }\n  | { mode: \"json_object\" }\n  | { mode: \"json_schema\"; schema: Record<string, unknown> };\n\n/**\n * Map an explicit `responseFormat` override to the default\n * `structuredOutput` capability. Loose wire modes (`\"json_object\"`,\n * `\"text\"`) don't enforce shape, so the agent needs to see the soft\n * schema hint in the system prompt — that only happens when the\n * capability is `false`. Default (no override) stays `true` to\n * preserve the prior assumption that OpenAI models support strict\n * structured output.\n */\nexport function inferStructuredOutput(\n  responseFormat: OpenAIResponseFormat | undefined,\n): boolean {\n  if (responseFormat === \"json_object\" || responseFormat === \"text\") {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Decide the structured-output mode for a call.\n *\n * When `override` (the `responseFormat` config) is set, it wins: `\"text\"`\n * emits nothing, `\"json_object\"` always picks the loose mode, and\n * `\"json_schema\"` picks strict mode (with the same strict-compatibility\n * safety check - a malformed schema still degrades to `json_object` rather\n * than 400). The override exists because some targets (older OpenAI models,\n * OpenRouter routes, Ollama OpenAI-compat) reject strict `json_schema`\n * outright.\n *\n * When the override is omitted, strict `json_schema` mode (token-level\n * enforcement) is used only when the schema is a proper root-object JSON\n * Schema whose every object lists all of its properties in `required`. For\n * anything else it falls back to loose `json_object` mode. Client-side\n * Standard Schema `validate()` still enforces the full shape.\n */\nexport function planStructuredOutput(\n  responseSchema: Record<string, unknown> | undefined,\n  override: OpenAIResponseFormat | undefined,\n): StructuredOutputPlan {\n  if (!responseSchema || override === \"text\") {\n    return { mode: \"none\" };\n  }\n\n  if (override === \"json_object\") {\n    return { mode: \"json_object\" };\n  }\n\n  // Either auto-select (no override) or explicit `\"json_schema\"`. The\n  // strict-compat check still applies in the explicit case - a malformed or\n  // non-object schema would 400 before sampling, so degrade to `json_object`.\n  if (isStrictCompatible(responseSchema)) {\n    return { mode: \"json_schema\", schema: responseSchema };\n  }\n\n  return { mode: \"json_object\" };\n}\n\n/**\n * OpenAI strict `json_schema` mode requires the root to be a JSON Schema\n * object type (`{ type: \"object\", properties: ... }`). Anything else\n * (top-level arrays, primitives, unknown shapes) is rejected with a 400\n * before a token is sampled. Checked structurally here so the first call\n * doesn't crash on a malformed extraction.\n */\nexport function isStrictCompatible(schema: Record<string, unknown>): boolean {\n  return (\n    schema.type === \"object\" &&\n    typeof schema.properties === \"object\" &&\n    schema.properties !== null &&\n    isStrictSafeNode(schema)\n  );\n}\n\n/**\n * Recursively check the one strict-mode rule schemas most often trip on:\n * every object must list ALL of its `properties` in `required` (OpenAI\n * strict has no notion of optional - optional fields must be expressed as\n * nullable, e.g. `type: [\"string\", \"null\"]`, and still appear in\n * `required`). A schema that violates this anywhere in the tree is NOT sent\n * in strict mode, so a hand-built or optional-bearing schema can't 400 the\n * call (\"'required' ... must include every key in properties\").\n */\nfunction isStrictSafeNode(node: unknown): boolean {\n  if (!node || typeof node !== \"object\") {\n    return true;\n  }\n\n  const record = node as Record<string, unknown>;\n\n  if (record.type === \"object\" && record.properties && typeof record.properties === \"object\") {\n    const properties = record.properties as Record<string, unknown>;\n    const keys = Object.keys(properties);\n    const required = Array.isArray(record.required) ? (record.required as unknown[]) : [];\n\n    if (keys.some((key) => !required.includes(key))) {\n      return false;\n    }\n\n    for (const key of keys) {\n      if (!isStrictSafeNode(properties[key])) {\n        return false;\n      }\n    }\n  }\n\n  if (record.items !== undefined && !isStrictSafeNode(record.items)) {\n    return false;\n  }\n\n  for (const branch of [\"anyOf\", \"allOf\", \"oneOf\"] as const) {\n    const value = record[branch];\n\n    if (Array.isArray(value) && value.some((sub) => !isStrictSafeNode(sub))) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":";;;;;;;;;;AAqBA,SAAgB,sBACd,gBACS;CACT,IAAI,mBAAmB,iBAAiB,mBAAmB,QACzD,OAAO;CAGT,OAAO;AACT;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,qBACd,gBACA,UACsB;CACtB,IAAI,CAAC,kBAAkB,aAAa,QAClC,OAAO,EAAE,MAAM,OAAO;CAGxB,IAAI,aAAa,eACf,OAAO,EAAE,MAAM,cAAc;CAM/B,IAAI,mBAAmB,cAAc,GACnC,OAAO;EAAE,MAAM;EAAe,QAAQ;CAAe;CAGvD,OAAO,EAAE,MAAM,cAAc;AAC/B;;;;;;;;AASA,SAAgB,mBAAmB,QAA0C;CAC3E,OACE,OAAO,SAAS,YAChB,OAAO,OAAO,eAAe,YAC7B,OAAO,eAAe,QACtB,iBAAiB,MAAM;AAE3B;;;;;;;;;;AAWA,SAAS,iBAAiB,MAAwB;CAChD,IAAI,CAAC,QAAQ,OAAO,SAAS,UAC3B,OAAO;CAGT,MAAM,SAAS;CAEf,IAAI,OAAO,SAAS,YAAY,OAAO,cAAc,OAAO,OAAO,eAAe,UAAU;EAC1F,MAAM,aAAa,OAAO;EAC1B,MAAM,OAAO,OAAO,KAAK,UAAU;EACnC,MAAM,WAAW,MAAM,QAAQ,OAAO,QAAQ,IAAK,OAAO,WAAyB,CAAC;EAEpF,IAAI,KAAK,MAAM,QAAQ,CAAC,SAAS,SAAS,GAAG,CAAC,GAC5C,OAAO;EAGT,KAAK,MAAM,OAAO,MAChB,IAAI,CAAC,iBAAiB,WAAW,IAAI,GACnC,OAAO;CAGb;CAEA,IAAI,OAAO,UAAU,UAAa,CAAC,iBAAiB,OAAO,KAAK,GAC9D,OAAO;CAGT,KAAK,MAAM,UAAU;EAAC;EAAS;EAAS;CAAO,GAAY;EACzD,MAAM,QAAQ,OAAO;EAErB,IAAI,MAAM,QAAQ,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC,iBAAiB,GAAG,CAAC,GACpE,OAAO;CAEX;CAEA,OAAO;AACT"}

package/esm/utils/to-openai-messages.mjs

@@ -127,7 +127,7 @@ function toOpenAIContentPart(part) {
 	};
 	if (part.type === "image") return {
 		type: "image_url",
-		image_url: { url: "url" in part.source ? part.source.url : `data:${part.source.mediaType};base64,${part.source.base64}` }
+		image_url: { url: toImageUrl(part.source) }
 	};
 	if (part.type === "pdf") {
 		if ("url" in part.source) throw new InvalidRequestError("OpenAI chat completions cannot fetch a remote-URL PDF; supply base64 document bytes instead.");
@@ -149,6 +149,13 @@ function toOpenAIContentPart(part) {
 	};
 }
 /**
+* Render an image source as a URL: a remote URL passes through, inlined
+* base64 bytes become a `data:` URL. Shared with the Responses adapter.
+*/
+function toImageUrl(source) {
+	return "url" in source ? source.url : `data:${source.mediaType};base64,${source.base64}`;
+}
+/**
 * Narrow a neutral audio media type to the two formats OpenAI's
 * `input_audio` accepts (`wav` / `mp3`). An unsupported type raises a
 * typed `InvalidRequestError` up front rather than a provider 400.
@@ -160,5 +167,5 @@ function toOpenAIAudioFormat(mediaType) {
 }
 
 //#endregion
-export { toOpenAIMessages };
+export { stringifyContent, toImageUrl, toOpenAIMessages };
 //# sourceMappingURL=to-openai-messages.mjs.map

package/esm/utils/to-openai-messages.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"to-openai-messages.mjs","names":[],"sources":["../../../../../../../ai-openai/src/utils/to-openai-messages.ts"],"sourcesContent":["import { InvalidRequestError, type ContentPart, type Message } from \"@warlock.js/ai\";\nimport type OpenAI from \"openai\";\n\n/**\n * Convert vendor-neutral Message[] to OpenAI's chat message shape.\n * Handles the `tool` role (requires `tool_call_id`) and assistant messages\n * that carry `toolCalls` from a prior model response.\n *\n * Multipart `content` (a `ContentPart[]`) is mapped into OpenAI's user-message\n * content-parts shape: text becomes `{ type: \"text\", text }`, images become\n * `{ type: \"image_url\", image_url: { url } }` — with base64 sources rendered\n * as `data:` URLs inline.\n *\n * @example\n * const openaiMessages = toOpenAIMessages([\n *   { role: \"user\", content: \"Hi\" },\n *   { role: \"tool\", toolCallId: \"call_1\", content: '{\"ok\":true}' },\n * ]);\n *\n * @example\n * toOpenAIMessages([\n *   { role: \"user\", content: [\n *     { type: \"text\", text: \"What is this?\" },\n *     { type: \"image\", source: { url: \"https://example.com/cat.jpg\" } },\n *   ]},\n * ]);\n */\nexport function toOpenAIMessages(\n  messages: Message[],\n  cacheBreakpoints: number = 0,\n): OpenAI.Chat.Completions.ChatCompletionMessageParam[] {\n  const mapped = messages.map((m) => {\n    if (m.role === \"tool\") {\n      return {\n        role: \"tool\",\n        content: stringifyContent(m.content),\n        tool_call_id: m.toolCallId ?? \"\",\n      } satisfies OpenAI.Chat.Completions.ChatCompletionToolMessageParam;\n    }\n    if (m.role === \"assistant\" && m.toolCalls && m.toolCalls.length > 0) {\n      return {\n        role: \"assistant\",\n        content: stringifyContent(m.content),\n        tool_calls: m.toolCalls.map((tc) => ({\n          id: tc.id,\n          type: \"function\" as const,\n          function: { name: tc.name, arguments: JSON.stringify(tc.input ?? {}) },\n        })),\n      } satisfies OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam;\n    }\n\n    if (m.role === \"user\" && Array.isArray(m.content)) {\n      return {\n        role: \"user\",\n        content: m.content.map(toOpenAIContentPart),\n      } satisfies OpenAI.Chat.Completions.ChatCompletionUserMessageParam;\n    }\n\n    return { role: m.role, content: stringifyContent(m.content) } as\n      | OpenAI.Chat.Completions.ChatCompletionUserMessageParam\n      | OpenAI.Chat.Completions.ChatCompletionSystemMessageParam\n      | OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam;\n  });\n\n  return addPromptCacheBreakpoints(mapped, cacheBreakpoints);\n}\n\n/** Place explicit markers on the last requested user-content parts (maximum four). */\nfunction addPromptCacheBreakpoints(\n  messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],\n  requested: number,\n): OpenAI.Chat.Completions.ChatCompletionMessageParam[] {\n  let remaining = Math.min(4, Math.max(0, Math.floor(requested)));\n  if (remaining === 0) return messages;\n\n  const marked = [...messages];\n  for (let index = marked.length - 1; index >= 0 && remaining > 0; index--) {\n    const message = marked[index];\n    if (message === undefined || message.role !== \"user\") continue;\n\n    if (typeof message.content === \"string\") {\n      marked[index] = {\n        ...message,\n        content: [\n          { type: \"text\", text: message.content, prompt_cache_breakpoint: { mode: \"explicit\" } },\n        ],\n      };\n      remaining--;\n      continue;\n    }\n\n    const content = [...message.content];\n    for (let partIndex = content.length - 1; partIndex >= 0 && remaining > 0; partIndex--) {\n      const part = content[partIndex];\n      if (part === undefined) continue;\n      content[partIndex] = { ...part, prompt_cache_breakpoint: { mode: \"explicit\" } };\n      remaining--;\n    }\n    marked[index] = { ...message, content };\n  }\n\n  return marked;\n}\n\n/**\n * Multipart content is only meaningful on user messages — for any other\n * role (system / assistant text / tool), collapse a `ContentPart[]` to\n * its concatenated text so OpenAI's wire format stays valid. Plain\n * strings pass through unchanged.\n */\nfunction stringifyContent(content: string | ContentPart[]): string {\n  if (typeof content === \"string\") {\n    return content;\n  }\n\n  return content\n    .filter((part): part is { type: \"text\"; text: string } => part.type === \"text\")\n    .map((part) => part.text)\n    .join(\"\");\n}\n\n/**\n * Map a resolved `ContentPart` to an OpenAI chat content part — one\n * branch per modality, each to its real wire shape:\n *\n * - `text` → `{ type: \"text\" }`.\n * - `image` → `{ type: \"image_url\" }` (remote URL, or a `data:` URL for\n *   inlined base64 bytes).\n * - `pdf` → `{ type: \"file\", file: { file_data } }` (OpenAI document\n *   input; base64 only — there is no remote-URL file source).\n * - `audio` → `{ type: \"input_audio\", input_audio: { data, format } }`\n *   (base64 only; `wav` / `mp3` are the only formats OpenAI accepts).\n *\n * PDF and audio reach this point ONLY when the model declared the\n * matching capability (`openai.model({ name, pdf: true })` /\n * `{ audio: true }`) — the agent's modality gate throws upfront\n * otherwise, so capability and behavior stay in lockstep. A remote-URL\n * pdf/audio source raises a typed `InvalidRequestError` here rather\n * than a downstream provider fault.\n */\nfunction toOpenAIContentPart(part: ContentPart): OpenAI.Chat.Completions.ChatCompletionContentPart {\n  if (part.type === \"text\") {\n    return { type: \"text\", text: part.text };\n  }\n\n  if (part.type === \"image\") {\n    const url =\n      \"url\" in part.source\n        ? part.source.url\n        : `data:${part.source.mediaType};base64,${part.source.base64}`;\n\n    return { type: \"image_url\", image_url: { url } };\n  }\n\n  if (part.type === \"pdf\") {\n    if (\"url\" in part.source) {\n      throw new InvalidRequestError(\n        \"OpenAI chat completions cannot fetch a remote-URL PDF; supply base64 document bytes instead.\",\n      );\n    }\n\n    return {\n      type: \"file\",\n      file: {\n        filename: \"document.pdf\",\n        file_data: `data:${part.source.mediaType};base64,${part.source.base64}`,\n      },\n    };\n  }\n\n  // Audio — the remaining `ContentPart` variant.\n  if (\"url\" in part.source) {\n    throw new InvalidRequestError(\n      \"OpenAI chat completions cannot fetch remote-URL audio; supply base64 audio bytes instead.\",\n    );\n  }\n\n  return {\n    type: \"input_audio\",\n    input_audio: {\n      data: part.source.base64,\n      format: toOpenAIAudioFormat(part.source.mediaType),\n    },\n  };\n}\n\n/**\n * Narrow a neutral audio media type to the two formats OpenAI's\n * `input_audio` accepts (`wav` / `mp3`). An unsupported type raises a\n * typed `InvalidRequestError` up front rather than a provider 400.\n */\nfunction toOpenAIAudioFormat(mediaType: string): \"wav\" | \"mp3\" {\n  if (mediaType === \"audio/wav\" || mediaType === \"audio/x-wav\" || mediaType === \"audio/wave\") {\n    return \"wav\";\n  }\n\n  if (mediaType === \"audio/mp3\" || mediaType === \"audio/mpeg\" || mediaType === \"audio/mpga\") {\n    return \"mp3\";\n  }\n\n  throw new InvalidRequestError(\n    `OpenAI input_audio supports only \"wav\" and \"mp3\"; got \"${mediaType}\".`,\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"to-openai-messages.mjs","names":[],"sources":["../../../../../../../ai-openai/src/utils/to-openai-messages.ts"],"sourcesContent":["import { InvalidRequestError, type ContentPart, type Message } from \"@warlock.js/ai\";\nimport type OpenAI from \"openai\";\n\n/**\n * Convert vendor-neutral Message[] to OpenAI's chat message shape.\n * Handles the `tool` role (requires `tool_call_id`) and assistant messages\n * that carry `toolCalls` from a prior model response.\n *\n * Multipart `content` (a `ContentPart[]`) is mapped into OpenAI's user-message\n * content-parts shape: text becomes `{ type: \"text\", text }`, images become\n * `{ type: \"image_url\", image_url: { url } }` — with base64 sources rendered\n * as `data:` URLs inline.\n *\n * @example\n * const openaiMessages = toOpenAIMessages([\n *   { role: \"user\", content: \"Hi\" },\n *   { role: \"tool\", toolCallId: \"call_1\", content: '{\"ok\":true}' },\n * ]);\n *\n * @example\n * toOpenAIMessages([\n *   { role: \"user\", content: [\n *     { type: \"text\", text: \"What is this?\" },\n *     { type: \"image\", source: { url: \"https://example.com/cat.jpg\" } },\n *   ]},\n * ]);\n */\nexport function toOpenAIMessages(\n  messages: Message[],\n  cacheBreakpoints: number = 0,\n): OpenAI.Chat.Completions.ChatCompletionMessageParam[] {\n  const mapped = messages.map((m) => {\n    if (m.role === \"tool\") {\n      return {\n        role: \"tool\",\n        content: stringifyContent(m.content),\n        tool_call_id: m.toolCallId ?? \"\",\n      } satisfies OpenAI.Chat.Completions.ChatCompletionToolMessageParam;\n    }\n    if (m.role === \"assistant\" && m.toolCalls && m.toolCalls.length > 0) {\n      return {\n        role: \"assistant\",\n        content: stringifyContent(m.content),\n        tool_calls: m.toolCalls.map((tc) => ({\n          id: tc.id,\n          type: \"function\" as const,\n          function: { name: tc.name, arguments: JSON.stringify(tc.input ?? {}) },\n        })),\n      } satisfies OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam;\n    }\n\n    if (m.role === \"user\" && Array.isArray(m.content)) {\n      return {\n        role: \"user\",\n        content: m.content.map(toOpenAIContentPart),\n      } satisfies OpenAI.Chat.Completions.ChatCompletionUserMessageParam;\n    }\n\n    return { role: m.role, content: stringifyContent(m.content) } as\n      | OpenAI.Chat.Completions.ChatCompletionUserMessageParam\n      | OpenAI.Chat.Completions.ChatCompletionSystemMessageParam\n      | OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam;\n  });\n\n  return addPromptCacheBreakpoints(mapped, cacheBreakpoints);\n}\n\n/** Place explicit markers on the last requested user-content parts (maximum four). */\nfunction addPromptCacheBreakpoints(\n  messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],\n  requested: number,\n): OpenAI.Chat.Completions.ChatCompletionMessageParam[] {\n  let remaining = Math.min(4, Math.max(0, Math.floor(requested)));\n  if (remaining === 0) return messages;\n\n  const marked = [...messages];\n  for (let index = marked.length - 1; index >= 0 && remaining > 0; index--) {\n    const message = marked[index];\n    if (message === undefined || message.role !== \"user\") continue;\n\n    if (typeof message.content === \"string\") {\n      marked[index] = {\n        ...message,\n        content: [\n          { type: \"text\", text: message.content, prompt_cache_breakpoint: { mode: \"explicit\" } },\n        ],\n      };\n      remaining--;\n      continue;\n    }\n\n    const content = [...message.content];\n    for (let partIndex = content.length - 1; partIndex >= 0 && remaining > 0; partIndex--) {\n      const part = content[partIndex];\n      if (part === undefined) continue;\n      content[partIndex] = { ...part, prompt_cache_breakpoint: { mode: \"explicit\" } };\n      remaining--;\n    }\n    marked[index] = { ...message, content };\n  }\n\n  return marked;\n}\n\n/**\n * Multipart content is only meaningful on user messages — for any other\n * role (system / assistant text / tool), collapse a `ContentPart[]` to\n * its concatenated text so OpenAI's wire format stays valid. Plain\n * strings pass through unchanged.\n */\nexport function stringifyContent(content: string | ContentPart[]): string {\n  if (typeof content === \"string\") {\n    return content;\n  }\n\n  return content\n    .filter((part): part is { type: \"text\"; text: string } => part.type === \"text\")\n    .map((part) => part.text)\n    .join(\"\");\n}\n\n/**\n * Map a resolved `ContentPart` to an OpenAI chat content part — one\n * branch per modality, each to its real wire shape:\n *\n * - `text` → `{ type: \"text\" }`.\n * - `image` → `{ type: \"image_url\" }` (remote URL, or a `data:` URL for\n *   inlined base64 bytes).\n * - `pdf` → `{ type: \"file\", file: { file_data } }` (OpenAI document\n *   input; base64 only — there is no remote-URL file source).\n * - `audio` → `{ type: \"input_audio\", input_audio: { data, format } }`\n *   (base64 only; `wav` / `mp3` are the only formats OpenAI accepts).\n *\n * PDF and audio reach this point ONLY when the model declared the\n * matching capability (`openai.model({ name, pdf: true })` /\n * `{ audio: true }`) — the agent's modality gate throws upfront\n * otherwise, so capability and behavior stay in lockstep. A remote-URL\n * pdf/audio source raises a typed `InvalidRequestError` here rather\n * than a downstream provider fault.\n */\nfunction toOpenAIContentPart(part: ContentPart): OpenAI.Chat.Completions.ChatCompletionContentPart {\n  if (part.type === \"text\") {\n    return { type: \"text\", text: part.text };\n  }\n\n  if (part.type === \"image\") {\n    return { type: \"image_url\", image_url: { url: toImageUrl(part.source) } };\n  }\n\n  if (part.type === \"pdf\") {\n    if (\"url\" in part.source) {\n      throw new InvalidRequestError(\n        \"OpenAI chat completions cannot fetch a remote-URL PDF; supply base64 document bytes instead.\",\n      );\n    }\n\n    return {\n      type: \"file\",\n      file: {\n        filename: \"document.pdf\",\n        file_data: `data:${part.source.mediaType};base64,${part.source.base64}`,\n      },\n    };\n  }\n\n  // Audio — the remaining `ContentPart` variant.\n  if (\"url\" in part.source) {\n    throw new InvalidRequestError(\n      \"OpenAI chat completions cannot fetch remote-URL audio; supply base64 audio bytes instead.\",\n    );\n  }\n\n  return {\n    type: \"input_audio\",\n    input_audio: {\n      data: part.source.base64,\n      format: toOpenAIAudioFormat(part.source.mediaType),\n    },\n  };\n}\n\n/**\n * Render an image source as a URL: a remote URL passes through, inlined\n * base64 bytes become a `data:` URL. Shared with the Responses adapter.\n */\nexport function toImageUrl(\n  source: Extract<ContentPart, { type: \"image\" }>[\"source\"],\n): string {\n  return \"url\" in source ? source.url : `data:${source.mediaType};base64,${source.base64}`;\n}\n\n/**\n * Narrow a neutral audio media type to the two formats OpenAI's\n * `input_audio` accepts (`wav` / `mp3`). An unsupported type raises a\n * typed `InvalidRequestError` up front rather than a provider 400.\n */\nfunction toOpenAIAudioFormat(mediaType: string): \"wav\" | \"mp3\" {\n  if (mediaType === \"audio/wav\" || mediaType === \"audio/x-wav\" || mediaType === \"audio/wave\") {\n    return \"wav\";\n  }\n\n  if (mediaType === \"audio/mp3\" || mediaType === \"audio/mpeg\" || mediaType === \"audio/mpga\") {\n    return \"mp3\";\n  }\n\n  throw new InvalidRequestError(\n    `OpenAI input_audio supports only \"wav\" and \"mp3\"; got \"${mediaType}\".`,\n  );\n}\n"],"mappings":"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"}

package/esm/utils/to-openai-tools.mjs

@@ -17,7 +17,7 @@ function toOpenAITools(tools) {
 		function: {
 			name: tool.name,
 			description: tool.description,
-			parameters: toParameters(tool.input)
+			parameters: toToolParameters(tool.input)
 		}
 	}));
 }
@@ -27,7 +27,7 @@ function toOpenAITools(tools) {
 * failed extraction) degrades to an empty-object schema so the tool
 * still registers and the model simply sees no parameters.
 */
-function toParameters(input) {
+function toToolParameters(input) {
 	const schema = extractJsonSchema(input);
 	if (schema && schema.type === "object") return schema;
 	return {
@@ -37,5 +37,5 @@ function toParameters(input) {
 }
 
 //#endregion
-export { toOpenAITools };
+export { toOpenAITools, toToolParameters };
 //# sourceMappingURL=to-openai-tools.mjs.map

package/esm/utils/to-openai-tools.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"to-openai-tools.mjs","names":[],"sources":["../../../../../../../ai-openai/src/utils/to-openai-tools.ts"],"sourcesContent":["import { extractJsonSchema, type ToolConfig } from \"@warlock.js/ai\";\nimport type OpenAI from \"openai\";\n\n/**\n * Convert vendor-neutral ToolConfig[] to OpenAI's tools array.\n * Uses the shared `extractJsonSchema` helper; falls back to an empty-object\n * schema when extraction fails so the tool still registers with the provider.\n *\n * @example\n * const tools = toOpenAITools([weatherTool, calculatorTool]);\n * await client.chat.completions.create({ model, messages, tools });\n */\nexport function toOpenAITools(\n  tools: ToolConfig<unknown, unknown>[] | undefined,\n): OpenAI.Chat.Completions.ChatCompletionTool[] | undefined {\n  if (!tools || tools.length === 0) {\n    return undefined;\n  }\n\n  return tools.map((tool) => ({\n    type: \"function\",\n    function: {\n      name: tool.name,\n      description: tool.description,\n      parameters: toParameters(tool.input),\n    },\n  }));\n}\n\n/**\n * Resolve a tool's input schema to a JSON-Schema object. OpenAI's\n * function `parameters` expects an object root; anything else (or a\n * failed extraction) degrades to an empty-object schema so the tool\n * still registers and the model simply sees no parameters.\n */\nfunction toParameters(input: ToolConfig<unknown, unknown>[\"input\"]): Record<string, unknown> {\n  const schema = extractJsonSchema(input);\n\n  if (schema && schema.type === \"object\") {\n    return schema;\n  }\n\n  return { type: \"object\", properties: {} };\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,cACd,OAC0D;CAC1D,IAAI,CAAC,SAAS,MAAM,WAAW,GAC7B;CAGF,OAAO,MAAM,KAAK,UAAU;EAC1B,MAAM;EACN,UAAU;GACR,MAAM,KAAK;GACX,aAAa,KAAK;GAClB,YAAY,aAAa,KAAK,KAAK;EACrC;CACF,EAAE;AACJ;;;;;;;AAQA,SAAS,aAAa,OAAuE;CAC3F,MAAM,SAAS,kBAAkB,KAAK;CAEtC,IAAI,UAAU,OAAO,SAAS,UAC5B,OAAO;CAGT,OAAO;EAAE,MAAM;EAAU,YAAY,CAAC;CAAE;AAC1C"}
+{"version":3,"file":"to-openai-tools.mjs","names":[],"sources":["../../../../../../../ai-openai/src/utils/to-openai-tools.ts"],"sourcesContent":["import { extractJsonSchema, type ToolConfig } from \"@warlock.js/ai\";\nimport type OpenAI from \"openai\";\n\n/**\n * Convert vendor-neutral ToolConfig[] to OpenAI's tools array.\n * Uses the shared `extractJsonSchema` helper; falls back to an empty-object\n * schema when extraction fails so the tool still registers with the provider.\n *\n * @example\n * const tools = toOpenAITools([weatherTool, calculatorTool]);\n * await client.chat.completions.create({ model, messages, tools });\n */\nexport function toOpenAITools(\n  tools: ToolConfig<unknown, unknown>[] | undefined,\n): OpenAI.Chat.Completions.ChatCompletionTool[] | undefined {\n  if (!tools || tools.length === 0) {\n    return undefined;\n  }\n\n  return tools.map((tool) => ({\n    type: \"function\",\n    function: {\n      name: tool.name,\n      description: tool.description,\n      parameters: toToolParameters(tool.input),\n    },\n  }));\n}\n\n/**\n * Resolve a tool's input schema to a JSON-Schema object. OpenAI's\n * function `parameters` expects an object root; anything else (or a\n * failed extraction) degrades to an empty-object schema so the tool\n * still registers and the model simply sees no parameters.\n */\nexport function toToolParameters(input: ToolConfig<unknown, unknown>[\"input\"]): Record<string, unknown> {\n  const schema = extractJsonSchema(input);\n\n  if (schema && schema.type === \"object\") {\n    return schema;\n  }\n\n  return { type: \"object\", properties: {} };\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,cACd,OAC0D;CAC1D,IAAI,CAAC,SAAS,MAAM,WAAW,GAC7B;CAGF,OAAO,MAAM,KAAK,UAAU;EAC1B,MAAM;EACN,UAAU;GACR,MAAM,KAAK;GACX,aAAa,KAAK;GAClB,YAAY,iBAAiB,KAAK,KAAK;EACzC;CACF,EAAE;AACJ;;;;;;;AAQA,SAAgB,iBAAiB,OAAuE;CACtG,MAAM,SAAS,kBAAkB,KAAK;CAEtC,IAAI,UAAU,OAAO,SAAS,UAC5B,OAAO;CAGT,OAAO;EAAE,MAAM;EAAU,YAAY,CAAC;CAAE;AAC1C"}

package/esm/utils/to-responses-input.mjs

@@ -0,0 +1,112 @@
+import { readReasoningReplay, toReplayReasoningItem } from "./reasoning-replay.mjs";
+import { stringifyContent, toImageUrl } from "./to-openai-messages.mjs";
+import { InvalidRequestError } from "@warlock.js/ai";
+
+//#region ../ai-openai/src/utils/to-responses-input.ts
+/**
+* Convert vendor-neutral `Message[]` into the Responses request pieces.
+*
+* - The FIRST system message becomes `instructions` (decision 9: it avoids
+*   the `system` vs `developer` role question on reasoning models). Any
+*   later system message stays inline as a `system` role item.
+* - `user` / `assistant` text becomes an `EasyInputMessage` (`{ role,
+*   content }`). Multipart user content becomes `input_text` / `input_image`
+*   parts; images always carry `detail: "auto"` because `ResponseInputImage.detail`
+*   is required by the SDK types.
+* - An assistant message that requested tools becomes its text (when
+*   non-empty) followed by one top-level `function_call` item per call; our
+*   `ModelToolCallRequest.id` is the wire `call_id`. No item `id` is sent:
+*   with `store: false` nothing was persisted for it to refer to.
+* - When `model` is given, reasoning items stored on the turn's tool calls
+*   (`providerMetadata.openaiResponses`, see `reasoning-replay.ts`) are
+*   emitted BEFORE the turn's text and `function_call` items (the order the
+*   API produced them), only if they were produced by that same model.
+*   Without `model` nothing is replayed.
+* - A `tool` message becomes a top-level `function_call_output` item.
+*
+* PDF and audio parts are rejected with a typed `InvalidRequestError`: the
+* Responses adapter declares those capabilities off, so they only arrive
+* here if a caller bypasses the agent's capability gate.
+*
+* @example
+* toResponsesInput([
+*   { role: "system", content: "Be brief." },
+*   { role: "user", content: "Hi" },
+* ]);
+* // { instructions: "Be brief.", input: [{ role: "user", content: "Hi" }] }
+*/
+function toResponsesInput(messages, model) {
+	const input = [];
+	let instructions;
+	let instructionsTaken = false;
+	for (const message of messages) {
+		if (message.role === "system") {
+			const text = stringifyContent(message.content);
+			if (!instructionsTaken) {
+				instructionsTaken = true;
+				instructions = text === "" ? void 0 : text;
+				continue;
+			}
+			input.push({
+				role: "system",
+				content: text
+			});
+			continue;
+		}
+		if (message.role === "tool") {
+			input.push({
+				type: "function_call_output",
+				call_id: message.toolCallId ?? "",
+				output: stringifyContent(message.content)
+			});
+			continue;
+		}
+		if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+			const text = stringifyContent(message.content);
+			if (model !== void 0) for (const item of readReasoningReplay(message.toolCalls, model)) input.push(toReplayReasoningItem(item));
+			if (text !== "") input.push({
+				role: "assistant",
+				content: text
+			});
+			for (const call of message.toolCalls) input.push({
+				type: "function_call",
+				call_id: call.id,
+				name: call.name,
+				arguments: JSON.stringify(call.input ?? {})
+			});
+			continue;
+		}
+		if (message.role === "user" && Array.isArray(message.content)) {
+			input.push({
+				role: "user",
+				content: message.content.map(toResponsesContentPart)
+			});
+			continue;
+		}
+		input.push({
+			role: message.role,
+			content: stringifyContent(message.content)
+		});
+	}
+	return {
+		...instructions !== void 0 ? { instructions } : {},
+		input
+	};
+}
+/** Map a resolved `ContentPart` to a Responses input content part (text and images only). */
+function toResponsesContentPart(part) {
+	if (part.type === "text") return {
+		type: "input_text",
+		text: part.text
+	};
+	if (part.type === "image") return {
+		type: "input_image",
+		image_url: toImageUrl(part.source),
+		detail: "auto"
+	};
+	throw new InvalidRequestError(`OpenAI api: "responses" does not accept ${part.type} input in this adapter; use api: "chat" for ${part.type} attachments.`);
+}
+
+//#endregion
+export { toResponsesInput };
+//# sourceMappingURL=to-responses-input.mjs.map

package/esm/utils/to-responses-input.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-responses-input.mjs","names":[],"sources":["../../../../../../../ai-openai/src/utils/to-responses-input.ts"],"sourcesContent":["import { InvalidRequestError, type ContentPart, type Message } from \"@warlock.js/ai\";\nimport type OpenAI from \"openai\";\nimport { stringifyContent, toImageUrl } from \"./to-openai-messages\";\nimport { readReasoningReplay, toReplayReasoningItem } from \"./reasoning-replay\";\n\n/** One item of the Responses `input` array. */\nexport type ResponsesInputItem = OpenAI.Responses.ResponseInputItem;\n\n/** What `toResponsesInput` produces: the `instructions` string plus the `input` items. */\nexport type ResponsesInputPlan = {\n  /** The system prompt, sent as the top-level `instructions` field. */\n  instructions?: string;\n  input: ResponsesInputItem[];\n};\n\n/**\n * Convert vendor-neutral `Message[]` into the Responses request pieces.\n *\n * - The FIRST system message becomes `instructions` (decision 9: it avoids\n *   the `system` vs `developer` role question on reasoning models). Any\n *   later system message stays inline as a `system` role item.\n * - `user` / `assistant` text becomes an `EasyInputMessage` (`{ role,\n *   content }`). Multipart user content becomes `input_text` / `input_image`\n *   parts; images always carry `detail: \"auto\"` because `ResponseInputImage.detail`\n *   is required by the SDK types.\n * - An assistant message that requested tools becomes its text (when\n *   non-empty) followed by one top-level `function_call` item per call; our\n *   `ModelToolCallRequest.id` is the wire `call_id`. No item `id` is sent:\n *   with `store: false` nothing was persisted for it to refer to.\n * - When `model` is given, reasoning items stored on the turn's tool calls\n *   (`providerMetadata.openaiResponses`, see `reasoning-replay.ts`) are\n *   emitted BEFORE the turn's text and `function_call` items (the order the\n *   API produced them), only if they were produced by that same model.\n *   Without `model` nothing is replayed.\n * - A `tool` message becomes a top-level `function_call_output` item.\n *\n * PDF and audio parts are rejected with a typed `InvalidRequestError`: the\n * Responses adapter declares those capabilities off, so they only arrive\n * here if a caller bypasses the agent's capability gate.\n *\n * @example\n * toResponsesInput([\n *   { role: \"system\", content: \"Be brief.\" },\n *   { role: \"user\", content: \"Hi\" },\n * ]);\n * // { instructions: \"Be brief.\", input: [{ role: \"user\", content: \"Hi\" }] }\n */\nexport function toResponsesInput(messages: Message[], model?: string): ResponsesInputPlan {\n  const input: ResponsesInputItem[] = [];\n  let instructions: string | undefined;\n  let instructionsTaken = false;\n\n  for (const message of messages) {\n    if (message.role === \"system\") {\n      const text = stringifyContent(message.content);\n\n      if (!instructionsTaken) {\n        instructionsTaken = true;\n        instructions = text === \"\" ? undefined : text;\n        continue;\n      }\n\n      input.push({ role: \"system\", content: text });\n      continue;\n    }\n\n    if (message.role === \"tool\") {\n      input.push({\n        type: \"function_call_output\",\n        call_id: message.toolCallId ?? \"\",\n        output: stringifyContent(message.content),\n      });\n      continue;\n    }\n\n    if (message.role === \"assistant\" && message.toolCalls && message.toolCalls.length > 0) {\n      const text = stringifyContent(message.content);\n\n      if (model !== undefined) {\n        for (const item of readReasoningReplay(message.toolCalls, model)) {\n          input.push(toReplayReasoningItem(item));\n        }\n      }\n\n      if (text !== \"\") {\n        input.push({ role: \"assistant\", content: text });\n      }\n\n      for (const call of message.toolCalls) {\n        input.push({\n          type: \"function_call\",\n          call_id: call.id,\n          name: call.name,\n          arguments: JSON.stringify(call.input ?? {}),\n        });\n      }\n\n      continue;\n    }\n\n    if (message.role === \"user\" && Array.isArray(message.content)) {\n      input.push({ role: \"user\", content: message.content.map(toResponsesContentPart) });\n      continue;\n    }\n\n    input.push({ role: message.role, content: stringifyContent(message.content) });\n  }\n\n  return { ...(instructions !== undefined ? { instructions } : {}), input };\n}\n\n/** Map a resolved `ContentPart` to a Responses input content part (text and images only). */\nfunction toResponsesContentPart(\n  part: ContentPart,\n): OpenAI.Responses.ResponseInputText | OpenAI.Responses.ResponseInputImage {\n  if (part.type === \"text\") {\n    return { type: \"input_text\", text: part.text };\n  }\n\n  if (part.type === \"image\") {\n    return { type: \"input_image\", image_url: toImageUrl(part.source), detail: \"auto\" };\n  }\n\n  throw new InvalidRequestError(\n    `OpenAI api: \"responses\" does not accept ${part.type} input in this adapter; use api: \"chat\" for ${part.type} attachments.`,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,iBAAiB,UAAqB,OAAoC;CACxF,MAAM,QAA8B,CAAC;CACrC,IAAI;CACJ,IAAI,oBAAoB;CAExB,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,QAAQ,SAAS,UAAU;GAC7B,MAAM,OAAO,iBAAiB,QAAQ,OAAO;GAE7C,IAAI,CAAC,mBAAmB;IACtB,oBAAoB;IACpB,eAAe,SAAS,KAAK,SAAY;IACzC;GACF;GAEA,MAAM,KAAK;IAAE,MAAM;IAAU,SAAS;GAAK,CAAC;GAC5C;EACF;EAEA,IAAI,QAAQ,SAAS,QAAQ;GAC3B,MAAM,KAAK;IACT,MAAM;IACN,SAAS,QAAQ,cAAc;IAC/B,QAAQ,iBAAiB,QAAQ,OAAO;GAC1C,CAAC;GACD;EACF;EAEA,IAAI,QAAQ,SAAS,eAAe,QAAQ,aAAa,QAAQ,UAAU,SAAS,GAAG;GACrF,MAAM,OAAO,iBAAiB,QAAQ,OAAO;GAE7C,IAAI,UAAU,QACZ,KAAK,MAAM,QAAQ,oBAAoB,QAAQ,WAAW,KAAK,GAC7D,MAAM,KAAK,sBAAsB,IAAI,CAAC;GAI1C,IAAI,SAAS,IACX,MAAM,KAAK;IAAE,MAAM;IAAa,SAAS;GAAK,CAAC;GAGjD,KAAK,MAAM,QAAQ,QAAQ,WACzB,MAAM,KAAK;IACT,MAAM;IACN,SAAS,KAAK;IACd,MAAM,KAAK;IACX,WAAW,KAAK,UAAU,KAAK,SAAS,CAAC,CAAC;GAC5C,CAAC;GAGH;EACF;EAEA,IAAI,QAAQ,SAAS,UAAU,MAAM,QAAQ,QAAQ,OAAO,GAAG;GAC7D,MAAM,KAAK;IAAE,MAAM;IAAQ,SAAS,QAAQ,QAAQ,IAAI,sBAAsB;GAAE,CAAC;GACjF;EACF;EAEA,MAAM,KAAK;GAAE,MAAM,QAAQ;GAAM,SAAS,iBAAiB,QAAQ,OAAO;EAAE,CAAC;CAC/E;CAEA,OAAO;EAAE,GAAI,iBAAiB,SAAY,EAAE,aAAa,IAAI,CAAC;EAAI;CAAM;AAC1E;;AAGA,SAAS,uBACP,MAC0E;CAC1E,IAAI,KAAK,SAAS,QAChB,OAAO;EAAE,MAAM;EAAc,MAAM,KAAK;CAAK;CAG/C,IAAI,KAAK,SAAS,SAChB,OAAO;EAAE,MAAM;EAAe,WAAW,WAAW,KAAK,MAAM;EAAG,QAAQ;CAAO;CAGnF,MAAM,IAAI,oBACR,2CAA2C,KAAK,KAAK,8CAA8C,KAAK,KAAK,cAC/G;AACF"}

package/esm/utils/to-responses-tools.mjs

@@ -0,0 +1,51 @@
+import { toToolParameters } from "./to-openai-tools.mjs";
+
+//#region ../ai-openai/src/utils/to-responses-tools.ts
+/**
+* Convert vendor-neutral `ToolConfig[]` to Responses function tools.
+*
+* Responses tools are FLAT (`name` / `description` / `parameters` sit beside
+* `type`, not under a nested `function` object) and `strict` is required by
+* the SDK type (`FunctionTool.strict: boolean | null`). The Chat path never
+* sets `strict` (non-strict is the OpenAI default there), so every tool is
+* sent with `strict: false` to keep the same behavior.
+*
+* @example
+* toResponsesTools([weatherTool]);
+* // [{ type: "function", name: "getWeather", description: "...", parameters: {...}, strict: false }]
+*/
+function toResponsesTools(tools) {
+	if (!tools || tools.length === 0) return;
+	return tools.map((tool) => ({
+		type: "function",
+		name: tool.name,
+		description: tool.description,
+		parameters: toToolParameters(tool.input),
+		strict: false
+	}));
+}
+/**
+* Read an optional `toolChoice` call option into the Responses `tool_choice`.
+*
+* `ModelCallOptions` does not declare `toolChoice` today (it only arrives
+* through the open index signature), so the value is validated here rather
+* than trusted. Accepted: `"none" | "auto" | "required"`, or a forced
+* function as `{ name }` / `{ type: "function", name }` (the Chat-style
+* nested `{ type: "function", function: { name } }` is also accepted). The
+* Responses form is flat: `{ type: "function", name }`. Anything else yields
+* `undefined`, leaving the provider default.
+*/
+function toResponsesToolChoice(toolChoice) {
+	if (toolChoice === "none" || toolChoice === "auto" || toolChoice === "required") return toolChoice;
+	if (typeof toolChoice !== "object" || toolChoice === null) return;
+	const record = toolChoice;
+	const name = typeof record.name === "string" ? record.name : record.function?.name;
+	if (typeof name === "string" && name !== "") return {
+		type: "function",
+		name
+	};
+}
+
+//#endregion
+export { toResponsesToolChoice, toResponsesTools };
+//# sourceMappingURL=to-responses-tools.mjs.map

package/esm/utils/to-responses-tools.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-responses-tools.mjs","names":[],"sources":["../../../../../../../ai-openai/src/utils/to-responses-tools.ts"],"sourcesContent":["import type { ToolConfig } from \"@warlock.js/ai\";\nimport type OpenAI from \"openai\";\nimport { toToolParameters } from \"./to-openai-tools\";\n\n/**\n * Convert vendor-neutral `ToolConfig[]` to Responses function tools.\n *\n * Responses tools are FLAT (`name` / `description` / `parameters` sit beside\n * `type`, not under a nested `function` object) and `strict` is required by\n * the SDK type (`FunctionTool.strict: boolean | null`). The Chat path never\n * sets `strict` (non-strict is the OpenAI default there), so every tool is\n * sent with `strict: false` to keep the same behavior.\n *\n * @example\n * toResponsesTools([weatherTool]);\n * // [{ type: \"function\", name: \"getWeather\", description: \"...\", parameters: {...}, strict: false }]\n */\nexport function toResponsesTools(\n  tools: ToolConfig<unknown, unknown>[] | undefined,\n): OpenAI.Responses.FunctionTool[] | undefined {\n  if (!tools || tools.length === 0) {\n    return undefined;\n  }\n\n  return tools.map((tool) => ({\n    type: \"function\",\n    name: tool.name,\n    description: tool.description,\n    parameters: toToolParameters(tool.input),\n    strict: false,\n  }));\n}\n\n/**\n * Read an optional `toolChoice` call option into the Responses `tool_choice`.\n *\n * `ModelCallOptions` does not declare `toolChoice` today (it only arrives\n * through the open index signature), so the value is validated here rather\n * than trusted. Accepted: `\"none\" | \"auto\" | \"required\"`, or a forced\n * function as `{ name }` / `{ type: \"function\", name }` (the Chat-style\n * nested `{ type: \"function\", function: { name } }` is also accepted). The\n * Responses form is flat: `{ type: \"function\", name }`. Anything else yields\n * `undefined`, leaving the provider default.\n */\nexport function toResponsesToolChoice(\n  toolChoice: unknown,\n): OpenAI.Responses.ToolChoiceOptions | OpenAI.Responses.ToolChoiceFunction | undefined {\n  if (toolChoice === \"none\" || toolChoice === \"auto\" || toolChoice === \"required\") {\n    return toolChoice;\n  }\n\n  if (typeof toolChoice !== \"object\" || toolChoice === null) {\n    return undefined;\n  }\n\n  const record = toolChoice as { name?: unknown; function?: { name?: unknown } };\n  const name = typeof record.name === \"string\" ? record.name : record.function?.name;\n\n  if (typeof name === \"string\" && name !== \"\") {\n    return { type: \"function\", name };\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,SAAgB,iBACd,OAC6C;CAC7C,IAAI,CAAC,SAAS,MAAM,WAAW,GAC7B;CAGF,OAAO,MAAM,KAAK,UAAU;EAC1B,MAAM;EACN,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,YAAY,iBAAiB,KAAK,KAAK;EACvC,QAAQ;CACV,EAAE;AACJ;;;;;;;;;;;;AAaA,SAAgB,sBACd,YACsF;CACtF,IAAI,eAAe,UAAU,eAAe,UAAU,eAAe,YACnE,OAAO;CAGT,IAAI,OAAO,eAAe,YAAY,eAAe,MACnD;CAGF,MAAM,SAAS;CACf,MAAM,OAAO,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO,OAAO,UAAU;CAE9E,IAAI,OAAO,SAAS,YAAY,SAAS,IACvC,OAAO;EAAE,MAAM;EAAY;CAAK;AAIpC"}

package/llms-full.txt

@@ -8,7 +8,7 @@
 
 ---
 name: setup-openai
-description: 'Wire @warlock.js/ai-openai — new OpenAISDK({apiKey, baseURL?, provider?, pricing?}) for OpenAI / Azure / OpenRouter, .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for ModelContract, .embedder({name, dimensions?}) for embeddings, .image({name, pricing?}) for gpt-image-*/dall-e-* image generation (via ai.image). PDF input maps to OpenAI file parts (opt-in pdf:true), audio input to input_audio (opt-in audio:true). Triggers: `OpenAISDK`, `.model`, `.embedder`, `.image`, `.embed`, `.embedMany`, `baseURL`, `pricing`, `responseSchema`, `responseFormat`, `reasoning_effort`, `reasoningTokens`, `cachedTokens`, `gpt-image`, `dall-e`, `ai.image`, `pdf input`, `input_audio`, o-series / gpt-5 reasoning, prompt caching; "wire openai into a warlock agent", "configure gpt-4o", "use o3 / gpt-5 reasoning effort", "route through openrouter or azure openai", "openai embeddings with warlock", "generate images with gpt-image / dall-e", "send a pdf / audio to gpt-4o"; typical import `import { OpenAISDK } from "@warlock.js/ai-openai"`. Skip: the ai.image verb surface — `@warlock.js/ai/generate-images/SKILL.md`; agent wiring — `@warlock.js/ai/run-ai-agent/SKILL.md`; adapter comparison — `@warlock.js/ai/pick-ai-provider/SKILL.md`; competing adapters `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `openai` SDK, Vercel `@ai-sdk/openai`.'
+description: 'Wire @warlock.js/ai-openai — new OpenAISDK({apiKey, baseURL?, provider?, pricing?}) for OpenAI / Azure / OpenRouter, .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for ModelContract, .embedder({name, dimensions?}) for embeddings, .image({name, pricing?}) for gpt-image-*/dall-e-* image generation (via ai.image). PDF input maps to OpenAI file parts (opt-in pdf:true), audio input to input_audio (opt-in audio:true). Triggers: `OpenAISDK`, `.model`, `.embedder`, `.image`, `.embed`, `.embedMany`, `baseURL`, `pricing`, `responseSchema`, `responseFormat`, `reasoning_effort`, `reasoningTokens`, `cachedTokens`, `gpt-image`, `dall-e`, `ai.image`, `pdf input`, `input_audio`, o-series / gpt-5 reasoning, `api: "responses"`, Responses API, reasoning with tools, prompt caching; "wire openai into a warlock agent", "configure gpt-4o", "use o3 / gpt-5 reasoning effort", "route through openrouter or azure openai", "openai embeddings with warlock", "generate images with gpt-image / dall-e", "send a pdf / audio to gpt-4o"; typical import `import { OpenAISDK } from "@warlock.js/ai-openai"`. Skip: the ai.image verb surface — `@warlock.js/ai/generate-images/SKILL.md`; agent wiring — `@warlock.js/ai/run-ai-agent/SKILL.md`; adapter comparison — `@warlock.js/ai/pick-ai-provider/SKILL.md`; competing adapters `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `openai` SDK, Vercel `@ai-sdk/openai`.'
 ---
 
 # `@warlock.js/ai-openai`
@@ -163,9 +163,26 @@ The gpt-6 models (`gpt-6-astra` / `gpt-6-sol` / `gpt-6-luna`) are hard-400 cases
 400 Function tools with reasoning_effort are not supported for gpt-6-sol in /v1/chat/completions. To use function tools, use /v1/responses or set reasoning_effort to 'none'.
 ```
 
-Tools work with reasoning off (the adapter's default when tools are present and no reasoning is set). Responses API support, planned for 5.27, lifts this.
+Tools work with reasoning off (the adapter's default when tools are present and no reasoning is set). For reasoning **and** tools together, use the Responses API below.
 
-Calling **without** `tools` is unaffected — `reasoning_effort` is still omitted by default in that case (provider default reasoning, nothing to unblock). Trade-off of the `"none"` default: you lose reasoning on that call. For tool-heavy agent work (function calls + good replies rather than deep analysis) this is the right call — it's the difference between empty replies and working ones. When you need reasoning **and** tools together, use the Responses API (planned).
+Calling **without** `tools` is unaffected — `reasoning_effort` is still omitted by default in that case (provider default reasoning, nothing to unblock). Trade-off of the `"none"` default: you lose reasoning on that call. For tool-heavy agent work (function calls + good replies rather than deep analysis) this is the right call — it's the difference between empty replies and working ones. When you need reasoning **and** tools together, use the Responses API (next section).
+
+### Reasoning + tools: the Responses API (`api: "responses"`)
+
+Opt a direct-OpenAI model into `/v1/responses`, where reasoning models accept function tools with reasoning on:
+
+```ts
+const model = openai.model({ name: "gpt-6-sol", api: "responses" });
+await model.complete(messages, { tools, reasoning: { effort: "high" } }); // reasoning stays on, tools work
+```
+
+- Chat Completions stays the default; nothing changes unless you pass `api: "responses"`.
+- Only the direct `openai` provider accepts it. `@warlock.js/ai-deepseek`, `ai-groq`, `ai-xai` and `ai-mistral` (which reuse this adapter with their own `baseURL`) reject `api: "responses"` with `InvalidRequestError`.
+- With tools attached, reasoning uses the provider default instead of being forced to `"none"`: expect more reasoning tokens and latency than the Chat path. Pass `reasoning: { effort }` to choose.
+- The system prompt is sent as `instructions`; requests use `store: false` (no server-side conversation state).
+- Reasoning is carried across a tool loop without server storage: each response asks for encrypted reasoning, which rides on the first tool call of the turn (`providerMetadata.openaiResponses`) and is sent back on the next request when the model is the same. It is persisted with your conversation history.
+- `complete()` and `stream()` both work; streamed chunks follow the same order as the Chat path (deltas, then tool calls, then `done`). Usage reports `reasoningTokens` and `cachedTokens` the same way.
+- `pdf` and `audio` inputs are not available on this path.
 
 ## Token usage — what's reported
 

package/llms.txt

@@ -6,4 +6,4 @@
 
 ## Skills
 
-- [setup-openai](@warlock.js/ai-openai/setup-openai/SKILL.md): Wire @warlock.js/ai-openai — new OpenAISDK({apiKey, baseURL?, provider?, pricing?}) for OpenAI / Azure / OpenRouter, .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for ModelContract, .embedder({name, dimensions?}) for embeddings, .image({name, pricing?}) for gpt-image-*/dall-e-* image generation (via ai.image). PDF input maps to OpenAI file parts (opt-in pdf:true), audio input to input_audio (opt-in audio:true). Triggers: `OpenAISDK`, `.model`, `.embedder`, `.image`, `.embed`, `.embedMany`, `baseURL`, `pricing`, `responseSchema`, `responseFormat`, `reasoning_effort`, `reasoningTokens`, `cachedTokens`, `gpt-image`, `dall-e`, `ai.image`, `pdf input`, `input_audio`, o-series / gpt-5 reasoning, prompt caching; "wire openai into a warlock agent", "configure gpt-4o", "use o3 / gpt-5 reasoning effort", "route through openrouter or azure openai", "openai embeddings with warlock", "generate images with gpt-image / dall-e", "send a pdf / audio to gpt-4o"; typical import `import { OpenAISDK } from "@warlock.js/ai-openai"`. Skip: the ai.image verb surface — `@warlock.js/ai/generate-images/SKILL.md`; agent wiring — `@warlock.js/ai/run-ai-agent/SKILL.md`; adapter comparison — `@warlock.js/ai/pick-ai-provider/SKILL.md`; competing adapters `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `openai` SDK, Vercel `@ai-sdk/openai`.
+- [setup-openai](@warlock.js/ai-openai/setup-openai/SKILL.md): Wire @warlock.js/ai-openai — new OpenAISDK({apiKey, baseURL?, provider?, pricing?}) for OpenAI / Azure / OpenRouter, .model({name, vision?, reasoning?, structuredOutput?, responseFormat?, pdf?, audio?}) for ModelContract, .embedder({name, dimensions?}) for embeddings, .image({name, pricing?}) for gpt-image-*/dall-e-* image generation (via ai.image). PDF input maps to OpenAI file parts (opt-in pdf:true), audio input to input_audio (opt-in audio:true). Triggers: `OpenAISDK`, `.model`, `.embedder`, `.image`, `.embed`, `.embedMany`, `baseURL`, `pricing`, `responseSchema`, `responseFormat`, `reasoning_effort`, `reasoningTokens`, `cachedTokens`, `gpt-image`, `dall-e`, `ai.image`, `pdf input`, `input_audio`, o-series / gpt-5 reasoning, `api: "responses"`, Responses API, reasoning with tools, prompt caching; "wire openai into a warlock agent", "configure gpt-4o", "use o3 / gpt-5 reasoning effort", "route through openrouter or azure openai", "openai embeddings with warlock", "generate images with gpt-image / dall-e", "send a pdf / audio to gpt-4o"; typical import `import { OpenAISDK } from "@warlock.js/ai-openai"`. Skip: the ai.image verb surface — `@warlock.js/ai/generate-images/SKILL.md`; agent wiring — `@warlock.js/ai/run-ai-agent/SKILL.md`; adapter comparison — `@warlock.js/ai/pick-ai-provider/SKILL.md`; competing adapters `@warlock.js/ai-anthropic`, `@warlock.js/ai-bedrock`, `@warlock.js/ai-google`, `@warlock.js/ai-ollama`; raw `openai` SDK, Vercel `@ai-sdk/openai`.

package/package.json

@@ -14,12 +14,12 @@
   },
   "dependencies": {
     "openai": "^7.23.0",
-    "@warlock.js/logger": "5.26.0"
+    "@warlock.js/logger": "5.28.0"
   },
   "peerDependencies": {
-    "@warlock.js/ai": "5.26.0"
+    "@warlock.js/ai": "5.28.0"
   },
-  "version": "5.26.0",
+  "version": "5.28.0",
   "main": "./cjs/index.cjs",
   "module": "./esm/index.mjs",
   "types": "./esm/index.d.mts",