moa-mcp-server/dist/types/index.js

MCP Server for Memory of Agents (MOA) API - Memory Management & Intelligent Memory endpoints only

import { z } from 'zod';
export const ConfigSchema = z.object({
    moa: z.object({
        apiKey: z.string(),
        baseUrl: z.string().url('MOA base URL must be a valid URL').default('https://beta-api.memof.ai'),
        timeout: z.number().positive().default(30000),
    }),
    server: z.object({
        name: z.string().default('moa-mcp-server'),
        version: z.string().default('0.1.2'),
    }),
    logging: z.object({
        level: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
    }),
});
export const MemoryCreateRequestSchema = z.object({
    content: z.string().min(1).max(10000).describe('Memory content'),
    metadata: z.record(z.any()).optional().describe('Additional metadata').default({}),
});
export const MemoryUpdateRequestSchema = z.object({
    content: z.string().min(1).max(10000).optional().describe('Updated content for the memory'),
    metadata: z.record(z.any()).optional().describe('Updated metadata'),
});
export const MemoryResponseSchema = z.object({
    id: z.number().int(),
    user_id: z.number().int(),
    raw_content: z.string(),
    processed_content: z.string().nullable(),
    semantic_summary: z.string().nullable(),
    entities: z.array(z.any()).nullable(),
    sentiment_score: z.number().nullable(),
    intent: z.string().nullable(),
    context_tags: z.array(z.string()).nullable(),
    relationships: z.array(z.any()).nullable(),
    quality_score: z.number().nullable(),
    temporal_relevance: z.number().nullable(),
    importance_score: z.number().nullable(),
    retrieval_frequency: z.number().int().nullable().default(0),
    last_accessed: z.string().datetime().nullable(),
    user_feedback_score: z.number().nullable(),
    dynamic_quality_score: z.number().nullable(),
    retrieval_context_tags: z.array(z.string()).nullable(),
    personalization_score: z.number().nullable(),
    processing_status: z.string(),
    is_processed: z.boolean(),
    created_at: z.string().datetime(),
    updated_at: z.string().datetime(),
});
export const MemoryListResponseSchema = z.object({
    memories: z.array(MemoryResponseSchema),
    total: z.number().int(),
    page: z.number().int(),
    per_page: z.number().int(),
    has_next: z.boolean(),
    has_prev: z.boolean(),
});
export const MemoryStatsResponseSchema = z.object({
    total_memories: z.number().int(),
    processed_memories: z.number().int(),
    pending_memories: z.number().int(),
    failed_memories: z.number().int(),
    average_quality_score: z.number(),
    average_importance_score: z.number(),
    top_contexts: z.array(z.record(z.number())),
    top_entities: z.array(z.record(z.number())),
    sentiment_distribution: z.record(z.number()),
});
export const MemoryProcessingStatusSchema = z.object({
    memory_id: z.number().int(),
    status: z.string(),
    progress: z.number().describe('Progress between 0.0 and 1.0'),
    current_step: z.string().nullable(),
    errors: z.array(z.string()).default([]),
    processing_time: z.number().nullable(),
});
export const QueryRequestSchema = z.object({
    query: z.string().min(1).describe('The query string'),
    max_results: z.number().int().default(10).describe('Maximum number of results'),
    include_insights: z.boolean().default(true).describe('Include AI-generated insights'),
    include_related: z.boolean().default(true).describe('Include related memories'),
    include_context: z.boolean().default(true).describe('Include enhanced context'),
    time_range: z.string().nullable().optional().describe('Time range filter: hour, day, week, month, quarter, year, all'),
    content_types: z.array(z.string()).nullable().optional().describe('Filter by content types'),
    quality_threshold: z.number().nullable().optional().describe('Minimum quality score (0.0-1.0)'),
    search_strategy: z.enum([
        'adaptive', 'semantic', 'contextual', 'vector', 'temporal',
        'comprehensive', 'fast', 'hybrid', 'intelligent'
    ]).default('adaptive').describe('Search strategy'),
    personalization_level: z.enum(['none', 'low', 'medium', 'high']).default('high').describe('Level of personalization'),
});
export const ValidationResultSchema = z.object({
    memory_id: z.number().int(),
    relevance_score: z.number().describe('AI-assessed relevance (0.0-1.0)'),
    reasoning: z.string().describe('AI explanation of relevance'),
    key_aspects: z.array(z.string()).default([]).describe('Key matching aspects'),
    personalization_fit: z.number().describe('User-specific fit (0.0-1.0)'),
    confidence: z.number().describe('AI confidence in assessment (0.0-1.0)'),
});
export const ValidatedResultSchema = z.object({
    memory: MemoryResponseSchema,
    validation: ValidationResultSchema,
    enhanced_context: z.record(z.any()).default({}).describe('Additional context'),
    personalization_score: z.number().describe('Personalized relevance (0.0-1.0)'),
    final_relevance_score: z.number().describe('Combined final score (0.0-1.0)'),
    retrieval_path: z.string().describe('How this result was found'),
    matching_aspects: z.array(z.string()).default([]).describe('What aspects matched'),
    suggested_actions: z.array(z.string()).default([]).describe('Suggested follow-up actions'),
});
export const QueryInsightsSchema = z.object({
    summary: z.string().describe('AI-generated summary of findings'),
    key_themes: z.array(z.string()).default([]).describe('Main themes in results'),
    temporal_patterns: z.record(z.any()).nullable().describe('Time-based patterns'),
    entity_relationships: z.record(z.any()).nullable().describe('Entity connections'),
    confidence_assessment: z.string().describe('Overall confidence in results'),
    recommendations: z.array(z.string()).default([]).describe('AI recommendations'),
    search_coverage: z.number().describe('How much of memory space was covered (0.0-1.0)'),
    result_diversity: z.number().describe('Diversity of results (0.0-1.0)'),
    novelty_score: z.number().describe('How novel/unexpected results are (0.0-1.0)'),
});
export const QueryContextSchema = z.object({
    original_query: z.string(),
    query_hash: z.string(),
    query_type: z.string(),
    intent: z.string(),
    entities: z.array(z.string()),
    context_tags: z.array(z.string()),
    temporal_hints: z.record(z.any()).nullable(),
    semantic_themes: z.array(z.string()),
    processing_time: z.number(),
    confidence: z.number(),
    context_weights: z.record(z.number()),
});
export const QueryResponseSchema = z.object({
    results: z.array(ValidatedResultSchema),
    insights: QueryInsightsSchema,
    query_context: QueryContextSchema,
    processing_time_ms: z.number().describe('Total processing time'),
    total_memories_searched: z.number().int().describe('Total memories examined'),
    confidence_score: z.number().describe('Overall result confidence (0.0-1.0)'),
    related_queries: z.array(z.string()).nullable().optional().describe('Suggested related queries'),
    suggestions: z.array(z.string()).nullable().optional().describe('Query improvement suggestions'),
    usage_analytics: z.record(z.any()).nullable().optional().describe('Usage analytics'),
    personalization_insights: z.record(z.any()).nullable().optional().describe('Personalization data'),
});
export const BatchQueryRequestSchema = z.object({
    queries: z.array(QueryRequestSchema).min(1).max(50),
    parallel_processing: z.boolean().default(true).describe('Process queries in parallel'),
    shared_context: z.record(z.any()).nullable().optional().describe('Shared context for all queries'),
});
export class MOAAPIError extends Error {
    statusCode;
    response;
    constructor(message, statusCode, response) {
        super(message);
        this.statusCode = statusCode;
        this.response = response;
        this.name = 'MOAAPIError';
    }
}
export class ConfigurationError extends Error {
    constructor(message) {
        super(message);
        this.name = 'ConfigurationError';
    }
}