@aigne/core 1.72.0 → 1.74.0-beta

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

@@ -1,106 +0,0 @@
-import { 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 retrieval operations.
- *
- * This interface defines the parameters that can be used to query and filter
- * memories when retrieving them from storage.
- */
-export interface MemoryRetrieverInput extends Message {
-    /**
-     * Maximum number of memories to retrieve.
-     * Used for pagination or limiting result set size.
-     */
-    limit?: number;
-    /**
-     * Search term to filter memories by.
-     * How the search is implemented depends on the specific retriever implementation.
-     */
-    search?: string | Message;
-}
-/**
- * Output from memory retrieval operations.
- *
- * This interface represents the result of retrieving memories from storage,
- * containing an array of memory objects that match the query criteria.
- */
-export interface MemoryRetrieverOutput extends Message {
-    /**
-     * Array of retrieved memory objects.
-     * Each memory includes its ID, content, and creation timestamp.
-     */
-    memories: Memory[];
-}
-/**
- * @hidden
- */
-export declare const memoryRetrieverInputSchema: z.ZodObject<{
-    limit: z.ZodOptional<z.ZodNumber>;
-    search: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-}, "strip", z.ZodTypeAny, {
-    search?: string | Record<string, unknown> | undefined;
-    limit?: number | undefined;
-}, {
-    search?: string | Record<string, unknown> | undefined;
-    limit?: number | undefined;
-}>;
-/**
- * @hidden
- */
-export declare const memoryRetrieverOutputSchema: z.ZodObject<{
-    memories: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        content: z.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 MemoryRetrieverOptions extends Omit<AgentOptions<MemoryRetrieverInput, MemoryRetrieverOutput>, "inputSchema" | "outputSchema"> {
-    process?: FunctionAgentFn<MemoryRetrieverInput, MemoryRetrieverOutput>;
-}
-/**
- * Abstract base class for agents that retrieve memories from storage.
- *
- * The MemoryRetriever serves as a foundation for implementing specific memory
- * retrieval mechanisms. Implementations of this class are responsible for:
- *
- * 1. Querying a memory storage backend to find relevant memories
- * 2. Filtering memories based on search criteria
- * 3. Limiting the number of results returned
- * 4. Potentially implementing sorting, ranking, or relevance-based retrieval
- *
- * Custom implementations should extend this class and provide concrete
- * implementations of the process method to handle the actual retrieval logic.
- */
-export declare class MemoryRetriever extends Agent<MemoryRetrieverInput, MemoryRetrieverOutput> {
-    tag: string;
-    /**
-     * Creates a new MemoryRetriever instance with predefined input and output schemas.
-     *
-     * @param options - Configuration options for the memory retriever agent
-     */
-    constructor(options: MemoryRetrieverOptions);
-    private _process?;
-    process(input: MemoryRetrieverInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<MemoryRetrieverOutput>>;
-}

package/lib/cjs/memory/retriever.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryRetriever = exports.memoryRetrieverOutputSchema = exports.memoryRetrieverInputSchema = void 0;
-const zod_1 = require("zod");
-const agent_js_1 = require("../agents/agent.js");
-/**
- * @hidden
- */
-exports.memoryRetrieverInputSchema = zod_1.z.object({
-    limit: zod_1.z.number().optional(),
-    search: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.string(), zod_1.z.unknown())]).optional(),
-});
-/**
- * @hidden
- */
-exports.memoryRetrieverOutputSchema = 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 retrieve memories from storage.
- *
- * The MemoryRetriever serves as a foundation for implementing specific memory
- * retrieval mechanisms. Implementations of this class are responsible for:
- *
- * 1. Querying a memory storage backend to find relevant memories
- * 2. Filtering memories based on search criteria
- * 3. Limiting the number of results returned
- * 4. Potentially implementing sorting, ranking, or relevance-based retrieval
- *
- * Custom implementations should extend this class and provide concrete
- * implementations of the process method to handle the actual retrieval logic.
- */
-class MemoryRetriever extends agent_js_1.Agent {
-    tag = "MemoryRetrieverAgent";
-    /**
-     * Creates a new MemoryRetriever instance with predefined input and output schemas.
-     *
-     * @param options - Configuration options for the memory retriever agent
-     */
-    constructor(options) {
-        super({
-            ...options,
-            inputSchema: exports.memoryRetrieverInputSchema,
-            outputSchema: exports.memoryRetrieverOutputSchema,
-        });
-        this._process = options.process;
-    }
-    _process;
-    process(input, options) {
-        if (!this._process) {
-            throw new Error("MemoryRetriever process function is not implemented.");
-        }
-        return this._process.apply(this, [input, options]);
-    }
-}
-exports.MemoryRetriever = MemoryRetriever;

package/lib/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/lib/cjs/prompt/agent-session.d.ts

