@xynehq/jaf 0.1.2

package/dist/a2a/index.d.ts

@@ -0,0 +1,378 @@
+/**
+ * A2A Integration for JAF - Main Export
+ * Pure functional A2A protocol support for Functional Agent Framework
+ */
+export type { A2AAgent, A2AAgentTool, A2AMessage, A2APart, A2ATask, A2AArtifact, A2AError, A2AStreamEvent, AgentCard, AgentSkill, AgentState, StreamEvent, ToolContext, A2AToolResult, JSONRPCRequest, JSONRPCResponse, JSONRPCError, SendMessageRequest, SendStreamingMessageRequest, GetTaskRequest, MessageSendConfiguration, A2AServerConfig, A2AClientConfig, A2AClientState } from './types.js';
+export type { A2AExecutionContext, A2AExecutionEvent, A2AExecutionResult } from './executor.js';
+export { createA2AAgent, createA2ATool, getProcessingMessage, createInitialAgentState, addMessageToState, updateStateFromRunResult, createUserMessage, transformA2AAgentToJAF, transformA2AToolToJAF, createRunConfigForA2AAgent, transformToRunState, processAgentQuery, extractTextFromA2AMessage, createA2ATextMessage, createA2ADataMessage, createA2ATask, updateA2ATaskStatus, addArtifactToA2ATask, completeA2ATask } from './agent.js';
+export { executeA2AAgent, convertToA2AStreamEvents, executeA2AAgentWithStreaming } from './executor.js';
+export { validateJSONRPCRequest, createJSONRPCSuccessResponse, createJSONRPCErrorResponse, createA2AError, mapErrorToA2AError, validateSendMessageRequest, handleMessageSend, handleMessageStream, handleTasksGet, handleTasksCancel, handleGetAuthenticatedExtendedCard, routeA2ARequest, createProtocolHandlerConfig } from './protocol.js';
+export { generateAgentCard, generateSkillsFromAgents, generateExamplesForAgent, generateExamplesForTool, generateSecuritySchemes, generateSecurityRequirements, generateAgentCardForAgent, validateAgentCard, createMinimalAgentCard, mergeAgentCards, createAgentCardFromConfig } from './agent-card.js';
+export { createA2AServer, startA2AServer } from './server.js';
+import { createSimpleA2ATaskProvider } from './memory/factory.js';
+export { createA2AClient, createMessageRequest, createStreamingMessageRequest, sendA2ARequest, sendMessage, streamMessage, getAgentCard, discoverAgents, sendMessageToAgent, streamMessageToAgent, extractTextResponse, checkA2AHealth, getA2ACapabilities, connectToA2AAgent } from './client.js';
+export { A2AErrorCodes } from './types.js';
+export { a2aMessageSchema, sendMessageRequestSchema } from './types.js';
+export * from './memory/index.js';
+export { createWeatherAgent, getWeatherAgentProcessingMessage, weatherAgentExamples } from './examples/weather-agent.js';
+export { createCalculatorAgent, createGreetingAgent, startExampleServer } from './examples/server-example.js';
+export declare const A2A: {
+    readonly agent: (config: {
+        readonly name: string;
+        readonly description: string;
+        readonly instruction: string;
+        readonly tools: readonly import("./types.js").A2AAgentTool[];
+        readonly supportedContentTypes?: readonly string[];
+    }) => import("./types.js").A2AAgent;
+    readonly tool: <T>(config: {
+        readonly name: string;
+        readonly description: string;
+        readonly parameters: import("zod").ZodType<T>;
+        readonly execute: (args: T, context?: import("./types.js").ToolContext) => Promise<any | import("./types.js").A2AToolResult>;
+    }) => import("./types.js").A2AAgentTool;
+    readonly server: {
+        readonly create: (config: import("./types.js").A2AServerConfig) => Promise<{
+            app: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
+            config: {
+                host: string;
+                capabilities: Partial<{
+                    readonly streaming?: boolean;
+                    readonly pushNotifications?: boolean;
+                    readonly stateTransitionHistory?: boolean;
+                }>;
+                agentCard: {
+                    capabilities: Partial<{
+                        readonly streaming?: boolean;
+                        readonly pushNotifications?: boolean;
+                        readonly stateTransitionHistory?: boolean;
+                    }>;
+                    protocolVersion: string;
+                    name: string;
+                    description: string;
+                    url: string;
+                    preferredTransport?: string;
+                    version: string;
+                    provider?: {
+                        readonly organization: string;
+                        readonly url: string;
+                    };
+                    defaultInputModes: readonly string[];
+                    defaultOutputModes: readonly string[];
+                    skills: readonly import("./types.js").AgentSkill[];
+                    securitySchemes?: Readonly<Record<string, any>>;
+                    security?: readonly Record<string, readonly string[]>[];
+                };
+                taskProvider: import("./memory/types.js").A2ATaskProvider;
+                protocolHandler: {
+                    agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                    modelProvider: any;
+                    agentCard: any;
+                    taskProvider: import("./memory/types.js").A2ATaskProvider | undefined;
+                    handleRequest: (request: import("./types.js").JSONRPCRequest, agentName?: string) => Promise<import("./types.js").JSONRPCResponse> | AsyncGenerator<import("./types.js").JSONRPCResponse, void, unknown>;
+                };
+                agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                port: number;
+            };
+            start: () => Promise<void>;
+            stop: () => Promise<void>;
+            addAgent: (name: string, agent: import("./types.js").A2AAgent) => {
+                host: string;
+                capabilities: Partial<{
+                    readonly streaming?: boolean;
+                    readonly pushNotifications?: boolean;
+                    readonly stateTransitionHistory?: boolean;
+                }>;
+                agentCard: {
+                    capabilities: Partial<{
+                        readonly streaming?: boolean;
+                        readonly pushNotifications?: boolean;
+                        readonly stateTransitionHistory?: boolean;
+                    }>;
+                    protocolVersion: string;
+                    name: string;
+                    description: string;
+                    url: string;
+                    preferredTransport?: string;
+                    version: string;
+                    provider?: {
+                        readonly organization: string;
+                        readonly url: string;
+                    };
+                    defaultInputModes: readonly string[];
+                    defaultOutputModes: readonly string[];
+                    skills: readonly import("./types.js").AgentSkill[];
+                    securitySchemes?: Readonly<Record<string, any>>;
+                    security?: readonly Record<string, readonly string[]>[];
+                };
+                taskProvider: import("./memory/types.js").A2ATaskProvider;
+                protocolHandler: {
+                    agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                    modelProvider: any;
+                    agentCard: any;
+                    taskProvider: import("./memory/types.js").A2ATaskProvider | undefined;
+                    handleRequest: (request: import("./types.js").JSONRPCRequest, agentName?: string) => Promise<import("./types.js").JSONRPCResponse> | AsyncGenerator<import("./types.js").JSONRPCResponse, void, unknown>;
+                };
+                agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                port: number;
+            };
+            removeAgent: (name: string) => {
+                host: string;
+                capabilities: Partial<{
+                    readonly streaming?: boolean;
+                    readonly pushNotifications?: boolean;
+                    readonly stateTransitionHistory?: boolean;
+                }>;
+                agentCard: {
+                    capabilities: Partial<{
+                        readonly streaming?: boolean;
+                        readonly pushNotifications?: boolean;
+                        readonly stateTransitionHistory?: boolean;
+                    }>;
+                    protocolVersion: string;
+                    name: string;
+                    description: string;
+                    url: string;
+                    preferredTransport?: string;
+                    version: string;
+                    provider?: {
+                        readonly organization: string;
+                        readonly url: string;
+                    };
+                    defaultInputModes: readonly string[];
+                    defaultOutputModes: readonly string[];
+                    skills: readonly import("./types.js").AgentSkill[];
+                    securitySchemes?: Readonly<Record<string, any>>;
+                    security?: readonly Record<string, readonly string[]>[];
+                };
+                taskProvider: import("./memory/types.js").A2ATaskProvider;
+                protocolHandler: {
+                    agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                    modelProvider: any;
+                    agentCard: any;
+                    taskProvider: import("./memory/types.js").A2ATaskProvider | undefined;
+                    handleRequest: (request: import("./types.js").JSONRPCRequest, agentName?: string) => Promise<import("./types.js").JSONRPCResponse> | AsyncGenerator<import("./types.js").JSONRPCResponse, void, unknown>;
+                };
+                agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                port: number;
+            };
+            getAgentCard: () => {
+                capabilities: Partial<{
+                    readonly streaming?: boolean;
+                    readonly pushNotifications?: boolean;
+                    readonly stateTransitionHistory?: boolean;
+                }>;
+                protocolVersion: string;
+                name: string;
+                description: string;
+                url: string;
+                preferredTransport?: string;
+                version: string;
+                provider?: {
+                    readonly organization: string;
+                    readonly url: string;
+                };
+                defaultInputModes: readonly string[];
+                defaultOutputModes: readonly string[];
+                skills: readonly import("./types.js").AgentSkill[];
+                securitySchemes?: Readonly<Record<string, any>>;
+                security?: readonly Record<string, readonly string[]>[];
+            };
+            handleRequest: (request: import("./types.js").JSONRPCRequest) => Promise<import("./types.js").JSONRPCResponse | AsyncIterable<import("./types.js").JSONRPCResponse>>;
+        }>;
+        readonly start: (config: import("./types.js").A2AServerConfig) => Promise<{
+            app: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
+            config: {
+                host: string;
+                capabilities: Partial<{
+                    readonly streaming?: boolean;
+                    readonly pushNotifications?: boolean;
+                    readonly stateTransitionHistory?: boolean;
+                }>;
+                agentCard: {
+                    capabilities: Partial<{
+                        readonly streaming?: boolean;
+                        readonly pushNotifications?: boolean;
+                        readonly stateTransitionHistory?: boolean;
+                    }>;
+                    protocolVersion: string;
+                    name: string;
+                    description: string;
+                    url: string;
+                    preferredTransport?: string;
+                    version: string;
+                    provider?: {
+                        readonly organization: string;
+                        readonly url: string;
+                    };
+                    defaultInputModes: readonly string[];
+                    defaultOutputModes: readonly string[];
+                    skills: readonly import("./types.js").AgentSkill[];
+                    securitySchemes?: Readonly<Record<string, any>>;
+                    security?: readonly Record<string, readonly string[]>[];
+                };
+                taskProvider: import("./memory/types.js").A2ATaskProvider;
+                protocolHandler: {
+                    agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                    modelProvider: any;
+                    agentCard: any;
+                    taskProvider: import("./memory/types.js").A2ATaskProvider | undefined;
+                    handleRequest: (request: import("./types.js").JSONRPCRequest, agentName?: string) => Promise<import("./types.js").JSONRPCResponse> | AsyncGenerator<import("./types.js").JSONRPCResponse, void, unknown>;
+                };
+                agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                port: number;
+            };
+            start: () => Promise<void>;
+            stop: () => Promise<void>;
+            addAgent: (name: string, agent: import("./types.js").A2AAgent) => {
+                host: string;
+                capabilities: Partial<{
+                    readonly streaming?: boolean;
+                    readonly pushNotifications?: boolean;
+                    readonly stateTransitionHistory?: boolean;
+                }>;
+                agentCard: {
+                    capabilities: Partial<{
+                        readonly streaming?: boolean;
+                        readonly pushNotifications?: boolean;
+                        readonly stateTransitionHistory?: boolean;
+                    }>;
+                    protocolVersion: string;
+                    name: string;
+                    description: string;
+                    url: string;
+                    preferredTransport?: string;
+                    version: string;
+                    provider?: {
+                        readonly organization: string;
+                        readonly url: string;
+                    };
+                    defaultInputModes: readonly string[];
+                    defaultOutputModes: readonly string[];
+                    skills: readonly import("./types.js").AgentSkill[];
+                    securitySchemes?: Readonly<Record<string, any>>;
+                    security?: readonly Record<string, readonly string[]>[];
+                };
+                taskProvider: import("./memory/types.js").A2ATaskProvider;
+                protocolHandler: {
+                    agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                    modelProvider: any;
+                    agentCard: any;
+                    taskProvider: import("./memory/types.js").A2ATaskProvider | undefined;
+                    handleRequest: (request: import("./types.js").JSONRPCRequest, agentName?: string) => Promise<import("./types.js").JSONRPCResponse> | AsyncGenerator<import("./types.js").JSONRPCResponse, void, unknown>;
+                };
+                agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                port: number;
+            };
+            removeAgent: (name: string) => {
+                host: string;
+                capabilities: Partial<{
+                    readonly streaming?: boolean;
+                    readonly pushNotifications?: boolean;
+                    readonly stateTransitionHistory?: boolean;
+                }>;
+                agentCard: {
+                    capabilities: Partial<{
+                        readonly streaming?: boolean;
+                        readonly pushNotifications?: boolean;
+                        readonly stateTransitionHistory?: boolean;
+                    }>;
+                    protocolVersion: string;
+                    name: string;
+                    description: string;
+                    url: string;
+                    preferredTransport?: string;
+                    version: string;
+                    provider?: {
+                        readonly organization: string;
+                        readonly url: string;
+                    };
+                    defaultInputModes: readonly string[];
+                    defaultOutputModes: readonly string[];
+                    skills: readonly import("./types.js").AgentSkill[];
+                    securitySchemes?: Readonly<Record<string, any>>;
+                    security?: readonly Record<string, readonly string[]>[];
+                };
+                taskProvider: import("./memory/types.js").A2ATaskProvider;
+                protocolHandler: {
+                    agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                    modelProvider: any;
+                    agentCard: any;
+                    taskProvider: import("./memory/types.js").A2ATaskProvider | undefined;
+                    handleRequest: (request: import("./types.js").JSONRPCRequest, agentName?: string) => Promise<import("./types.js").JSONRPCResponse> | AsyncGenerator<import("./types.js").JSONRPCResponse, void, unknown>;
+                };
+                agents: ReadonlyMap<string, import("./types.js").A2AAgent>;
+                port: number;
+            };
+            getAgentCard: () => {
+                capabilities: Partial<{
+                    readonly streaming?: boolean;
+                    readonly pushNotifications?: boolean;
+                    readonly stateTransitionHistory?: boolean;
+                }>;
+                protocolVersion: string;
+                name: string;
+                description: string;
+                url: string;
+                preferredTransport?: string;
+                version: string;
+                provider?: {
+                    readonly organization: string;
+                    readonly url: string;
+                };
+                defaultInputModes: readonly string[];
+                defaultOutputModes: readonly string[];
+                skills: readonly import("./types.js").AgentSkill[];
+                securitySchemes?: Readonly<Record<string, any>>;
+                security?: readonly Record<string, readonly string[]>[];
+            };
+            handleRequest: (request: import("./types.js").JSONRPCRequest) => Promise<import("./types.js").JSONRPCResponse | AsyncIterable<import("./types.js").JSONRPCResponse>>;
+        }>;
+    };
+    readonly client: {
+        readonly create: (baseUrl: string, config?: Partial<import("./types.js").A2AClientConfig>) => import("./types.js").A2AClientState;
+        readonly connect: (baseUrl: string) => Promise<{
+            client: import("./types.js").A2AClientState;
+            agentCard: import("./types.js").AgentCard;
+            ask: (message: string, config?: any) => Promise<string>;
+            stream: (message: string, config?: any) => AsyncGenerator<import("./types.js").A2AStreamEvent, void, unknown>;
+            health: () => Promise<{
+                status: string;
+                agents: string[];
+                timestamp: string;
+            }>;
+            capabilities: () => Promise<any>;
+        }>;
+        readonly discover: (baseUrl: string) => Promise<import("./types.js").AgentCard>;
+    };
+    readonly protocol: {
+        readonly validate: (request: any) => request is import("./types.js").JSONRPCRequest;
+        readonly createSuccess: (id: string | number, result: any) => import("./types.js").JSONRPCResponse;
+        readonly createError: (id: string | number | null, error: import("./types.js").JSONRPCError) => import("./types.js").JSONRPCResponse;
+    };
+    readonly card: {
+        readonly generate: (config: import("./types.js").A2AServerConfig["agentCard"], agents: ReadonlyMap<string, import("./types.js").A2AAgent>, baseUrl?: string) => import("./types.js").AgentCard;
+        readonly validate: (card: import("./types.js").AgentCard) => {
+            isValid: boolean;
+            errors: readonly string[];
+        };
+        readonly minimal: (name: string, description: string, url?: string) => import("./types.js").AgentCard;
+    };
+    readonly memory: {
+        readonly createTaskProvider: (config: import("./memory/types.js").A2ATaskProviderConfig, externalClients?: {
+            redis?: any;
+            postgres?: any;
+        }) => Promise<import("./memory/types.js").A2ATaskProvider>;
+        readonly createSimpleTaskProvider: typeof createSimpleA2ATaskProvider;
+        readonly createCompositeTaskProvider: (primary: import("./memory/types.js").A2ATaskProvider, fallback?: import("./memory/types.js").A2ATaskProvider) => import("./memory/types.js").A2ATaskProvider;
+        readonly createTaskProviderFromEnv: (externalClients?: {
+            redis?: any;
+            postgres?: any;
+        }) => Promise<import("./memory/types.js").A2ATaskProvider>;
+        readonly validateTaskProviderConfig: (config: any) => {
+            valid: boolean;
+            errors: string[];
+        };
+    };
+};
+export default A2A;
+//# sourceMappingURL=index.d.ts.map

