@discomedia/utils 1.0.67 → 1.0.69

package/dist/index.mjs

@@ -1139,6 +1139,29 @@ function dateTimeForGS(date) {
         .replace(/\./g, '/');
 }
 
+/**
+ * Represents OpenAI models
+ */
+const OPENAI_MODELS = [
+    'gpt-5',
+    'gpt-5-mini',
+    'gpt-5.4-mini',
+    'gpt-5-nano',
+    'gpt-5.1',
+    'gpt-5.4',
+    'gpt-5.5',
+    'gpt-5.5-pro',
+    'gpt-5.2',
+    'gpt-5.2-pro',
+    'gpt-5.1-codex',
+    'gpt-5.1-codex-max',
+];
+/**
+ * Type guard to check if a model is a supported direct OpenAI model.
+ */
+function isOpenAIModel(model) {
+    return OPENAI_MODELS.includes(model);
+}
 /**
  * Type guard to check if a model is an OpenRouter model
  */
@@ -1151,6 +1174,8 @@ function isOpenRouterModel(model) {
         'openai/gpt-5.1',
         'openai/gpt-5.4',
         'openai/gpt-5.4-pro',
+        'openai/gpt-5.5',
+        'openai/gpt-5.5-pro',
         'openai/gpt-5.2',
         'openai/gpt-5.2-pro',
         'openai/gpt-5.1-codex',
@@ -1168,6 +1193,8 @@ function isOpenRouterModel(model) {
 
 var Types = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    OPENAI_MODELS: OPENAI_MODELS,
+    isOpenAIModel: isOpenAIModel,
     isOpenRouterModel: isOpenRouterModel
 });
 
