@aigne/core 1.72.0 → 1.74.0-beta

package/lib/cjs/loader/schema.js

@@ -1,162 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInstructionsSchema = exports.imageModelSchema = exports.chatModelSchema = exports.defaultInputSchema = exports.inputOutputSchema = void 0;
-exports.optionalize = optionalize;
-exports.camelizeSchema = camelizeSchema;
-exports.preprocessSchema = preprocessSchema;
-exports.instructionsToPromptBuilder = instructionsToPromptBuilder;
-const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
-const yaml_1 = require("yaml");
-const zod_1 = require("zod");
-const agent_js_1 = require("../agents/agent.js");
-const chat_model_js_1 = require("../agents/chat-model.js");
-const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
-const template_js_1 = require("../prompt/template.js");
-const camelize_js_1 = require("../utils/camelize.js");
-const type_utils_js_1 = require("../utils/type-utils.js");
-const inputOutputSchema = ({ path }) => {
-    const includeExternalSchema = async (schema) => {
-        if (schema?.type === "object" && schema.properties) {
-            return {
-                ...schema,
-                properties: Object.fromEntries(await Promise.all(Object.entries(schema.properties).map(async ([key, value]) => [
-                    key,
-                    await includeExternalSchema(value),
-                ]))),
-            };
-        }
-        if (schema?.type === "array" && schema.items) {
-            return { ...schema, items: await includeExternalSchema(schema.items) };
-        }
-        // Load nested schemas from file
-        if (typeof schema === "string") {
-            const raw = await index_js_1.nodejs.fs.readFile(index_js_1.nodejs.path.join(index_js_1.nodejs.path.dirname(path), schema), "utf8");
-            return nestedJsonSchema.parseAsync((0, yaml_1.parse)(raw));
-        }
-        return schema;
-    };
-    const nestedJsonSchema = zod_1.z
-        .object({
-        type: zod_1.z.string(),
-    })
-        .passthrough()
-        .transform((v) => includeExternalSchema(v));
-    const jsonSchemaSchema = zod_1.z
-        .object({
-        type: zod_1.z.literal("object"),
-        properties: zod_1.z.record(zod_1.z.any()),
-        required: zod_1.z.array(zod_1.z.string()).optional(),
-        additionalProperties: zod_1.z.boolean().optional(),
-    })
-        .transform((v) => includeExternalSchema(v));
-    return zod_1.z.union([
-        zod_1.z
-            .string()
-            .transform((v) => index_js_1.nodejs.fs
-            .readFile(index_js_1.nodejs.path.join(index_js_1.nodejs.path.dirname(path), v), "utf8")
-            .then((raw) => jsonSchemaSchema.parseAsync((0, yaml_1.parse)(raw)))),
-        jsonSchemaSchema,
-    ]);
-};
-exports.inputOutputSchema = inputOutputSchema;
-exports.defaultInputSchema = zod_1.z.record(zod_1.z.string(), (0, agent_js_1.getterSchema)(zod_1.z.unknown()));
-const chatModelObjectSchema = camelizeSchema(zod_1.z
-    .object({
-    model: optionalize((0, agent_js_1.getterSchema)(zod_1.z.string())),
-    temperature: optionalize((0, agent_js_1.getterSchema)(zod_1.z.number().min(0).max(2))),
-    topP: optionalize((0, agent_js_1.getterSchema)(zod_1.z.number().min(0))),
-    frequencyPenalty: optionalize((0, agent_js_1.getterSchema)(zod_1.z.number().min(-2).max(2))),
-    presencePenalty: optionalize((0, agent_js_1.getterSchema)(zod_1.z.number().min(-2).max(2))),
-    thinkingEffort: optionalize((0, agent_js_1.getterSchema)(zod_1.z.union([
-        zod_1.z.number().int(),
-        zod_1.z.literal("high"),
-        zod_1.z.literal("medium"),
-        zod_1.z.literal("low"),
-        zod_1.z.literal("minimal"),
-    ]))),
-})
-    .passthrough());
-exports.chatModelSchema = zod_1.z
-    .preprocess((v) => {
-    if (!(0, type_utils_js_1.isRecord)(v))
-        return v;
-    return {
-        ...v,
-        model: v.model ||
-            (v.provider && v.name ? `${v.provider || ""}:${v.name || ""}` : undefined) ||
-            undefined,
-    };
-}, zod_1.z.union([zod_1.z.string(), chatModelObjectSchema]))
-    .transform((v) => typeof v === "string" ? { model: v } : v);
-const imageModelObjectSchema = camelizeSchema(zod_1.z
-    .object({
-    model: optionalize((0, agent_js_1.getterSchema)(zod_1.z.string())),
-})
-    .passthrough());
-exports.imageModelSchema = zod_1.z
-    .union([zod_1.z.string(), imageModelObjectSchema])
-    .transform((v) => typeof v === "string" ? { model: v } : v);
-function optionalize(schema) {
-    return schema.nullish().transform((v) => v ?? undefined);
-}
-function camelizeSchema(schema, { shallow = true } = {}) {
-    return zod_1.z.preprocess((v) => ((0, type_utils_js_1.isRecord)(v) ? (0, camelize_js_1.camelize)(v, shallow) : v), schema);
-}
-function preprocessSchema(fn, schema) {
-    return zod_1.z.preprocess(fn, schema);
-}
-const instructionItemSchema = camelizeSchema(zod_1.z.union([
-    zod_1.z.object({
-        role: chat_model_js_1.roleSchema.default("system"),
-        url: zod_1.z.string(),
-        cacheControl: optionalize(zod_1.z.object({
-            type: zod_1.z.literal("ephemeral"),
-            ttl: optionalize(zod_1.z.union([zod_1.z.literal("5m"), zod_1.z.literal("1h")])),
-        })),
-    }),
-    zod_1.z.object({
-        role: chat_model_js_1.roleSchema.default("system"),
-        content: zod_1.z.string(),
-        cacheControl: optionalize(zod_1.z.object({
-            type: zod_1.z.literal("ephemeral"),
-            ttl: optionalize(zod_1.z.union([zod_1.z.literal("5m"), zod_1.z.literal("1h")])),
-        })),
-    }),
-]));
-const parseInstructionItem = ({ filepath }) => async ({ role, cacheControl, ...v }) => {
-    if (role === "tool")
-        throw new Error(`'tool' role is not allowed in instruction item in agent file ${filepath}`);
-    if ("content" in v && typeof v.content === "string") {
-        return { role, content: v.content, path: filepath, cacheControl };
-    }
-    if ("url" in v && typeof v.url === "string") {
-        const url = index_js_1.nodejs.path.isAbsolute(v.url)
-            ? v.url
-            : index_js_1.nodejs.path.join(index_js_1.nodejs.path.dirname(filepath), v.url);
-        return index_js_1.nodejs.fs
-            .readFile(url, "utf8")
-            .then((content) => ({ role, content, path: url, cacheControl }));
-    }
-    throw new Error(`Invalid instruction item in agent file ${filepath}. Expected 'content' or 'url' property`);
-};
-const getInstructionsSchema = ({ filepath }) => zod_1.z
-    .union([zod_1.z.string(), instructionItemSchema, zod_1.z.array(instructionItemSchema)])
-    .transform(async (v) => {
-    if (typeof v === "string")
-        return [{ role: "system", content: v, path: filepath }];
-    if (Array.isArray(v)) {
-        return Promise.all(v.map((item) => parseInstructionItem({ filepath })(item)));
-    }
-    return [await parseInstructionItem({ filepath })(v)];
-});
-exports.getInstructionsSchema = getInstructionsSchema;
-function instructionsToPromptBuilder(instructions) {
-    return new prompt_builder_js_1.PromptBuilder({
-        instructions: typeof instructions === "string"
-            ? instructions
-            : template_js_1.ChatMessagesTemplate.from((0, template_js_1.parseChatMessages)(instructions.map((i) => ({
-                ...i,
-                options: { workingDir: index_js_1.nodejs.path.dirname(i.path) },
-            })))),
-    });
-}

