@aigne/core 1.0.17 → 1.1.0-beta.2

package/lib/esm/prompt/template.js

@@ -0,0 +1,158 @@
+import Mustache from "mustache";
+import { z } from "zod";
+export class PromptTemplate {
+    template;
+    static from(template) {
+        return new PromptTemplate(template);
+    }
+    constructor(template) {
+        this.template = template;
+    }
+    format(variables) {
+        return Mustache.render(this.template, variables, undefined, {
+            escape: (v) => {
+                return typeof v === "object" ? JSON.stringify(v) : v;
+            },
+        });
+    }
+}
+export class ChatMessageTemplate {
+    role;
+    content;
+    name;
+    constructor(role, content, name) {
+        this.role = role;
+        this.content = content;
+        this.name = name;
+    }
+    format(variables) {
+        let { content } = this;
+        if (Array.isArray(content)) {
+            content = content.map((i) => {
+                if (i.type === "text")
+                    return { ...i, text: PromptTemplate.from(i.text).format(variables) };
+                return i;
+            });
+        }
+        else if (typeof content === "string") {
+            content = PromptTemplate.from(content).format(variables);
+        }
+        return {
+            role: this.role,
+            content,
+            name: this.name,
+        };
+    }
+}
+export class SystemMessageTemplate extends ChatMessageTemplate {
+    static from(content, name) {
+        return new SystemMessageTemplate("system", content, name);
+    }
+}
+export class UserMessageTemplate extends ChatMessageTemplate {
+    static from(template, name) {
+        return new UserMessageTemplate("user", template, name);
+    }
+}
+export class AgentMessageTemplate extends ChatMessageTemplate {
+    toolCalls;
+    static from(template, name) {
+        return typeof template === "string"
+            ? new AgentMessageTemplate(template, undefined, name)
+            : new AgentMessageTemplate(undefined, template, name);
+    }
+    constructor(content, toolCalls, name) {
+        super("agent", content, name);
+        this.toolCalls = toolCalls;
+    }
+    format(variables) {
+        return {
+            ...super.format(variables),
+            toolCalls: this.toolCalls,
+        };
+    }
+}
+export class ToolMessageTemplate extends ChatMessageTemplate {
+    toolCallId;
+    static from(content, toolCallId, name) {
+        return new ToolMessageTemplate(content, toolCallId, name);
+    }
+    constructor(content, toolCallId, name) {
+        super("tool", typeof content === "string" ? content : JSON.stringify(content), name);
+        this.toolCallId = toolCallId;
+    }
+    format(variables) {
+        return {
+            ...super.format(variables),
+            toolCallId: this.toolCallId,
+        };
+    }
+}
+export class ChatMessagesTemplate {
+    messages;
+    static from(messages) {
+        return new ChatMessagesTemplate(typeof messages === "string" ? [UserMessageTemplate.from(messages)] : messages);
+    }
+    constructor(messages) {
+        this.messages = messages;
+    }
+    format(variables) {
+        return this.messages.map((message) => message.format(variables));
+    }
+}
+const systemChatMessageSchema = z.object({
+    role: z.literal("system"),
+    content: z.string(),
+    name: z.string().optional(),
+});
+const userChatMessageSchema = z.object({
+    role: z.literal("user"),
+    content: z.string(),
+    name: z.string().optional(),
+});
+const chatModelOutputToolCallSchema = z.object({
+    id: z.string(),
+    type: z.literal("function"),
+    function: z.object({
+        name: z.string(),
+        arguments: z.record(z.unknown()),
+    }),
+});
+const agentChatMessageSchema = z.object({
+    role: z.literal("agent"),
+    content: z.string().optional(),
+    toolCalls: z.array(chatModelOutputToolCallSchema).optional(),
+    name: z.string().optional(),
+});
+const toolChatMessageSchema = z.object({
+    role: z.literal("tool"),
+    content: z
+        .union([z.string(), z.record(z.unknown())])
+        .transform((val) => (typeof val !== "string" ? JSON.stringify(val) : val)),
+    toolCallId: z.string(),
+    name: z.string().optional(),
+});
+const chatMessageSchema = z.union([
+    systemChatMessageSchema,
+    userChatMessageSchema,
+    agentChatMessageSchema,
+    toolChatMessageSchema,
+]);
+const chatMessagesSchema = z.array(chatMessageSchema);
+export function parseChatMessages(messages) {
+    const result = chatMessagesSchema.safeParse(messages);
+    if (!result.success)
+        return undefined;
+    return result.data.map((message) => {
+        switch (message.role) {
+            case "system":
+                return SystemMessageTemplate.from(message.content, message.name);
+            case "user":
+                return UserMessageTemplate.from(message.content, message.name);
+            case "agent":
+                return new AgentMessageTemplate(message.content, message.toolCalls, message.name);
+            case "tool":
+                return ToolMessageTemplate.from(message.content, message.toolCallId, message.name);
+        }
+    });
+}

