memorysync-sdk 1.1.1 → 1.3.0

package/dist/index.d.mts

@@ -26,6 +26,296 @@ declare class ServerError extends MemorySyncError {
     constructor(message: string, options?: ErrorOptions);
 }
 
+/**
+ * Connector namespaces — `client.connections`, `client.objects` and friends.
+ *
+ * Covers the connector API: creating and managing connections to Slack, Google
+ * Drive, S3 and Granola, driving syncs, and inspecting the objects a sync
+ * produced. Shaped after `client.connections.*` in comparable SDKs so the layout
+ * is familiar.
+ *
+ * ## Why these return raw payloads
+ *
+ * Connector responses are large, provider-shaped and still moving — a Slack
+ * channel listing looks nothing like an S3 prefix listing, and both carry
+ * provider fields that change when the provider changes. Freezing them into
+ * interfaces would mean an SDK release every time a provider adds a field, and
+ * callers unable to see the new field until then. Typed models are reserved for
+ * the small, stable, first-party shapes (memories, history, feedback, ontology).
+ */
+/** The client's request function, injected so namespaces carry no transport. */
+type RequestFn = <T>(method: string, path: string, options?: {
+    body?: unknown;
+    query?: Record<string, unknown>;
+}) => Promise<T>;
+type Json = Record<string, unknown>;
+declare class Namespace {
+    protected readonly req: RequestFn;
+    constructor(request: RequestFn);
+}
+/** Slack connection settings. */
+declare class SlackNamespace extends Namespace {
+    /**
+     * Channels the app can see and could be added.
+     *
+     * Private channels appear only where the deployment allows them *and* a human
+     * has invited the app, so this never widens what someone already granted.
+     */
+    availableChannels(connectionId: string, query?: Json): Promise<Json>;
+    /** Channels currently selected for syncing. */
+    channels(connectionId: string): Promise<Json>;
+    /** Select channels for syncing. */
+    addChannels(connectionId: string, channelIds: string[]): Promise<Json>;
+    /** Stop syncing one channel. */
+    removeChannel(connectionId: string, channelId: string): Promise<Json>;
+    /**
+     * Channels this connection will never sync.
+     *
+     * The deployment-wide floor cannot be removed here; a tenant may only add to it.
+     */
+    exclusionPolicy(connectionId: string): Promise<Json>;
+    /** Replace this connection's additions to the exclusion policy. */
+    setExclusionPolicy(connectionId: string, policy: Json): Promise<Json>;
+    /** Slack users seen on this connection and who they map to. */
+    identities(connectionId: string): Promise<Json>;
+    /** Map a Slack user to a MemorySync end user. */
+    linkIdentity(connectionId: string, body: Json): Promise<Json>;
+    /** Re-read the Slack member list and refresh the identity table. */
+    syncIdentities(connectionId: string): Promise<Json>;
+}
+/** Google Drive connection settings. */
+declare class GoogleDriveNamespace extends Namespace {
+    /** Config for rendering Google's own file picker in your UI. */
+    pickerConfig(connectionId: string): Promise<Json>;
+    /** Files and folders selected for syncing. */
+    resources(connectionId: string, query?: Json): Promise<Json>;
+    /** Select files or folders for syncing. */
+    addResources(connectionId: string, body: Json): Promise<Json>;
+    /** Stop syncing one file or folder. */
+    removeResource(connectionId: string, resourceId: string): Promise<Json>;
+}
+/** S3 connection settings. */
+declare class S3Namespace extends Namespace {
+    /** Prefixes visible in the bucket that could be added. */
+    availablePrefixes(connectionId: string, query?: Json): Promise<Json>;
+    /** Prefixes currently selected for syncing. */
+    prefixes(connectionId: string): Promise<Json>;
+    /** Select prefixes for syncing. */
+    addPrefixes(connectionId: string, prefixes: string[]): Promise<Json>;
+    /**
+     * Stop syncing the given prefixes.
+     *
+     * The prefixes travel in the body rather than the path because they contain
+     * slashes, which is why this DELETE carries one.
+     */
+    removePrefixes(connectionId: string, prefixes: string[]): Promise<Json>;
+    /** Keys and patterns this connection will never sync. */
+    exclusionPolicy(connectionId: string): Promise<Json>;
+    /** Replace this connection's additions to the exclusion policy. */
+    setExclusionPolicy(connectionId: string, policy: Json): Promise<Json>;
+    /** Effective S3 settings, including the per-object size ceiling. */
+    settings(connectionId: string): Promise<Json>;
+}
+/** Granola connection settings. */
+declare class GranolaNamespace extends Namespace {
+    /** Folders that could be added. */
+    availableFolders(connectionId: string, query?: Json): Promise<Json>;
+    /** Folders currently selected for syncing. */
+    folders(connectionId: string): Promise<Json>;
+    /** Select folders for syncing. */
+    addFolders(connectionId: string, body: Json): Promise<Json>;
+    /** Stop syncing one folder. */
+    removeFolder(connectionId: string, folderId: string): Promise<Json>;
+    /** Folders and meetings this connection will never sync. */
+    exclusionPolicy(connectionId: string): Promise<Json>;
+    /** Replace this connection's additions to the exclusion policy. */
+    setExclusionPolicy(connectionId: string, policy: Json): Promise<Json>;
+    /** Meeting participants seen on this connection and who they map to. */
+    identities(connectionId: string): Promise<Json>;
+    /** Map a participant to a MemorySync end user. */
+    linkIdentity(connectionId: string, body: Json): Promise<Json>;
+    /** Move an existing mapping to a different end user. */
+    relinkIdentity(connectionId: string, body: Json): Promise<Json>;
+    /** Effective Granola settings for this connection. */
+    settings(connectionId: string): Promise<Json>;
+    /** Update Granola settings for this connection. */
+    setSettings(connectionId: string, settings: Json): Promise<Json>;
+}
+/** Starting an OAuth connection. */
+declare class ConnectionOAuthNamespace extends Namespace {
+    /**
+     * Begin an OAuth connection and get the URL to send the user to.
+     *
+     * The user completes consent in a browser and the provider calls the platform
+     * back — not your backend. Poll {@link status} to find out how it went.
+     */
+    initiate(provider: string, body?: Json): Promise<Json>;
+    /** Where an in-flight OAuth connection got to. */
+    status(query?: Json): Promise<Json>;
+}
+/**
+ * Connections to external sources.
+ *
+ * Provider-specific settings live in sub-namespaces: `connections.slack`,
+ * `connections.gdrive`, `connections.s3`, `connections.granola`.
+ */
+declare class ConnectionsNamespace extends Namespace {
+    readonly slack: SlackNamespace;
+    readonly gdrive: GoogleDriveNamespace;
+    readonly s3: S3Namespace;
+    readonly granola: GranolaNamespace;
+    readonly oauth: ConnectionOAuthNamespace;
+    constructor(request: RequestFn);
+    /** Every connection in this organization. */
+    list(query?: Json): Promise<Json>;
+    /** One connection, including its status and last sync. */
+    get(connectionId: string): Promise<Json>;
+    /** Connect a provider that authenticates with an API key or bot token. */
+    createWithApiKey(provider: string, apiKey: string, body?: Json): Promise<Json>;
+    /** Connect a provider that needs a credential bundle, such as S3 keys. */
+    createWithCredentials(provider: string, credentials: Json, body?: Json): Promise<Json>;
+    /** Change a connection's name, schedule or settings. */
+    update(connectionId: string, body: Json): Promise<Json>;
+    /**
+     * Remove a connection.
+     *
+     * Stops future syncing. Memories already extracted are left in place — use
+     * {@link purge} for those, so disconnecting never silently deletes knowledge
+     * someone still depends on.
+     */
+    delete(connectionId: string): Promise<Json>;
+    /** Re-authorise a connection whose credentials expired or were revoked. */
+    reconnect(connectionId: string, body?: Json): Promise<Json>;
+    /**
+     * Delete the memories this connection produced.
+     *
+     * Separate from {@link delete} on purpose: removing a connection and removing
+     * what it taught you are different decisions.
+     */
+    purge(connectionId: string, body?: Json): Promise<Json>;
+    /** Current and recent sync state for a connection. */
+    syncStatus(connectionId: string): Promise<Json>;
+    /** Start a sync now instead of waiting for the schedule. */
+    triggerSync(connectionId: string, body?: Json): Promise<Json>;
+    /** Objects a connection has ingested — files, messages, meetings. */
+    objects(connectionId: string, query?: Json): Promise<Json>;
+    /** Object listing with richer filtering and paging than {@link objects}. */
+    objectsV2(connectionId: string, query?: Json): Promise<Json>;
+    /** Apply one action to many objects — pause, resume, re-extract. */
+    bulkObjectAction(connectionId: string, body: Json): Promise<Json>;
+    /** Connector totals: connections, objects synced, memories produced. */
+    stats(query?: Json): Promise<Json>;
+    /** Audit trail of connector activity. */
+    auditLogs(query?: Json): Promise<Json>;
+}
+/**
+ * A single synced object: a Drive file, a Slack message batch, an S3 key, a
+ * meeting transcript.
+ */
+declare class ObjectsNamespace extends Namespace {
+    /** Metadata and sync state for one object. */
+    get(objectId: string): Promise<Json>;
+    /** What extraction made of this object. */
+    analysis(objectId: string): Promise<Json>;
+    /** Every action taken on this object. */
+    audit(objectId: string, query?: Json): Promise<Json>;
+    /** Versions of this object seen across syncs. */
+    history(objectId: string, query?: Json): Promise<Json>;
+    /** Which memories this object produced, and whether extraction finished. */
+    memoryStatus(objectId: string): Promise<Json>;
+    /** Row and column statistics for spreadsheet-shaped objects. */
+    structuredStats(objectId: string): Promise<Json>;
+    /** Score this object for extraction worthiness without extracting. */
+    evaluate(objectId: string, body?: Json): Promise<Json>;
+    /** Stop re-syncing this object, leaving its memories in place. */
+    pause(objectId: string): Promise<Json>;
+    /** Resume syncing a paused object. */
+    resume(objectId: string): Promise<Json>;
+    /**
+     * Run extraction again over content already fetched.
+     *
+     * Counts against the plan's add allowance, exactly like the first extraction,
+     * because it creates memories the same way.
+     */
+    reextract(objectId: string, body?: Json): Promise<Json>;
+    /** Fetch this object from the provider again, then extract. */
+    resync(objectId: string, body?: Json): Promise<Json>;
+    /** Remove the memories this object produced, keeping the object record. */
+    deleteMemories(objectId: string, query?: Json): Promise<Json>;
+}
+/** Connectors this deployment supports. */
+declare class ProvidersNamespace extends Namespace {
+    /** Every available provider and what it needs to connect. */
+    list(query?: Json): Promise<Json>;
+    /** One provider's capabilities, scopes and settings schema. */
+    get(providerId: string): Promise<Json>;
+}
+/** Individual sync runs. */
+declare class SyncJobsNamespace extends Namespace {
+    /** Progress and outcome of one sync run. */
+    get(jobId: string): Promise<Json>;
+    /** Stop a running sync. Objects already ingested are kept. */
+    cancel(jobId: string, body?: Json): Promise<Json>;
+}
+/** Turn websites into memories. */
+declare class WebCrawlerNamespace extends Namespace {
+    /** Check a URL is reachable and crawlable before committing to a job. */
+    validate(url: string, body?: Json): Promise<Json>;
+    /**
+     * Start a crawl. Returns a job to poll.
+     *
+     * Crawling only fetches and stores page content. Nothing becomes a memory until
+     * you call {@link importJob}, so a large crawl cannot quietly consume your add
+     * allowance.
+     */
+    crawl(url: string, body?: Json): Promise<Json>;
+    /** Crawl jobs for this organization. */
+    jobs(query?: Json): Promise<Json>;
+    /** One crawl job's status and progress. */
+    job(jobId: string): Promise<Json>;
+    /** Stop a running crawl. Pages already fetched are kept. */
+    cancelJob(jobId: string): Promise<Json>;
+    /** Delete a crawl job and its fetched pages. */
+    deleteJob(jobId: string): Promise<Json>;
+    /** Pages a crawl fetched, before any import. */
+    jobContent(jobId: string, query?: Json): Promise<Json>;
+    /** Page counts, byte totals and error breakdown for a crawl. */
+    jobStatistics(jobId: string): Promise<Json>;
+    /**
+     * Turn a completed crawl's pages into memories.
+     *
+     * This is the step that creates memories, so this is the step that is billed —
+     * one unit per memory created, like every other ingestion path.
+     */
+    importJob(jobId: string, body?: Json): Promise<Json>;
+    /** Crawls running right now. */
+    active(): Promise<Json>;
+    /** Crawler limits in force: depth, page ceiling, rate, timeouts. */
+    config(): Promise<Json>;
+}
+/**
+ * The `/api/v1/integrations` surface.
+ *
+ * Kept because the catalog and the web crawler live here and have no v2
+ * equivalent. For connection lifecycle use `client.connections`, which is the
+ * current API — `connected()` and `stats()` here are older, thinner views of the
+ * same data.
+ */
+declare class IntegrationsNamespace extends Namespace {
+    readonly webCrawler: WebCrawlerNamespace;
+    constructor(request: RequestFn);
+    /** Every integration this deployment offers, for building a picker UI. */
+    catalog(query?: Json): Promise<Json>;
+    /** Integrations currently connected. Older view of `connections.list()`. */
+    connected(query?: Json): Promise<Json>;
+    /** Legacy integration counters. Prefer `connections.stats()`. */
+    stats(query?: Json): Promise<Json>;
+    /** Update a legacy integration record. */
+    update(integrationId: string, body: Json): Promise<Json>;
+    /** Delete a legacy integration record. */
+    delete(integrationId: string): Promise<Json>;
+}
+
 interface ControlPlaneConfig {
     baseUrl: string;
     accessToken?: string;
@@ -546,6 +836,140 @@ interface ExportResponse {
     generatedAt: string;
 }
 
+/** One edit inside a {@link MemorySyncClient.batchUpdate} call. */
+interface BatchUpdateItem {
+    memoryId: number;
+    tags?: string[];
+    importance?: number;
+    metadata?: Record<string, unknown>;
+    source?: string;
+    eventType?: string;
+}
+interface BatchUpdateItemResult {
+    index: number;
+    memoryId: number;
+    status: "updated" | "not_found";
+    changedFields: string[];
+}
+/**
+ * Result of a batch update.
+ *
+ * The server answers `207 Multi-Status`: a batch may legitimately name a memory
+ * the caller cannot see, and the caller needs to know which one rather than
+ * losing the whole request. `notFound` is an ordinary outcome, not an error.
+ */
+interface BatchUpdateResponse {
+    total: number;
+    updated: number;
+    notFound: number;
+    results: BatchUpdateItemResult[];
+}
+/**
+ * Criteria for a filter-based delete.
+ *
+ * At least one field must be set — an all-empty filter would mean "delete
+ * everything I own", which has to be an explicit `purgeUser()` call instead.
+ * `tags` matches memories carrying **all** the listed tags, not any of them.
+ */
+interface ForgetFilters {
+    source?: string;
+    eventType?: string;
+    tags?: string[];
+    tier?: string;
+    before?: string;
+    after?: string;
+}
+interface ForgetRequest {
+    memoryIds?: number[];
+    filters?: ForgetFilters;
+    /** Return the ids that *would* be deleted without deleting anything. */
+    dryRun?: boolean;
+    reason?: string;
+}
+type RevisionEvent = "created" | "updated" | "superseded" | "soft_deleted" | "restored" | "archived" | "purged";
+/**
+ * One recorded change to a memory.
+ *
+ * Revision 0 is the creation entry, synthesised by the server. `actor` is `null`
+ * for changes made by background workers, which have no request behind them —
+ * that is expected rather than missing data.
+ */
+interface RevisionEntry {
+    revision: number;
+    event: RevisionEvent;
+    changedFields: string[];
+    diff: Record<string, {
+        old?: unknown;
+        new?: unknown;
+    }>;
+    actor: string | null;
+    createdAt: string;
+}
+interface HistoryResponse {
+    memoryId: number;
+    total: number;
+    revisions: RevisionEntry[];
+    /**
+     * The fields changes are recorded for. Worth reading: only user-meaningful
+     * fields are tracked, so without this you cannot tell "nothing changed" from
+     * "that change is not recorded".
+     */
+    trackedFields: string[];
+}
+type FeedbackSignal = "positive" | "negative" | "retrieved" | "ignored";
+interface FeedbackTrend {
+    momentum: string;
+    consistency: number;
+    trendMultiplier: number;
+    recentCount: number;
+}
+interface FeedbackSummary {
+    totalSignals: number;
+    signalCounts: Record<string, number>;
+    trend: FeedbackTrend;
+}
+interface FeedbackResponse {
+    memoryId: number;
+    signal: FeedbackSignal;
+    importanceBefore: number;
+    importanceAfter: number;
+    /** Delta actually applied. `0` when ranking influence is off, or when the change was clamped at the bounds. */
+    adjustment: number;
+    /** Whether this signal was allowed to change ranking. Reported, not assumed. */
+    influencedRanking: boolean;
+    summary: FeedbackSummary;
+}
+/**
+ * The memory vocabulary in effect for an organization.
+ *
+ * The built-in types are a floor: they always apply and cannot be removed,
+ * because dropping a type would leave memories already filed under it invisible
+ * to any typed retrieval. Only `custom*` entries are removable.
+ */
+interface Ontology {
+    contentTypes: string[];
+    relationTypes: string[];
+    builtinContentTypes: string[];
+    builtinRelationTypes: string[];
+    customContentTypes: string[];
+    customRelationTypes: string[];
+    maxCustomTypes: number;
+}
+interface OntologyUpdateRequest {
+    contentTypes?: string[];
+    relationTypes?: string[];
+}
+interface UploadRequest {
+    /** File contents. A `Blob`/`File` in browsers and Node 18+, or a `Uint8Array`. */
+    file: Blob | Uint8Array;
+    /** Required: the server picks its parser from the extension. */
+    filename: string;
+    contentType?: string;
+    source?: string;
+    metadata?: Record<string, unknown>;
+    endUserId?: string;
+}
+
 declare class MemorySyncClient {
     private readonly apiKey;
     private readonly baseUrl;
@@ -553,6 +977,16 @@ declare class MemorySyncClient {
     private readonly endUserId?;
     private readonly timeoutMs;
     private readonly fetchImpl;
+    /** Connections to external sources, with provider sub-namespaces. */
+    readonly connections: ConnectionsNamespace;
+    /** Individual objects a connector ingested. */
+    readonly objects: ObjectsNamespace;
+    /** Connectors this deployment supports. */
+    readonly providers: ProvidersNamespace;
+    /** Individual sync runs. */
+    readonly syncJobs: SyncJobsNamespace;
+    /** The legacy `/api/v1/integrations` surface, including the web crawler. */
+    readonly integrations: IntegrationsNamespace;
     constructor(config: MemorySyncConfig);
     private headers;
     private request;
@@ -564,11 +998,179 @@ declare class MemorySyncClient {
     query(req: QueryRequest): Promise<QueryResponse>;
     get(memoryId: number): Promise<MemoryRecord>;
     update(memoryId: number, req: UpdateRequest): Promise<MemoryRecord>;
+    /**
+     * Delete memories, either by id or by filter. Returns the deleted ids.
+     *
+     * Accepts the legacy positional form `forget([1,2], "reason")` as well as
+     * `forget({ filters, dryRun })`. The positional form is kept because it ships
+     * in 1.1.x and removing it would break installed callers for no benefit.
+     *
+     * Exactly one selector. Passing both is rejected rather than resolved by a
+     * precedence rule, because getting that wrong on a delete cannot be undone.
+     * Deletion is scoped to the calling end user, so a filter never reaches
+     * another end user's memories — including the organisation's connector history.
+     */
+    forget(request: ForgetRequest): Promise<number[]>;
     forget(memoryIds: number[], reason?: string): Promise<number[]>;
+    /**
+     * Delete every memory belonging to the calling end user.
+     *
+     * Separate from {@link forget} on purpose: this reads like what it does, so a
+     * whole-namespace delete can never be the accidental result of an empty filter.
+     */
+    purgeUser(): Promise<Record<string, unknown>>;
     summarize(req: SummarizeRequest): Promise<MemoryRecord>;
     compose(req: ComposeRequest): Promise<ComposeResponse>;
     exportAll(): Promise<ExportResponse>;
     createRelation(fromMemoryId: number, req: RelationCreateRequest): Promise<RelationRecord>;
+    /**
+     * Ingest a document and store the memories extracted from its text.
+     *
+     * Accepts the formats the connectors accept — PDF, DOCX, PPTX, XLSX, CSV,
+     * text, Markdown, HTML, source code, and images/audio/video where
+     * transcription is configured.
+     *
+     * Billed as an add, one unit per memory created. Resolves to the first stored
+     * memory, or an {@link AddSkippedResponse} when the file yielded nothing worth
+     * keeping — a blank scan, a sheet of empty cells, or content the extractor
+     * judges trivial are all normal outcomes rather than errors.
+     */
+    upload(req: UploadRequest): Promise<AddResponse>;
+    /**
+     * Apply many metadata edits in one request.
+     *
+     * Editable: `tags`, `importance`, `metadata`, `source`, `eventType`. A memory's
+     * text, embeddings, owner, environment and project are not editable.
+     *
+     * Applied in one transaction, so the batch either lands or it does not — but an
+     * id the caller cannot see is reported per item rather than failing the request.
+     */
+    batchUpdate(items: BatchUpdateItem[]): Promise<BatchUpdateResponse>;
+    /**
+     * Recorded changes to one memory, oldest first.
+     *
+     * Entry 0 is the creation. Later entries carry the old and new value per field.
+     * Entries written by background workers have `actor: null`. Only
+     * user-meaningful fields are tracked; the watched list comes back in
+     * `trackedFields`.
+     */
+    history(memoryId: number, opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<HistoryResponse>;
+    /**
+     * Tell MemorySync whether a memory was useful.
+     *
+     * By default this moves the memory's `importance`, a weighted retrieval-ranking
+     * factor, so a memory marked useful surfaces more readily and one marked wrong
+     * surfaces less. The size of the move is adaptive: consistent signals amplify
+     * it, mixed signals damp it. Importance is clamped to [0.05, 1.0], so no run of
+     * negative feedback can make a memory permanently unreachable. Not billed.
+     */
+    feedback(memoryId: number, signal: FeedbackSignal, opts?: {
+        comment?: string;
+    }): Promise<FeedbackResponse>;
+    /** The memory vocabulary in effect for this organization. */
+    getOntology(): Promise<Ontology>;
+    /**
+     * Replace this organization's *additions* to the vocabulary.
+     *
+     * The two vocabularies are independent: omit one and it is left untouched, so
+     * adding a content type cannot wipe your relation types. Pass an empty array to
+     * clear a vocabulary's custom entries. The built-in types always remain.
+     */
+    updateOntology(req: OntologyUpdateRequest): Promise<Ontology>;
+    /**
+     * Alias of {@link query} against `/memory/retrieve`.
+     *
+     * Both paths are live, and integrators arriving from other platforms reach for
+     * `retrieve`. Identical semantics.
+     */
+    retrieve(req: QueryRequest): Promise<QueryResponse>;
+    /**
+     * Route a question to the best knowledge source and answer from it.
+     *
+     * Returns the raw payload: the response carries routing diagnostics whose shape
+     * is richer and more volatile than an SDK should freeze into an interface.
+     */
+    searchRouted(query: string, opts?: {
+        k?: number;
+        route?: string;
+        includeReasoning?: boolean;
+    }): Promise<Record<string, unknown>>;
+    /** Compose an answer across several memories, with citations. */
+    synthesize(opts?: {
+        query?: string;
+        memoryIds?: number[];
+        maxMemories?: number;
+    }): Promise<Record<string, unknown>>;
+    /** Re-embed this end user's memories. Returns immediately (`202`). */
+    refresh(): Promise<Record<string, unknown>>;
+    /** Nodes and typed edges for this end user's memory graph. */
+    graph(opts?: {
+        limit?: number;
+        memoryId?: number;
+        depth?: number;
+    }): Promise<Record<string, unknown>>;
+    /** Semantic clusters over this end user's memories. */
+    clusters(opts?: {
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    /** Contradictions and open decisions detected across memories. */
+    decisions(opts?: {
+        limit?: number;
+    }): Promise<Record<string, unknown>>;
+    /** Record which side of a contradiction wins. */
+    resolveDecision(opts?: {
+        decisionId?: string;
+        winningMemoryId?: number;
+        resolution?: string;
+        note?: string;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * The intelligence report: themes, entities, patterns, dual-horizon view.
+     *
+     * `scope` is explicit by design server-side — nothing is inferred, so if you do
+     * not ask for a scope you do not get it.
+     */
+    intelligence(opts?: {
+        limit?: number;
+        scope?: string;
+        projectId?: string;
+    }): Promise<Record<string, unknown>>;
+    /** Counts and coverage for the knowledge base. */
+    knowledgeStats(): Promise<Record<string, unknown>>;
+    /** Add a conversation turn and extract memories from it. */
+    addTurn(req: {
+        tenantId: string;
+        userId: string;
+        messages: Array<Record<string, unknown>>;
+        sessionId?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Build a prompt-ready context block for an LLM call.
+     *
+     * `types` narrows the result to those content types. Names outside the
+     * organization's vocabulary are dropped rather than rejected, so a stale client
+     * gets a narrower answer instead of an error.
+     */
+    recall(req: {
+        tenantId: string;
+        userId: string;
+        prompt: string;
+        k?: number;
+        types?: string[];
+    }): Promise<Record<string, unknown>>;
+    /** Async ingestion status for one memory. */
+    status(memoryId: number): Promise<Record<string, unknown>>;
+    /** Page through a specific end user's memories. */
+    listMemories(req: {
+        tenantId: string;
+        userId: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Record<string, unknown>>;
 }
 
-export { type AddRequest, type AddResponse, type AddSkippedResponse, type ApiKeyTestResponse, type ApiKeyTestStatus, type AuditActor, type AuditEvent, type AuditEventListResponse, type AuditEventQuery, type AuditResource, type AuditSortDirection, AuthError, type BulkAddItem, type BulkAddItemResult, type BulkAddResponse, type BulkRevokeApiKeyResult, type BulkRevokeApiKeysRequest, type BulkRevokeApiKeysResponse, type ComposeRequest, type ComposeResponse, ControlPlaneClient, type ControlPlaneConfig, type ControlPlaneRequestOptions, type CreateOrganizationRequest, type CreateWebhookRequest, type CreatedWebhook, type CurrentPlanResponse, type ExportResponse, type Integration, type IntegrationQuery, type LoginRequest, type LoginResponse, type MemoryRecord, MemorySyncClient, type MemorySyncConfig, MemorySyncError, NotFoundError, type OrganizationMembership, type OrganizationSettings, type OrganizationSettingsQuery, type Plan, type PlanLimits, type Project, type QueryFilters, type QueryRequest, type QueryResponse, RateLimitError, type RelationCreateRequest, type RelationRecord, type RelationshipType, type ReplayWebhookDeliveriesRequest, type ReplayWebhookDeliveriesResponse, ServerError, type Session, type SessionListResponse, type SummarizeRequest, type TeamMember, type TestWebhookRequest, type TestWebhookResponse, type UpdateRequest, type UpdateWebhookRequest, ValidationError, type Webhook, type WebhookDelivery, type WebhookDeliveryListResponse, type WebhookDeliveryQuery, type WebhookListResponse, type WebhookRetryConfig, type WebhookSignatureConfig };
+export { type AddRequest, type AddResponse, type AddSkippedResponse, type ApiKeyTestResponse, type ApiKeyTestStatus, type AuditActor, type AuditEvent, type AuditEventListResponse, type AuditEventQuery, type AuditResource, type AuditSortDirection, AuthError, type BatchUpdateItem, type BatchUpdateItemResult, type BatchUpdateResponse, type BulkAddItem, type BulkAddItemResult, type BulkAddResponse, type BulkRevokeApiKeyResult, type BulkRevokeApiKeysRequest, type BulkRevokeApiKeysResponse, type ComposeRequest, type ComposeResponse, ConnectionOAuthNamespace, ConnectionsNamespace, ControlPlaneClient, type ControlPlaneConfig, type ControlPlaneRequestOptions, type CreateOrganizationRequest, type CreateWebhookRequest, type CreatedWebhook, type CurrentPlanResponse, type ExportResponse, type FeedbackResponse, type FeedbackSignal, type FeedbackSummary, type FeedbackTrend, type ForgetFilters, type ForgetRequest, GoogleDriveNamespace, GranolaNamespace, type HistoryResponse, type Integration, type IntegrationQuery, IntegrationsNamespace, type LoginRequest, type LoginResponse, type MemoryRecord, MemorySyncClient, type MemorySyncConfig, MemorySyncError, NotFoundError, ObjectsNamespace, type Ontology, type OntologyUpdateRequest, type OrganizationMembership, type OrganizationSettings, type OrganizationSettingsQuery, type Plan, type PlanLimits, type Project, ProvidersNamespace, type QueryFilters, type QueryRequest, type QueryResponse, RateLimitError, type RelationCreateRequest, type RelationRecord, type RelationshipType, type ReplayWebhookDeliveriesRequest, type ReplayWebhookDeliveriesResponse, type RevisionEntry, type RevisionEvent, S3Namespace, ServerError, type Session, type SessionListResponse, SlackNamespace, type SummarizeRequest, SyncJobsNamespace, type TeamMember, type TestWebhookRequest, type TestWebhookResponse, type UpdateRequest, type UpdateWebhookRequest, type UploadRequest, ValidationError, WebCrawlerNamespace, type Webhook, type WebhookDelivery, type WebhookDeliveryListResponse, type WebhookDeliveryQuery, type WebhookListResponse, type WebhookRetryConfig, type WebhookSignatureConfig };