@@ -1,163 +0,0 @@
-import type { AFS } from "@aigne/afs";
-import type { AgentInvokeOptions } from "../agents/agent.js";
-import type { ChatModelInputMessage } from "../agents/chat-model.js";
-import { type CompactConfig, type SessionMemoryConfig, type SessionMode, type UserMemoryConfig } from "./compact/types.js";
-export * from "./compact/types.js";
-export interface AgentSessionOptions {
-    sessionId: string;
-    userId?: string;
-    agentId?: string;
-    afs?: AFS;
-    /**
-     * Session mode
-     * - "auto": Enable history recording, compaction, and memory extraction
-     * - "disabled": Disable all session features (history, compaction, memory)
-     *
-     * **Should be "disabled" for internal utility agents** (extractors, compactors, etc.)
-     * to avoid recursive memory extraction and unnecessary overhead.
-     *
-     * @default DEFAULT_SESSION_MODE ("auto")
-     */
-    mode?: SessionMode;
-    /**
-     * Compaction configuration
-     */
-    compact?: CompactConfig;
-    /**
-     * Session memory configuration
-     */
-    sessionMemory?: SessionMemoryConfig;
-    /**
-     * User memory configuration
-     */
-    userMemory?: UserMemoryConfig;
-}
-export declare class AgentSession {
-    readonly sessionId: string;
-    readonly userId?: string;
-    readonly agentId?: string;
-    private afs?;
-    private historyModulePath?;
-    private mode;
-    private compactConfig;
-    private sessionMemoryConfig;
-    private userMemoryConfig;
-    private runtimeState;
-    private initialized?;
-    private compactionPromise?;
-    private sessionMemoryUpdatePromise?;
-    private userMemoryUpdatePromise?;
-    constructor(options: AgentSessionOptions);
-    /**
-     * Check if memory extraction is enabled
-     * Memory extraction requires mode to be "auto" AND AFS history module to be available
-     */
-    private get isMemoryEnabled();
-    setSystemMessages(...messages: ChatModelInputMessage[]): Promise<void>;
-    getMessages(): Promise<ChatModelInputMessage[]>;
-    /**
-     * Format user memory facts into a system message
-     * Applies token budget limit to ensure memory injection fits within constraints
-     */
-    private formatUserMemory;
-    /**
-     * Format session memory facts into a system message
-     * Applies token budget limit to ensure memory injection fits within constraints
-     */
-    private formatSessionMemory;
-    private formatMemoryTemplate;
-    startMessage(input: unknown, message: ChatModelInputMessage, options: AgentInvokeOptions): Promise<void>;
-    endMessage(output: unknown, message: ChatModelInputMessage | undefined, options: AgentInvokeOptions): Promise<void>;
-    /**
-     * Manually trigger compaction
-     */
-    compact(options: AgentInvokeOptions): Promise<void>;
-    /**
-     * Internal method that performs the actual compaction
-     */
-    private doCompact;
-    private compactCurrentEntry;
-    private maybeCompactCurrentEntry;
-    private maybeAutoCompact;
-    /**
-     * Estimate token count for messages
-     * Applies singleMessageLimit to each text block individually
-     * Non-text tokens (images, tool calls) are always counted in full
-     */
-    private estimateMessagesTokens;
-    /**
-     * Split entries into batches based on token limit
-     * Each batch will not exceed the specified maxTokens
-     */
-    private splitIntoBatches;
-    appendCurrentMessages(messages: ChatModelInputMessage | ChatModelInputMessage[], options: AgentInvokeOptions): Promise<void>;
-    /**
-     * Truncate text content to fit within target token limit
-     * @param text The text to truncate
-     * @param currentTokens Current token count of the text
-     * @param targetTokens Target token count after truncation
-     * @returns Truncated text
-     */
-    private truncateText;
-    private truncateLargeMessage;
-    private ensureInitialized;
-    private initialize;
-    /**
-     * Load session memory facts
-     * @returns Array of memory fact entries for the current session
-     */
-    private loadSessionMemory;
-    /**
-     * Load user memory facts
-     * @returns Array of memory fact entries for the current user
-     */
-    private loadUserMemory;
-    /**
-     * Load session history including compact content and history entries
-     * @returns Object containing history compact and history entries
-     */
-    private loadSessionHistory;
-    /**
-     * Manually trigger session memory update
-     */
-    updateSessionMemory(options: AgentInvokeOptions): Promise<void>;
-    private maybeAutoUpdateSessionMemory;
-    private maybeAutoUpdateUserMemory;
-    /**
-     * Internal method that performs the actual session memory update
-     */
-    private doUpdateSessionMemory;
-    /**
-     * Manually trigger user memory update
-     */
-    updateUserMemory(options: AgentInvokeOptions): Promise<void>;
-    /**
-     * Internal method that performs the actual user memory extraction
-     */
-    private doUpdateUserMemory;
-    /**
-     * Find Agent Skill content from a single message
-     * @param msg - Message to search in
-     * @returns The skill content text if found, undefined otherwise
-     */
-    private findSkillContentInMessage;
-    /**
-     * Find the last Agent Skill from a list of messages
-     * @param messages - Messages to search through
-     * @returns The last Agent Skill found, or undefined if none found
-     */
-    private findLastAgentSkillFromMessages;
-    /**
-     * Find the last Agent Skill from a list of history entries
-     * @param entries - History entries to search through
-     * @returns The last Agent Skill found, or undefined if none found
-     */
-    private findLastAgentSkill;
-    private initializeDefaultCompactor;
-    private initializeDefaultSessionMemoryExtractor;
-    private initializeDefaultUserMemoryExtractor;
-    private get maxTokens();
-    private get keepRecentRatio();
-    private get keepRecentTokens();
-    private get singleMessageLimit();
-}