package/lib/esm/utils/logger.d.ts

@@ -1,3 +1,6 @@
-type Logger = Pick<typeof console, "debug" | "info" | "warn" | "error">;
-export declare const logger: Logger;
-export {};
+import debug from "debug";
+export declare const logger: {
+    base: debug.Debugger;
+    debug: debug.Debugger;
+    error: debug.Debugger;
+};

package/lib/esm/utils/logger.js

@@ -1,14 +1,6 @@
-function logLevel() {
-    return process.env.LOG_LEVEL || "info";
-}
-function createLogger(logger, level = logLevel()) {
-    return {
-        debug: level === "debug" ? logger.debug : () => { },
-        info: level === "debug" || level === "info" ? logger.info : () => { },
-        warn: level === "debug" || level === "info" || level === "warn"
-            ? logger.warn
-            : () => { },
-        error: logger.error,
-    };
-}
-export const logger = createLogger(console);
+import debug from "debug";
+export const logger = {
+    base: debug("@aigne/core"),
+    debug: debug("@aigne/core:debug"),
+    error: debug("@aigne/core:error"),
+};

package/lib/esm/utils/type-utils.d.ts

@@ -1 +1,5 @@
-export type ArrayElement<T> = T extends (infer U)[] ? U : never;
+export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
+export declare function orArrayToArray<T>(value?: T | T[]): T[];
+export declare function get(obj: unknown, path: string | string[], type?: undefined): unknown | undefined;
+export declare function get(obj: unknown, path: string | string[], type: "string"): string | undefined;
+export declare function get(obj: unknown, path: string | string[], type: "number"): number | undefined;

package/lib/esm/utils/type-utils.js