package/dist/a2a/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/a2a/index.ts"],"names":[],"mappings":"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"}

package/dist/a2a/index.js

@@ -0,0 +1,72 @@
+/**
+ * A2A Integration for JAF - Main Export
+ * Pure functional A2A protocol support for Functional Agent Framework
+ */
+// Agent Creation Functions
+import { createA2AAgent, createA2ATool } from './agent.js';
+export { createA2AAgent, createA2ATool, getProcessingMessage, createInitialAgentState, addMessageToState, updateStateFromRunResult, createUserMessage, transformA2AAgentToJAF, transformA2AToolToJAF, createRunConfigForA2AAgent, transformToRunState, processAgentQuery, extractTextFromA2AMessage, createA2ATextMessage, createA2ADataMessage, createA2ATask, updateA2ATaskStatus, addArtifactToA2ATask, completeA2ATask } from './agent.js';
+// Execution Functions
+export { executeA2AAgent, convertToA2AStreamEvents, executeA2AAgentWithStreaming } from './executor.js';
+// Protocol Handlers
+import { validateJSONRPCRequest, createJSONRPCSuccessResponse, createJSONRPCErrorResponse } from './protocol.js';
+export { validateJSONRPCRequest, createJSONRPCSuccessResponse, createJSONRPCErrorResponse, createA2AError, mapErrorToA2AError, validateSendMessageRequest, handleMessageSend, handleMessageStream, handleTasksGet, handleTasksCancel, handleGetAuthenticatedExtendedCard, routeA2ARequest, createProtocolHandlerConfig } from './protocol.js';
+// Agent Card Generation
+import { generateAgentCard, validateAgentCard, createMinimalAgentCard } from './agent-card.js';
+export { generateAgentCard, generateSkillsFromAgents, generateExamplesForAgent, generateExamplesForTool, generateSecuritySchemes, generateSecurityRequirements, generateAgentCardForAgent, validateAgentCard, createMinimalAgentCard, mergeAgentCards, createAgentCardFromConfig } from './agent-card.js';
+// Server Functions
+import { createA2AServer, startA2AServer } from './server.js';
+export { createA2AServer, startA2AServer } from './server.js';
+// Client Functions
+import { createA2AClient, discoverAgents, connectToA2AAgent } from './client.js';
+// Memory Functions
+import { createA2ATaskProvider, createSimpleA2ATaskProvider, createCompositeA2ATaskProvider, createA2ATaskProviderFromEnv, validateA2ATaskProviderConfig } from './memory/factory.js';
+export { createA2AClient, createMessageRequest, createStreamingMessageRequest, sendA2ARequest, sendMessage, streamMessage, getAgentCard, discoverAgents, sendMessageToAgent, streamMessageToAgent, extractTextResponse, checkA2AHealth, getA2ACapabilities, connectToA2AAgent } from './client.js';
+// Error Codes
+export { A2AErrorCodes } from './types.js';
+// Validation Schemas
+export { a2aMessageSchema, sendMessageRequestSchema } from './types.js';
+// Memory and Task Provider Support
+export * from './memory/index.js';
+// Example Agents (optional, for development and testing)
+export { createWeatherAgent, getWeatherAgentProcessingMessage, weatherAgentExamples } from './examples/weather-agent.js';
+export { createCalculatorAgent, createGreetingAgent, startExampleServer } from './examples/server-example.js';
+// Convenience functions for common use cases
+export const A2A = {
+    // Quick agent creation
+    agent: createA2AAgent,
+    tool: createA2ATool,
+    // Quick server setup
+    server: {
+        create: createA2AServer,
+        start: startA2AServer
+    },
+    // Quick client setup
+    client: {
+        create: createA2AClient,
+        connect: connectToA2AAgent,
+        discover: discoverAgents
+    },
+    // Protocol utilities
+    protocol: {
+        validate: validateJSONRPCRequest,
+        createSuccess: createJSONRPCSuccessResponse,
+        createError: createJSONRPCErrorResponse
+    },
+    // Agent card utilities
+    card: {
+        generate: generateAgentCard,
+        validate: validateAgentCard,
+        minimal: createMinimalAgentCard
+    },
+    // Task memory utilities
+    memory: {
+        createTaskProvider: createA2ATaskProvider,
+        createSimpleTaskProvider: createSimpleA2ATaskProvider,
+        createCompositeTaskProvider: createCompositeA2ATaskProvider,
+        createTaskProviderFromEnv: createA2ATaskProviderFromEnv,
+        validateTaskProviderConfig: validateA2ATaskProviderConfig
+    }
+};
+// Default export for convenience
+export default A2A;
+//# sourceMappingURL=index.js.map

