genkitx-azure-openai/lib/gpt.js

Genkit AI framework plugin for Azure OpenAI APIs.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var gpt_exports = {};
__export(gpt_exports, {
  OpenAiConfigSchema: () => OpenAiConfigSchema,
  SUPPORTED_GPT_MODELS: () => SUPPORTED_GPT_MODELS,
  codexMini: () => codexMini,
  gpt35Turbo: () => gpt35Turbo,
  gpt4: () => gpt4,
  gpt41: () => gpt41,
  gpt41Mini: () => gpt41Mini,
  gpt41Nano: () => gpt41Nano,
  gpt45: () => gpt45,
  gpt4o: () => gpt4o,
  gpt4oMini: () => gpt4oMini,
  gpt5: () => gpt5,
  gpt51: () => gpt51,
  gpt51Chat: () => gpt51Chat,
  gpt51Codex: () => gpt51Codex,
  gpt51CodexMax: () => gpt51CodexMax,
  gpt51CodexMini: () => gpt51CodexMini,
  gpt52: () => gpt52,
  gpt52Chat: () => gpt52Chat,
  gpt52Codex: () => gpt52Codex,
  gpt5Chat: () => gpt5Chat,
  gpt5Codex: () => gpt5Codex,
  gpt5Mini: () => gpt5Mini,
  gpt5Nano: () => gpt5Nano,
  gpt5Pro: () => gpt5Pro,
  gptModel: () => gptModel,
  gptOss120b: () => gptOss120b,
  gptOss20b: () => gptOss20b,
  o1: () => o1,
  o1Mini: () => o1Mini,
  o1Preview: () => o1Preview,
  o3: () => o3,
  o3Mini: () => o3Mini,
  o3Pro: () => o3Pro,
  o4Mini: () => o4Mini,
  toOpenAiMessages: () => toOpenAiMessages,
  toOpenAiRequestBody: () => toOpenAiRequestBody,
  toOpenAiTextAndMedia: () => toOpenAiTextAndMedia
});
module.exports = __toCommonJS(gpt_exports);
var import_genkit = require("genkit");
var import_model = require("genkit/model");
const MODELS_SUPPORTING_OPENAI_RESPONSE_FORMAT = [
  "gpt-4",
  "gpt-4-32k",
  "gpt-4o",
  "gpt-4o-mini",
  "gpt-o1",
  "gpt-o1-mini",
  "gpt-o1-preview",
  "gpt-3.5-turbo",
  "gpt-3.5-turbo-instruct",
  "gpt-3.5-turbo-26k",
  "gpt-4.5",
  "gpt-4.1-mini",
  "gpt-4.1-nano",
  "gpt-4.1",
  "gpt-5",
  "gpt-5-mini",
  "gpt-5-nano",
  "gpt-5-chat",
  "gpt-5-codex",
  "gpt-5-pro",
  "gpt-5.1",
  "gpt-5.1-chat",
  "gpt-5.1-codex",
  "gpt-5.1-codex-mini",
  "gpt-5.1-codex-max",
  "gpt-5.2",
  "gpt-5.2-chat",
  "gpt-5.2-codex",
  "gpt-oss-120b",
  "gpt-oss-20b",
  "o3",
  "o3-mini",
  "o3-pro",
  "o4-mini",
  "o1",
  "o1-mini",
  "o1-preview",
  "codex-mini"
];
const OpenAiConfigSchema = import_genkit.GenerationCommonConfigSchema.extend({
  frequencyPenalty: import_genkit.z.number().min(-2).max(2).optional(),
  logitBias: import_genkit.z.record(import_genkit.z.string(), import_genkit.z.number().min(-100).max(100)).optional(),
  logProbs: import_genkit.z.boolean().optional(),
  presencePenalty: import_genkit.z.number().min(-2).max(2).optional(),
  seed: import_genkit.z.number().int().optional(),
  topLogProbs: import_genkit.z.number().int().min(0).max(20).optional(),
  user: import_genkit.z.string().optional(),
  visualDetailLevel: import_genkit.z.enum(["auto", "low", "high"]).optional()
});
const gpt4o = (0, import_model.modelRef)({
  name: "azure-openai/gpt-4o",
  info: {
    versions: ["gpt-4o"],
    label: "OpenAI - GPT-4o",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt4oMini = (0, import_model.modelRef)({
  name: "azure-openai/gpt-4o-mini",
  info: {
    versions: ["gpt-4o-mini"],
    label: "OpenAI - GPT-4o Mini",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt4 = (0, import_model.modelRef)({
  name: "azure-openai/gpt-4",
  info: {
    versions: ["gpt-4", "gpt-4-32k"],
    label: "OpenAI - GPT-4",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt45 = (0, import_model.modelRef)({
  name: "azure-openai/gpt-4.5",
  info: {
    versions: ["gpt-4.5-preview"],
    label: "OpenAI - GPT-4.5",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt5 = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5",
  info: {
    versions: ["gpt-5"],
    label: "OpenAI - GPT-5",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt5Mini = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5-mini",
  info: {
    versions: ["gpt-5-mini"],
    label: "OpenAI - GPT-5 Mini",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt5Nano = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5-nano",
  info: {
    versions: ["gpt-5-nano"],
    label: "OpenAI - GPT-5 Nano",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt5Chat = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5-chat",
  info: {
    versions: ["gpt-5-chat"],
    label: "OpenAI - GPT-5 Chat",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt5Codex = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5-codex",
  info: {
    versions: ["gpt-5-codex"],
    label: "OpenAI - GPT-5 Codex",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt5Pro = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5-pro",
  info: {
    versions: ["gpt-5-pro"],
    label: "OpenAI - GPT-5 Pro",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt51 = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5.1",
  info: {
    versions: ["gpt-5.1"],
    label: "OpenAI - GPT-5.1",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt51Chat = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5.1-chat",
  info: {
    versions: ["gpt-5.1-chat"],
    label: "OpenAI - GPT-5.1 Chat",
    supports: {
      multiturn: true,
      tools: true,
      media: false,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt51Codex = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5.1-codex",
  info: {
    versions: ["gpt-5.1-codex"],
    label: "OpenAI - GPT-5.1 Codex",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt51CodexMini = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5.1-codex-mini",
  info: {
    versions: ["gpt-5.1-codex-mini"],
    label: "OpenAI - GPT-5.1 Codex Mini",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt51CodexMax = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5.1-codex-max",
  info: {
    versions: ["gpt-5.1-codex-max"],
    label: "OpenAI - GPT-5.1 Codex Max",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt52 = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5.2",
  info: {
    versions: ["gpt-5.2"],
    label: "OpenAI - GPT-5.2",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt52Chat = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5.2-chat",
  info: {
    versions: ["gpt-5.2-chat"],
    label: "OpenAI - GPT-5.2 Chat",
    supports: {
      multiturn: true,
      tools: true,
      media: false,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt52Codex = (0, import_model.modelRef)({
  name: "azure-openai/gpt-5.2-codex",
  info: {
    versions: ["gpt-5.2-codex"],
    label: "OpenAI - GPT-5.2 Codex",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gptOss120b = (0, import_model.modelRef)({
  name: "azure-openai/gpt-oss-120b",
  info: {
    versions: ["gpt-oss-120b"],
    label: "OpenAI - GPT-OSS 120B",
    supports: {
      multiturn: true,
      tools: true,
      media: false,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gptOss20b = (0, import_model.modelRef)({
  name: "azure-openai/gpt-oss-20b",
  info: {
    versions: ["gpt-oss-20b"],
    label: "OpenAI - GPT-OSS 20B",
    supports: {
      multiturn: true,
      tools: true,
      media: false,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt41 = (0, import_model.modelRef)({
  name: "azure-openai/gpt-4.1",
  info: {
    versions: ["gpt-4.1"],
    label: "OpenAI - GPT-4.1",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt41Mini = (0, import_model.modelRef)({
  name: "azure-openai/gpt-4.1-mini",
  info: {
    versions: ["gpt-4.1-mini"],
    label: "OpenAI - GPT-4.1 Mini",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt41Nano = (0, import_model.modelRef)({
  name: "azure-openai/gpt-4.1-nano",
  info: {
    versions: ["gpt-4.1-nano"],
    label: "OpenAI - GPT-4.1 Nano",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text", "json"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const o1 = (0, import_model.modelRef)({
  name: "azure-openai/o1",
  info: {
    versions: ["o1"],
    label: "OpenAI - o1",
    supports: {
      multiturn: true,
      tools: false,
      media: true,
      systemRole: true,
      output: ["text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const o1Mini = (0, import_model.modelRef)({
  name: "azure-openai/o1-mini",
  info: {
    versions: ["o1-mini"],
    label: "OpenAI - o1 Mini",
    supports: {
      multiturn: true,
      tools: true,
      media: false,
      systemRole: true,
      output: ["text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const o1Preview = (0, import_model.modelRef)({
  name: "azure-openai/o1-preview",
  info: {
    versions: ["o1-preview"],
    label: "OpenAI - o1 Preview",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const o3 = (0, import_model.modelRef)({
  name: "azure-openai/o3",
  info: {
    versions: ["o3"],
    label: "OpenAI - o3",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const o4Mini = (0, import_model.modelRef)({
  name: "azure-openai/o4-mini",
  info: {
    versions: ["o4-mini"],
    label: "OpenAI - o4 Mini",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const o3Mini = (0, import_model.modelRef)({
  name: "azure-openai/o3-mini",
  info: {
    versions: ["o3-mini"],
    label: "OpenAI - o3 Mini",
    supports: {
      multiturn: true,
      tools: true,
      media: false,
      systemRole: true,
      output: ["text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const o3Pro = (0, import_model.modelRef)({
  name: "azure-openai/o3-pro",
  info: {
    versions: ["o3-pro"],
    label: "OpenAI - o3 Pro",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const codexMini = (0, import_model.modelRef)({
  name: "azure-openai/codex-mini",
  info: {
    versions: ["codex-mini"],
    label: "OpenAI - Codex Mini",
    supports: {
      multiturn: true,
      tools: true,
      media: true,
      systemRole: true,
      output: ["text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const gpt35Turbo = (0, import_model.modelRef)({
  name: "azure-openai/gpt-3.5-turbo",
  info: {
    versions: ["gpt-3.5-turbo", "gpt-35-turbo-instruct", "gpt-35-turbo-16k"],
    label: "OpenAI - GPT-3.5 Turbo",
    supports: {
      multiturn: true,
      tools: true,
      media: false,
      systemRole: true,
      output: ["json", "text"]
    }
  },
  configSchema: OpenAiConfigSchema
});
const SUPPORTED_GPT_MODELS = {
  "o1-mini": o1Mini,
  "o1-preview": o1Preview,
  o1,
  o3,
  "o3-mini": o3Mini,
  "o3-pro": o3Pro,
  "o4-mini": o4Mini,
  "codex-mini": codexMini,
  "gpt-4.1": gpt41,
  "gpt-4.1-mini": gpt41Mini,
  "gpt-4.1-nano": gpt41Nano,
  "gpt-4": gpt4,
  "gpt-4o": gpt4o,
  "gpt-4o-mini": gpt4oMini,
  "gpt-4.5": gpt45,
  "gpt-5": gpt5,
  "gpt-5-mini": gpt5Mini,
  "gpt-5-nano": gpt5Nano,
  "gpt-5-chat": gpt5Chat,
  "gpt-5-codex": gpt5Codex,
  "gpt-5-pro": gpt5Pro,
  "gpt-5.1": gpt51,
  "gpt-5.1-chat": gpt51Chat,
  "gpt-5.1-codex": gpt51Codex,
  "gpt-5.1-codex-mini": gpt51CodexMini,
  "gpt-5.1-codex-max": gpt51CodexMax,
  "gpt-5.2": gpt52,
  "gpt-5.2-chat": gpt52Chat,
  "gpt-5.2-codex": gpt52Codex,
  "gpt-oss-120b": gptOss120b,
  "gpt-oss-20b": gptOss20b,
  "gpt-3.5-turbo": gpt35Turbo
};
function toOpenAIRole(role) {
  switch (role) {
    case "user":
      return "user";
    case "model":
      return "assistant";
    case "system":
      return "system";
    case "tool":
      return "tool";
    default:
      throw new Error(`role ${role} doesn't map to an OpenAI role.`);
  }
}
function toOpenAiTool(tool) {
  let parameters;
  if (tool.inputSchema !== null) {
    if (typeof tool.inputSchema === "string") {
      try {
        parameters = JSON.parse(tool.inputSchema);
      } catch (error) {
        const errorMessage = error instanceof Error ? error.message : "Unknown parsing error";
        throw new Error(
          `Invalid JSON schema for function '${tool.name}': ${errorMessage}`
        );
      }
    } else {
      parameters = tool.inputSchema;
    }
    parameters.type = "object";
    parameters.properties = {
      ...tool.inputSchema.properties
    };
  }
  return {
    type: "function",
    function: {
      name: tool.name,
      parameters
    }
  };
}
function toOpenAiTextAndMedia(part, visualDetailLevel) {
  if (part.text) {
    return {
      type: "text",
      text: part.text
    };
  } else if (part.media) {
    return {
      type: "image_url",
      image_url: {
        url: part.media.url,
        detail: visualDetailLevel
      }
    };
  }
  throw Error(
    `Unsupported genkit part fields encountered for current message role: ${part}.`
  );
}
function toOpenAiMessages(messages, visualDetailLevel = "auto") {
  const openAiMsgs = [];
  for (const message of messages) {
    const msg = new import_genkit.Message(message);
    const role = toOpenAIRole(message.role);
    switch (role) {
      case "user":
        openAiMsgs.push({
          role,
          content: msg.content.map(
            (part) => toOpenAiTextAndMedia(part, visualDetailLevel)
          )
        });
        break;
      case "system":
        openAiMsgs.push({
          role,
          content: msg.text
        });
        break;
      case "assistant": {
        const toolCalls = msg.content.filter((part) => part.toolRequest).map((part) => {
          if (!part.toolRequest) {
            throw Error(
              "Mapping genkit message to openai tool call content part but message.toolRequest not provided."
            );
          }
          return {
            id: part.toolRequest.ref || "",
            type: "function",
            function: {
              name: part.toolRequest.name,
              arguments: JSON.stringify(part.toolRequest.input)
            }
          };
        });
        if (toolCalls?.length > 0) {
          openAiMsgs.push({
            role,
            tool_calls: toolCalls
          });
        } else {
          openAiMsgs.push({
            role,
            content: msg.text
          });
        }
        break;
      }
      case "tool": {
        const toolResponseParts = msg.toolResponseParts();
        toolResponseParts.map((part) => {
          openAiMsgs.push({
            role,
            tool_call_id: part.toolResponse.ref || "",
            content: typeof part.toolResponse.output === "string" ? part.toolResponse.output : JSON.stringify(part.toolResponse.output)
          });
        });
        break;
      }
      default: {
        throw new Error("unrecognized role");
      }
    }
  }
  return openAiMsgs;
}
const finishReasonMap = {
  length: "length",
  stop: "stop",
  tool_calls: "stop",
  content_filter: "blocked",
  function_call: "stop"
};
function fromOpenAiToolCall(toolCall, choice) {
  if (!("function" in toolCall && toolCall.function && typeof toolCall.function === "object")) {
    throw Error(
      `Unexpected openAI chunk choice. tool_calls was provided but one or more tool_calls is missing function property.`
    );
  }
  const f = toolCall.function;
  if (choice.finish_reason === "tool_calls") {
    return {
      toolRequest: {
        name: f.name,
        ref: toolCall.id,
        input: f.arguments ? JSON.parse(f.arguments) : f.arguments
      }
    };
  } else {
    return {
      toolRequest: {
        name: f.name,
        ref: toolCall.id,
        input: ""
      }
    };
  }
}
function fromOpenAiChoice(choice, jsonMode = false) {
  const toolRequestParts = choice.message.tool_calls?.map(
    (toolCall) => fromOpenAiToolCall(toolCall, choice)
  );
  return {
    index: choice.index,
    finishReason: finishReasonMap[choice.finish_reason] || "other",
    message: {
      role: "model",
      content: toolRequestParts ? (
        // Note: Not sure why I have to cast here exactly.
        // Otherwise it thinks toolRequest must be 'undefined' if provided
        toolRequestParts
      ) : [
        jsonMode ? { data: JSON.parse(choice.message.content) } : { text: choice.message.content }
      ]
    },
    custom: {}
  };
}
function fromOpenAiChunkChoice(choice, jsonMode = false) {
  const toolRequestParts = choice.delta.tool_calls?.map(
    (toolCall) => fromOpenAiToolCall(toolCall, choice)
  );
  return {
    index: choice.index,
    finishReason: choice.finish_reason ? finishReasonMap[choice.finish_reason] || "other" : "unknown",
    message: {
      role: "model",
      content: toolRequestParts ? (
        // Note: Not sure why I have to cast here exactly.
        // Otherwise it thinks toolRequest must be 'undefined' if provided
        toolRequestParts
      ) : [
        jsonMode ? { data: JSON.parse(choice.delta.content) } : { text: choice.delta.content }
      ]
    },
    custom: {}
  };
}
function toOpenAiRequestBody(modelName, request) {
  const mapToSnakeCase = (obj) => {
    return Object.entries(obj).reduce(
      (acc, [key, value]) => {
        const snakeCaseKey = key.replace(
          /[A-Z]/g,
          (letter) => `_${letter.toLowerCase()}`
        );
        acc[snakeCaseKey] = value;
        return acc;
      },
      {}
    );
  };
  const model = SUPPORTED_GPT_MODELS[modelName];
  if (!model) throw new Error(`Unsupported model: ${modelName}`);
  const openAiMessages = toOpenAiMessages(
    request.messages,
    request.config?.visualDetailLevel
  );
  const mappedModelName = request.config?.version || modelName;
  const body = {
    messages: openAiMessages,
    tools: request.tools?.map(toOpenAiTool),
    model: mappedModelName,
    max_tokens: request.config?.maxOutputTokens,
    temperature: request.config?.temperature,
    top_p: request.config?.topP,
    n: request.candidates,
    stop: request.config?.stopSequences,
    ...mapToSnakeCase(request.config?.custom || {})
  };
  const response_format = request.output?.format;
  if (response_format && MODELS_SUPPORTING_OPENAI_RESPONSE_FORMAT.includes(mappedModelName)) {
    if (response_format === "json" && model.info?.supports?.output?.includes("json")) {
      body.response_format = {
        type: "json_object"
      };
    } else if (response_format === "text" && model.info?.supports?.output?.includes("text")) {
      body.response_format = {
        type: "text"
      };
    } else {
      throw new Error(
        `${response_format} format is not supported for GPT models currently`
      );
    }
  }
  for (const key in body) {
    const typedKey = key;
    if (!body[typedKey] || Array.isArray(body[typedKey]) && !body[typedKey].length)
      delete body[typedKey];
  }
  return body;
}
function gptModel(ai, name, client) {
  const modelId = `azure-openai/${name}`;
  const model = SUPPORTED_GPT_MODELS[name];
  if (!model) throw new Error(`Unsupported model: ${name}`);
  return ai.defineModel(
    {
      name: modelId,
      ...model.info,
      configSchema: SUPPORTED_GPT_MODELS[name].configSchema
    },
    async (request, streamingCallback) => {
      let response;
      const body = toOpenAiRequestBody(name, request);
      if (streamingCallback) {
        const stream = client.chat.completions.stream({
          ...body,
          stream: true,
          stream_options: {
            include_usage: true
          }
        });
        for await (const chunk of stream) {
          chunk.choices?.forEach((chunk2) => {
            const c = fromOpenAiChunkChoice(chunk2);
            streamingCallback({
              index: c.index,
              content: c.message.content
            });
          });
        }
        response = await stream.finalChatCompletion();
      } else {
        response = await client.chat.completions.create(body);
      }
      return {
        candidates: response.choices.map(
          (c) => fromOpenAiChoice(c, request.output?.format === "json")
        ),
        usage: {
          inputTokens: response.usage?.prompt_tokens,
          outputTokens: response.usage?.completion_tokens,
          totalTokens: response.usage?.total_tokens
        },
        custom: response
      };
    }
  );
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  OpenAiConfigSchema,
  SUPPORTED_GPT_MODELS,
  codexMini,
  gpt35Turbo,
  gpt4,
  gpt41,
  gpt41Mini,
  gpt41Nano,
  gpt45,
  gpt4o,
  gpt4oMini,
  gpt5,
  gpt51,
  gpt51Chat,
  gpt51Codex,
  gpt51CodexMax,
  gpt51CodexMini,
  gpt52,
  gpt52Chat,
  gpt52Codex,
  gpt5Chat,
  gpt5Codex,
  gpt5Mini,
  gpt5Nano,
  gpt5Pro,
  gptModel,
  gptOss120b,
  gptOss20b,
  o1,
  o1Mini,
  o1Preview,
  o3,
  o3Mini,
  o3Pro,
  o4Mini,
  toOpenAiMessages,
  toOpenAiRequestBody,
  toOpenAiTextAndMedia
});
//# sourceMappingURL=gpt.js.map