@@ -1 +1,17 @@
-export {};
+import { get as _get } from "lodash";
+import isNil from "lodash/isNil";
+export function isNonNullable(value) {
+    return !isNil(value);
+}
+export function orArrayToArray(value) {
+    if (isNil(value))
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+export function get(obj, path, type) {
+    const v = _get(obj, path);
+    if (type === "string" && typeof v === "string")
+        return v;
+    if (type === "number" && typeof v === "number")
+        return v;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.0.17",
+  "version": "1.1.0-beta.2",
   "description": "AIGNE core library",
   "publishConfig": {
     "access": "public"
@@ -24,32 +24,36 @@
     "url": "git+https://github.com/blocklet/ai-studio.git"
   },
   "dependencies": {
-    "@google/generative-ai": "^0.21.0",
+    "@google/generative-ai": "^0.24.0",
+    "@modelcontextprotocol/sdk": "^1.6.1",
+    "@n8n/json-schema-to-zod": "^1.1.0",
+    "@types/debug": "^4.1.12",
     "@types/mustache": "^4.2.5",
+    "debug": "^4.4.0",
     "lodash": "^4.17.21",
     "mustache": "^4.2.0",
-    "nanoid": "^5.0.9",
-    "openai": "^4.79.1",
-    "tsyringe": "^4.8.0",
-    "ufo": "^1.5.4"
+    "nanoid": "^5.1.3",
+    "openai": "^4.86.2",
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.3"
   },
   "peerDependencies": {
     "@google/generative-ai": "^0.21.0",
     "openai": "^4.79.1"
   },
   "devDependencies": {
-    "@tsconfig/recommended": "^1.0.8",
-    "@types/bun": "^1.1.17",
-    "@types/lodash": "^4.17.14",
-    "core-js": "^3.40.0",
+    "@types/bun": "^1.2.4",
+    "@types/lodash": "^4.17.16",
     "npm-run-all": "^4.1.5",
-    "reflect-metadata": "^0.2.2",
     "rimraf": "^6.0.1",
-    "typescript": "^5.7.3"
+    "typescript": "^5.8.2"
   },
   "scripts": {
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
     "build": "tsc --build scripts/tsconfig.build.json",
-    "clean": "rimraf lib",
-    "test": "bun test"
+    "clean": "rimraf lib coverage",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter lcov"
   }
 }

package/lib/cjs/agent.d.ts

@@ -1,96 +0,0 @@
-import type { Context, ContextState } from "./context";
-import type { DataSchema } from "./definitions/data-schema";
-import type { AgentMemory, CreateRunnableMemory } from "./definitions/memory";
-import type { AgentPreload, BindAgentInputs, BoundAgent, PreloadCreator } from "./definitions/preload";
-import type { MemorableSearchOutput, MemoryItemWithScore, MemoryMessage } from "./memorable";
-import { type RunOptions, Runnable, type RunnableDefinition, type RunnableInput, type RunnableOutput, type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "./runnable";
-import { OrderedRecord } from "./utils";
-import type { ExtractRunnableOutputType } from "./utils/runnable-type";
-export type AgentPreloads = Record<string, unknown>;
-export type AgentMemories = Record<string, MemoryItemWithScore[]>;
-export declare abstract class Agent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Runnable<I, O, State> {
-    definition: AgentDefinition;
-    context?: Context<State> | undefined;
-    constructor(definition: AgentDefinition, context?: Context<State> | undefined);
-    private getMemoryQuery;
-    /**
-     * Load memories that are defined in the agent definition.
-     * @param input The agent input.
-     * @param context The AIGNE context.
-     * @returns A dictionary of memories, where the key is the memory id or name and the value is an array of memory items.
-     */
-    protected loadMemories(input: I): Promise<Memories>;
-    /**
-     * Update memories by user messages and assistant responses.
-     * @param messages Messages to be added to memories.
-     */
-    protected updateMemories(messages: MemoryMessage[]): Promise<void>;
-    protected loadPreloads(input: I): Promise<Preloads>;
-    run(input: I, options: RunOptions & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    run(input: I, options?: RunOptions & {
-        stream?: false;
-    }): Promise<O>;
-    private addHistory;
-    /**
-     * Hook that is called before the agent result is returned.
-     * @param _result The agent result.
-     */
-    protected onResult(_result: O): Promise<void>;
-    abstract process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions): Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
-    /**
-     * Bind some inputs to the agent, used for process of `PipelineAgent` or case of `LLMDecisionAgent`.
-     * @param options The bind options.
-     * @returns The bound agent.
-     */
-    bind<Input extends BindAgentInputs<Record<string, never>, typeof this>>(options: {
-        description?: string;
-        input?: Input;
-    }): BoundAgent<Record<string, never>, typeof this, Readonly<Input>>;
-}
-export type AgentProcessOptions<Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> = {
-    preloads: Preloads;
-    memories: Memories;
-};
-export type AgentProcessInput<I extends RunnableInput, Preloads extends AgentPreloads, Memories extends AgentMemories> = I & Preloads & Memories;
-export interface AgentDefinition extends RunnableDefinition {
-    preloads?: OrderedRecord<AgentPreload>;
-    memories?: OrderedRecord<AgentMemory>;
-}
-export type CreateAgentInputSchema = Record<string, DataSchema>;
-export type CreateAgentOutputSchema<Extra extends Record<string, unknown> = Record<string, unknown>> = Record<string, DataSchema & Extra>;
-export type CreateAgentPreloadsSchema<I extends CreateAgentInputSchema> = Record<string, PreloadCreator<I>>;
-export type CreateAgentPreloadsType<I extends CreateAgentInputSchema, Preloads extends CreateAgentPreloadsSchema<I>> = {
-    [name in keyof Preloads]: ExtractRunnableOutputType<ReturnType<Preloads[name]>["runnable"]>;
-};
-export type CreateAgentMemoriesSchema<I extends CreateAgentInputSchema, Extras extends Record<string, unknown> = Record<string, unknown>> = Record<string, CreateRunnableMemory<I> & Extras>;
-export type CreateAgentMemoriesType<I extends CreateAgentInputSchema, Memories extends CreateAgentMemoriesSchema<I, Record<string, unknown>>> = {
-    [key in keyof Memories]: MemorableSearchOutput<Memories[key]["memory"]>;
-};
-/**
- * Common options to create Agent.
- */
-export interface CreateAgentOptions<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I, Record<string, unknown>>> {
-    context?: Context<State>;
-    /**
-     * Agent name, used to identify the agent.
-     */
-    name?: string;
-    /**
-     * Input variables for this agent.
-     */
-    inputs: I;
-    /**
-     * Output variables for this agent.
-     */
-    outputs: O;
-    /**
-     * Preload runnables before running this agent. the preloaded data are available in the agent as input variables.
-     */
-    preloads?: Preloads;
-    /**
-     * Memories to be used in this agent.
-     */
-    memories?: Memories;
-}

package/lib/cjs/agent.js

@@ -1,165 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Agent = void 0;
-const runnable_1 = require("./runnable");
-const utils_1 = require("./utils");
-const logger_1 = require("./utils/logger");
-class Agent extends runnable_1.Runnable {
-    definition;
-    context;
-    constructor(definition, context) {
-        super(definition, context);
-        this.definition = definition;
-        this.context = context;
-    }
-    async getMemoryQuery(input, query) {
-        if (query?.from === "variable") {
-            const i = utils_1.OrderedRecord.find(this.definition.inputs, (i) => i.id === query.fromVariableId);
-            if (!i)
-                throw new Error(`Input variable ${query.fromVariableId} not found`);
-            const value = i.name ? input[i.name] : undefined;
-            return (0, utils_1.renderMessage)("{{value}}", { value });
-        }
-        return Object.entries(input)
-            .map(([key, value]) => `${key} ${value}`)
-            .join("\n");
-    }
-    /**
-     * Load memories that are defined in the agent definition.
-     * @param input The agent input.
-     * @param context The AIGNE context.
-     * @returns A dictionary of memories, where the key is the memory id or name and the value is an array of memory items.
-     */
-    async loadMemories(input) {
-        const { definition: { memories }, context, } = this;
-        if (!memories?.$indexes.length)
-            return {};
-        if (!context)
-            throw new Error("Context is required");
-        const { userId, sessionId } = context.state;
-        return Object.fromEntries((await Promise.all(utils_1.OrderedRecord.map(memories, async ({ id, name, memory, query, options }) => {
-            if (!name || !memory)
-                return null;
-            const q = await this.getMemoryQuery(input, query);
-            const { results: memories } = await memory.search(q, {
-                ...options,
-                userId,
-                sessionId,
-            });
-            return [
-                [id, memories],
-                [name, memories],
-            ];
-        })))
-            .flat()
-            .filter(utils_1.isNonNullable));
-    }
-    /**
-     * Update memories by user messages and assistant responses.
-     * @param messages Messages to be added to memories.
-     */
-    async updateMemories(messages) {
-        const { context, definition: { memories }, } = this;
-        if (!context)
-            throw new Error("Context is required");
-        const { userId, sessionId } = context.state ?? {};
-        await Promise.all(utils_1.OrderedRecord.map(memories, async ({ memory }) => {
-            if (!memory) {
-                logger_1.logger.warn(`Memory is not defined in agent ${this.name || this.id}`);
-                return;
-            }
-            await memory.add(messages, { userId, sessionId });
-        }));
-    }
-    async loadPreloads(input) {
-        const { context, definition: { preloads }, } = this;
-        if (!preloads?.$indexes.length)
-            return {};
-        if (!context)
-            throw new Error("Context is required");
-        return Object.fromEntries(await Promise.all(utils_1.OrderedRecord.map(preloads, async (preload) => {
-            if (!preload.runnable?.id)
-                throw new Error("Runnable id in preload is required");
-            const runnable = await context.resolve(preload.runnable.id);
-            const runnableInput = Object.fromEntries(utils_1.OrderedRecord.map(runnable.definition.inputs, (i) => {
-                if (!i.name)
-                    return null;
-                const bind = preload.input?.[i.id];
-                if (!bind)
-                    return null;
-                if (bind.from !== "input")
-                    throw new Error(`Unsupported bind from ${bind.from}`);
-                const from = this.definition.inputs[bind.fromInput];
-                if (!from)
-                    throw new Error(`Input ${bind.fromInput} not found`);
-                if (!from.name)
-                    return null;
-                const v = input[from.name];
-                return [i.name, v];
-            }).filter(utils_1.isNonNullable));
-            const result = await runnable.run(runnableInput);
-            return [preload.id, result];
-        })));
-    }
-    async run(input, options) {
-        logger_1.logger.debug(`AIGNE core: run agent ${this.name || this.id} with`, {
-            input,
-        });
-        const preloads = await this.loadPreloads(input);
-        const memories = await this.loadMemories(input);
-        const processResult = await this.process({ ...input, ...preloads, ...memories }, { preloads, memories });
-        if (options?.stream) {
-            const stream = processResult instanceof ReadableStream ||
-                (0, utils_1.isAsyncGenerator)(processResult)
-                ? processResult
-                : (0, utils_1.objectToRunnableResponseStream)(processResult);
-            return (0, utils_1.extractOutputsFromRunnableOutput)(stream, async (result) => {
-                // TODO: validate result against outputs schema
-                logger_1.logger.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
-                    result,
-                });
-                await this.addHistory({ input, output: result });
-                await this.onResult(result);
-            });
-        }
-        const result = processResult instanceof ReadableStream
-            ? await (0, utils_1.runnableResponseStreamToObject)(processResult)
-            : Symbol.asyncIterator in processResult
-                ? await (0, utils_1.runnableResponseStreamToObject)(processResult)
-                : processResult;
-        logger_1.logger.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
-            result,
-        });
-        // TODO: validate result against outputs schema
-        await this.addHistory({ input, output: result });
-        await this.onResult(result);
-        return result;
-    }
-    async addHistory({ input, output }) {
-        await this.context?.historyManager?.create({ input, output }, {
-            userId: this.context?.state.userId,
-            sessionId: this.context?.state.sessionId,
-            agentId: this.id,
-        });
-    }
-    /**
-     * Hook that is called before the agent result is returned.
-     * @param _result The agent result.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async onResult(_result) {
-        // Override this method to perform additional operations before the result is returned
-    }
-    /**
-     * Bind some inputs to the agent, used for process of `PipelineAgent` or case of `LLMDecisionAgent`.
-     * @param options The bind options.
-     * @returns The bound agent.
-     */
-    bind(options) {
-        return {
-            ...options,
-            runnable: this,
-        };
-    }
-}
-exports.Agent = Agent;

