@tanstack/ai
Version:
Type-safe TypeScript AI SDK for streaming chat, tool calling, agents, structured outputs, and multimodal generation.
140 lines (139 loc) • 5.25 kB
JavaScript
function toJsonSchema(obj) {
const result = {};
for (const [key, value] of Object.entries(obj)) {
if (key === "$schema") continue;
result[key] = value;
}
return result;
}
function isPropertyCarrier(schema) {
return (typeof schema === "object" || typeof schema === "function") && schema !== null;
}
function isStandardJSONSchema(schema) {
if (!isPropertyCarrier(schema) || !("~standard" in schema)) return false;
const standard = schema["~standard"];
if (typeof standard !== "object" || standard === null || !("version" in standard) || standard.version !== 1 || !("jsonSchema" in standard) || typeof standard.jsonSchema !== "object" || standard.jsonSchema === null || !("input" in standard.jsonSchema)) {
return false;
}
return typeof standard.jsonSchema.input === "function";
}
function isStandardSchema(schema) {
return isPropertyCarrier(schema) && "~standard" in schema && typeof schema["~standard"] === "object" && schema["~standard"] !== null && "version" in schema["~standard"] && schema["~standard"].version === 1 && "validate" in schema["~standard"] && typeof schema["~standard"].validate === "function";
}
function makeStructuredOutputCompatible(schema, originalRequired = []) {
const result = { ...schema };
if (result.type === "object" && result.properties) {
const properties = { ...result.properties };
const allPropertyNames = Object.keys(properties);
for (const propName of allPropertyNames) {
const prop = properties[propName];
if (!prop) continue;
const wasOptional = !originalRequired.includes(propName);
if (prop.type === "object" && prop.properties) {
const transformed = makeStructuredOutputCompatible(
prop,
prop.required || []
);
properties[propName] = wasOptional ? { ...transformed, type: ["object", "null"] } : transformed;
} else if (prop.type === "array" && prop.items) {
const items = Array.isArray(prop.items) ? prop.items[0] : prop.items;
const transformed = {
...prop,
items: items ? makeStructuredOutputCompatible(items, items.required || []) : prop.items
};
properties[propName] = wasOptional ? { ...transformed, type: ["array", "null"] } : transformed;
} else if (wasOptional) {
if (prop.type && !Array.isArray(prop.type)) {
properties[propName] = {
...prop,
type: [prop.type, "null"]
};
} else if (Array.isArray(prop.type) && !prop.type.includes("null")) {
properties[propName] = {
...prop,
type: [...prop.type, "null"]
};
}
}
}
result.properties = properties;
result.required = allPropertyNames;
result.additionalProperties = false;
}
if (result.type === "array" && result.items) {
const items = Array.isArray(result.items) ? result.items[0] : result.items;
if (items) {
result.items = makeStructuredOutputCompatible(items, items.required || []);
}
}
return result;
}
function convertSchemaToJsonSchema(schema, options = {}) {
if (!schema) return void 0;
const { forStructuredOutput = false } = options;
if (isStandardJSONSchema(schema)) {
const jsonSchema = schema["~standard"].jsonSchema.input({
target: "draft-07"
});
let result = toJsonSchema(jsonSchema);
if ("properties" in result && !result.type) {
result.type = "object";
}
if (result.type === "object" && !("properties" in result)) {
result.properties = {};
}
if (result.type === "object" && !("required" in result)) {
result.required = [];
}
if (forStructuredOutput) {
result = makeStructuredOutputCompatible(result, result.required || []);
}
return result;
}
if (isStandardSchema(schema)) {
throw new Error(
"Schema is a Standard Schema validator but does not expose a JSON Schema converter on `~standard.jsonSchema`. Use Zod v4.2+, ArkType v2.1.28+, or wrap a Valibot schema with `toStandardJsonSchema()` from `@valibot/to-json-schema` before passing it as `outputSchema`."
);
}
if (typeof schema !== "object") {
return schema;
}
if (forStructuredOutput) {
const typedView = toJsonSchema(schema);
return makeStructuredOutputCompatible(typedView, typedView.required || []);
}
return schema;
}
class StandardSchemaValidationError extends Error {
name = "StandardSchemaValidationError";
issues;
constructor(issues) {
super(
`Validation failed: ${issues.map((i) => i.message || "Validation failed").join(", ")}`
);
this.issues = issues;
}
}
function parseWithStandardSchema(schema, data) {
if (!isStandardSchema(schema)) {
return data;
}
const result = schema["~standard"].validate(data);
if (result instanceof Promise) {
throw new Error(
"Schema validation returned a Promise. Use validateWithStandardSchema for async validation."
);
}
if (!result.issues) {
return result.value;
}
throw new StandardSchemaValidationError(result.issues);
}
export {
StandardSchemaValidationError,
convertSchemaToJsonSchema,
isStandardJSONSchema,
isStandardSchema,
parseWithStandardSchema
};
//# sourceMappingURL=schema-converter.js.map