@wp-typia/project-tools 0.23.1 → 0.24.1

package/dist/runtime/post-meta-binding-fields.js

@@ -0,0 +1,135 @@
+import path from "node:path";
+import { readJsonFile, readJsonFileSync } from "./json-utils.js";
+const SUPPORTED_SCHEMA_TYPES = new Set([
+    "array",
+    "boolean",
+    "integer",
+    "number",
+    "object",
+    "string",
+]);
+function isJsonRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveSchemaType(schema) {
+    const type = schema.type;
+    if (typeof type === "string" && SUPPORTED_SCHEMA_TYPES.has(type)) {
+        return type;
+    }
+    if (Array.isArray(type) &&
+        type.every((entry) => typeof entry === "string")) {
+        const nonNullType = type.find((entry) => entry !== "null" && SUPPORTED_SCHEMA_TYPES.has(entry));
+        if (nonNullType) {
+            return nonNullType;
+        }
+    }
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        return "string";
+    }
+    return "unknown";
+}
+function resolveFallbackValue(name, schema, schemaType) {
+    const enumValue = Array.isArray(schema.enum)
+        ? schema.enum.find((entry) => typeof entry === "string")
+        : undefined;
+    if (typeof enumValue === "string") {
+        return enumValue;
+    }
+    switch (schemaType) {
+        case "array":
+            return "[]";
+        case "boolean":
+            return "false";
+        case "integer":
+        case "number":
+            return "0";
+        case "object":
+            return "{}";
+        default:
+            return `${name} preview`;
+    }
+}
+function resolveFieldLabel(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function extractPostMetaBindingFields(schema, context) {
+    if (!isJsonRecord(schema) || !isJsonRecord(schema.properties)) {
+        throw new Error(`${context} must expose an object schema with top-level properties before it can back a binding source.`);
+    }
+    const required = Array.isArray(schema.required)
+        ? new Set(schema.required.filter((entry) => typeof entry === "string"))
+        : new Set();
+    const fields = Object.entries(schema.properties).map(([name, propertySchema]) => {
+        const property = isJsonRecord(propertySchema) ? propertySchema : {};
+        const schemaType = resolveSchemaType(property);
+        return {
+            fallbackValue: resolveFallbackValue(name, property, schemaType),
+            label: resolveFieldLabel(name),
+            name,
+            required: required.has(name),
+            schemaType,
+        };
+    });
+    if (fields.length === 0) {
+        throw new Error(`${context} does not expose any top-level properties that can back binding fields.`);
+    }
+    return fields;
+}
+/**
+ * Load and extract binding fields from a post-meta JSON Schema artifact.
+ *
+ * @param projectDir Workspace root directory.
+ * @param postMeta Post-meta inventory entry that points to the schema file.
+ * @returns Promise resolving to the extracted top-level binding fields.
+ * @throws If the schema cannot be read or does not expose object properties.
+ */
+export async function loadPostMetaBindingFields(projectDir, postMeta) {
+    const schemaPath = path.join(projectDir, postMeta.schemaFile);
+    const schema = await readJsonFile(schemaPath, {
+        context: `post meta schema for ${postMeta.slug}`,
+    });
+    return extractPostMetaBindingFields(schema, postMeta.schemaFile);
+}
+/**
+ * Synchronously load and extract binding fields from a post-meta JSON Schema artifact.
+ *
+ * @param projectDir Workspace root directory.
+ * @param postMeta Post-meta inventory entry that points to the schema file.
+ * @returns Extracted top-level binding fields.
+ * @throws If the schema cannot be read or does not expose object properties.
+ */
+export function loadPostMetaBindingFieldsSync(projectDir, postMeta) {
+    const schemaPath = path.join(projectDir, postMeta.schemaFile);
+    const schema = readJsonFileSync(schemaPath, {
+        context: `post meta schema for ${postMeta.slug}`,
+    });
+    return extractPostMetaBindingFields(schema, postMeta.schemaFile);
+}
+/**
+ * Validate and resolve a top-level post-meta binding path.
+ *
+ * @param fields Binding fields extracted from the post-meta schema.
+ * @param postMetaSlug Post-meta contract slug used in diagnostics.
+ * @param metaPath User-provided field path to validate.
+ * @returns The matching binding field.
+ * @throws If the path is empty, nested, or missing from the schema fields.
+ */
+export function assertPostMetaBindingPath(fields, postMetaSlug, metaPath) {
+    const trimmed = metaPath.trim();
+    if (!trimmed) {
+        throw new Error("Post meta binding path must include a value.");
+    }
+    if (trimmed.includes(".")) {
+        throw new Error(`Nested post meta path "${trimmed}" for "${postMetaSlug}" is not supported yet. Use one of the top-level fields: ${fields.map((field) => field.name).join(", ")}.`);
+    }
+    const field = fields.find((candidate) => candidate.name === trimmed);
+    if (!field) {
+        throw new Error(`Post meta path "${trimmed}" does not exist in the "${postMetaSlug}" schema. Expected one of: ${fields.map((candidate) => candidate.name).join(", ")}.`);
+    }
+    return field;
+}

package/dist/runtime/template-source-cache-markers.js

@@ -1,3 +1,4 @@
+import { safeJsonParse } from './json-utils.js';
 /**
  * Marker file written after a cache entry is fully populated.
  */
@@ -41,7 +42,9 @@ export function sanitizeExternalTemplateCacheMetadata(metadata) {
 export function parseExternalTemplateCacheEntryMarker(markerText) {
     let marker;
     try {
-        marker = JSON.parse(markerText);
+        marker = safeJsonParse(markerText, {
+            context: 'external template cache entry marker',
+        });
     }
     catch {
         return null;
@@ -78,7 +81,9 @@ export function isExternalTemplateCacheEntryFreshForTtl(createdAtMs, nowMs, ttlM
 export function parseExternalTemplateCachePruneMarker(markerText) {
     let marker;
     try {
-        marker = JSON.parse(markerText);
+        marker = safeJsonParse(markerText, {
+            context: 'external template cache prune marker',
+        });
     }
     catch {
         return null;

package/dist/runtime/typia-llm-json-schema.d.ts

@@ -0,0 +1,24 @@
+import type { JsonSchemaObject } from './schema-core.js';
+/**
+ * Clone a JSON-compatible value when the caller has provided one.
+ *
+ * @template T JSON-compatible value type.
+ * @param value Optional value to clone with the shared JSON clone helper.
+ * @returns A cloned value, or undefined when the input is undefined.
+ */
+export declare function cloneJsonValueIfDefined<T>(value: T | undefined): T | undefined;
+/**
+ * Check whether a candidate is a non-null JSON Schema object.
+ *
+ * @param value Candidate value to narrow.
+ * @returns True when the value is an object and not an array.
+ */
+export declare function isJsonSchemaObject(value: unknown): value is JsonSchemaObject;
+/**
+ * Narrow a `typia.llm` artifact field before applying JSON Schema mutations.
+ *
+ * @param value Candidate schema value emitted by `typia.llm`.
+ * @param context Human-readable artifact path for diagnostics.
+ * @returns The value narrowed to the shared JSON Schema object shape.
+ */
+export declare function assertJsonSchemaObject(value: unknown, context: string): JsonSchemaObject;

package/dist/runtime/typia-llm-json-schema.js

@@ -0,0 +1,33 @@
+import { cloneJsonValue } from './json-utils.js';
+/**
+ * Clone a JSON-compatible value when the caller has provided one.
+ *
+ * @template T JSON-compatible value type.
+ * @param value Optional value to clone with the shared JSON clone helper.
+ * @returns A cloned value, or undefined when the input is undefined.
+ */
+export function cloneJsonValueIfDefined(value) {
+    return value === undefined ? undefined : cloneJsonValue(value);
+}
+/**
+ * Check whether a candidate is a non-null JSON Schema object.
+ *
+ * @param value Candidate value to narrow.
+ * @returns True when the value is an object and not an array.
+ */
+export function isJsonSchemaObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Narrow a `typia.llm` artifact field before applying JSON Schema mutations.
+ *
+ * @param value Candidate schema value emitted by `typia.llm`.
+ * @param context Human-readable artifact path for diagnostics.
+ * @returns The value narrowed to the shared JSON Schema object shape.
+ */
+export function assertJsonSchemaObject(value, context) {
+    if (isJsonSchemaObject(value)) {
+        return value;
+    }
+    throw new Error(`${context} must be a JSON Schema object.`);
+}

package/dist/runtime/typia-llm-openapi-constraints.d.ts

@@ -0,0 +1,20 @@
+import type { ApplyOpenApiConstraintsToTypiaLlmFunctionArtifactOptions, ProjectedTypiaLlmFunctionArtifact } from './typia-llm-types.js';
+/**
+ * Clone a projected function artifact before mutation-oriented constraint work.
+ *
+ * @param functionArtifact Projected artifact to clone.
+ * @returns A cloned artifact with parameters and optional output deep-cloned,
+ * and tags shallow-copied when present.
+ */
+export declare function cloneProjectedTypiaLlmFunctionArtifact(functionArtifact: ProjectedTypiaLlmFunctionArtifact): ProjectedTypiaLlmFunctionArtifact;
+/**
+ * Restores canonical request and response constraints from an endpoint-aware
+ * OpenAPI document onto one projected `typia.llm` function artifact.
+ *
+ * Query-only inputs merge into the root parameter object. Mixed body/query
+ * inputs merge into the generated `body` and `query` properties.
+ *
+ * @param options Projected artifact plus the canonical OpenAPI document.
+ * @returns A cloned artifact enriched with OpenAPI-backed constraints when available.
+ */
+export declare function applyOpenApiConstraintsToTypiaLlmFunctionArtifact({ functionArtifact, openApiDocument, operationId, }: ApplyOpenApiConstraintsToTypiaLlmFunctionArtifactOptions): ProjectedTypiaLlmFunctionArtifact;

package/dist/runtime/typia-llm-openapi-constraints.js

@@ -0,0 +1,254 @@
+import { cloneJsonValue } from './json-utils.js';
+import { assertJsonSchemaObject, cloneJsonValueIfDefined, isJsonSchemaObject, } from './typia-llm-json-schema.js';
+const JSON_SCHEMA_CONSTRAINT_KEYS = [
+    'additionalProperties',
+    'const',
+    'default',
+    'enum',
+    'exclusiveMaximum',
+    'exclusiveMinimum',
+    'format',
+    'maxItems',
+    'maxLength',
+    'maximum',
+    'minItems',
+    'minLength',
+    'minimum',
+    'multipleOf',
+    'pattern',
+    'type',
+];
+function decodeJsonPointerSegment(segment) {
+    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+function resolveOpenApiReferenceTarget(document, reference) {
+    if (!reference.startsWith('#/')) {
+        throw new Error(`Unsupported OpenAPI schema reference "${reference}".`);
+    }
+    let current = document;
+    for (const rawSegment of reference.slice(2).split('/')) {
+        const segment = decodeJsonPointerSegment(rawSegment);
+        if (Array.isArray(current)) {
+            const index = Number.parseInt(segment, 10);
+            current = Number.isInteger(index) ? current[index] : undefined;
+            continue;
+        }
+        if (!isJsonSchemaObject(current)) {
+            current = undefined;
+            break;
+        }
+        current = current[segment];
+    }
+    if (!isJsonSchemaObject(current)) {
+        throw new Error(`Unable to resolve OpenAPI schema reference "${reference}".`);
+    }
+    return current;
+}
+function resolveOpenApiSchemaObject(document, schema, seenReferences = new Set()) {
+    if (!isJsonSchemaObject(schema)) {
+        return {};
+    }
+    const reference = schema.$ref;
+    if (typeof reference !== 'string') {
+        return schema;
+    }
+    if (seenReferences.has(reference)) {
+        return schema;
+    }
+    return resolveOpenApiSchemaObject(document, resolveOpenApiReferenceTarget(document, reference), new Set([...seenReferences, reference]));
+}
+function collectOpenApiSeenReferences(schema, seenReferences) {
+    const reference = schema.$ref;
+    if (typeof reference !== 'string' || seenReferences.has(reference)) {
+        return seenReferences;
+    }
+    return new Set([...seenReferences, reference]);
+}
+/**
+ * Copy constraint-oriented JSON Schema keywords from `source` into `target`.
+ *
+ * This helper intentionally mutates and returns `target` so nested OpenAPI
+ * constraint restoration can preserve the projected typia.llm schema shape.
+ * Callers that need immutable behavior should clone the target before calling.
+ */
+function mergeJsonSchemaConstraintProperties(document, target, source, seenReferences = new Set()) {
+    const nextSeenReferences = collectOpenApiSeenReferences(source, seenReferences);
+    const resolvedSource = resolveOpenApiSchemaObject(document, source, seenReferences);
+    const merged = target;
+    for (const key of JSON_SCHEMA_CONSTRAINT_KEYS) {
+        if (resolvedSource[key] !== undefined) {
+            merged[key] = cloneJsonValue(resolvedSource[key]);
+        }
+    }
+    if (Array.isArray(resolvedSource.required)) {
+        merged.required = resolvedSource.required.filter((value) => typeof value === 'string');
+    }
+    if (Array.isArray(resolvedSource.items)) {
+        merged.items = cloneJsonValue(resolvedSource.items);
+    }
+    else if (isJsonSchemaObject(resolvedSource.items)) {
+        const nextItems = isJsonSchemaObject(merged.items) ? merged.items : {};
+        merged.items = mergeJsonSchemaConstraintProperties(document, nextItems, resolvedSource.items, nextSeenReferences);
+    }
+    if (isJsonSchemaObject(resolvedSource.properties)) {
+        const targetProperties = isJsonSchemaObject(merged.properties)
+            ? merged.properties
+            : {};
+        for (const [propertyName, propertySchema] of Object.entries(resolvedSource.properties)) {
+            if (!isJsonSchemaObject(propertySchema)) {
+                continue;
+            }
+            const nextProperty = isJsonSchemaObject(targetProperties[propertyName])
+                ? targetProperties[propertyName]
+                : {};
+            targetProperties[propertyName] = mergeJsonSchemaConstraintProperties(document, nextProperty, propertySchema, nextSeenReferences);
+        }
+        merged.properties = targetProperties;
+    }
+    return merged;
+}
+function findOpenApiOperationById(document, operationId) {
+    for (const pathItem of Object.values(document.paths)) {
+        if (!isJsonSchemaObject(pathItem)) {
+            continue;
+        }
+        for (const method of ['delete', 'get', 'patch', 'post', 'put']) {
+            const operation = resolveOpenApiSchemaObject(document, pathItem[method]);
+            if (!isJsonSchemaObject(operation) ||
+                typeof operation.operationId !== 'string') {
+                continue;
+            }
+            if (operation.operationId === operationId) {
+                return operation;
+            }
+        }
+    }
+    return null;
+}
+function resolveOpenApiRequestBodySchema(operation, document) {
+    const requestBody = resolveOpenApiSchemaObject(document, operation.requestBody);
+    const content = isJsonSchemaObject(requestBody.content)
+        ? requestBody.content
+        : null;
+    const jsonMediaType = content && isJsonSchemaObject(content['application/json'])
+        ? content['application/json']
+        : null;
+    const schema = jsonMediaType?.schema;
+    if (!isJsonSchemaObject(schema)) {
+        return null;
+    }
+    return resolveOpenApiSchemaObject(document, schema);
+}
+function resolveOpenApiSuccessResponseSchema(operation, document) {
+    for (const [statusCode, response] of Object.entries(operation.responses)) {
+        const resolvedResponse = resolveOpenApiSchemaObject(document, response);
+        if (!/^2(?:\d\d|XX)$/u.test(statusCode) ||
+            !isJsonSchemaObject(resolvedResponse)) {
+            continue;
+        }
+        const content = isJsonSchemaObject(resolvedResponse.content)
+            ? resolvedResponse.content
+            : null;
+        const jsonMediaType = content && isJsonSchemaObject(content['application/json'])
+            ? content['application/json']
+            : null;
+        const schema = jsonMediaType?.schema;
+        if (!isJsonSchemaObject(schema)) {
+            continue;
+        }
+        return resolveOpenApiSchemaObject(document, schema);
+    }
+    return null;
+}
+function getOrCreateObjectProperty(target, propertyName) {
+    const targetProperties = isJsonSchemaObject(target.properties)
+        ? target.properties
+        : {};
+    const nextProperty = isJsonSchemaObject(targetProperties[propertyName])
+        ? targetProperties[propertyName]
+        : {};
+    targetProperties[propertyName] = nextProperty;
+    target.properties = targetProperties;
+    return nextProperty;
+}
+function applyOpenApiQueryParameterConstraints(target, operation, document) {
+    for (const parameter of operation.parameters ?? []) {
+        const resolvedParameter = resolveOpenApiSchemaObject(document, parameter);
+        if (!isJsonSchemaObject(resolvedParameter) ||
+            resolvedParameter.in !== 'query' ||
+            typeof resolvedParameter.name !== 'string') {
+            continue;
+        }
+        const propertyTarget = getOrCreateObjectProperty(target, resolvedParameter.name);
+        mergeJsonSchemaConstraintProperties(document, propertyTarget, resolveOpenApiSchemaObject(document, resolvedParameter.schema));
+        if (resolvedParameter.required === true) {
+            const required = new Set(Array.isArray(target.required)
+                ? target.required.filter((value) => typeof value === 'string')
+                : []);
+            required.add(resolvedParameter.name);
+            target.required = [...required];
+        }
+    }
+}
+/**
+ * Clone a projected function artifact before mutation-oriented constraint work.
+ *
+ * @param functionArtifact Projected artifact to clone.
+ * @returns A cloned artifact with parameters and optional output deep-cloned,
+ * and tags shallow-copied when present.
+ */
+export function cloneProjectedTypiaLlmFunctionArtifact(functionArtifact) {
+    return {
+        description: functionArtifact.description,
+        name: functionArtifact.name,
+        output: cloneJsonValueIfDefined(functionArtifact.output),
+        parameters: cloneJsonValue(functionArtifact.parameters),
+        ...(functionArtifact.tags ? { tags: [...functionArtifact.tags] } : {}),
+    };
+}
+/**
+ * Restores canonical request and response constraints from an endpoint-aware
+ * OpenAPI document onto one projected `typia.llm` function artifact.
+ *
+ * Query-only inputs merge into the root parameter object. Mixed body/query
+ * inputs merge into the generated `body` and `query` properties.
+ *
+ * @param options Projected artifact plus the canonical OpenAPI document.
+ * @returns A cloned artifact enriched with OpenAPI-backed constraints when available.
+ */
+export function applyOpenApiConstraintsToTypiaLlmFunctionArtifact({ functionArtifact, openApiDocument, operationId, }) {
+    const constrainedArtifact = cloneProjectedTypiaLlmFunctionArtifact(functionArtifact);
+    const operation = findOpenApiOperationById(openApiDocument, operationId);
+    if (!operation) {
+        return constrainedArtifact;
+    }
+    const hasQueryParameters = (operation.parameters ?? []).some((parameter) => {
+        const resolvedParameter = resolveOpenApiSchemaObject(openApiDocument, parameter);
+        return (isJsonSchemaObject(resolvedParameter) &&
+            resolvedParameter.in === 'query' &&
+            typeof resolvedParameter.name === 'string');
+    });
+    const requestBodySchema = resolveOpenApiRequestBodySchema(operation, openApiDocument);
+    const parameterSchema = assertJsonSchemaObject(constrainedArtifact.parameters, `typia.llm parameters for "${constrainedArtifact.name}"`);
+    if (requestBodySchema) {
+        if (hasQueryParameters) {
+            mergeJsonSchemaConstraintProperties(openApiDocument, getOrCreateObjectProperty(parameterSchema, 'body'), requestBodySchema);
+        }
+        else {
+            mergeJsonSchemaConstraintProperties(openApiDocument, parameterSchema, requestBodySchema);
+        }
+    }
+    if (hasQueryParameters) {
+        applyOpenApiQueryParameterConstraints(requestBodySchema
+            ? getOrCreateObjectProperty(parameterSchema, 'query')
+            : parameterSchema, operation, openApiDocument);
+    }
+    if (constrainedArtifact.output) {
+        const outputSchema = assertJsonSchemaObject(constrainedArtifact.output, `typia.llm output for "${constrainedArtifact.name}"`);
+        const responseSchema = resolveOpenApiSuccessResponseSchema(operation, openApiDocument);
+        if (responseSchema) {
+            mergeJsonSchemaConstraintProperties(openApiDocument, outputSchema, responseSchema);
+        }
+    }
+    return constrainedArtifact;
+}

package/dist/runtime/typia-llm-projection.d.ts

@@ -0,0 +1,25 @@
+import type { ProjectedTypiaLlmApplicationArtifact, ProjectedTypiaLlmFunctionArtifact, ProjectedTypiaLlmStructuredOutputArtifact, ProjectTypiaLlmApplicationArtifactOptions, ProjectTypiaLlmStructuredOutputArtifactOptions, TypiaLlmFunctionLike } from './typia-llm-types.js';
+/**
+ * Projects one compiled `typia.llm` function schema into a JSON-friendly
+ * artifact record.
+ *
+ * @param functionSchema Function schema from a compiled `typia.llm.application(...)`.
+ * @returns JSON-friendly function artifact.
+ */
+export declare function projectTypiaLlmApplicationFunction(functionSchema: TypiaLlmFunctionLike): ProjectedTypiaLlmFunctionArtifact;
+/**
+ * Projects a compiled `typia.llm.application(...)` result into a JSON-friendly
+ * downstream adapter artifact.
+ *
+ * @param options Compiled application value and source metadata.
+ * @returns JSON-friendly application artifact.
+ */
+export declare function projectTypiaLlmApplicationArtifact({ application, generatedFrom, openApiProjection, transformFunction, }: ProjectTypiaLlmApplicationArtifactOptions): ProjectedTypiaLlmApplicationArtifact;
+/**
+ * Projects a compiled `typia.llm.structuredOutput(...)` result into a
+ * JSON-friendly downstream adapter artifact.
+ *
+ * @param options Compiled structured-output value and source metadata.
+ * @returns JSON-friendly structured-output artifact.
+ */
+export declare function projectTypiaLlmStructuredOutputArtifact({ generatedFrom, structuredOutput, }: ProjectTypiaLlmStructuredOutputArtifactOptions): ProjectedTypiaLlmStructuredOutputArtifact;

package/dist/runtime/typia-llm-projection.js

@@ -0,0 +1,58 @@
+import { cloneJsonValue } from './json-utils.js';
+import { cloneJsonValueIfDefined } from './typia-llm-json-schema.js';
+import { applyOpenApiConstraintsToTypiaLlmFunctionArtifact, cloneProjectedTypiaLlmFunctionArtifact, } from './typia-llm-openapi-constraints.js';
+/**
+ * Projects one compiled `typia.llm` function schema into a JSON-friendly
+ * artifact record.
+ *
+ * @param functionSchema Function schema from a compiled `typia.llm.application(...)`.
+ * @returns JSON-friendly function artifact.
+ */
+export function projectTypiaLlmApplicationFunction(functionSchema) {
+    return {
+        description: functionSchema.description,
+        name: functionSchema.name,
+        output: cloneJsonValueIfDefined(functionSchema.output),
+        parameters: cloneJsonValue(functionSchema.parameters),
+        ...(functionSchema.tags ? { tags: [...functionSchema.tags] } : {}),
+    };
+}
+/**
+ * Projects a compiled `typia.llm.application(...)` result into a JSON-friendly
+ * downstream adapter artifact.
+ *
+ * @param options Compiled application value and source metadata.
+ * @returns JSON-friendly application artifact.
+ */
+export function projectTypiaLlmApplicationArtifact({ application, generatedFrom, openApiProjection, transformFunction, }) {
+    return {
+        functions: application.functions.map((functionSchema) => {
+            const functionArtifact = projectTypiaLlmApplicationFunction(functionSchema);
+            const openApiAlignedArtifact = openApiProjection
+                ? applyOpenApiConstraintsToTypiaLlmFunctionArtifact({
+                    functionArtifact,
+                    openApiDocument: openApiProjection.openApiDocument,
+                    operationId: openApiProjection.resolveOperationId?.(functionSchema, functionArtifact) ?? functionSchema.name,
+                })
+                : functionArtifact;
+            const transformedArtifact = transformFunction
+                ? transformFunction(openApiAlignedArtifact, functionSchema)
+                : openApiAlignedArtifact;
+            return cloneProjectedTypiaLlmFunctionArtifact(transformedArtifact);
+        }),
+        generatedFrom: cloneJsonValue(generatedFrom),
+    };
+}
+/**
+ * Projects a compiled `typia.llm.structuredOutput(...)` result into a
+ * JSON-friendly downstream adapter artifact.
+ *
+ * @param options Compiled structured-output value and source metadata.
+ * @returns JSON-friendly structured-output artifact.
+ */
+export function projectTypiaLlmStructuredOutputArtifact({ generatedFrom, structuredOutput, }) {
+    return {
+        generatedFrom: cloneJsonValue(generatedFrom),
+        parameters: cloneJsonValue(structuredOutput.parameters),
+    };
+}

package/dist/runtime/typia-llm-render.d.ts

@@ -0,0 +1,21 @@
+import type { EndpointManifestDefinition } from '@wp-typia/block-runtime/metadata-core';
+import type { RenderTypiaLlmModuleOptions, TypiaLlmEndpointMethodDescriptor } from './typia-llm-types.js';
+export declare function renderTypiaLlmModuleFromMethodDescriptors({ applicationExportName, interfaceName, structuredOutputExportName, structuredOutputTypeName, typesImportPath, }: Omit<RenderTypiaLlmModuleOptions, 'manifest'>, methods: readonly TypiaLlmEndpointMethodDescriptor[]): string;
+/**
+ * Builds the generated controller method descriptors that bridge endpoint
+ * manifests to `typia.llm` TypeScript interfaces.
+ *
+ * @param manifest Endpoint manifest that owns operation and source type names.
+ * @returns Ordered method descriptors matching the manifest endpoints.
+ * @throws When an endpoint has ambiguous query/body input mapping.
+ * @throws When an endpoint references a missing input or output contract.
+ */
+export declare function buildTypiaLlmEndpointMethodDescriptors(manifest: EndpointManifestDefinition): TypiaLlmEndpointMethodDescriptor[];
+/**
+ * Renders a build-time-only TypeScript module that invokes `typia.llm` against
+ * canonical manifest-owned contracts.
+ *
+ * @param options Render options for the generated adapter module.
+ * @returns The generated TypeScript source.
+ */
+export declare function renderTypiaLlmModule({ applicationExportName, interfaceName, manifest, structuredOutputExportName, structuredOutputTypeName, typesImportPath, }: RenderTypiaLlmModuleOptions): string;