package/lib/cjs/constants.d.ts

@@ -1,7 +0,0 @@
-export declare const TYPES: {
-    context: symbol;
-    definition: symbol;
-    llmModel: symbol;
-    sandboxFunctionRunner: symbol;
-};
-export declare const StreamTextOutputName = "$text";

package/lib/cjs/constants.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamTextOutputName = exports.TYPES = void 0;
-exports.TYPES = {
-    context: Symbol.for("AIGNE_CONTEXT"),
-    definition: Symbol.for("AIGNE_DEFINITION"),
-    llmModel: Symbol.for("AIGNE_LLM_MODEL"),
-    sandboxFunctionRunner: Symbol.for("AIGNE_SANDBOX_FUNCTION_RUNNER"),
-};
-exports.StreamTextOutputName = "$text";

package/lib/cjs/context.d.ts

@@ -1,23 +0,0 @@
-import type { LLMModelConfiguration } from "./llm-model";
-import type { Memorable } from "./memorable";
-import type { Runnable, RunnableDefinition } from "./runnable";
-export interface ContextState {
-    userId?: string;
-    sessionId?: string;
-    [key: string]: unknown;
-}
-export interface ContextConfig {
-    llmModel?: LLMModelConfiguration;
-}
-export interface Context<State extends ContextState = ContextState, Config extends ContextConfig = ContextConfig> {
-    id: string;
-    state: State;
-    config: Config;
-    historyManager?: Memorable<{
-        input: object;
-        output: object;
-    }>;
-    resolve<T extends Runnable>(id: string | RunnableDefinition | T): Promise<T>;
-    register<R extends Array<RunnableDefinition | Runnable> = []>(...definition: R): void;
-    resolveDependency<T>(token: string | symbol): T;
-}