package/lib/cjs/memory/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./memory.js";
-export * from "./recorder.js";
-export * from "./retriever.js";

package/lib/cjs/memory/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./memory.js"), exports);
-__exportStar(require("./recorder.js"), exports);
-__exportStar(require("./retriever.js"), exports);

package/lib/cjs/memory/memory.d.ts

@@ -1,93 +0,0 @@
-import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../agents/agent.js";
-import type { Context } from "../aigne/context.js";
-import type { MessagePayload } from "../aigne/message-queue.js";
-import { MemoryRecorder, type MemoryRecorderInput, type MemoryRecorderOptions, type MemoryRecorderOutput } from "./recorder.js";
-import { MemoryRetriever, type MemoryRetrieverInput, type MemoryRetrieverOptions, type MemoryRetrieverOutput } from "./retriever.js";
-export interface Memory {
-    id: string;
-    sessionId?: string | null;
-    content: unknown;
-    createdAt: string;
-}
-export declare const newMemoryId: () => string;
-export interface MemoryAgentOptions extends Partial<Pick<MemoryAgent, "autoUpdate">>, Pick<AgentOptions, "subscribeTopic" | "skills"> {
-    recorder?: MemoryRecorder | MemoryRecorderOptions["process"] | MemoryRecorderOptions;
-    retriever?: MemoryRetriever | MemoryRetrieverOptions["process"] | MemoryRetrieverOptions;
-}
-/**
- * A specialized agent responsible for managing, storing, and retrieving memories within the agent system.
- *
- * MemoryAgent serves as a bridge between application logic and memory storage/retrieval mechanisms.
- * It delegates the actual memory operations to specialized recorder and retriever agents that
- * are attached as skills. This agent doesn't directly process messages like other agents but
- * instead provides memory management capabilities to the system.
- */
-export declare class MemoryAgent extends Agent {
-    tag: string;
-    /**
-     * Creates a new MemoryAgent instance.
-     */
-    constructor(options: MemoryAgentOptions);
-    private _retriever?;
-    /**
-     * Agent used for retrieving memories from storage.
-     *
-     * This retriever is automatically added to the agent's skills when set.
-     * Setting a new retriever will remove any previously set retriever from skills.
-     */
-    get retriever(): MemoryRetriever | undefined;
-    set retriever(value: MemoryRetriever | undefined);
-    private _recorder?;
-    /**
-     * Agent used for recording and storing new memories.
-     *
-     * This recorder is automatically added to the agent's skills when set.
-     * Setting a new recorder will remove any previously set recorder from skills.
-     */
-    get recorder(): MemoryRecorder | undefined;
-    set recorder(value: MemoryRecorder | undefined);
-    /**
-     * Controls whether to automatically update the memory when agent call completes.
-     *
-     * When true, the agent will automatically record any relevant information
-     * after completing operations, creating a history of interactions.
-     */
-    autoUpdate?: boolean;
-    /**
-     * Indicates whether this agent can be directly called.
-     *
-     * MemoryAgent is designed to be used as a supporting component rather than
-     * being directly invoked for processing, so this returns false.
-     */
-    get isCallable(): boolean;
-    /**
-     * The standard message processing method required by the Agent interface.
-     *
-     * MemoryAgent doesn't directly process messages like other agents, so this method
-     * throws an error when called. Use the specialized retrieve() and record() methods instead.
-     */
-    process(_input: Message, _options: AgentInvokeOptions): Promise<Message>;
-    /**
-     * Retrieves memories based on the provided input criteria.
-     *
-     * Delegates the actual retrieval operation to the configured retriever agent.
-     *
-     * @param input - The retrieval parameters (can include search terms, limits, etc.)
-     * @param context - The execution context
-     * @returns A promise resolving to the retrieved memories
-     * @throws Error - If no retriever has been initialized
-     */
-    retrieve(input: MemoryRetrieverInput, context: Context): Promise<MemoryRetrieverOutput>;
-    /**
-     * Records new memories based on the provided input content.
-     *
-     * Delegates the actual recording operation to the configured recorder agent.
-     *
-     * @param input - The content to be recorded as memories
-     * @param context - The execution context
-     * @returns A promise resolving to the recorded memories
-     * @throws Error - If no recorder has been initialized
-     */
-    record(input: MemoryRecorderInput, context: Context): Promise<MemoryRecorderOutput>;
-    onMessage({ role, source, message, context }: MessagePayload): Promise<void>;
-}

