@neo4j-labs/agent-memory 0.3.0

package/dist/client-DSqbWQoa.d.ts

@@ -0,0 +1,551 @@
+import { L as Logger, T as Transport } from './index-qfRrdQNP.js';
+
+/**
+ * Core type definitions for neo4j-agent-memory TypeScript client.
+ *
+ * Canonical types use camelCase. Wire format depends on transport:
+ *   - BridgeTransport: snake_case JSON
+ *   - RestTransport: camelCase JSON (matches the hosted service)
+ *
+ * Sub-clients translate between wire and canonical forms.
+ */
+type MessageRole = "user" | "assistant" | "system";
+type ToolCallStatus = "pending" | "success" | "failure" | "error" | "timeout" | "cancelled";
+interface Message {
+    id: string;
+    role: MessageRole;
+    content: string;
+    timestamp: string;
+    embedding?: number[];
+    metadata: Record<string, unknown>;
+    /** Hosted service: link back to the conversation. */
+    conversationId?: string;
+}
+interface Conversation {
+    id: string;
+    /** Bridge protocol session identifier (free-form string). */
+    sessionId: string;
+    messages: Message[];
+    /** Hosted service: message count when returned by list/metadata endpoints. */
+    messageCount?: number;
+    title?: string;
+    createdAt: string;
+    updatedAt?: string;
+    /** Hosted service: workspace owning this conversation. */
+    workspaceId?: string;
+    /** Hosted service: user the conversation belongs to. */
+    userId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SessionInfo {
+    sessionId: string;
+    messageCount: number;
+    createdAt: string;
+    updatedAt?: string;
+}
+/** A 3-tier conversational context window — hosted service. */
+interface ConversationContext {
+    reflections: Reflection[];
+    observations: Observation[];
+    recentMessages: Message[];
+}
+interface Observation {
+    id: string;
+    conversationId: string;
+    content: string;
+    windowStart?: string;
+    windowEnd?: string;
+    createdAt: string;
+}
+interface Reflection {
+    id: string;
+    conversationId: string;
+    content: string;
+    createdAt: string;
+}
+/** Bridge taxonomy. */
+type EntityType = "PERSON" | "ORGANIZATION" | "LOCATION" | "EVENT" | "OBJECT";
+/** Hosted-service entity taxonomy. */
+type HostedEntityType = "person" | "organization" | "location" | "concept" | "tool" | "custom";
+interface Entity {
+    id: string;
+    name: string;
+    type: string;
+    subtype?: string;
+    description?: string;
+    embedding?: number[];
+    canonicalName?: string;
+    createdAt: string;
+    /** Hosted service. */
+    updatedAt?: string;
+    /** Hosted service: confidence score (0-1). */
+    confidence?: number;
+    /** Hosted service: which extraction stage produced the entity. */
+    sourceStage?: string;
+    /** Hosted service: relationships referenced by getEntity. */
+    relationships?: EntityRelationshipRef[];
+}
+interface EntityRelationshipRef {
+    id: string;
+    type: string;
+    targetId: string;
+    targetName?: string;
+    properties?: Record<string, unknown>;
+}
+interface EntityHistory {
+    entityId: string;
+    mentions: EntityMention[];
+}
+interface EntityMention {
+    conversationId: string;
+    messageId?: string;
+    content: string;
+    timestamp: string;
+}
+interface EntityGraphNode {
+    id: string;
+    name: string;
+    type: string;
+}
+interface EntityGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    type: string;
+}
+interface EntityGraph {
+    nodes: EntityGraphNode[];
+    edges: EntityGraphEdge[];
+}
+interface EntityFeedbackResult {
+    id: string;
+    updated: boolean;
+}
+interface EntityMergeResult {
+    sourceId: string;
+    targetId: string;
+    status: string;
+}
+interface Preference {
+    id: string;
+    category: string;
+    preference: string;
+    context?: string;
+    embedding?: number[];
+}
+interface Fact {
+    id: string;
+    subject: string;
+    predicate: string;
+    object: string;
+    embedding?: number[];
+}
+interface Relationship {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    relationshipType: string;
+    properties: Record<string, unknown>;
+}
+interface ReasoningTrace {
+    id: string;
+    sessionId: string;
+    task: string;
+    steps: ReasoningStep[];
+    outcome?: string;
+    success?: boolean;
+    startedAt: string;
+    completedAt?: string;
+}
+interface ReasoningStep {
+    id: string;
+    traceId: string;
+    stepNumber: number;
+    thought?: string;
+    action?: string;
+    observation?: string;
+    toolCalls: ToolCall[];
+}
+interface ToolCall {
+    id: string;
+    /** Reasoning step this tool call hangs off (hosted service exposes this). */
+    stepId?: string;
+    toolName: string;
+    arguments: Record<string, unknown>;
+    result?: unknown;
+    status: ToolCallStatus;
+    durationMs?: number;
+    error?: string;
+}
+interface ToolStats {
+    name: string;
+    totalCalls: number;
+    successfulCalls: number;
+    failedCalls: number;
+    successRate: number;
+    avgDurationMs?: number;
+}
+/** Hosted-service flat reasoning step (per-conversation, no trace wrapper). */
+interface AgentStep {
+    id: string;
+    conversationId: string;
+    reasoning: string;
+    actionTaken: string;
+    result?: string;
+    createdAt: string;
+}
+/** Hosted: detailed step with tool calls + influenced entities. */
+interface AgentStepExplanation extends AgentStep {
+    toolCalls: ToolCall[];
+    influencedEntities: Entity[];
+}
+/** Hosted: flat reasoning trace (steps + tool calls under one conversation). */
+interface ConversationTrace {
+    conversationId: string;
+    steps: AgentStep[];
+    toolCalls: ToolCall[];
+}
+/** Hosted: provenance of an entity's creation. */
+interface EntityProvenance {
+    entityId: string;
+    steps: AgentStep[];
+}
+interface CypherResult {
+    columns: string[];
+    rows: unknown[][];
+    stats?: Record<string, unknown>;
+}
+interface ApiKey {
+    id: string;
+    label: string;
+    scopes: string[];
+    workspaceId: string;
+    createdAt: string;
+    expiresAt?: string;
+    /** Plaintext key — only present at creation time. */
+    key?: string;
+}
+interface AccessTokenPair {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+}
+type TransportMode = "auto" | "bridge" | "rest";
+interface MemoryClientOptions {
+    /** Service base URL (bridge endpoint, or `https://.../v1` for REST). */
+    endpoint?: string;
+    /** API key for authentication. */
+    apiKey?: string;
+    /** Override transport selection. Default: "auto" (REST if endpoint contains /v1). */
+    transport?: TransportMode;
+    /** OAuth refresh-token-aware token provider. Overrides apiKey when supplied. */
+    tokenProvider?: () => string | Promise<string>;
+    /** Shared entity namespace for multi-agent collaboration. */
+    namespace?: string;
+    /** Request timeout in milliseconds. Default: 30000. */
+    timeout?: number;
+    /** Additional headers to include in every request. */
+    headers?: Record<string, string>;
+    /**
+     * Optional logger invoked once per request / response / error. Useful for
+     * tracing requests in development. Caller controls log level by ignoring
+     * unwanted event kinds. See {@link LogEvent}.
+     */
+    logger?: Logger;
+}
+interface AddMessageOptions {
+    metadata?: Record<string, unknown>;
+}
+interface GetConversationOptions {
+    limit?: number;
+}
+interface SearchMessagesOptions {
+    sessionId?: string;
+    limit?: number;
+    threshold?: number;
+}
+interface ListSessionsOptions {
+    limit?: number;
+}
+interface SearchEntitiesOptions {
+    limit?: number;
+    type?: string;
+}
+interface SearchPreferencesOptions {
+    category?: string;
+    limit?: number;
+}
+interface GetRelatedEntitiesOptions {
+    relationshipType?: string;
+    depth?: number;
+}
+interface ListTracesOptions {
+    sessionId?: string;
+    limit?: number;
+}
+interface RecordToolCallOptions {
+    result?: unknown;
+    status?: ToolCallStatus;
+    durationMs?: number;
+    error?: string;
+}
+interface CompleteTraceOptions {
+    outcome?: string;
+    success?: boolean;
+}
+interface AddRelationshipOptions {
+    properties?: Record<string, unknown>;
+}
+interface GetSimilarTracesOptions {
+    limit?: number;
+    successOnly?: boolean;
+}
+interface CreateConversationOptions {
+    userId: string;
+    metadata?: Record<string, unknown>;
+}
+interface ListConversationsOptions {
+    limit?: number;
+    userId?: string;
+}
+interface BulkMessageInput {
+    role: MessageRole;
+    content: string;
+    metadata?: Record<string, unknown>;
+}
+interface ListEntitiesOptions {
+    type?: HostedEntityType | string;
+    limit?: number;
+}
+interface UpdateEntityOptions {
+    name?: string;
+    description?: string;
+}
+interface SetEntityFeedbackOptions {
+    userScore: number;
+    confirmed: boolean;
+}
+interface RecordStepInput {
+    conversationId: string;
+    reasoning: string;
+    actionTaken: string;
+    result?: string;
+}
+interface CreateApiKeyInput {
+    label: string;
+    scopes: string[];
+    workspaceId: string;
+}
+
+/**
+ * Auth & API-key management — hosted service only.
+ *
+ * Static `nams_*` keys can be created, listed, revealed, and revoked. OAuth
+ * refresh-token rotation is also exposed for clients running PKCE flows.
+ */
+
+declare class AuthClient {
+    private readonly transport;
+    constructor(transport: Transport);
+    /** List API keys for a workspace (no plaintext). */
+    listApiKeys(workspaceId: string): Promise<ApiKey[]>;
+    /** Create a new API key. The plaintext value is returned only once. */
+    createApiKey(input: CreateApiKeyInput): Promise<ApiKey>;
+    /** Revoke (delete) an API key by id. */
+    revokeApiKey(keyId: string): Promise<void>;
+    /** Reveal the plaintext value of a stored API key. */
+    revealApiKey(keyId: string, workspaceId: string): Promise<ApiKey>;
+    /** Exchange a refresh token for a fresh access/refresh pair. */
+    refreshAccessToken(refreshToken: string): Promise<AccessTokenPair>;
+}
+
+/**
+ * Long-term memory operations.
+ *
+ * Bridge methods (Silver tier) plus Volume 5 / hosted-native methods for
+ * entity feedback, history, merge-by-id, graph view, and provenance.
+ */
+
+declare class LongTermMemory {
+    private readonly transport;
+    constructor(transport: Transport);
+    addEntity(name: string, entityType: string, options?: {
+        description?: string;
+    }): Promise<Entity>;
+    addPreference(category: string, preference: string, options?: {
+        context?: string;
+    }): Promise<Preference>;
+    addFact(subject: string, predicate: string, obj: string): Promise<Fact>;
+    searchEntities(query: string, options?: SearchEntitiesOptions): Promise<Entity[]>;
+    searchPreferences(query: string, options?: SearchPreferencesOptions): Promise<Preference[]>;
+    getEntityByName(name: string): Promise<Entity | null>;
+    getRelatedEntities(entityId: string, options?: GetRelatedEntitiesOptions): Promise<Entity[]>;
+    addRelationship(sourceId: string, targetId: string, relationshipType: string, options?: AddRelationshipOptions): Promise<Relationship>;
+    mergeDuplicateEntities(sourceId: string, targetId: string, options?: {
+        canonicalName?: string;
+    }): Promise<Entity>;
+    /** List all entities, optionally filtered by entity type. */
+    listEntities(options?: ListEntitiesOptions): Promise<Entity[]>;
+    /** Fetch one entity (with relationships) by id. */
+    getEntity(entityId: string): Promise<Entity>;
+    /** Update an existing entity's name and/or description.
+     *
+     * The hosted PUT /v1/entities/{id} returns `{status: "updated"}` rather
+     * than the full entity, so when the response lacks an `id` we follow up
+     * with a GET to keep the SDK contract — "update returns the updated
+     * Entity". Bridge transports return the entity directly, so we tolerate
+     * both shapes.
+     */
+    updateEntity(entityId: string, options: UpdateEntityOptions): Promise<Entity>;
+    /** Delete an entity and its relationships. */
+    deleteEntity(entityId: string): Promise<void>;
+    /** Score an entity 0-1 and optionally mark it human-confirmed. */
+    setEntityFeedback(entityId: string, options: SetEntityFeedbackOptions): Promise<EntityFeedbackResult>;
+    /** All cross-conversation mentions of this entity. */
+    getEntityHistory(entityId: string): Promise<EntityHistory>;
+    /** Merge `sourceId` into `targetId`, leaving a SAME_AS provenance link. */
+    mergeEntities(sourceId: string, targetId: string): Promise<EntityMergeResult>;
+    /** Full-graph view of all entities + edges. Pair with NVL for visualization. */
+    getEntityGraph(): Promise<EntityGraph>;
+}
+
+/**
+ * Cypher query console — read-only access to the underlying graph.
+ *
+ * Hosted service only: write operations are rejected with HTTP 400.
+ */
+
+declare class QueryConsole {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Execute a read-only Cypher query.
+     *
+     * @example
+     * const r = await client.query.cypher({
+     *   cypher: "MATCH (e:Entity) RETURN e.name AS name LIMIT $n",
+     *   params: { n: 10 },
+     * });
+     */
+    cypher(input: {
+        cypher: string;
+        params?: Record<string, unknown>;
+    }): Promise<CypherResult>;
+}
+
+/**
+ * Reasoning memory operations.
+ *
+ * Bridge methods (Silver tier) wrap traces. Volume 5 / hosted-native methods
+ * are flatter — steps belong directly to a conversation, with explain &
+ * provenance views for the reasoning trail behind any entity.
+ */
+
+declare class ReasoningMemory {
+    private readonly transport;
+    constructor(transport: Transport);
+    startTrace(sessionId: string, task: string): Promise<ReasoningTrace>;
+    addStep(traceId: string, options?: {
+        thought?: string;
+        action?: string;
+        observation?: string;
+    }): Promise<ReasoningStep>;
+    recordToolCall(stepId: string, toolName: string, args: Record<string, unknown>, options?: RecordToolCallOptions): Promise<ToolCall>;
+    completeTrace(traceId: string, options?: CompleteTraceOptions): Promise<ReasoningTrace>;
+    getTraceWithSteps(traceId: string): Promise<ReasoningTrace | null>;
+    listTraces(options?: ListTracesOptions): Promise<ReasoningTrace[]>;
+    getToolStats(toolName?: string): Promise<ToolStats[]>;
+    getSimilarTraces(task: string, options?: GetSimilarTracesOptions): Promise<ReasoningTrace[]>;
+    /** Record one reasoning step under a conversation (hosted REACT model). */
+    recordStep(input: RecordStepInput): Promise<AgentStep>;
+    /** List all reasoning steps for one conversation. */
+    listSteps(conversationId: string): Promise<AgentStep[]>;
+    /** Detailed step explanation with tool calls and influenced entities. */
+    explainStep(stepId: string): Promise<AgentStepExplanation>;
+    /** Full reasoning trace for a conversation (steps + tool calls). */
+    getTraceByConversation(conversationId: string): Promise<ConversationTrace>;
+    /** All reasoning steps that influenced an entity's creation.
+     *
+     * Hosted REST returns the chain under `provenance`; bridge / older
+     * responses use `steps`. Accept either.
+     */
+    getEntityProvenance(entityId: string): Promise<EntityProvenance>;
+}
+
+/**
+ * Short-term (conversational) memory operations.
+ *
+ * Bridge methods (Bronze tier) speak the TCK BaseAdapter contract.
+ * Hosted methods speak the Volume 5 / Platinum tier hosted service operations.
+ */
+
+declare class ShortTermMemory {
+    private readonly transport;
+    constructor(transport: Transport);
+    addMessage(sessionId: string, role: MessageRole, content: string, options?: AddMessageOptions): Promise<Message>;
+    getConversation(sessionId: string, options?: GetConversationOptions): Promise<Conversation>;
+    searchMessages(query: string, options?: SearchMessagesOptions): Promise<Message[]>;
+    listSessions(options?: ListSessionsOptions): Promise<SessionInfo[]>;
+    deleteMessage(messageId: string): Promise<boolean>;
+    clearSession(sessionId: string): Promise<void>;
+    /** Create a new conversation (hosted service). */
+    createConversation(options: CreateConversationOptions): Promise<Conversation>;
+    /** List conversations the API key has access to. */
+    listConversations(options?: ListConversationsOptions): Promise<Conversation[]>;
+    /** Fetch conversation metadata (no messages). */
+    getConversationMetadata(conversationId: string): Promise<Conversation>;
+    /** Delete a conversation and all its messages. */
+    deleteConversation(conversationId: string): Promise<void>;
+    /**
+     * Three-tier conversational context (reflections + observations + recent
+     * messages). The richest input you can hand an LLM about a conversation.
+     */
+    getContext(conversationId: string): Promise<ConversationContext>;
+    /** Bulk-add up to 100 messages in one request. */
+    bulkAddMessages(conversationId: string, messages: BulkMessageInput[]): Promise<Message[]>;
+    /** Auto-generated message-window summaries. */
+    getObservations(conversationId: string, options?: {
+        limit?: number;
+    }): Promise<Observation[]>;
+    /** Higher-level reflections derived from observations. */
+    getReflections(conversationId: string): Promise<Reflection[]>;
+}
+
+/**
+ * MemoryClient — root entry point for all memory operations.
+ *
+ * Zero-config form (Node, Bun, Deno):
+ *
+ *     const client = new MemoryClient();
+ *
+ * defaults the endpoint to https://memory.neo4jlabs.com/v1 and reads
+ * MEMORY_API_KEY from the environment.
+ *
+ * Edge runtimes (Cloudflare Workers, Vercel Edge) read env from the request
+ * handler scope, not module init, so pass apiKey explicitly:
+ *
+ *     const client = new MemoryClient({ apiKey: env.MEMORY_API_KEY });
+ *
+ * The first request triggers the auth probe automatically; calling
+ * `connect()` upfront is supported but optional.
+ */
+
+declare class MemoryClient {
+    /** Short-term (conversational) memory operations. */
+    readonly shortTerm: ShortTermMemory;
+    /** Long-term (entity / preference / fact / graph) memory operations. */
+    readonly longTerm: LongTermMemory;
+    /** Reasoning (trace / step / tool call / provenance) memory operations. */
+    readonly reasoning: ReasoningMemory;
+    /** Read-only Cypher query console (hosted service only). */
+    readonly query: QueryConsole;
+    /** API-key & OAuth management (hosted service only). */
+    readonly auth: AuthClient;
+    private readonly transport;
+    constructor(options?: MemoryClientOptions);
+    constructor(transport: Transport);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+}
+
+export { type SessionInfo as $, type AccessTokenPair as A, type BulkMessageInput as B, type CompleteTraceOptions as C, type ListTracesOptions as D, type Entity as E, type Fact as F, type GetConversationOptions as G, type HostedEntityType as H, LongTermMemory as I, type MemoryClientOptions as J, type Message as K, type ListConversationsOptions as L, MemoryClient as M, type MessageRole as N, type Observation as O, type Preference as P, QueryConsole as Q, ReasoningMemory as R, type ReasoningStep as S, type ReasoningTrace as T, type RecordStepInput as U, type RecordToolCallOptions as V, type Reflection as W, type Relationship as X, type SearchEntitiesOptions as Y, type SearchMessagesOptions as Z, type SearchPreferencesOptions as _, type AddMessageOptions as a, type SetEntityFeedbackOptions as a0, ShortTermMemory as a1, type ToolCall as a2, type ToolCallStatus as a3, type ToolStats as a4, type TransportMode as a5, type UpdateEntityOptions as a6, type AddRelationshipOptions as b, type AgentStep as c, type AgentStepExplanation as d, type ApiKey as e, AuthClient as f, type Conversation as g, type ConversationContext as h, type ConversationTrace as i, type CreateApiKeyInput as j, type CreateConversationOptions as k, type CypherResult as l, type EntityFeedbackResult as m, type EntityGraph as n, type EntityGraphEdge as o, type EntityGraphNode as p, type EntityHistory as q, type EntityMention as r, type EntityMergeResult as s, type EntityProvenance as t, type EntityRelationshipRef as u, type EntityType as v, type GetRelatedEntitiesOptions as w, type GetSimilarTracesOptions as x, type ListEntitiesOptions as y, type ListSessionsOptions as z };