package/lib/cjs/definitions/data-schema.d.ts

@@ -1,61 +0,0 @@
-import type { MakeNullablePropertyOptional } from "../utils/nullable";
-import { OrderedRecord } from "../utils/ordered-map";
-import type { ArrayElement } from "../utils/type-utils";
-import type { DataType } from "./data-type";
-export declare function schemaToDataType(dataType: {
-    [name: string]: DataSchema;
-}): OrderedRecord<DataType>;
-export type DataSchema = DataSchemaString | DataSchemaNumber | DataSchemaBoolean | DataSchemaObject | DataSchemaArray;
-export interface DataSchemaBase {
-    description?: string;
-    required?: boolean;
-}
-export interface DataSchemaString extends DataSchemaBase {
-    type: "string";
-}
-export interface DataSchemaNumber extends DataSchemaBase {
-    type: "number";
-}
-export interface DataSchemaBoolean extends DataSchemaBase {
-    type: "boolean";
-}
-export interface DataSchemaObject extends DataSchemaBase {
-    type: "object";
-    properties?: {
-        [key: string]: DataSchema;
-    };
-}
-export interface DataSchemaArray extends DataSchemaBase {
-    type: "array";
-    items?: DataSchema;
-}
-type SchemaTypeInner<T extends DataSchema> = T extends DataSchemaString ? string : T extends DataSchemaNumber ? number : T extends DataSchemaBoolean ? boolean : T extends DataSchemaObject ? MakeNullablePropertyOptional<{
-    [K in keyof T["properties"]]: SchemaType<NonNullable<T["properties"]>[K]>;
-}> : T extends DataSchemaArray ? Extract<T["items"], null | undefined> extends never ? SchemaType<NonNullable<T["items"]>>[] : SchemaType<{
-    type: "object";
-}>[] : never;
-type SchemaType<T extends DataSchema> = T["required"] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
-export type SchemaToType<T extends Record<string, DataSchema>> = SchemaType<{
-    type: "object";
-    required: true;
-    properties: T;
-}>;
-type TypeToSchemaInner<T> = Extract<T, string | undefined> extends string | undefined ? DataSchemaString & {
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : Extract<T, number | undefined> extends number | undefined ? DataSchemaNumber & {
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : Extract<T, boolean | undefined> extends boolean | undefined ? DataSchemaBoolean & {
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : Extract<T, object | undefined> extends object | undefined ? DataSchemaObject & {
-    properties: {
-        [K in keyof T]: TypeToSchemaInner<NonNullable<T[K]>>;
-    };
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : Extract<T, [] | undefined> extends [] | undefined ? DataSchemaArray & {
-    items: Extract<T, undefined> extends undefined ? undefined : TypeToSchemaInner<NonNullable<ArrayElement<T>>>;
-    required: Extract<T, undefined> extends undefined ? false : true;
-} : never;
-export type TypeToSchema<T extends Record<string, unknown>> = {
-    [K in keyof T]: TypeToSchemaInner<T[K]>;
-};
-export {};