package/lib/cjs/memory/memory.js

@@ -1,147 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryAgent = exports.newMemoryId = void 0;
-const uuid_1 = require("@aigne/uuid");
-const zod_1 = require("zod");
-const agent_js_1 = require("../agents/agent.js");
-const type_utils_js_1 = require("../utils/type-utils.js");
-const recorder_js_1 = require("./recorder.js");
-const retriever_js_1 = require("./retriever.js");
-const newMemoryId = () => (0, uuid_1.v7)();
-exports.newMemoryId = newMemoryId;
-/**
- * A specialized agent responsible for managing, storing, and retrieving memories within the agent system.
- *
- * MemoryAgent serves as a bridge between application logic and memory storage/retrieval mechanisms.
- * It delegates the actual memory operations to specialized recorder and retriever agents that
- * are attached as skills. This agent doesn't directly process messages like other agents but
- * instead provides memory management capabilities to the system.
- */
-class MemoryAgent extends agent_js_1.Agent {
-    tag = "MemoryAgent";
-    /**
-     * Creates a new MemoryAgent instance.
-     */
-    constructor(options) {
-        (0, type_utils_js_1.checkArguments)("MemoryAgent", memoryAgentOptionsSchema, options);
-        super({
-            subscribeTopic: options.subscribeTopic,
-            skills: options.skills,
-        });
-        this.recorder =
-            options.recorder instanceof recorder_js_1.MemoryRecorder
-                ? options.recorder
-                : options.recorder &&
-                    new recorder_js_1.MemoryRecorder(typeof options.recorder === "function"
-                        ? { process: options.recorder }
-                        : options.recorder);
-        this.retriever =
-            options.retriever instanceof retriever_js_1.MemoryRetriever
-                ? options.retriever
-                : options.retriever &&
-                    new retriever_js_1.MemoryRetriever(typeof options.retriever === "function"
-                        ? { process: options.retriever }
-                        : options.retriever);
-        this.autoUpdate = options.autoUpdate;
-    }
-    _retriever;
-    /**
-     * Agent used for retrieving memories from storage.
-     *
-     * This retriever is automatically added to the agent's skills when set.
-     * Setting a new retriever will remove any previously set retriever from skills.
-     */
-    get retriever() {
-        return this._retriever;
-    }
-    set retriever(value) {
-        if (this._retriever)
-            (0, type_utils_js_1.remove)(this.skills, [this._retriever]);
-        this._retriever = value;
-        if (value)
-            this.skills.push(value);
-    }
-    _recorder;
-    /**
-     * Agent used for recording and storing new memories.
-     *
-     * This recorder is automatically added to the agent's skills when set.
-     * Setting a new recorder will remove any previously set recorder from skills.
-     */
-    get recorder() {
-        return this._recorder;
-    }
-    set recorder(value) {
-        if (this._recorder)
-            (0, type_utils_js_1.remove)(this.skills, [this._recorder]);
-        this._recorder = value;
-        if (value)
-            this.skills.push(value);
-    }
-    /**
-     * Controls whether to automatically update the memory when agent call completes.
-     *
-     * When true, the agent will automatically record any relevant information
-     * after completing operations, creating a history of interactions.
-     */
-    autoUpdate;
-    /**
-     * Indicates whether this agent can be directly called.
-     *
-     * MemoryAgent is designed to be used as a supporting component rather than
-     * being directly invoked for processing, so this returns false.
-     */
-    get isCallable() {
-        return false;
-    }
-    /**
-     * The standard message processing method required by the Agent interface.
-     *
-     * MemoryAgent doesn't directly process messages like other agents, so this method
-     * throws an error when called. Use the specialized retrieve() and record() methods instead.
-     */
-    async process(_input, _options) {
-        throw new Error("Method not implemented.");
-    }
-    /**
-     * Retrieves memories based on the provided input criteria.
-     *
-     * Delegates the actual retrieval operation to the configured retriever agent.
-     *
-     * @param input - The retrieval parameters (can include search terms, limits, etc.)
-     * @param context - The execution context
-     * @returns A promise resolving to the retrieved memories
-     * @throws Error - If no retriever has been initialized
-     */
-    async retrieve(input, context) {
-        if (!this.retriever)
-            throw new Error("MemoryAgent retriever not initialized");
-        return context.invoke(this.retriever, input);
-    }
-    /**
-     * Records new memories based on the provided input content.
-     *
-     * Delegates the actual recording operation to the configured recorder agent.
-     *
-     * @param input - The content to be recorded as memories
-     * @param context - The execution context
-     * @returns A promise resolving to the recorded memories
-     * @throws Error - If no recorder has been initialized
-     */
-    async record(input, context) {
-        if (!this.recorder)
-            throw new Error("MemoryAgent recorder not initialized");
-        return context.invoke(this.recorder, input);
-    }
-    async onMessage({ role, source, message, context }) {
-        this.record({ content: [role === "user" ? { input: message } : { output: message, source }] }, context);
-    }
-}
-exports.MemoryAgent = MemoryAgent;
-const memoryAgentOptionsSchema = zod_1.z.object({
-    retriever: zod_1.z.custom().optional(),
-    recorder: zod_1.z.custom().optional(),
-    autoUpdate: zod_1.z.boolean().optional(),
-    subscribeTopic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
-    skills: zod_1.z.array(zod_1.z.custom()).optional(),
-});

