viscribe 0.1.0

package/dist/index.cjs

@@ -0,0 +1,826 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_MODEL: () => DEFAULT_MODEL,
+  StructuredOutputError: () => StructuredOutputError,
+  StructuredOutputFinishReasonError: () => StructuredOutputFinishReasonError,
+  StructuredOutputParseError: () => StructuredOutputParseError,
+  StructuredOutputRefusalError: () => StructuredOutputRefusalError,
+  StructuredOutputValidationError: () => StructuredOutputValidationError,
+  ViscribeAI: () => ViscribeAI,
+  buildSchemaFromFields: () => buildSchemaFromFields,
+  images: () => images_exports
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/images.ts
+var images_exports = {};
+__export(images_exports, {
+  ask: () => ask,
+  assertImagePathExists: () => assertImagePathExists,
+  buildImageSource: () => buildImageSource,
+  classify: () => classify,
+  compare: () => compare,
+  describe: () => describe,
+  extract: () => extract
+});
+
+// src/client.ts
+var import_openai = __toESM(require("openai"), 1);
+
+// src/image-source.ts
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_url = require("url");
+function buildImageSource(input) {
+  const provided = [
+    input.imageUrl !== void 0,
+    input.imageBase64 !== void 0,
+    input.imagePath !== void 0
+  ].filter(Boolean).length;
+  if (provided !== 1) {
+    throw new Error(
+      "Provide exactly one of 'imageUrl', 'imageBase64', or 'imagePath'."
+    );
+  }
+  if (input.imageUrl !== void 0) {
+    validateImageUrl(input.imageUrl);
+    return input.imageUrl;
+  }
+  if (input.imagePath !== void 0) {
+    const imageBytes = (0, import_node_fs.readFileSync)(input.imagePath);
+    const mimeType = detectImageMimeType(imageBytes);
+    return `data:${mimeType};base64,${imageBytes.toString("base64")}`;
+  }
+  if (input.imageBase64?.startsWith("data:")) {
+    validateDataUrl(input.imageBase64);
+    return input.imageBase64;
+  }
+  if (input.imageBase64 !== void 0) {
+    const imageBytes = decodeBase64(input.imageBase64);
+    const mimeType = detectImageMimeType(imageBytes);
+    return `data:${mimeType};base64,${input.imageBase64}`;
+  }
+  throw new Error(
+    "Provide exactly one of 'imageUrl', 'imageBase64', or 'imagePath'."
+  );
+}
+async function assertImagePathExists(imagePath) {
+  const result = await (0, import_promises.stat)(imagePath);
+  if (!result.isFile()) {
+    throw new Error(`imagePath does not point to a file: ${imagePath}`);
+  }
+}
+function validateImageUrl(imageUrl) {
+  let parsed;
+  try {
+    parsed = new import_node_url.URL(imageUrl);
+  } catch (error) {
+    throw new Error("imageUrl must be an absolute http:// or https:// URL.", {
+      cause: error
+    });
+  }
+  if (!["http:", "https:"].includes(parsed.protocol) || !parsed.host) {
+    throw new Error("imageUrl must be an absolute http:// or https:// URL.");
+  }
+}
+function validateDataUrl(dataUrl) {
+  if (!dataUrl.includes(";base64,")) {
+    throw new Error("imageBase64 data URLs must include ';base64,'.");
+  }
+  const payload = dataUrl.split(",", 2)[1];
+  decodeBase64(payload);
+}
+function decodeBase64(payload) {
+  if (!payload || payload.length % 4 !== 0) {
+    throw new Error("imageBase64 must be valid base64 data.");
+  }
+  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(payload)) {
+    throw new Error("imageBase64 must be valid base64 data.");
+  }
+  return Buffer.from(payload, "base64");
+}
+function detectImageMimeType(imageBytes) {
+  if (imageBytes.subarray(0, 3).equals(Buffer.from([255, 216, 255]))) {
+    return "image/jpeg";
+  }
+  if (imageBytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (imageBytes.subarray(0, 6).toString("ascii") === "GIF87a" || imageBytes.subarray(0, 6).toString("ascii") === "GIF89a") {
+    return "image/gif";
+  }
+  if (imageBytes.length >= 12 && imageBytes.subarray(0, 4).toString("ascii") === "RIFF" && imageBytes.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  if (imageBytes.subarray(0, 2).toString("ascii") === "BM") {
+    return "image/bmp";
+  }
+  throw new Error("Unsupported image format. Use JPEG, PNG, GIF, WebP, or BMP.");
+}
+
+// src/prompts.ts
+var EXTRACT_SYSTEM_PROMPT = `
+You are an expert at extracting structured information from images.
+
+CRITICAL INSTRUCTIONS:
+- Respond with valid JSON only.
+- Do not include explanatory text, code blocks, or markdown formatting.
+- Your response must be a single JSON object that exactly matches the provided schema.
+
+TASK:
+- Analyze the image carefully and extract data according to the provided schema.
+- Be precise and accurate.
+- If a value is not visible or cannot be inferred from the image, use null
+  when the schema allows it.
+- Ensure all required fields are included.
+`.trim();
+var DESCRIBE_SYSTEM_PROMPT = `
+You are an expert image analyst.
+
+CRITICAL INSTRUCTIONS:
+- Respond with valid JSON only.
+- Do not include explanatory text, code blocks, or markdown formatting.
+- Your response must be a single JSON object that exactly matches the provided schema.
+- Follow any user-provided instruction closely.
+
+TASK:
+- Provide a detailed, objective description of the image.
+- Focus on main elements, context, and notable details.
+- If tags are requested, generate up to 5 relevant tags.
+`.trim();
+var CLASSIFY_SYSTEM_PROMPT = `
+You are an expert at image classification.
+
+CRITICAL INSTRUCTIONS:
+- Respond with valid JSON only.
+- Do not include explanatory text, code blocks, or markdown formatting.
+- Your response must be a single JSON object that exactly matches the provided schema.
+
+TASK:
+- Analyze the image and classify it according to the requested categories or task.
+- Return only categories that are supported by the image.
+- If the image cannot be classified into a requested category, return an empty list.
+`.trim();
+var ASK_SYSTEM_PROMPT = `
+You are an expert at analyzing images and answering related questions.
+
+CRITICAL INSTRUCTIONS:
+- Respond with valid JSON only.
+- Do not include explanatory text, code blocks, or markdown formatting.
+- Your response must be a single JSON object that exactly matches the provided schema.
+
+TASK:
+- Carefully examine the provided image.
+- Deliver a clear, accurate, and detailed response to the question.
+- If the answer cannot be determined from the image, state that the information is not available.
+`.trim();
+var COMPARE_SYSTEM_PROMPT = `
+You are an expert at comparing images.
+
+CRITICAL INSTRUCTIONS:
+- Respond with valid JSON only.
+- Do not include explanatory text, code blocks, or markdown formatting.
+- Your response must be a single JSON object that exactly matches the provided schema.
+
+TASK:
+- Analyze two provided images, focusing on their visual elements.
+- Identify and describe similarities.
+- Highlight differences in color, texture, composition, subject matter, and context.
+- Point out notable features unique to each image.
+`.trim();
+
+// src/schema.ts
+function buildSchemaFromFields(fields) {
+  if (fields.length === 0) {
+    throw new Error("At least one extraction field is required.");
+  }
+  if (fields.length > 10) {
+    throw new Error("A maximum of 10 extraction fields is supported.");
+  }
+  const names = fields.map((field) => validateField(field).name);
+  const duplicates = names.filter((name, index) => names.indexOf(name) !== index);
+  if (duplicates.length > 0) {
+    throw new Error(
+      `Field names must be unique. Duplicates: ${[...new Set(duplicates)].join(", ")}.`
+    );
+  }
+  const properties = Object.fromEntries(
+    fields.map((field) => [field.name, schemaForField(field)])
+  );
+  return {
+    title: "ExtractedData",
+    description: "Structured data extracted from an image.",
+    type: "object",
+    properties,
+    required: names,
+    additionalProperties: false
+  };
+}
+function validateField(field) {
+  if (!field.name) {
+    throw new Error("Field name cannot be empty.");
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(field.name)) {
+    throw new Error(
+      "Field names must contain letters, numbers, or underscores, and cannot start with a number."
+    );
+  }
+  if (!["text", "number", "array_text", "array_number"].includes(field.type)) {
+    throw new Error("Unsupported field type.");
+  }
+  return field;
+}
+function schemaForField(field) {
+  const schema = field.type === "text" ? { type: ["string", "null"] } : field.type === "number" ? { type: ["number", "null"] } : field.type === "array_text" ? {
+    type: ["array", "null"],
+    items: { type: "string" },
+    maxItems: 5
+  } : {
+    type: ["array", "null"],
+    items: { type: "number" },
+    maxItems: 5
+  };
+  if (field.description) {
+    return { ...schema, description: field.description };
+  }
+  return schema;
+}
+
+// src/client.ts
+var DEFAULT_MODEL = "gpt-4o-mini";
+var CLIENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "apiKey",
+  "api_key",
+  "organization",
+  "project",
+  "baseURL",
+  "baseUrl",
+  "base_url",
+  "timeout",
+  "maxRetries",
+  "max_retries",
+  "defaultHeaders",
+  "defaultQuery",
+  "fetch",
+  "httpAgent"
+]);
+var DESCRIBE_SCHEMA = {
+  title: "ImageDescription",
+  description: "Structured description of an image.",
+  type: "object",
+  properties: {
+    image_description: {
+      type: "string",
+      description: "Objective description of the image."
+    },
+    tags: {
+      type: "array",
+      items: { type: "string" },
+      maxItems: 5,
+      description: "Relevant tags describing the image."
+    }
+  },
+  required: ["image_description", "tags"],
+  additionalProperties: false
+};
+var DESCRIBE_NO_TAGS_SCHEMA = {
+  title: "ImageDescription",
+  description: "Structured description of an image.",
+  type: "object",
+  properties: {
+    image_description: {
+      type: "string",
+      description: "Objective description of the image."
+    }
+  },
+  required: ["image_description"],
+  additionalProperties: false
+};
+var CLASSIFY_SCHEMA = {
+  title: "ImageClassification",
+  description: "Structured classification of an image.",
+  type: "object",
+  properties: {
+    classification: {
+      type: "array",
+      items: { type: "string" },
+      description: "Predicted class names."
+    }
+  },
+  required: ["classification"],
+  additionalProperties: false
+};
+var ASK_SCHEMA = {
+  title: "ImageQuestionAnswer",
+  description: "Answer to a question about an image.",
+  type: "object",
+  properties: {
+    answer: {
+      type: "string",
+      description: "Answer to the question based on the image."
+    }
+  },
+  required: ["answer"],
+  additionalProperties: false
+};
+var COMPARE_SCHEMA = {
+  title: "ImageComparison",
+  description: "Structured comparison of two images.",
+  type: "object",
+  properties: {
+    comparison_result: {
+      type: "string",
+      description: "Textual comparison of the two images."
+    }
+  },
+  required: ["comparison_result"],
+  additionalProperties: false
+};
+var StructuredOutputError = class extends Error {
+};
+var StructuredOutputRefusalError = class extends StructuredOutputError {
+};
+var StructuredOutputParseError = class extends StructuredOutputError {
+};
+var StructuredOutputValidationError = class extends StructuredOutputError {
+};
+var StructuredOutputFinishReasonError = class extends StructuredOutputError {
+};
+var ViscribeAI = class {
+  model;
+  strict;
+  images;
+  modelConfig;
+  client;
+  constructor(options = {}) {
+    const modelConfig = resolveModelConfig(options);
+    this.model = modelConfig.model;
+    this.modelConfig = {
+      client: modelConfig.client,
+      request: modelConfig.request
+    };
+    this.strict = options.strict ?? true;
+    this.client = options.client;
+    this.images = {
+      extract: (extractOptions) => this.extractImage(extractOptions),
+      describe: (describeOptions) => this.describeImage(describeOptions),
+      classify: (classifyOptions) => this.classifyImage(classifyOptions),
+      ask: (askOptions) => this.askImage(askOptions),
+      compare: (compareOptions) => this.compareImages(compareOptions)
+    };
+  }
+  async extractImage(options) {
+    const schema = resolveOutputSchema(options);
+    return this.structuredImageRequest({
+      messages: singleImageMessages({
+        systemPrompt: EXTRACT_SYSTEM_PROMPT,
+        userPrompt: options.instruction ?? "Extract information from this image according to the provided schema.",
+        imageSource: options
+      }),
+      schema
+    });
+  }
+  async describeImage(options) {
+    return this.structuredImageRequest({
+      messages: singleImageMessages({
+        systemPrompt: DESCRIBE_SYSTEM_PROMPT,
+        userPrompt: options.instruction ?? "Describe this image.",
+        imageSource: options
+      }),
+      schema: options.generateTags ?? true ? DESCRIBE_SCHEMA : DESCRIBE_NO_TAGS_SCHEMA
+    });
+  }
+  async classifyImage(options) {
+    const classes = validateClassificationOptions(options);
+    return this.structuredImageRequest({
+      messages: singleImageMessages({
+        systemPrompt: CLASSIFY_SYSTEM_PROMPT,
+        userPrompt: classificationPrompt({ ...options, classes }),
+        imageSource: options
+      }),
+      schema: classificationSchema({ multiLabel: options.multiLabel ?? false }),
+      transform: (data) => normalizeClassification(data, { classes })
+    });
+  }
+  async askImage(options) {
+    const question = validateQuestion(options.question);
+    return this.structuredImageRequest({
+      messages: singleImageMessages({
+        systemPrompt: ASK_SYSTEM_PROMPT,
+        userPrompt: question,
+        imageSource: options
+      }),
+      schema: ASK_SCHEMA
+    });
+  }
+  async compareImages(options) {
+    return this.structuredImageRequest({
+      messages: compareMessages(options),
+      schema: COMPARE_SCHEMA
+    });
+  }
+  async structuredImageRequest(options) {
+    const response = await this.getClient().chat.completions.create({
+      messages: options.messages,
+      model: this.model,
+      response_format: responseFormatForSchema(options.schema, this.strict),
+      ...this.modelConfig.request
+    });
+    return resultFromResponse(response, {
+      rawSchema: options.schema,
+      transform: options.transform
+    });
+  }
+  getClient() {
+    if (!this.client) {
+      this.client = new import_openai.default(
+        this.modelConfig.client
+      );
+    }
+    return this.client;
+  }
+};
+function resolveModelConfig(options) {
+  const raw = typeof options.modelConfig === "string" ? { model: options.modelConfig } : { ...options.modelConfig ?? {} };
+  raw.model ??= DEFAULT_MODEL;
+  raw.temperature ??= 0;
+  if (options.apiKey) {
+    raw.apiKey = options.apiKey;
+  }
+  if (options.temperature !== void 0) {
+    raw.temperature = options.temperature;
+  }
+  const model = String(raw.model);
+  delete raw.model;
+  const client = {};
+  const request = {};
+  for (const [key, value] of Object.entries(raw)) {
+    const normalizedKey = normalizeClientKey(key);
+    if (CLIENT_CONFIG_KEYS.has(key) || CLIENT_CONFIG_KEYS.has(normalizedKey)) {
+      client[normalizedKey] = value;
+    } else {
+      request[key] = value;
+    }
+  }
+  return { model, client, request };
+}
+function normalizeClientKey(key) {
+  return key === "api_key" ? "apiKey" : key === "base_url" || key === "baseUrl" ? "baseURL" : key === "max_retries" ? "maxRetries" : key;
+}
+function resolveOutputSchema(options) {
+  if (!options.outputSchema) {
+    throw new Error("'outputSchema' must be provided.");
+  }
+  return Array.isArray(options.outputSchema) ? buildSchemaFromFields(options.outputSchema) : options.outputSchema;
+}
+function singleImageMessages(options) {
+  const imageSource = buildImageSource(options.imageSource);
+  return [
+    { role: "system", content: options.systemPrompt },
+    {
+      role: "user",
+      content: [
+        {
+          type: "text",
+          text: options.userPrompt
+        },
+        { type: "image_url", image_url: { url: imageSource } }
+      ]
+    }
+  ];
+}
+function compareMessages(options) {
+  const image1Source = buildNumberedImageSource("image1", {
+    imageUrl: options.image1Url,
+    imageBase64: options.image1Base64,
+    imagePath: options.image1Path
+  });
+  const image2Source = buildNumberedImageSource("image2", {
+    imageUrl: options.image2Url,
+    imageBase64: options.image2Base64,
+    imagePath: options.image2Path
+  });
+  return [
+    { role: "system", content: COMPARE_SYSTEM_PROMPT },
+    {
+      role: "user",
+      content: [
+        {
+          type: "text",
+          text: options.instruction ?? "Describe the similarities and differences between these two images."
+        },
+        { type: "image_url", image_url: { url: image1Source } },
+        { type: "image_url", image_url: { url: image2Source } }
+      ]
+    }
+  ];
+}
+function buildNumberedImageSource(label, input) {
+  const provided = [
+    input.imageUrl !== void 0,
+    input.imageBase64 !== void 0,
+    input.imagePath !== void 0
+  ].filter(Boolean).length;
+  if (provided !== 1) {
+    throw new Error(
+      `Provide exactly one source for '${label}': '${label}Url', '${label}Base64', or '${label}Path'.`
+    );
+  }
+  return buildImageSource(input);
+}
+function classificationSchema(options) {
+  const schema = structuredClone(CLASSIFY_SCHEMA);
+  const properties = schema.properties;
+  if (!options.multiLabel && isPlainObject(properties)) {
+    const classification = properties.classification;
+    if (isPlainObject(classification)) {
+      classification.maxItems = 1;
+    }
+  }
+  return schema;
+}
+function classificationPrompt(options) {
+  const parts = [options.instruction ?? "Classify this image."];
+  if (options.classes && options.classes.length > 0) {
+    parts.push(`Allowed classes: ${options.classes.join(", ")}.`);
+  } else if (options.classes) {
+    parts.push("No allowed classes were provided; return an empty list.");
+  }
+  if (options.classDescriptions) {
+    const descriptions = Object.entries(options.classDescriptions).map(([className, description]) => `- ${className}: ${description}`).join("\n");
+    parts.push(`Class descriptions:
+${descriptions}`);
+  }
+  parts.push(
+    options.multiLabel ? "Return every relevant class in the classification list." : "Return at most one class in the classification list."
+  );
+  return parts.join("\n");
+}
+function validateClassificationOptions(options) {
+  const classes = options.classes ? [...options.classes] : void 0;
+  if (options.classDescriptions) {
+    if (!classes || classes.length === 0) {
+      throw new Error(
+        "'classDescriptions' can only be provided when 'classes' is provided."
+      );
+    }
+    const invalidClasses = Object.keys(options.classDescriptions).filter(
+      (className) => !classes.includes(className)
+    );
+    if (invalidClasses.length > 0) {
+      throw new Error(
+        `'classDescriptions' contains entries not present in 'classes': ${invalidClasses.sort().join(", ")}.`
+      );
+    }
+  }
+  return classes;
+}
+function normalizeClassification(data, options) {
+  const rawClassification = data.classification;
+  let classification;
+  if (typeof rawClassification === "string") {
+    classification = rawClassification ? [rawClassification] : [];
+  } else if (Array.isArray(rawClassification)) {
+    classification = rawClassification.filter((value) => typeof value === "string").map((value) => value);
+  } else {
+    classification = [];
+  }
+  if (options.classes) {
+    const allowedClasses = new Set(options.classes);
+    classification = classification.filter(
+      (className) => allowedClasses.has(className)
+    );
+  }
+  return { classification };
+}
+function validateQuestion(question) {
+  if (typeof question !== "string" || question.trim().length === 0) {
+    throw new Error("'question' must be provided.");
+  }
+  return question.trim();
+}
+function responseFormatForSchema(rawSchema, strict) {
+  if (rawSchema.type === "json_schema" && typeof rawSchema.json_schema === "object" && rawSchema.json_schema !== null) {
+    const jsonSchema = { ...rawSchema.json_schema };
+    jsonSchema.strict ??= strict;
+    return { type: "json_schema", json_schema: jsonSchema };
+  }
+  const schema = strict ? strictJsonSchema(rawSchema) : { ...rawSchema };
+  const name = String(schema.title ?? "ExtractedData");
+  const description = typeof schema.description === "string" ? schema.description : void 0;
+  delete schema.title;
+  delete schema.description;
+  return {
+    type: "json_schema",
+    json_schema: {
+      name,
+      ...description ? { description } : {},
+      strict,
+      schema
+    }
+  };
+}
+function strictJsonSchema(schema) {
+  const copy = structuredClone(schema);
+  ensureStrictJsonSchema(copy);
+  return copy;
+}
+function ensureStrictJsonSchema(schema) {
+  for (const defsKey of ["$defs", "definitions"]) {
+    const defs = schema[defsKey];
+    if (isPlainObject(defs)) {
+      for (const value of Object.values(defs)) {
+        if (isPlainObject(value)) ensureStrictJsonSchema(value);
+      }
+    }
+  }
+  if (schema.type === "object" && schema.additionalProperties === void 0) {
+    schema.additionalProperties = false;
+  }
+  if (isPlainObject(schema.properties)) {
+    schema.required = Object.keys(schema.properties);
+    for (const value of Object.values(schema.properties)) {
+      if (isPlainObject(value)) ensureStrictJsonSchema(value);
+    }
+  }
+  if (isPlainObject(schema.items)) {
+    ensureStrictJsonSchema(schema.items);
+  }
+  for (const key of ["anyOf", "allOf"]) {
+    const value = schema[key];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (isPlainObject(item)) ensureStrictJsonSchema(item);
+      }
+    }
+  }
+  if (schema.default === null) {
+    delete schema.default;
+  }
+}
+function resultFromResponse(response, context) {
+  const parsed = parseStructuredResponse(response);
+  return {
+    data: context.transform ? context.transform(parsed) : parsed,
+    raw: response,
+    usageMetadata: usageMetadata(response)
+  };
+}
+function parseStructuredResponse(response) {
+  const choice = firstChoice(response);
+  if (choice.finish_reason === "length" || choice.finish_reason === "content_filter") {
+    throw new StructuredOutputFinishReasonError(
+      `Model finished with reason '${choice.finish_reason}'.`
+    );
+  }
+  const message = choice.message;
+  if (!isPlainObject(message)) {
+    throw new StructuredOutputParseError("Response does not contain a message.");
+  }
+  const refusal = message.refusal;
+  if (typeof refusal === "string" && refusal) {
+    throw new StructuredOutputRefusalError(refusal);
+  }
+  const parsed = message.parsed;
+  if (isPlainObject(parsed)) {
+    return parsed;
+  }
+  const content = messageContentText(message);
+  return loadsJsonObject(content);
+}
+function firstChoice(response) {
+  if (!isPlainObject(response) || !Array.isArray(response.choices)) {
+    throw new StructuredOutputParseError("Response does not contain choices.");
+  }
+  const choice = response.choices[0];
+  if (!isPlainObject(choice)) {
+    throw new StructuredOutputParseError("Response does not contain choices.");
+  }
+  return choice;
+}
+function messageContentText(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (Array.isArray(message.content)) {
+    const text = message.content.filter(
+      (block) => isPlainObject(block) && (block.type === "text" || block.type === "output_text") && typeof block.text === "string"
+    ).map((block) => block.text).join("");
+    if (text) return text;
+  }
+  throw new StructuredOutputParseError(
+    "Response message does not contain text content."
+  );
+}
+function loadsJsonObject(content) {
+  const trimmed = content.trim();
+  const attempts = [trimmed];
+  if (trimmed.startsWith("```")) {
+    const lines = trimmed.split(/\r?\n/);
+    if (lines.length >= 3 && lines.at(-1)?.trim() === "```") {
+      attempts.push(lines.slice(1, -1).join("\n").trim());
+    }
+  }
+  const firstBrace = trimmed.indexOf("{");
+  const lastBrace = trimmed.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace > firstBrace) {
+    attempts.push(trimmed.slice(firstBrace, lastBrace + 1));
+  }
+  let lastError;
+  for (const attempt of attempts) {
+    try {
+      const data = JSON.parse(attempt);
+      if (!isPlainObject(data)) {
+        throw new StructuredOutputParseError(
+          "Structured output must be a JSON object."
+        );
+      }
+      return data;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw new StructuredOutputParseError("Could not parse structured output JSON.", {
+    cause: lastError
+  });
+}
+function usageMetadata(response) {
+  if (!isPlainObject(response) || !isPlainObject(response.usage)) {
+    return {};
+  }
+  const metadata = { ...response.usage };
+  if (typeof metadata.prompt_tokens === "number") {
+    metadata.input_tokens = metadata.prompt_tokens;
+  }
+  if (typeof metadata.completion_tokens === "number") {
+    metadata.output_tokens = metadata.completion_tokens;
+  }
+  return metadata;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/images.ts
+async function extract(options) {
+  const client = new ViscribeAI(options);
+  return client.images.extract(options);
+}
+async function describe(options) {
+  const client = new ViscribeAI(options);
+  return client.images.describe(options);
+}
+async function classify(options) {
+  const client = new ViscribeAI(options);
+  return client.images.classify(options);
+}
+async function ask(options) {
+  const client = new ViscribeAI(options);
+  return client.images.ask(options);
+}
+async function compare(options) {
+  const client = new ViscribeAI(options);
+  return client.images.compare(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_MODEL,
+  StructuredOutputError,
+  StructuredOutputFinishReasonError,
+  StructuredOutputParseError,
+  StructuredOutputRefusalError,
+  StructuredOutputValidationError,
+  ViscribeAI,
+  buildSchemaFromFields,
+  images
+});