Function bundleSchema

src/core/structured-output-schema.ts:152–204

(rootSchema: JsonObject, commonSchema: JsonObject)

}

function bundleSchema(rootSchema: JsonObject, commonSchema: JsonObject): JsonObject {
  if (typeof rootSchema.$id !== 'string' || rootSchema.$id.length === 0) {
    throw new Error('Structured output schema must declare a non-empty $id.');
  }

  const pendingDefs = new Set<string>();
  const bundled = collectAndRewriteCommonRefs(cloneJson(rootSchema), pendingDefs);
  if (!isRecord(bundled)) {
    throw new Error('Structured output schema bundling produced a non-object root.');
  }

  const commonDefs = getCommonDefinitions(commonSchema);
  const rootDefs = bundled.$defs;
  const localDefsCandidate = rootDefs === undefined ? {} : cloneJson(rootDefs);
  if (!isRecord(localDefsCandidate)) {
    throw new Error('Structured output schema root $defs must be an object when present.');
  }
  const localDefs = localDefsCandidate;

  const processedDefs = new Set<string>();
  while (pendingDefs.size > 0) {
    const defName = pendingDefs.values().next().value;
    if (defName === undefined) {
      break;
    }
    pendingDefs.delete(defName);
    if (processedDefs.has(defName)) {
      continue;
    }

    const commonDef = commonDefs[defName];
    if (commonDef === undefined) {
      throw new Error(`Missing common structured output definition: ${defName}`);
    }

    const rewrittenDef = collectAndRewriteCommonRefs(cloneJson(commonDef), pendingDefs);
    mergeDefinition(localDefs, defName, rewrittenDef);
    processedDefs.add(defName);
  }

  if (Object.keys(localDefs).length > 0) {
    bundled.$defs = localDefs;
  }

  const serialized = JSON.stringify(bundled);
  if (serialized.includes(COMMON_DEFS_REF_PREFIX)) {
    throw new Error(
      'Structured output schema still contains external common $refs after bundling.',
    );
  }

  return bundled;
}

function inlineRegistrationSchemaResource(schema: JsonObject): {
  schema: JsonObject;