package/dist/index-qfRrdQNP.d.ts

@@ -0,0 +1,42 @@
+/** Single event emitted to the user-supplied logger. */
+type LogEvent = {
+    kind: "request";
+    method: string;
+    url: string;
+    httpMethod?: string;
+} | {
+    kind: "response";
+    method: string;
+    url: string;
+    status: number;
+    requestId?: string;
+    durationMs: number;
+} | {
+    kind: "error";
+    method: string;
+    url: string;
+    status?: number;
+    requestId?: string;
+    durationMs: number;
+    message: string;
+};
+type Logger = (event: LogEvent) => void;
+
+/**
+ * Transport abstraction layer.
+ *
+ * RestTransport speaks the hosted REST API at https://memory.neo4jlabs.com/v1
+ * and is the transport every application should use. BridgeTransport speaks
+ * the TCK bridge protocol and is exposed via the `./testing` subpath for
+ * conformance testing only.
+ */
+interface Transport {
+    /** Send a request to the backend and return the parsed response. */
+    request<T>(method: string, params: Record<string, unknown>): Promise<T>;
+    /** Establish the connection. */
+    connect(): Promise<void>;
+    /** Close the connection and release resources. */
+    close(): Promise<void>;
+}
+
+export type { Logger as L, Transport as T, LogEvent as a };

