@aigne/core 1.72.0 → 1.74.0-beta

package/lib/dts/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/dts/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/dts/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();
-}

package/lib/dts/prompt/compact/compactor.d.ts

@@ -1,7 +0,0 @@
-import { AIAgent, type AIAgentOptions } from "../../agents/ai-agent.js";
-import type { CompactContent, CompactorInput } from "./types.js";
-export interface CreateCompactorOptions extends AIAgentOptions<CompactorInput, CompactContent> {
-}
-export declare class AISessionCompactor extends AIAgent<CompactorInput, CompactContent> {
-    constructor(options?: CreateCompactorOptions);
-}

package/lib/dts/prompt/compact/session-memory-extractor.d.ts

@@ -1,7 +0,0 @@
-import { AIAgent, type AIAgentOptions } from "../../agents/ai-agent.js";
-import type { MemoryExtractorInput, MemoryExtractorOutput } from "./types.js";
-export interface CreateSessionMemoryExtractorOptions extends AIAgentOptions<MemoryExtractorInput, MemoryExtractorOutput> {
-}
-export declare class AISessionMemoryExtractor extends AIAgent<MemoryExtractorInput, MemoryExtractorOutput> {
-    constructor(options?: CreateSessionMemoryExtractorOptions);
-}