package/dist/a2a/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/a2a/index.ts"],"names":[],"mappings":"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"}

package/dist/a2a/memory/cleanup.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A2A Task Cleanup Service for JAF
+ * Pure functional cleanup and expiration policies for A2A tasks
+ */
+import { A2ATaskProvider, A2AResult } from './types.js';
+/**
+ * Configuration for task cleanup policies
+ */
+export interface A2ATaskCleanupConfig {
+    readonly enabled: boolean;
+    readonly interval: number;
+    readonly maxAge: number;
+    readonly maxCompletedTasks: number;
+    readonly maxFailedTasks: number;
+    readonly retainStates: readonly string[];
+    readonly batchSize: number;
+    readonly dryRun: boolean;
+}
+/**
+ * Default cleanup configuration
+ */
+export declare const defaultCleanupConfig: A2ATaskCleanupConfig;
+/**
+ * Result type for cleanup operations
+ */
+export interface CleanupResult {
+    readonly expiredCleaned: number;
+    readonly excessCompletedCleaned: number;
+    readonly excessFailedCleaned: number;
+    readonly totalCleaned: number;
+    readonly errors: readonly string[];
+}
+/**
+ * Pure function to perform task cleanup
+ */
+export declare const performTaskCleanup: (taskProvider: A2ATaskProvider, config?: A2ATaskCleanupConfig) => Promise<A2AResult<CleanupResult>>;
+/**
+ * Pure function to create a cleanup scheduler
+ */
+export declare const createTaskCleanupScheduler: (taskProvider: A2ATaskProvider, config?: A2ATaskCleanupConfig) => {
+    start: () => void;
+    stop: () => void;
+    runOnce: () => Promise<A2AResult<CleanupResult>>;
+    isRunning: () => boolean;
+    config: A2ATaskCleanupConfig;
+};
+/**
+ * Pure function to validate cleanup configuration
+ */
+export declare const validateCleanupConfig: (config: Partial<A2ATaskCleanupConfig>) => {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Helper function to create cleanup config from environment variables
+ */
+export declare const createCleanupConfigFromEnv: () => A2ATaskCleanupConfig;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/a2a/memory/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../../src/a2a/memory/cleanup.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,SAAS,EAA2D,MAAM,YAAY,CAAC;AAEjH;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,oBASlC,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,cAAc,eAAe,EAC7B,SAAQ,oBAA2C,KAClD,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC,CAwKlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,GACrC,cAAc,eAAe,EAC7B,SAAQ,oBAA2C;;;;;;CA0DpD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,OAAO,CAAC,oBAAoB,CAAC,KAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CA2B/G,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,QAAO,oBAW7C,CAAC"}