@@ -1646,7 +1673,7 @@ const safeJSON = (text) => {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const VERSION = '6.34.0'; // x-release-please-version
+const VERSION = '6.35.0'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -4974,8 +5001,8 @@ class Speech extends APIResource {
      * ```ts
      * const speech = await client.audio.speech.create({
      *   input: 'input',
-     *   model: 'string',
-     *   voice: 'string',
+     *   model: 'tts-1',
+     *   voice: 'alloy',
      * });
      *
      * const content = await speech.blob();
@@ -5453,10 +5480,10 @@ const toFloat32Array = (base64Str) => {
  */
 const readEnv = (env) => {
     if (typeof globalThis.process !== 'undefined') {
-        return globalThis.process.env?.[env]?.trim() ?? undefined;
+        return globalThis.process.env?.[env]?.trim() || undefined;
     }
     if (typeof globalThis.Deno !== 'undefined') {
-        return globalThis.Deno.env?.get?.(env)?.trim();
+        return globalThis.Deno.env?.get?.(env)?.trim() || undefined;
     }
     return undefined;
 };
@@ -9042,7 +9069,6 @@ OpenAI.Containers = Containers;
 OpenAI.Skills = Skills;
 OpenAI.Videos = Videos;
 
-// functions
 function getEnumValues(entries) {
     const numericValues = Object.values(entries).filter((v) => typeof v === "number");
     const values = Object.entries(entries)
@@ -9188,7 +9214,7 @@ function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
         delete result.schema.default;
     }
     // set prefault as default
-    if (ctx.io === "input" && result.schema._prefault)
+    if (ctx.io === "input" && "_prefault" in result.schema)
         (_a = result.schema).default ?? (_a.default = result.schema._prefault);
     delete result.schema._prefault;
     // pulling fresh from ctx.seen in case it was overwritten
@@ -9416,11 +9442,20 @@ function finalize(ctx, schema) {
         result.$id = ctx.external.uri(id);
     }
     Object.assign(result, root.def ?? root.schema);
+    // The `id` in `.meta()` is a Zod-specific registration tag used to extract
+    // schemas into $defs — it is not user-facing JSON Schema metadata. Strip it
+    // from the output body where it would otherwise leak. The id is preserved
+    // implicitly via the $defs key (and via $ref paths).
+    const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
+    if (rootMetaId !== undefined && result.id === rootMetaId)
+        delete result.id;
     // build defs object
     const defs = ctx.external?.defs ?? {};
     for (const entry of ctx.seen.entries()) {
         const seen = entry[1];
         if (seen.def && seen.defId) {
+            if (seen.def.id === seen.defId)
+                delete seen.def.id;
             defs[seen.defId] = seen.def;
         }
     }
@@ -9488,6 +9523,8 @@ function isTransforming(_schema, _ctx) {
         return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
     }
     if (def.type === "pipe") {
+        if (_schema._zod.traits.has("$ZodCodec"))
+            return true;
         return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
     }
     if (def.type === "object") {
@@ -9576,8 +9613,12 @@ const numberProcessor = (schema, ctx, _json, _params) => {
         json.type = "integer";
     else
         json.type = "number";
-    if (typeof exclusiveMinimum === "number") {
-        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+    // when both minimum and exclusiveMinimum exist, pick the more restrictive one
+    const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
+    const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
+    const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
+    if (exMin) {
+        if (legacy) {
             json.minimum = exclusiveMinimum;
             json.exclusiveMinimum = true;
         }
@@ -9585,17 +9626,11 @@ const numberProcessor = (schema, ctx, _json, _params) => {
             json.exclusiveMinimum = exclusiveMinimum;
         }
     }
-    if (typeof minimum === "number") {
+    else if (typeof minimum === "number") {
         json.minimum = minimum;
-        if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
-            if (exclusiveMinimum >= minimum)
-                delete json.minimum;
-            else
-                delete json.exclusiveMinimum;
-        }
     }
-    if (typeof exclusiveMaximum === "number") {
-        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+    if (exMax) {
+        if (legacy) {
             json.maximum = exclusiveMaximum;
             json.exclusiveMaximum = true;
         }
@@ -9603,14 +9638,8 @@ const numberProcessor = (schema, ctx, _json, _params) => {
             json.exclusiveMaximum = exclusiveMaximum;
         }
     }
-    if (typeof maximum === "number") {
+    else if (typeof maximum === "number") {
         json.maximum = maximum;
-        if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
-            if (exclusiveMaximum <= maximum)
-                delete json.maximum;
-            else
-                delete json.exclusiveMaximum;
-        }
     }
     if (typeof multipleOf === "number")
         json.multipleOf = multipleOf;
@@ -9793,7 +9822,10 @@ const arrayProcessor = (schema, ctx, _json, params) => {
     if (typeof maximum === "number")
         json.maxItems = maximum;
     json.type = "array";
-    json.items = process$1(def.element, ctx, { ...params, path: [...params.path, "items"] });
+    json.items = process$1(def.element, ctx, {
+        ...params,
+        path: [...params.path, "items"],
+    });
 };
 const objectProcessor = (schema, ctx, _json, params) => {
     const json = _json;
@@ -10010,7 +10042,8 @@ const catchProcessor = (schema, ctx, json, params) => {
 };
 const pipeProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
-    const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
+    const inIsTransform = def.in._zod.traits.has("$ZodTransform");
+    const innerType = ctx.io === "input" ? (inIsTransform ? def.out : def.in) : def.out;
     process$1(innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = innerType;
@@ -10208,235 +10241,6 @@ function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
     addErrorMessage(res, key, errorMessage, refs);
 }
 
-var util;
-(function (util) {
-    util.assertEqual = (_) => { };
-    function assertIs(_arg) { }
-    util.assertIs = assertIs;
-    function assertNever(_x) {
-        throw new Error();
-    }
-    util.assertNever = assertNever;
-    util.arrayToEnum = (items) => {
-        const obj = {};
-        for (const item of items) {
-            obj[item] = item;
-        }
-        return obj;
-    };
-    util.getValidEnumValues = (obj) => {
-        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-        const filtered = {};
-        for (const k of validKeys) {
-            filtered[k] = obj[k];
-        }
-        return util.objectValues(filtered);
-    };
-    util.objectValues = (obj) => {
-        return util.objectKeys(obj).map(function (e) {
-            return obj[e];
-        });
-    };
-    util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban
-        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban
-        : (object) => {
-            const keys = [];
-            for (const key in object) {
-                if (Object.prototype.hasOwnProperty.call(object, key)) {
-                    keys.push(key);
-                }
-            }
-            return keys;
-        };
-    util.find = (arr, checker) => {
-        for (const item of arr) {
-            if (checker(item))
-                return item;
-        }
-        return undefined;
-    };
-    util.isInteger = typeof Number.isInteger === "function"
-        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
-        : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
-    function joinValues(array, separator = " | ") {
-        return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator);
-    }
-    util.joinValues = joinValues;
-    util.jsonStringifyReplacer = (_, value) => {
-        if (typeof value === "bigint") {
-            return value.toString();
-        }
-        return value;
-    };
-})(util || (util = {}));
-var objectUtil;
-(function (objectUtil) {
-    objectUtil.mergeShapes = (first, second) => {
-        return {
-            ...first,
-            ...second, // second overwrites first
-        };
-    };
-})(objectUtil || (objectUtil = {}));
-util.arrayToEnum([
-    "string",
-    "nan",
-    "number",
-    "integer",
-    "float",
-    "boolean",
-    "date",
-    "bigint",
-    "symbol",
-    "function",
-    "undefined",
-    "null",
-    "array",
-    "object",
-    "unknown",
-    "promise",
-    "void",
-    "never",
-    "map",
-    "set",
-]);
-
-util.arrayToEnum([
-    "invalid_type",
-    "invalid_literal",
-    "custom",
-    "invalid_union",
-    "invalid_union_discriminator",
-    "invalid_enum_value",
-    "unrecognized_keys",
-    "invalid_arguments",
-    "invalid_return_type",
-    "invalid_date",
-    "invalid_string",
-    "too_small",
-    "too_big",
-    "invalid_intersection_types",
-    "not_multiple_of",
-    "not_finite",
-]);
-class ZodError extends Error {
-    get errors() {
-        return this.issues;
-    }
-    constructor(issues) {
-        super();
-        this.issues = [];
-        this.addIssue = (sub) => {
-            this.issues = [...this.issues, sub];
-        };
-        this.addIssues = (subs = []) => {
-            this.issues = [...this.issues, ...subs];
-        };
-        const actualProto = new.target.prototype;
-        if (Object.setPrototypeOf) {
-            // eslint-disable-next-line ban/ban
-            Object.setPrototypeOf(this, actualProto);
-        }
-        else {
-            this.__proto__ = actualProto;
-        }
-        this.name = "ZodError";
-        this.issues = issues;
-    }
-    format(_mapper) {
-        const mapper = _mapper ||
-            function (issue) {
-                return issue.message;
-            };
-        const fieldErrors = { _errors: [] };
-        const processError = (error) => {
-            for (const issue of error.issues) {
-                if (issue.code === "invalid_union") {
-                    issue.unionErrors.map(processError);
-                }
-                else if (issue.code === "invalid_return_type") {
-                    processError(issue.returnTypeError);
-                }
-                else if (issue.code === "invalid_arguments") {
-                    processError(issue.argumentsError);
-                }
-                else if (issue.path.length === 0) {
-                    fieldErrors._errors.push(mapper(issue));
-                }
-                else {
-                    let curr = fieldErrors;
-                    let i = 0;
-                    while (i < issue.path.length) {
-                        const el = issue.path[i];
-                        const terminal = i === issue.path.length - 1;
-                        if (!terminal) {
-                            curr[el] = curr[el] || { _errors: [] };
-                            // if (typeof el === "string") {
-                            //   curr[el] = curr[el] || { _errors: [] };
-                            // } else if (typeof el === "number") {
-                            //   const errorArray: any = [];
-                            //   errorArray._errors = [];
-                            //   curr[el] = curr[el] || errorArray;
-                            // }
-                        }
-                        else {
-                            curr[el] = curr[el] || { _errors: [] };
-                            curr[el]._errors.push(mapper(issue));
-                        }
-                        curr = curr[el];
-                        i++;
-                    }
-                }
-            }
-        };
-        processError(this);
-        return fieldErrors;
-    }
-    static assert(value) {
-        if (!(value instanceof ZodError)) {
-            throw new Error(`Not a ZodError: ${value}`);
-        }
-    }
-    toString() {
-        return this.message;
-    }
-    get message() {
-        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
-    }
-    get isEmpty() {
-        return this.issues.length === 0;
-    }
-    flatten(mapper = (issue) => issue.message) {
-        const fieldErrors = Object.create(null);
-        const formErrors = [];
-        for (const sub of this.issues) {
-            if (sub.path.length > 0) {
-                const firstEl = sub.path[0];
-                fieldErrors[firstEl] = fieldErrors[firstEl] || [];
-                fieldErrors[firstEl].push(mapper(sub));
-            }
-            else {
-                formErrors.push(mapper(sub));
-            }
-        }
-        return { formErrors, fieldErrors };
-    }
-    get formErrors() {
-        return this.flatten();
-    }
-}
-ZodError.create = (issues) => {
-    const error = new ZodError(issues);
-    return error;
-};
-
-var errorUtil;
-(function (errorUtil) {
-    errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-    // biome-ignore lint:
-    errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
-})(errorUtil || (errorUtil = {}));
-
 var ZodFirstPartyTypeKind;
 (function (ZodFirstPartyTypeKind) {
     ZodFirstPartyTypeKind["ZodString"] = "ZodString";
@@ -11817,57 +11621,12 @@ function zodTextFormat(zodObject, name, props) {
 }
 
 // llm-openai-config.ts
-const DEFAULT_MODEL = 'gpt-4.1-mini';
-const GPT_5_4_HIGH_CONTEXT_THRESHOLD_TOKENS = 272_000;
-const GPT_5_4_HIGH_CONTEXT_INPUT_MULTIPLIER = 2;
-const GPT_5_4_HIGH_CONTEXT_OUTPUT_MULTIPLIER = 1.5;
-/** Token costs in USD per 1M tokens. Last updated Mar 2026. */
+const DEFAULT_MODEL = 'gpt-5-mini';
+const GPT_5_HIGH_CONTEXT_THRESHOLD_TOKENS = 272_000;
+const GPT_5_HIGH_CONTEXT_INPUT_MULTIPLIER = 2;
+const GPT_5_HIGH_CONTEXT_OUTPUT_MULTIPLIER = 1.5;
+/** Token costs in USD per 1M tokens. Last updated May 2026. */
 const openAiModelCosts = {
-    'gpt-4o': {
-        inputCost: 2.5 / 1_000_000,
-        cacheHitCost: 1.25 / 1_000_000,
-        outputCost: 10 / 1_000_000,
-    },
-    'gpt-4o-mini': {
-        inputCost: 0.15 / 1_000_000,
-        cacheHitCost: 0.075 / 1_000_000,
-        outputCost: 0.6 / 1_000_000,
-    },
-    'o1-mini': {
-        inputCost: 1.1 / 1_000_000,
-        cacheHitCost: 0.55 / 1_000_000,
-        outputCost: 4.4 / 1_000_000,
-    },
-    'o1': {
-        inputCost: 15 / 1_000_000,
-        cacheHitCost: 7.5 / 1_000_000,
-        outputCost: 60 / 1_000_000,
-    },
-    'o3-mini': {
-        inputCost: 1.1 / 1_000_000,
-        cacheHitCost: 0.55 / 1_000_000,
-        outputCost: 4.4 / 1_000_000,
-    },
-    'o3': {
-        inputCost: 2 / 1_000_000,
-        cacheHitCost: 0.5 / 1_000_000,
-        outputCost: 8 / 1_000_000,
-    },
-    'gpt-4.1': {
-        inputCost: 2 / 1_000_000,
-        cacheHitCost: 0.5 / 1_000_000,
-        outputCost: 8 / 1_000_000,
-    },
-    'gpt-4.1-mini': {
-        inputCost: 0.4 / 1_000_000,
-        cacheHitCost: 0.1 / 1_000_000,
-        outputCost: 1.6 / 1_000_000,
-    },
-    'gpt-4.1-nano': {
-        inputCost: 0.1 / 1_000_000,
-        cacheHitCost: 0.025 / 1_000_000,
-        outputCost: 0.4 / 1_000_000,
-    },
     'gpt-5': {
         inputCost: 1.25 / 1_000_000,
         cacheHitCost: 0.125 / 1_000_000,
@@ -11898,7 +11657,12 @@ const openAiModelCosts = {
         cacheHitCost: 0.25 / 1_000_000,
         outputCost: 15 / 1_000_000,
     },
-    'gpt-5.4-pro': {
+    'gpt-5.5': {
+        inputCost: 5 / 1_000_000,
+        cacheHitCost: 0.5 / 1_000_000,
+        outputCost: 30 / 1_000_000,
+    },
+    'gpt-5.5-pro': {
         inputCost: 30 / 1_000_000,
         outputCost: 180 / 1_000_000,
     },
@@ -11921,11 +11685,6 @@ const openAiModelCosts = {
         cacheHitCost: 0.125 / 1_000_000,
         outputCost: 10 / 1_000_000,
     },
-    'o4-mini': {
-        inputCost: 1.1 / 1_000_000,
-        cacheHitCost: 0.275 / 1_000_000,
-        outputCost: 4.4 / 1_000_000,
-    },
 };
 const deepseekModelCosts = {
     'deepseek-chat': {
@@ -11939,8 +11698,8 @@ const deepseekModelCosts = {
         outputCost: 2.19 / 1_000_000, // $2.19 per 1M tokens
     },
 };
-function shouldUseGPT54HighContextPricing(model, inputTokens) {
-    return (model === 'gpt-5.4' || model === 'gpt-5.4-pro') && inputTokens > GPT_5_4_HIGH_CONTEXT_THRESHOLD_TOKENS;
+function shouldUseGPT5HighContextPricing(model, inputTokens) {
+    return (model === 'gpt-5.4' || model === 'gpt-5.5') && inputTokens > GPT_5_HIGH_CONTEXT_THRESHOLD_TOKENS;
 }
 /** Image generation costs in USD per image. Based on OpenAI pricing as of Feb 2025. */
 const openAiImageCosts = {
@@ -11993,10 +11752,10 @@ function calculateCost(provider, model, inputTokens, outputTokens, reasoningToke
     }
     let outputCost = outputTokens * modelCosts.outputCost;
     let reasoningCost = (reasoningTokens || 0) * modelCosts.outputCost;
-    if (provider === 'openai' && shouldUseGPT54HighContextPricing(model, inputTokens)) {
-        inputCost *= GPT_5_4_HIGH_CONTEXT_INPUT_MULTIPLIER;
-        outputCost *= GPT_5_4_HIGH_CONTEXT_OUTPUT_MULTIPLIER;
-        reasoningCost *= GPT_5_4_HIGH_CONTEXT_OUTPUT_MULTIPLIER;
+    if (provider === 'openai' && shouldUseGPT5HighContextPricing(model, inputTokens)) {
+        inputCost *= GPT_5_HIGH_CONTEXT_INPUT_MULTIPLIER;
+        outputCost *= GPT_5_HIGH_CONTEXT_OUTPUT_MULTIPLIER;
+        reasoningCost *= GPT_5_HIGH_CONTEXT_OUTPUT_MULTIPLIER;
     }
     return inputCost + outputCost + reasoningCost;
 }
@@ -12381,94 +12140,13 @@ async function parseResponse(content, responseFormat) {
 }
 
 // llm-openai.ts
-const isSupportedModel = (model) => {
-    return [
-        'gpt-4o-mini',
-        'gpt-4o',
-        'o1-mini',
-        'o1',
-        'o3-mini',
-        'gpt-4.1',
-        'gpt-4.1-mini',
-        'gpt-4.1-nano',
-        'gpt-5',
-        'gpt-5-mini',
-        'gpt-5.4-mini',
-        'gpt-5-nano',
-        'gpt-5.1',
-        'gpt-5.4',
-        'gpt-5.4-pro',
-        'gpt-5.2',
-        'gpt-5.2-pro',
-        'gpt-5.1-codex',
-        'gpt-5.1-codex-max',
-        'o4-mini',
-        'o3',
-    ].includes(model);
-};
 /**
- * Checks if the given model supports the temperature parameter. Reasoning models (o1*, o3*, o4*) do not support temperature.
+ * Checks if the given direct OpenAI model supports the temperature parameter.
  * @param model The model to check.
  * @returns True if the model supports the temperature parameter, false otherwise.
  */
-function supportsTemperature(model) {
-    // Reasoning models don't support temperature
-    // GPT-5 models also do not support temperature
-    const reasoningAndGPT5Models = [
-        'o1',
-        'o1-mini',
-        'o3-mini',
-        'o4-mini',
-        'o3',
-        'gpt-5',
-        'gpt-5-mini',
-        'gpt-5.4-mini',
-        'gpt-5-nano',
-        'gpt-5.1',
-        'gpt-5.4',
-        'gpt-5.4-pro',
-        'gpt-5.2',
-        'gpt-5.2-pro',
-        'gpt-5.1-codex',
-        'gpt-5.1-codex-max',
-    ];
-    return !reasoningAndGPT5Models.includes(model);
-}
-/**
- * Checks if the given model is a reasoning model. Reasoning models have different tool choice constraints.
- * @param model The model to check.
- * @returns True if the model is a reasoning model, false otherwise.
- */
-function isReasoningModel(model) {
-    const reasoningModels = ['o1', 'o1-mini', 'o3-mini', 'o4-mini', 'o3'];
-    return reasoningModels.includes(model);
-}
-/**
- * Checks if the given model is a GPT-5 model. GPT-5 models don't support tool_choice other than 'auto'.
- * @param model The model to check.
- * @returns True if the model is a GPT-5 model, false otherwise.
- */
-function isGPT5Model(model) {
-    const gpt5Models = [
-        'gpt-5',
-        'gpt-5-mini',
-        'gpt-5.4-mini',
-        'gpt-5-nano',
-        'gpt-5.1',
-        'gpt-5.4',
-        'gpt-5.4-pro',
-        'gpt-5.2',
-        'gpt-5.2-pro',
-        'gpt-5.1-codex',
-        'gpt-5.1-codex-max',
-    ];
-    return gpt5Models.includes(model);
-}
-function supportsStructuredOutputs(model) {
-    return normalizeModelName(model) !== 'gpt-5.4-pro';
-}
-function supportsDistillation(model) {
-    return normalizeModelName(model) !== 'gpt-5.4-pro';
+function supportsTemperature(_model) {
+    return false;
 }
 function isZodSchema(schema) {
     return typeof schema === 'object' && schema !== null && 'safeParse' in schema;
@@ -12503,7 +12181,7 @@ function buildJsonSchemaFormat(schema, schemaName, schemaDescription, schemaStri
  * - Built-in tools (web search, file search, computer use, code interpreter, image generation)
  * - Background processing
  * - Conversation state management
- * - Reasoning support for o-series models
+ * - GPT-5 reasoning controls
  *
  * @example
  * // Basic text response
@@ -12524,6 +12202,9 @@ function buildJsonSchemaFormat(schema, schemaName, schemaDescription, schemaStri
  */
 const makeResponsesAPICall = async (input, options = {}) => {
     const normalizedModel = normalizeModelName(options.model || DEFAULT_MODEL);
+    if (!isOpenAIModel(normalizedModel)) {
+        throw new Error(`Unsupported OpenAI model: ${normalizedModel}. Please use a supported GPT-5 model.`);
+    }
     const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
     if (!apiKey) {
         throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
@@ -12538,12 +12219,6 @@ const makeResponsesAPICall = async (input, options = {}) => {
         input,
         ...cleanOptions,
     };
-    if (requestBody.text?.format?.type === 'json_schema' && !supportsStructuredOutputs(normalizedModel)) {
-        throw new Error(`Model ${normalizedModel} does not support structured outputs`);
-    }
-    if (requestBody.store && !supportsDistillation(normalizedModel)) {
-        throw new Error(`Model ${normalizedModel} does not support distillation`);
-    }
     // Make the API call to the Responses endpoint
     const response = await openai.responses.create(requestBody);
     const cacheHitTokens = response.usage?.input_tokens_details?.cached_tokens || 0;
@@ -12650,8 +12325,8 @@ async function makeLLMCall(input, options = {}) {
     const { apiKey, model = DEFAULT_MODEL, responseFormat = 'text', schema, schemaName = 'response', schemaDescription, schemaStrict, tools, useCodeInterpreter = false, useWebSearch = false, imageBase64, imageDetail = 'high', context, } = options;
     // Validate model
     const normalizedModel = normalizeModelName(model);
-    if (!isSupportedModel(normalizedModel)) {
-        throw new Error(`Unsupported model: ${normalizedModel}. Please use one of the supported models.`);
+    if (!isOpenAIModel(normalizedModel)) {
+        throw new Error(`Unsupported OpenAI model: ${normalizedModel}. Please use a supported GPT-5 model.`);
     }
     // Process input for conversation context and image analysis
     let processedInput;
@@ -12720,10 +12395,6 @@ async function makeLLMCall(input, options = {}) {
         parallel_tool_calls: false,
         tools,
     };
-    // Only include temperature if the model supports it
-    if (supportsTemperature(normalizedModel)) {
-        responsesOptions.temperature = 0.2;
-    }
     // Configure response format
     if (schema) {
         responsesOptions.text = {
@@ -12739,39 +12410,17 @@ async function makeLLMCall(input, options = {}) {
     // Configure built-in tools
     if (useCodeInterpreter) {
         responsesOptions.tools = [{ type: 'code_interpreter', container: { type: 'auto' } }];
-        // For reasoning models, we can't force tool choice - they only support 'auto'
-        if (!isReasoningModel(normalizedModel)) {
-            responsesOptions.tool_choice = { type: 'code_interpreter' };
-        }
         responsesOptions.include = ['code_interpreter_call.outputs'];
     }
     if (useWebSearch) {
         responsesOptions.tools = [{ type: 'web_search_preview' }];
-        // For reasoning models and GPT-5 models, we can't force tool choice - they only support 'auto'
-        if (!isReasoningModel(normalizedModel) && !isGPT5Model(normalizedModel)) {
-            responsesOptions.tool_choice = { type: 'web_search_preview' };
-        }
     }
     return await makeResponsesAPICall(processedInput, responsesOptions);
 }
 
 const DEFAULT_IMAGE_MODEL = 'gpt-image-1.5';
 const resolveImageModel = (model) => model ?? DEFAULT_IMAGE_MODEL;
-const MULTIMODAL_VISION_MODELS = new Set([
-    'gpt-4o-mini',
-    'gpt-4o',
-    'gpt-5',
-    'gpt-5-mini',
-    'gpt-5.4-mini',
-    'gpt-5-nano',
-    'gpt-5.1',
-    'gpt-5.4',
-    'gpt-5.4-pro',
-    'gpt-5.2',
-    'gpt-5.2-pro',
-    'gpt-5.1-codex',
-    'gpt-5.1-codex-max',
-]);
+const MULTIMODAL_VISION_MODELS = new Set(OPENAI_MODELS);
 /**
  * Makes a call to the OpenAI Images API to generate images based on a text prompt.
  *
@@ -21913,5 +21562,5 @@ const disco = {
     },
 };
 
-export { AlpacaMarketDataAPI, AlpacaTradingAPI, disco, isOpenRouterModel };
+export { AlpacaMarketDataAPI, AlpacaTradingAPI, OPENAI_MODELS, disco, isOpenAIModel, isOpenRouterModel, supportsTemperature };
 //# sourceMappingURL=index.mjs.map