package/lib/cjs/memory/recorder.d.ts

@@ -1,93 +0,0 @@
-import { type ZodType, z } from "zod";
-import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type FunctionAgentFn, type Message } from "../agents/agent.js";
-import type { PromiseOrValue } from "../utils/type-utils.js";
-import type { Memory } from "./memory.js";
-/**
- * Input for memory recording operations.
- *
- * This interface represents the data needed to record new memories
- * in the system. The content array can contain any type of data that
- * should be stored as memories.
- */
-export interface MemoryRecorderInput extends Message {
-    content: {
-        input?: Message;
-        output?: Message;
-        source?: string;
-    }[];
-}
-/**
- * @hidden
- */
-export declare const memoryRecorderInputSchema: ZodType<MemoryRecorderInput>;
-/**
- * Output from memory recording operations.
- *
- * This interface represents the result of recording new memories,
- * including the newly created memory objects with their IDs and timestamps.
- */
-export interface MemoryRecorderOutput extends Message {
-    /**
-     * Array of newly created memory objects.
-     * Each memory includes a unique ID, the stored content, and a creation timestamp.
-     */
-    memories: Memory[];
-}
-/**
- * @hidden
- */
-export declare const memoryRecorderOutputSchema: z.ZodObject<{
-    memories: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        content: ZodType<{}, z.ZodTypeDef, {}>;
-        createdAt: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        content: {};
-        createdAt: string;
-    }, {
-        id: string;
-        content: {};
-        createdAt: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    memories: {
-        id: string;
-        content: {};
-        createdAt: string;
-    }[];
-}, {
-    memories: {
-        id: string;
-        content: {};
-        createdAt: string;
-    }[];
-}>;
-export interface MemoryRecorderOptions extends Omit<AgentOptions<MemoryRecorderInput, MemoryRecorderOutput>, "inputSchema" | "outputSchema"> {
-    process?: FunctionAgentFn<MemoryRecorderInput, MemoryRecorderOutput>;
-}
-/**
- * Abstract base class for agents that record and store memories.
- *
- * The MemoryRecorder serves as a foundation for implementing specific memory storage
- * mechanisms. Implementations of this class are responsible for:
- *
- * 1. Converting input content into standardized memory objects
- * 2. Assigning unique IDs to new memories
- * 3. Storing memories in an appropriate backend (database, file system, etc.)
- * 4. Ensuring proper timestamping of memories
- *
- * Custom implementations should extend this class and provide concrete
- * implementations of the process method to handle the actual storage logic.
- */
-export declare class MemoryRecorder extends Agent<MemoryRecorderInput, MemoryRecorderOutput> {
-    tag: string;
-    /**
-     * Creates a new MemoryRecorder instance with predefined input and output schemas.
-     *
-     * @param options - Configuration options for the memory recorder agent
-     */
-    constructor(options: MemoryRecorderOptions);
-    private _process?;
-    process(input: MemoryRecorderInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<MemoryRecorderOutput>>;
-}

package/lib/cjs/memory/recorder.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryRecorder = exports.memoryRecorderOutputSchema = exports.memoryRecorderInputSchema = void 0;
-const zod_1 = require("zod");
-const agent_js_1 = require("../agents/agent.js");
-/**
- * @hidden
- */
-exports.memoryRecorderInputSchema = zod_1.z.object({
-    content: zod_1.z.array(zod_1.z.object({
-        input: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
-        output: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
-        source: zod_1.z.string().optional(),
-    })),
-});
-/**
- * @hidden
- */
-exports.memoryRecorderOutputSchema = zod_1.z.object({
-    memories: zod_1.z.array(zod_1.z.object({
-        id: zod_1.z.string(),
-        content: zod_1.z.custom(),
-        createdAt: zod_1.z.string().datetime(),
-    })),
-});
-/**
- * Abstract base class for agents that record and store memories.
- *
- * The MemoryRecorder serves as a foundation for implementing specific memory storage
- * mechanisms. Implementations of this class are responsible for:
- *
- * 1. Converting input content into standardized memory objects
- * 2. Assigning unique IDs to new memories
- * 3. Storing memories in an appropriate backend (database, file system, etc.)
- * 4. Ensuring proper timestamping of memories
- *
- * Custom implementations should extend this class and provide concrete
- * implementations of the process method to handle the actual storage logic.
- */
-class MemoryRecorder extends agent_js_1.Agent {
-    tag = "MemoryRecorderAgent";
-    /**
-     * Creates a new MemoryRecorder instance with predefined input and output schemas.
-     *
-     * @param options - Configuration options for the memory recorder agent
-     */
-    constructor(options) {
-        super({
-            ...options,
-            inputSchema: exports.memoryRecorderInputSchema,
-            outputSchema: exports.memoryRecorderOutputSchema,
-        });
-        this._process = options.process;
-    }
-    _process;
-    process(input, options) {
-        if (!this._process) {
-            throw new Error("MemoryRecorder process function is not defined.");
-        }
-        return this._process.apply(this, [input, options]);
-    }
-}
-exports.MemoryRecorder = MemoryRecorder;