package/dist/index.d.ts

@@ -0,0 +1,93 @@
+export { A as AccessTokenPair, a as AddMessageOptions, b as AddRelationshipOptions, c as AgentStep, d as AgentStepExplanation, e as ApiKey, f as AuthClient, B as BulkMessageInput, C as CompleteTraceOptions, g as Conversation, h as ConversationContext, i as ConversationTrace, j as CreateApiKeyInput, k as CreateConversationOptions, l as CypherResult, E as Entity, m as EntityFeedbackResult, n as EntityGraph, o as EntityGraphEdge, p as EntityGraphNode, q as EntityHistory, r as EntityMention, s as EntityMergeResult, t as EntityProvenance, u as EntityRelationshipRef, v as EntityType, F as Fact, G as GetConversationOptions, w as GetRelatedEntitiesOptions, x as GetSimilarTracesOptions, H as HostedEntityType, L as ListConversationsOptions, y as ListEntitiesOptions, z as ListSessionsOptions, D as ListTracesOptions, I as LongTermMemory, M as MemoryClient, J as MemoryClientOptions, K as Message, N as MessageRole, O as Observation, P as Preference, Q as QueryConsole, R as ReasoningMemory, S as ReasoningStep, T as ReasoningTrace, U as RecordStepInput, V as RecordToolCallOptions, W as Reflection, X as Relationship, Y as SearchEntitiesOptions, Z as SearchMessagesOptions, _ as SearchPreferencesOptions, $ as SessionInfo, a0 as SetEntityFeedbackOptions, a1 as ShortTermMemory, a2 as ToolCall, a3 as ToolCallStatus, a4 as ToolStats, a5 as TransportMode, a6 as UpdateEntityOptions } from './client-DSqbWQoa.js';
+import { T as Transport, L as Logger } from './index-qfRrdQNP.js';
+export { a as LogEvent } from './index-qfRrdQNP.js';
+
+/**
+ * RestTransport — talks to the hosted Neo4j Agent Memory Service REST API.
+ *
+ * Endpoint should be the v1 root, e.g. `https://memory.neo4jlabs.com/v1`.
+ * Routes the bridge-style `request(method, params)` calls to the appropriate
+ * REST endpoints with snake_case ↔ camelCase translation on the wire.
+ *
+ * Hosted-native methods (added in Volume 5 of the spec) are routed natively.
+ * Legacy bridge-only methods (add_preference, add_fact, etc.) throw
+ * NotSupportedError because the hosted service has no equivalent.
+ */
+
+type TokenProvider = () => string | Promise<string>;
+interface RestTransportOptions {
+    /** Base URL — should end in /v1, e.g. https://memory.neo4jlabs.com/v1 */
+    endpoint: string;
+    /** Static `nams_*` API key. */
+    apiKey?: string;
+    /** Token provider (overrides apiKey if both supplied) — for OAuth refresh flows. */
+    tokenProvider?: TokenProvider;
+    /** Request timeout in milliseconds. Default: 30000. */
+    timeout?: number;
+    /** Additional headers to include in every request. */
+    headers?: Record<string, string>;
+    /** Per-request logger; see {@link Logger}. */
+    logger?: Logger;
+}
+declare class RestTransport implements Transport {
+    private readonly endpoint;
+    private readonly apiKey?;
+    private readonly tokenProvider?;
+    private readonly timeout;
+    private readonly headers;
+    private readonly logger?;
+    constructor(options: RestTransportOptions);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    request<T>(method: string, params: Record<string, unknown>): Promise<T>;
+    private emit;
+    private buildHeaders;
+}
+
+/**
+ * Error hierarchy for the neo4j-agent-memory TypeScript client.
+ *
+ * Every error from a failed HTTP exchange carries a `requestId` when the
+ * service emitted one. Quote it in support threads for fast log lookup.
+ */
+/** Options accepted by every MemoryError subclass. */
+interface MemoryErrorOptions extends ErrorOptions {
+    /** Server-generated correlation id (x-request-id or equivalent). */
+    requestId?: string;
+}
+declare class MemoryError extends Error {
+    /** Server-generated correlation id, when available. */
+    readonly requestId?: string;
+    constructor(message: string, options?: MemoryErrorOptions);
+    toString(): string;
+}
+declare class ConnectionError extends MemoryError {
+    constructor(message: string, options?: MemoryErrorOptions);
+}
+declare class AuthenticationError extends MemoryError {
+    constructor(message: string, options?: MemoryErrorOptions);
+}
+declare class NotFoundError extends MemoryError {
+    constructor(message: string, options?: MemoryErrorOptions);
+}
+declare class ValidationError extends MemoryError {
+    constructor(message: string, options?: MemoryErrorOptions);
+}
+declare class TransportError extends MemoryError {
+    readonly statusCode?: number;
+    readonly responseBody?: unknown;
+    constructor(message: string, statusCode?: number, responseBody?: unknown, options?: MemoryErrorOptions);
+}
+/** Raised when a transport cannot fulfil a method (e.g. REST has no equivalent). */
+declare class NotSupportedError extends MemoryError {
+    constructor(message: string, options?: MemoryErrorOptions);
+}
+
+/**
+ * Package version constant. Kept in sync with package.json via a
+ * dedicated version-check script run in CI. Imported by the transports to build
+ * the default User-Agent header.
+ */
+declare const VERSION = "0.3.0";
+
+export { AuthenticationError, ConnectionError, Logger, MemoryError, NotFoundError, NotSupportedError, RestTransport, type RestTransportOptions, type TokenProvider, Transport, TransportError, VERSION, ValidationError };