@mnexium/sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,944 @@
+/**
+ * Mnexium SDK Types
+ */
+/** Provider API key configuration */
+interface ProviderConfig {
+    apiKey: string;
+}
+/** Default settings for all process() calls */
+interface MnexiumDefaults {
+    /** Default model to use */
+    model?: string;
+    /** Subject ID for memory scoping. Auto-generated with subj_ prefix if omitted */
+    subjectId?: string;
+    /** Chat ID for conversation tracking. Auto-generated if omitted */
+    chatId?: string;
+    /** Save messages to chat history. Default: true */
+    log?: boolean;
+    /** Memory extraction: true (LLM decides), 'force' (always), false (never). Default: true */
+    learn?: boolean | 'force';
+    /** Inject relevant stored memories into context. Default: false */
+    recall?: boolean;
+    /** Include user profile in context. Default: false */
+    profile?: boolean;
+    /** Prepend previous messages from this chat. Default: true */
+    history?: boolean;
+    /** Enable conversation summarization. Use preset modes: 'light', 'balanced', 'aggressive'. Default: false */
+    summarize?: boolean | 'light' | 'balanced' | 'aggressive';
+    /** System prompt: true (auto-resolve), false (skip), or prompt ID like 'sp_abc'. Default: true */
+    systemPrompt?: boolean | string;
+    /** Custom metadata attached to saved logs */
+    metadata?: Record<string, unknown>;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Temperature for sampling */
+    temperature?: number;
+    /** Force regenerate trial key on every request (for testing) */
+    regenerateKey?: boolean;
+}
+interface MnexiumConfig {
+    /** Mnexium API key. If omitted, a trial key will be auto-provisioned. */
+    apiKey?: string;
+    /** Base URL for the Mnexium API. Defaults to https://mnexium.com/api/v1 */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Defaults to 30000 */
+    timeout?: number;
+    /** Maximum number of retries for failed requests. Defaults to 2 */
+    maxRetries?: number;
+    /** OpenAI configuration */
+    openai?: ProviderConfig;
+    /** Anthropic configuration */
+    anthropic?: ProviderConfig;
+    /** Google configuration */
+    google?: ProviderConfig;
+    /** Default settings for process() calls */
+    defaults?: MnexiumDefaults;
+}
+/** Options for creating a chat session (legacy name) */
+interface ChatSessionOptions {
+    /** Subject ID for memory scoping. Auto-generated if omitted */
+    subjectId?: string;
+    /** Chat ID for conversation tracking. Auto-generated if omitted */
+    chatId?: string;
+    /** Default model for this chat */
+    model?: string;
+    /** Save messages to chat history. Default: true */
+    log?: boolean;
+    /** Memory extraction: true (LLM decides), 'force' (always), false (never). Default: true */
+    learn?: boolean | 'force';
+    /** Inject relevant stored memories into context. Default: false */
+    recall?: boolean;
+    /** Include user profile in context. Default: false */
+    profile?: boolean;
+    /** Prepend previous messages from this chat. Default: true */
+    history?: boolean;
+    /** Enable conversation summarization */
+    summarize?: boolean | 'light' | 'balanced' | 'aggressive';
+    /** System prompt: true (auto-resolve), false (skip), or prompt ID */
+    systemPrompt?: boolean | string;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Temperature for sampling */
+    temperature?: number;
+    /** Custom metadata attached to saved logs */
+    metadata?: Record<string, unknown>;
+}
+/** Options for creating a Chat */
+interface ChatOptions {
+    /** Chat ID for conversation tracking. Auto-generated if omitted */
+    chatId?: string;
+    /** Default model for this chat */
+    model?: string;
+    /** Save messages to chat history. Default: true */
+    log?: boolean;
+    /** Memory extraction: true (LLM decides), 'force' (always), false (never). Default: true */
+    learn?: boolean | 'force';
+    /** Inject relevant stored memories into context. Default: false */
+    recall?: boolean;
+    /** Include user profile in context. Default: false */
+    profile?: boolean;
+    /** Prepend previous messages from this chat. Default: true */
+    history?: boolean;
+    /** Enable conversation summarization */
+    summarize?: boolean | 'light' | 'balanced' | 'aggressive';
+    /** System prompt: true (auto-resolve), false (skip), or prompt ID */
+    systemPrompt?: boolean | string;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Temperature for sampling */
+    temperature?: number;
+    /** Custom metadata attached to saved logs */
+    metadata?: Record<string, unknown>;
+}
+/** Options for listing chat history */
+interface ChatHistoryListOptions {
+    /** Maximum number of chats to return */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+/** A chat history item */
+interface ChatHistoryItem {
+    /** Chat ID */
+    chat_id: string;
+    /** Subject ID */
+    subject_id: string;
+    /** Number of messages in the chat */
+    message_count?: number;
+    /** Timestamp of last message */
+    last_message_at?: string;
+    /** Timestamp when chat was created */
+    created_at: string;
+}
+/** Options for chat.process() - content only, uses chat session defaults */
+interface ChatProcessOptions {
+    /** The user message content */
+    content: string;
+    /** Override model for this message */
+    model?: string;
+    /** Override log setting for this message */
+    log?: boolean;
+    /** Override learn setting for this message */
+    learn?: boolean | 'force';
+    /** Override recall setting for this message */
+    recall?: boolean;
+    /** Override profile setting for this message */
+    profile?: boolean;
+    /** Override history setting for this message */
+    history?: boolean;
+    /** Override summarize setting for this message */
+    summarize?: boolean | 'light' | 'balanced' | 'aggressive';
+    /** Override system prompt for this message */
+    systemPrompt?: boolean | string;
+    /** Override max tokens for this message */
+    maxTokens?: number;
+    /** Override temperature for this message */
+    temperature?: number;
+    /** Enable streaming */
+    stream?: boolean;
+    /** Override metadata for this message */
+    metadata?: Record<string, unknown>;
+    /** Force regenerate trial key */
+    regenerateKey?: boolean;
+}
+/** Options for the simplified process() API */
+interface ProcessOptions {
+    /** The user message content */
+    content: string;
+    /** Model to use (overrides default) */
+    model?: string;
+    /** Subject ID for memory scoping */
+    subjectId?: string;
+    /** Chat ID for conversation tracking */
+    chatId?: string;
+    /** Save messages to chat history. Default: true */
+    log?: boolean;
+    /** Memory extraction: true (LLM decides), 'force' (always), false (never). Default: true */
+    learn?: boolean | 'force';
+    /** Inject relevant stored memories into context. Default: false */
+    recall?: boolean;
+    /** Include user profile in context. Default: false */
+    profile?: boolean;
+    /** Prepend previous messages from this chat. Default: true */
+    history?: boolean;
+    /** Enable conversation summarization */
+    summarize?: boolean | 'light' | 'balanced' | 'aggressive';
+    /** System prompt: true (auto-resolve), false (skip), or prompt ID */
+    systemPrompt?: boolean | string;
+    /** Maximum tokens (overrides default) */
+    maxTokens?: number;
+    /** Temperature (overrides default) */
+    temperature?: number;
+    /** Enable streaming */
+    stream?: boolean;
+    /** Custom metadata attached to saved logs */
+    metadata?: Record<string, unknown>;
+    /** Force regenerate trial key (for key recovery) */
+    regenerateKey?: boolean;
+}
+/** Response from process() */
+interface ProcessResponse {
+    /** The assistant's response text */
+    content: string;
+    /** Chat ID for this conversation */
+    chatId: string;
+    /** Subject ID used */
+    subjectId: string;
+    /** Model used */
+    model: string;
+    /** Token usage */
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    /** Provisioned trial key (if auto-provisioned) */
+    provisionedKey?: string;
+    /** Claim URL for trial key */
+    claimUrl?: string;
+    /** Full raw response (for advanced use) */
+    raw: ChatCompletionResponse;
+}
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+}
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface MnxOptions {
+    /** Subject ID for memory scoping */
+    subjectId?: string;
+    /** Chat ID for conversation tracking */
+    chatId?: string;
+    /** Enable automatic memory learning. Defaults to true */
+    learn?: boolean | 'force';
+    /** Enable memory recall. Defaults to false */
+    recall?: boolean;
+    /** Enable chat history. Defaults to true */
+    history?: boolean;
+    /** Enable chat logging. Defaults to true */
+    log?: boolean;
+    /** Agent state configuration */
+    state?: {
+        load?: boolean;
+        key?: string;
+    };
+    /** System prompt ID or false to disable */
+    systemPrompt?: string | false;
+    /** Additional metadata to attach */
+    metadata?: Record<string, unknown>;
+    /** Force regenerate trial key (for key recovery) */
+    regenerateKey?: boolean;
+}
+interface ChatCompletionOptions extends MnxOptions {
+    /** Model to use (e.g., 'gpt-4o-mini', 'claude-3-sonnet', 'gemini-1.5-pro') */
+    model: string;
+    /** Messages for the conversation */
+    messages: ChatMessage[];
+    /** OpenAI API key */
+    openaiKey?: string;
+    /** Anthropic API key */
+    anthropicKey?: string;
+    /** Google API key */
+    googleKey?: string;
+    /** Enable streaming */
+    stream?: boolean;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Temperature for sampling */
+    temperature?: number;
+    /** Top-p sampling */
+    topP?: number;
+    /** Stop sequences */
+    stop?: string | string[];
+}
+interface ChatCompletionChoice {
+    index: number;
+    message: ChatMessage;
+    finish_reason: string | null;
+}
+interface ChatCompletionUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+interface MnxResponseData {
+    chat_id: string;
+    subject_id: string;
+    provisioned_key?: string;
+    claim_url?: string;
+}
+interface ChatCompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: ChatCompletionChoice[];
+    usage?: ChatCompletionUsage;
+    mnx: MnxResponseData;
+}
+interface Memory {
+    id: string;
+    project_id: string;
+    subject_id: string;
+    text: string;
+    source?: string;
+    visibility?: 'private' | 'shared';
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at?: string;
+    is_deleted?: boolean;
+    superseded_by?: string;
+}
+interface MemoryCreateOptions {
+    /** Subject ID to associate the memory with */
+    subjectId: string;
+    /** Memory text content */
+    text: string;
+    /** Source of the memory (e.g., 'user', 'agent', 'system') */
+    source?: string;
+    /** Visibility: 'private' (default) or 'shared' */
+    visibility?: 'private' | 'shared';
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+interface MemorySearchOptions {
+    /** Subject ID to search within */
+    subjectId: string;
+    /** Search query */
+    query: string;
+    /** Maximum number of results. Defaults to 10 */
+    limit?: number;
+    /** Minimum similarity score (0-1). Defaults to 0.7 */
+    minScore?: number;
+    /** Include deleted memories */
+    includeDeleted?: boolean;
+    /** Include superseded memories */
+    includeSuperseded?: boolean;
+}
+interface MemorySearchResult {
+    memory: Memory;
+    score: number;
+}
+interface Claim {
+    id: string;
+    project_id: string;
+    subject_id: string;
+    slot: string;
+    value: unknown;
+    confidence?: number;
+    source?: string;
+    source_memory_id?: string;
+    created_at: string;
+    updated_at?: string;
+    retracted_at?: string;
+}
+interface ClaimCreateOptions {
+    /** Subject ID */
+    subjectId: string;
+    /** Slot name (e.g., 'favorite_color', 'location') */
+    slot: string;
+    /** Claim value */
+    value: unknown;
+    /** Confidence score (0-1) */
+    confidence?: number;
+    /** Source of the claim */
+    source?: string;
+    /** ID of the memory this claim was extracted from */
+    sourceMemoryId?: string;
+}
+interface Profile {
+    subject_id: string;
+    project_id: string;
+    claims: Record<string, unknown>;
+    memory_count: number;
+    last_active?: string;
+}
+interface AgentState {
+    key: string;
+    value: unknown;
+    subject_id?: string;
+    ttl_seconds?: number;
+    created_at: string;
+    updated_at?: string;
+    expires_at?: string;
+}
+interface AgentStateSetOptions {
+    /** State key */
+    key: string;
+    /** State value (any JSON-serializable value) */
+    value: unknown;
+    /** Subject ID (optional, for subject-scoped state) */
+    subjectId?: string;
+    /** Time-to-live in seconds (optional) */
+    ttlSeconds?: number;
+}
+interface SystemPrompt {
+    id: string;
+    project_id: string;
+    name: string;
+    prompt_text: string;
+    is_default?: boolean;
+    created_at: string;
+    updated_at?: string;
+}
+interface SystemPromptCreateOptions {
+    /** Prompt name */
+    name: string;
+    /** Prompt text */
+    promptText: string;
+    /** Set as default prompt for the project */
+    isDefault?: boolean;
+}
+
+/**
+ * Streaming support for Mnexium SDK
+ *
+ * Provides an async iterable that yields text chunks from SSE streams,
+ * with access to final metadata after iteration completes.
+ */
+interface StreamChunk {
+    /** Incremental text content */
+    content: string;
+    /** The raw SSE data object (provider-specific) */
+    raw?: unknown;
+}
+/**
+ * StreamResponse is an async iterable that yields text chunks from an SSE stream.
+ *
+ * After iteration completes, metadata like usage, chatId, etc. are available.
+ *
+ * @example
+ * const stream = await chat.process({ content: 'Hello', stream: true });
+ * for await (const chunk of stream) {
+ *   process.stdout.write(chunk.content);
+ * }
+ * console.log('Done!', stream.totalContent);
+ * console.log('Usage:', stream.usage);
+ */
+declare class StreamResponse implements AsyncIterable<StreamChunk> {
+    /** The full accumulated content after streaming completes */
+    totalContent: string;
+    /** Chat ID (from response headers) */
+    chatId: string;
+    /** Subject ID (from response headers) */
+    subjectId: string;
+    /** Model used */
+    model: string;
+    /** Token usage (populated after stream ends, if available) */
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    /** Provisioned trial key */
+    provisionedKey?: string;
+    /** Claim URL */
+    claimUrl?: string;
+    private reader;
+    private decoder;
+    private consumed;
+    constructor(response: Response, metadata: {
+        chatId: string;
+        subjectId: string;
+        model: string;
+        provisionedKey?: string;
+        claimUrl?: string;
+    });
+    [Symbol.asyncIterator](): AsyncIterator<StreamChunk>;
+    /**
+     * Convenience: collect the full response as a string.
+     * Consumes the stream if not already consumed.
+     */
+    text(): Promise<string>;
+    private _extractChunk;
+    private _extractUsage;
+}
+
+/**
+ * Chat - A conversation thread with a stable chatId
+ */
+
+/**
+ * Chat represents a conversation thread with a stable chatId
+ *
+ * Chats belong to a Subject and maintain conversation history.
+ *
+ * @example
+ * const chat = alice.createChat({ history: true });
+ * await chat.process("Hello!");
+ * await chat.process("What did I just say?");
+ */
+declare class Chat {
+    /** The chat ID */
+    readonly id: string;
+    /** The subject ID this chat belongs to */
+    readonly subjectId: string;
+    private readonly client;
+    private readonly options;
+    constructor(client: Mnexium, subjectId: string, options?: ChatOptions);
+    /**
+     * Process a message in this chat
+     *
+     * @example
+     * // Non-streaming
+     * const response = await chat.process('Hello!');
+     *
+     * // Streaming
+     * const stream = await chat.process({ content: 'Hello!', stream: true });
+     * for await (const chunk of stream) {
+     *   process.stdout.write(chunk.content);
+     * }
+     */
+    process(input: string): Promise<ProcessResponse>;
+    process(input: ChatProcessOptions & {
+        stream: true;
+    }): Promise<StreamResponse>;
+    process(input: ChatProcessOptions): Promise<ProcessResponse>;
+}
+
+/**
+ * Real-time event stream for memory notifications via SSE
+ *
+ * Connects to GET /api/v1/events/memories and yields typed events.
+ *
+ * Events:
+ *   - connected: Initial connection confirmation
+ *   - memory.created: New memory created
+ *   - memory.updated: Memory updated
+ *   - memory.deleted: Memory deleted
+ *   - memory.superseded: Memory superseded
+ *   - profile.updated: Profile updated
+ *   - heartbeat: Keepalive (every 30s)
+ */
+
+interface MemoryEvent {
+    /** Event type */
+    type: 'connected' | 'memory.created' | 'memory.updated' | 'memory.deleted' | 'memory.superseded' | 'profile.updated' | 'heartbeat';
+    /** Event payload */
+    data: Record<string, unknown>;
+}
+/**
+ * EventStream is an async iterable that yields real-time memory events.
+ *
+ * @example
+ * const events = user.memories.subscribe();
+ * for await (const event of events) {
+ *   if (event.type === 'memory.created') {
+ *     console.log('New memory:', event.data);
+ *   }
+ * }
+ *
+ * // To stop listening:
+ * events.close();
+ */
+declare class EventStream implements AsyncIterable<MemoryEvent> {
+    private readonly client;
+    private readonly subjectId;
+    private reader;
+    private decoder;
+    private abortController;
+    private connected;
+    constructor(client: Mnexium, subjectId: string, options?: {
+        signal?: AbortSignal;
+    });
+    [Symbol.asyncIterator](): AsyncIterator<MemoryEvent>;
+    /** Close the event stream */
+    close(): void;
+    /** Whether the stream is currently connected */
+    get isConnected(): boolean;
+}
+
+/**
+ * Subject - A logical identity (user, agent, org, device) that owns memory, profile, and state
+ */
+
+/**
+ * Subject-scoped memories resource
+ */
+declare class SubjectMemoriesResource {
+    private readonly client;
+    private readonly subjectId;
+    constructor(client: Mnexium, subjectId: string);
+    search(query: string, options?: {
+        limit?: number;
+        minScore?: number;
+    }): Promise<any[]>;
+    add(text: string, options?: {
+        source?: string;
+        visibility?: 'private' | 'shared';
+        metadata?: Record<string, unknown>;
+    }): Promise<any>;
+    list(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any[]>;
+    get(memoryId: string): Promise<any>;
+    update(memoryId: string, updates: {
+        text?: string;
+        visibility?: 'private' | 'shared';
+        metadata?: Record<string, unknown>;
+    }): Promise<any>;
+    delete(memoryId: string): Promise<void>;
+    superseded(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any[]>;
+    restore(memoryId: string): Promise<any>;
+    recalls(options: {
+        chatId?: string;
+        memoryId?: string;
+    }): Promise<any[]>;
+    subscribe(options?: {
+        signal?: AbortSignal;
+    }): EventStream;
+}
+/**
+ * Subject-scoped profile resource
+ */
+declare class SubjectProfileResource {
+    private readonly client;
+    private readonly subjectId;
+    constructor(client: Mnexium, subjectId: string);
+    get(): Promise<any>;
+    update(updates: Array<{
+        field_key: string;
+        value: unknown;
+    }>): Promise<any>;
+    deleteField(fieldKey: string): Promise<void>;
+}
+/**
+ * Subject-scoped state resource
+ */
+declare class SubjectStateResource {
+    private readonly client;
+    private readonly subjectId;
+    constructor(client: Mnexium, subjectId: string);
+    get(key: string): Promise<any | null>;
+    set(key: string, value: unknown, options?: {
+        ttlSeconds?: number;
+    }): Promise<any>;
+    delete(key: string): Promise<void>;
+}
+/**
+ * Subject-scoped claims resource
+ */
+declare class SubjectClaimsResource {
+    private readonly client;
+    private readonly subjectId;
+    constructor(client: Mnexium, subjectId: string);
+    get(slot: string): Promise<any | null>;
+    set(predicate: string, value: unknown, options?: {
+        confidence?: number;
+        source?: string;
+    }): Promise<any>;
+    list(): Promise<Record<string, unknown>>;
+    truth(): Promise<any>;
+    history(): Promise<any[]>;
+    retract(claimId: string): Promise<any>;
+}
+/**
+ * Subject-scoped chats resource (for listing chat history)
+ */
+declare class SubjectChatsResource {
+    private readonly client;
+    private readonly subjectId;
+    constructor(client: Mnexium, subjectId: string);
+    list(options?: ChatHistoryListOptions): Promise<ChatHistoryItem[]>;
+    read(chatId: string): Promise<any[]>;
+    delete(chatId: string): Promise<void>;
+}
+/**
+ * Subject represents a logical identity (user, agent, org, device)
+ *
+ * Creating a Subject does NOT make a network call - it's a lightweight scoped handle.
+ *
+ * @example
+ * const alice = mnx.subject("user_123");
+ * await alice.process("Hello!");
+ * await alice.memories.search("hobbies");
+ */
+declare class Subject {
+    private readonly client;
+    /** The subject ID */
+    readonly id: string;
+    /** Subject-scoped memories */
+    readonly memories: SubjectMemoriesResource;
+    /** Subject-scoped profile */
+    readonly profile: SubjectProfileResource;
+    /** Subject-scoped state */
+    readonly state: SubjectStateResource;
+    /** Subject-scoped claims */
+    readonly claims: SubjectClaimsResource;
+    /** Subject-scoped chat history */
+    readonly chats: SubjectChatsResource;
+    constructor(client: Mnexium, subjectId: string);
+    /**
+     * Process a message with an ephemeral chat (no persistent chatId)
+     *
+     * @example
+     * const response = await alice.process("What's my favorite color?");
+     */
+    process(input: string | Omit<ProcessOptions, 'subjectId'>): Promise<ProcessResponse>;
+    /**
+     * Create a chat session for multi-turn conversation
+     *
+     * @example
+     * const chat = alice.createChat({ history: true });
+     * await chat.process("Hello!");
+     * await chat.process("What did I just say?");
+     */
+    createChat(options?: Omit<ChatOptions, 'subjectId'>): Chat;
+}
+
+/**
+ * Chat Resource - Chat completions API
+ */
+
+declare class ChatResource {
+    readonly completions: ChatCompletionsResource;
+    constructor(client: Mnexium);
+}
+declare class ChatCompletionsResource {
+    private readonly client;
+    constructor(client: Mnexium);
+    create(options: ChatCompletionOptions): Promise<ChatCompletionResponse>;
+}
+
+/**
+ * Memories Resource - Memory management API
+ */
+
+declare class MemoriesResource {
+    private readonly client;
+    constructor(client: Mnexium);
+    create(options: MemoryCreateOptions): Promise<Memory>;
+    get(id: string): Promise<Memory>;
+    list(subjectId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Memory[]>;
+    search(options: MemorySearchOptions): Promise<MemorySearchResult[]>;
+    delete(id: string): Promise<void>;
+}
+
+/**
+ * Claims Resource - Structured claims API
+ */
+
+declare class ClaimsResource {
+    private readonly client;
+    constructor(client: Mnexium);
+    create(options: ClaimCreateOptions): Promise<Claim>;
+    get(id: string): Promise<Claim>;
+    getBySlot(subjectId: string, slot: string): Promise<Claim | null>;
+    listSlots(subjectId: string): Promise<Record<string, unknown>>;
+    retract(id: string): Promise<void>;
+}
+
+/**
+ * Profiles Resource - Subject profiles API
+ */
+
+declare class ProfilesResource {
+    private readonly client;
+    constructor(client: Mnexium);
+    get(subjectId: string): Promise<Profile>;
+}
+
+/**
+ * State Resource - Agent state management API
+ */
+
+declare class StateResource {
+    private readonly client;
+    constructor(client: Mnexium);
+    get(key: string, subjectId?: string): Promise<AgentState | null>;
+    set(options: AgentStateSetOptions): Promise<AgentState>;
+    delete(key: string, subjectId?: string): Promise<void>;
+}
+
+/**
+ * Prompts Resource - System prompts management API
+ */
+
+declare class PromptsResource {
+    private readonly client;
+    constructor(client: Mnexium);
+    create(options: SystemPromptCreateOptions): Promise<SystemPrompt>;
+    get(id: string): Promise<SystemPrompt>;
+    list(): Promise<SystemPrompt[]>;
+    update(id: string, options: Partial<SystemPromptCreateOptions>): Promise<SystemPrompt>;
+    delete(id: string): Promise<void>;
+    resolve(options?: {
+        subjectId?: string;
+        chatId?: string;
+        combined?: boolean;
+    }): Promise<any>;
+}
+
+/**
+ * Mnexium SDK Client
+ */
+
+declare class Mnexium {
+    private readonly apiKey?;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    private provisionedKey?;
+    private readonly openaiConfig?;
+    private readonly anthropicConfig?;
+    private readonly googleConfig?;
+    private readonly defaults;
+    readonly chat: ChatResource;
+    readonly memories: MemoriesResource;
+    readonly claims: ClaimsResource;
+    readonly profiles: ProfilesResource;
+    readonly state: StateResource;
+    readonly prompts: PromptsResource;
+    constructor(config?: MnexiumConfig);
+    /**
+     * Process a message with Mnexium's memory-enhanced AI
+     *
+     * This is the simplified, recommended API for most use cases.
+     *
+     * @example
+     * // Simple usage
+     * const response = await mnx.process("Hello!");
+     *
+     * // With options
+     * const response = await mnx.process({
+     *   content: "Hello!",
+     *   model: "gpt-4o",
+     *   subjectId: "user_123",
+     * });
+     */
+    process(input: string): Promise<ProcessResponse>;
+    process(input: ProcessOptions & {
+        stream: true;
+    }): Promise<StreamResponse>;
+    process(input: ProcessOptions): Promise<ProcessResponse>;
+    /**
+     * Get the provisioned trial key (if auto-provisioned)
+     * @deprecated Use getTrialInfo() instead
+     */
+    getProvisionedKey(): string | undefined;
+    /**
+     * Get trial key info including the key and claim URL
+     *
+     * @example
+     * const trial = mnx.getTrialInfo();
+     * if (trial) {
+     *   console.log('Key:', trial.key);
+     *   console.log('Claim at:', trial.claimUrl);
+     * }
+     */
+    getTrialInfo(): {
+        key: string;
+        claimUrl: string;
+    } | null;
+    /**
+     * Get a Subject handle for a given subject ID
+     *
+     * Creating a Subject does NOT make a network call - it's a lightweight scoped handle.
+     *
+     * @example
+     * const alice = mnx.subject("user_123");
+     * await alice.process("Hello!");
+     * await alice.memories.search("hobbies");
+     */
+    subject(subjectId?: string): Subject;
+    /**
+     * Create a chat for a subject
+     *
+     * @example
+     * const alice = mnx.subject("user_123");
+     * const chat = mnx.createChat(alice, { history: true });
+     * // or with string:
+     * const chat = mnx.createChat("user_123", { history: true });
+     */
+    createChat(subject: Subject | string, options?: ChatOptions): Chat;
+    /**
+     * @deprecated Use createChat(subject, options) instead
+     */
+    createChatSession(options?: ChatSessionOptions): Chat;
+    /**
+     * Internal: Set provisioned key from response
+     */
+    _setProvisionedKey(key: string): void;
+    /**
+     * Internal: Make a raw API request (returns Response, used for streaming)
+     */
+    _requestRaw(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, options?: {
+        body?: unknown;
+        headers?: Record<string, string>;
+        query?: Record<string, string | number | boolean | undefined>;
+    }): Promise<Response>;
+    /**
+     * Internal: Make an API request
+     */
+    _request<T>(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, options?: {
+        body?: unknown;
+        headers?: Record<string, string>;
+        query?: Record<string, string | number | boolean | undefined>;
+    }): Promise<T>;
+    private _handleErrorResponse;
+    private _sleep;
+}
+
+/**
+ * Mnexium SDK Errors
+ */
+declare class MnexiumError extends Error {
+    constructor(message: string);
+}
+declare class AuthenticationError extends MnexiumError {
+    constructor(message?: string);
+}
+declare class RateLimitError extends MnexiumError {
+    readonly retryAfter?: number;
+    readonly current?: number;
+    readonly limit?: number;
+    constructor(message?: string, options?: {
+        retryAfter?: number;
+        current?: number;
+        limit?: number;
+    });
+}
+declare class APIError extends MnexiumError {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+
+export { APIError, type AgentState, type AgentStateSetOptions, AuthenticationError, Chat, type ChatCompletionOptions, type ChatCompletionResponse, type ChatHistoryItem, type ChatHistoryListOptions, type ChatMessage, type ChatOptions, type ChatProcessOptions, Chat as ChatSession, type ChatSessionOptions, type Claim, type ClaimCreateOptions, EventStream, type Memory, type MemoryCreateOptions, type MemoryEvent, type MemorySearchOptions, type MemorySearchResult, Mnexium, type MnexiumConfig, type MnexiumDefaults, MnexiumError, type MnxOptions, type ProcessOptions, type ProcessResponse, type Profile, type ProviderConfig, RateLimitError, type StreamChunk, StreamResponse, Subject, type SystemPrompt, type SystemPromptCreateOptions };