@subcortex-ai/sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1447 @@
+/**
+ * HTTP Transport Layer
+ *
+ * Handles fetch calls, auth headers, retry with backoff,
+ * timeout, request IDs, and snake_case ↔ camelCase mapping.
+ *
+ * This module is internal — consumers use SubCortexClient, not HttpTransport.
+ */
+interface RetryConfig {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+}
+interface HttpTransportOptions {
+    baseUrl: string;
+    tenantId: string;
+    apiKey?: string;
+    token?: string;
+    retry: RetryConfig;
+    timeoutMs: number;
+    fetchImpl: typeof fetch;
+    headers: Record<string, string>;
+    signal?: AbortSignal;
+}
+declare class HttpTransport {
+    private readonly opts;
+    constructor(options: HttpTransportOptions);
+    /** GET request with retry and typed response. */
+    get<T>(path: string, tenantId?: string): Promise<T>;
+    /** POST request with retry and typed response. */
+    post<T>(path: string, body: unknown, tenantId?: string): Promise<T>;
+    /** PUT request with retry and typed response. */
+    put<T>(path: string, body: unknown, tenantId?: string): Promise<T>;
+    /** DELETE request with retry and typed response. */
+    delete<T>(path: string, tenantId?: string): Promise<T>;
+    /** Core request method with retry loop. */
+    private request;
+    /** Fetch with AbortController timeout. */
+    private fetchWithTimeout;
+}
+
+/**
+ * Shared types used across the Cortex SDK.
+ */
+/** Paginated response wrapper. */
+interface PaginatedResponse<T> {
+    data: T[];
+    nextPageToken?: string;
+    totalCount?: number;
+}
+/** Result of a batch operation. */
+interface BatchResult<T> {
+    succeeded: T[];
+    errors: Array<{
+        index: number;
+        message: string;
+    }>;
+}
+/** Confidence score for an assertion or relationship. */
+interface ConfidenceScore {
+    value: number;
+    method?: 'EXPLICIT' | 'SOURCE_DEFAULT' | 'CONSENSUS' | 'MODEL_REPORTED' | 'TEMPORAL_DECAY';
+    modelConfidence?: number;
+}
+/** Bi-temporal bounds: when a fact is true vs when it was recorded. */
+interface TemporalBounds {
+    validFrom: string;
+    validUntil?: string;
+    transactionTime: string;
+}
+/** Provenance — where an assertion came from. */
+interface Provenance {
+    sourceId: string;
+    sourceType: 'HUMAN' | 'SYSTEM' | 'AI_AGENT' | 'IMPORT' | 'DERIVED' | 'SENSOR';
+    sourceLabel: string;
+    sourceTimestamp: string;
+    derivedFrom: string[];
+    derivationMethod?: string;
+    metadata: Record<string, string>;
+}
+/** Health check response. */
+interface HealthResponse {
+    status: string;
+    version: string;
+}
+
+/**
+ * SubCortex Built-in Schema
+ *
+ * These are the foundational types, predicates, relationship types,
+ * and confidence levels that SubCortex supports natively. They are
+ * NOT exhaustive — tenants can extend them. But these cover the
+ * universal patterns every agent-user interaction needs.
+ *
+ * Consumer systems import these instead of using raw strings.
+ */
+/**
+ * Well-known subject prefixes. SubCortex recognizes these and
+ * provides specialized behavior for each.
+ */
+declare enum SubjectPrefix {
+    /** The authenticated user interacting with the agent */
+    USER = "user",
+    /** A person mentioned by the user (not the user themselves) */
+    PERSON = "person",
+    /** A job role or position */
+    ROLE = "role",
+    /** A business entity / data model (e.g., Project, Invoice) */
+    ENTITY = "entity",
+    /** A property/field on an entity */
+    PROPERTY = "property",
+    /** A project, initiative, or ongoing effort */
+    PROJECT = "project",
+    /** An event, meeting, or milestone */
+    EVENT = "event",
+    /** An agent using SubCortex */
+    AGENT = "agent"
+}
+declare function subject(prefix: SubjectPrefix | string, identifier: string): string;
+/**
+ * Built-in predicates for user/person identity and profile.
+ */
+declare enum IdentityPredicate {
+    NAME = "name",
+    FULL_NAME = "full_name",
+    ROLE = "role",
+    TITLE = "title",
+    DEPARTMENT = "department",
+    TEAM = "team",
+    START_DATE = "start_date",
+    EMAIL = "email"
+}
+/**
+ * Built-in predicates for work context.
+ * NOTE: Org relationships (reports_to, manages, etc.) are NOT predicates.
+ * They are relationship types — connections between two subjects.
+ * See OrgRelationship enum.
+ */
+declare enum WorkPredicate {
+    EXPERTISE = "expertise",
+    CURRENT_PROJECT = "current_project",
+    PAIN_POINT = "pain_point"
+}
+/**
+ * Built-in predicates for events and status tracking.
+ */
+declare enum EventPredicate {
+    STATUS = "status",
+    STATUS_CHANGE = "status_change",
+    EVENT = "event",
+    DECISION = "decision",
+    OUTCOME = "outcome"
+}
+/**
+ * Built-in predicates for emotional/rapport tracking.
+ */
+declare enum RapportPredicate {
+    SENTIMENT = "sentiment",
+    FRUSTRATION = "frustration",
+    EXCITEMENT = "excitement",
+    CONCERN = "concern",
+    GOAL = "goal",
+    ASPIRATION = "aspiration",
+    PREFERENCE = "preference",
+    PAIN_POINT = "pain_point",
+    INTEREST = "interest",
+    COMMUNICATION_STYLE = "communication_style"
+}
+/**
+ * Built-in predicates for agent memory management.
+ */
+declare enum MemoryPredicate {
+    REMINDER = "reminder",
+    CONTEXT = "context",
+    CONTEXT_TASK = "context:task",
+    CURRENT_PROJECT = "current_project"
+}
+/**
+ * Built-in predicates for entity/schema definition.
+ */
+declare enum EntityPredicate {
+    TYPE = "type",
+    DESCRIPTION = "description",
+    FIELD_TYPE = "field_type",
+    REQUIRED = "required",
+    WORKFLOW = "workflow"
+}
+/**
+ * All built-in predicates combined.
+ * Consumer systems should use these instead of raw strings.
+ */
+declare const Predicates: {
+    readonly TYPE: EntityPredicate.TYPE;
+    readonly DESCRIPTION: EntityPredicate.DESCRIPTION;
+    readonly FIELD_TYPE: EntityPredicate.FIELD_TYPE;
+    readonly REQUIRED: EntityPredicate.REQUIRED;
+    readonly WORKFLOW: EntityPredicate.WORKFLOW;
+    readonly REMINDER: MemoryPredicate.REMINDER;
+    readonly CONTEXT: MemoryPredicate.CONTEXT;
+    readonly CONTEXT_TASK: MemoryPredicate.CONTEXT_TASK;
+    readonly CURRENT_PROJECT: MemoryPredicate.CURRENT_PROJECT;
+    readonly SENTIMENT: RapportPredicate.SENTIMENT;
+    readonly FRUSTRATION: RapportPredicate.FRUSTRATION;
+    readonly EXCITEMENT: RapportPredicate.EXCITEMENT;
+    readonly CONCERN: RapportPredicate.CONCERN;
+    readonly GOAL: RapportPredicate.GOAL;
+    readonly ASPIRATION: RapportPredicate.ASPIRATION;
+    readonly PREFERENCE: RapportPredicate.PREFERENCE;
+    readonly PAIN_POINT: RapportPredicate.PAIN_POINT;
+    readonly INTEREST: RapportPredicate.INTEREST;
+    readonly COMMUNICATION_STYLE: RapportPredicate.COMMUNICATION_STYLE;
+    readonly STATUS: EventPredicate.STATUS;
+    readonly STATUS_CHANGE: EventPredicate.STATUS_CHANGE;
+    readonly EVENT: EventPredicate.EVENT;
+    readonly DECISION: EventPredicate.DECISION;
+    readonly OUTCOME: EventPredicate.OUTCOME;
+    readonly EXPERTISE: WorkPredicate.EXPERTISE;
+    readonly NAME: IdentityPredicate.NAME;
+    readonly FULL_NAME: IdentityPredicate.FULL_NAME;
+    readonly ROLE: IdentityPredicate.ROLE;
+    readonly TITLE: IdentityPredicate.TITLE;
+    readonly DEPARTMENT: IdentityPredicate.DEPARTMENT;
+    readonly TEAM: IdentityPredicate.TEAM;
+    readonly START_DATE: IdentityPredicate.START_DATE;
+    readonly EMAIL: IdentityPredicate.EMAIL;
+};
+/**
+ * Built-in relationship types for organizational structure.
+ *
+ * Each relationship is directional. Many have a natural reverse:
+ *   reports_to ↔ manages
+ *   mentored_by ↔ mentors
+ *   member_of ↔ has_member
+ */
+declare enum OrgRelationship {
+    /** Person reports to user/manager */
+    REPORTS_TO = "reports_to",
+    /** User/manager manages person */
+    MANAGES = "manages",
+    /** Person is member of team/project */
+    MEMBER_OF = "member_of",
+    /** Team/project has this person as member */
+    HAS_MEMBER = "has_member",
+    /** Person holds a specific role */
+    HOLDS_ROLE = "holds_role",
+    /** Person is a candidate for a role */
+    CANDIDATE_FOR = "candidate_for",
+    /** Person collaborates with another person */
+    COLLABORATES_WITH = "collaborates_with",
+    /** Person mentors another person */
+    MENTORS = "mentors",
+    /** Person is mentored by another person */
+    MENTORED_BY = "mentored_by",
+    /** Person is a stakeholder in something */
+    STAKEHOLDER_IN = "stakeholder_in"
+}
+/**
+ * Built-in relationship types for entity/schema structure.
+ */
+declare enum EntityRelationship {
+    HAS_PROPERTY = "has_property",
+    BELONGS_TO = "belongs_to",
+    HAS_MANY = "has_many",
+    MANY_TO_MANY = "many_to_many",
+    DEPENDS_ON = "depends_on"
+}
+/**
+ * All built-in relationship types combined.
+ */
+declare const RelationshipTypes: {
+    readonly HAS_PROPERTY: EntityRelationship.HAS_PROPERTY;
+    readonly BELONGS_TO: EntityRelationship.BELONGS_TO;
+    readonly HAS_MANY: EntityRelationship.HAS_MANY;
+    readonly MANY_TO_MANY: EntityRelationship.MANY_TO_MANY;
+    readonly DEPENDS_ON: EntityRelationship.DEPENDS_ON;
+    /** Person reports to user/manager */
+    readonly REPORTS_TO: OrgRelationship.REPORTS_TO;
+    /** User/manager manages person */
+    readonly MANAGES: OrgRelationship.MANAGES;
+    /** Person is member of team/project */
+    readonly MEMBER_OF: OrgRelationship.MEMBER_OF;
+    /** Team/project has this person as member */
+    readonly HAS_MEMBER: OrgRelationship.HAS_MEMBER;
+    /** Person holds a specific role */
+    readonly HOLDS_ROLE: OrgRelationship.HOLDS_ROLE;
+    /** Person is a candidate for a role */
+    readonly CANDIDATE_FOR: OrgRelationship.CANDIDATE_FOR;
+    /** Person collaborates with another person */
+    readonly COLLABORATES_WITH: OrgRelationship.COLLABORATES_WITH;
+    /** Person mentors another person */
+    readonly MENTORS: OrgRelationship.MENTORS;
+    /** Person is mentored by another person */
+    readonly MENTORED_BY: OrgRelationship.MENTORED_BY;
+    /** Person is a stakeholder in something */
+    readonly STAKEHOLDER_IN: OrgRelationship.STAKEHOLDER_IN;
+};
+/**
+ * Standard confidence levels with numeric values.
+ * The agent chooses the level; SubCortex maps to the score.
+ */
+declare enum ConfidenceLevel {
+    /** User stated it directly: "My name is Alice" */
+    CONFIRMED = "confirmed",
+    /** Strongly implied: "I've been managing the team" → manager */
+    HIGH = "high",
+    /** Reasonable inference from context */
+    MODERATE = "moderate",
+    /** Speculative — worth checking later */
+    LOW = "low"
+}
+/** Map confidence levels to numeric scores */
+declare const ConfidenceScores: Record<ConfidenceLevel, number>;
+/** Convert a confidence level label to a numeric score */
+declare function confidenceToScore(level: ConfidenceLevel | string): number;
+/** Convert a numeric score to the closest confidence level */
+declare function scoreToConfidence(score: number): ConfidenceLevel;
+/**
+ * Whether a predicate supports multiple values on the same subject.
+ * Multi-value predicates don't trigger conflict detection in the Thalamus.
+ */
+/**
+ * Predicates that can have multiple values on the same subject.
+ * These don't trigger conflict detection in the Thalamus.
+ */
+declare const MULTI_VALUE_PREDICATES: Set<string>;
+/**
+ * Map from relationship type to its reverse.
+ * Used by brain.users.registerPerson() to create bidirectional edges.
+ */
+declare const REVERSE_RELATIONSHIPS: Record<string, string>;
+/**
+ * Agent-facing labels for relationship types.
+ * Used in tool descriptions so the model knows what's available.
+ */
+declare const RELATIONSHIP_LABELS: Record<string, string>;
+
+/**
+ * SubCortex Signal Types
+ *
+ * Signals represent emotional and rapport-related data that attach to
+ * the knowledge they relate to. Unlike assertions, signals:
+ * - Compound (never conflict)
+ * - Decay over time (exponential, configurable half-life)
+ * - Have trajectory (warming/cooling/stable/neutral)
+ * - Can be resolved by interaction (not just time)
+ *
+ * Storage: Signals are assertions with `signal:{type}` predicates.
+ * The consumer-facing API treats them as a separate entity.
+ */
+/**
+ * SYSTEM signal types — available for all tenants.
+ * Tenant-specific types use `custom:{tenant}:{type}` convention.
+ */
+declare const SYSTEM_SIGNAL_TYPES: readonly ["frustration", "excitement", "concern", "satisfaction", "confusion", "gratitude", "tension", "sentiment"];
+type SystemSignalType = typeof SYSTEM_SIGNAL_TYPES[number];
+/** Any valid signal type — system or custom */
+type SignalType = SystemSignalType | `custom:${string}`;
+declare function isValidSignalType(type: string): type is SignalType;
+/**
+ * Per-type decay half-life in hours.
+ * All start at 24h — structure supports per-type tuning.
+ */
+declare const SIGNAL_DECAY_CONFIG: Record<string, number>;
+declare function getDecayHalfLife(signalType: string): number;
+type Trajectory = 'warming' | 'cooling' | 'stable' | 'neutral';
+/** A single recorded signal */
+interface SignalEntry {
+    /** Assertion ID backing this signal */
+    id: string;
+    /** Signal type (e.g., 'frustration', 'excitement') */
+    type: string;
+    /** Human-readable content */
+    content: string;
+    /** Raw recorded intensity (0-1) */
+    intensity: number;
+    /** Time-decayed intensity */
+    decayedIntensity: number;
+    /** Age in hours since recorded */
+    ageHours: number;
+    /** Subject this signal is about (e.g., 'context:hiring', 'person:sarah') */
+    aboutSubject?: string;
+    /** If this signal was resolved by another signal */
+    resolvedBy?: string;
+    /** ISO timestamp when recorded */
+    timestamp: string;
+}
+/** Aggregated snapshot of all signals for a subject */
+interface SignalSnapshot {
+    /** All signal entries within the query window */
+    signals: SignalEntry[];
+    /** Overall rapport trajectory */
+    trajectory: Trajectory;
+    /** Aggregate intensity across all active signals */
+    aggregateIntensity: number;
+}
+/**
+ * Signal types that indicate a positive emotional shift.
+ * When recorded with `resolveConflicting: true`, these automatically
+ * resolve recent negative signals on the same subject.
+ */
+declare const POSITIVE_SIGNALS: Set<string>;
+/**
+ * Signal types that indicate a negative emotional state.
+ * These are candidates for resolution by a subsequent positive signal.
+ */
+declare const NEGATIVE_SIGNALS: Set<string>;
+interface RecordSignalInput {
+    /** User ID the signal is about */
+    userId: string;
+    /** Signal type */
+    type: SignalType;
+    /** Human-readable description */
+    content: string;
+    /** Intensity 0-1 (default: 0.7) */
+    intensity?: number;
+    /** Subject this signal relates to (e.g., a project, person, topic) */
+    aboutSubject?: string;
+    /** Session ID for contextual binding */
+    sessionId?: string;
+    /**
+     * When true and the signal type is a positive signal (satisfaction, excitement, gratitude),
+     * automatically resolves recent negative signals on the same subject within the last 72 hours.
+     * Resolved signals decay 4x faster. Default: false.
+     */
+    resolveConflicting?: boolean;
+}
+interface SignalQueryOptions {
+    /** Window in hours to look back (default: 72) */
+    windowHours?: number;
+    /** Filter to specific signal type */
+    type?: string;
+}
+interface ResolveSignalInput {
+    /** ID of the signal being resolved */
+    signalId: string;
+    /** ID of the signal that resolves it */
+    resolvedBySignalId: string;
+}
+
+/**
+ * User-related types for SubCortex rapport building.
+ *
+ * These types define the inputs and outputs for the high-level
+ * user operations that SubCortex provides out of the box.
+ */
+
+/** Input for identifying/checking a user */
+interface IdentifyUserInput {
+    /** The user's system ID (from the consumer platform) */
+    userId: string;
+    /** Display name from the system (used to seed if first encounter) */
+    displayName?: string;
+    /** Email from the system */
+    email?: string;
+    /** Agent ID — used to scope conflict detection to this agent's intake queue */
+    agentId?: string;
+}
+/** Result of user identification */
+interface UserIdentification {
+    /** The user subject in SubCortex */
+    subject: string;
+    /** Whether SubCortex has met this user before */
+    isKnown: boolean;
+    /** The user's name (from assertions, or seeded from system) */
+    name: string | null;
+    /** All assertions about this user */
+    memories: UserMemory[];
+    /** People connected to this user via relationships */
+    connectedPeople: ConnectedPerson[];
+    /** Active reminders to surface */
+    reminders: UserMemory[];
+    /** Active context anchors (projects, initiatives) */
+    contexts: UserMemory[];
+    /** Unresolved Thalamus conflicts */
+    conflicts: ConflictItem[];
+    /** Emotional signals within the query window (decayed, with trajectory) */
+    signals: SignalEntry[];
+    /** Overall rapport trajectory (warming/cooling/stable/neutral) */
+    rapportTrajectory: Trajectory;
+    /** Human-readable summary for the agent */
+    summary: string;
+}
+/** A single memory/assertion about the user */
+interface UserMemory {
+    id: string;
+    predicate: string;
+    value: unknown;
+    confidence: number;
+    createdAt: string;
+}
+/** A person connected to the user via relationship */
+interface ConnectedPerson {
+    subject: string;
+    name: string;
+    relationship: string;
+    facts: Array<{
+        predicate: string;
+        value: unknown;
+    }>;
+}
+/** An unresolved conflict from the Thalamus */
+interface ConflictItem {
+    id: string;
+    hint: string;
+}
+/** Input for registering a person the user mentions */
+interface RegisterPersonInput {
+    /** Person's full name */
+    name: string;
+    /** The user ID (subject user — who mentioned this person) */
+    userId: string;
+    /** The relationship between the user and this person */
+    relationship: string;
+    /** The person's role/title (optional) */
+    role?: string;
+    /** Additional details */
+    details?: string;
+    /** Confidence level */
+    confidence?: ConfidenceLevel | number;
+}
+/** Result of person registration */
+interface RegisterPersonResult {
+    /** The person subject created */
+    personSubject: string;
+    /** Assertions created */
+    assertionsCreated: number;
+    /** Relationships created */
+    relationshipsCreated: number;
+    /** Warnings (e.g., role conflicts) */
+    warnings: string[];
+}
+/** Input for recording an emotional state or rapport signal */
+interface RecordRapportInput {
+    /** The user ID */
+    userId: string;
+    /** Type of rapport signal */
+    type: 'sentiment' | 'frustration' | 'excitement' | 'concern' | 'goal' | 'aspiration' | 'preference' | 'interest';
+    /** The content */
+    value: string;
+    /** Optional: person this emotion relates to */
+    aboutPerson?: string;
+    /** Confidence */
+    confidence?: ConfidenceLevel | number;
+}
+
+/**
+ * SubCortex Users Namespace
+ *
+ * High-level operations for user rapport building.
+ * This is where orchestration logic lives — NOT in the consumer's proxy.
+ *
+ * The consumer agent calls brain.users.identify() and gets back
+ * a complete picture. One call, one round-trip, full context.
+ */
+
+declare class UsersNamespace {
+    private http;
+    private tenantId;
+    constructor(http: HttpTransport, tenantId: string);
+    /**
+     * Identify a user and retrieve their full context.
+     *
+     * This is the FIRST thing an agent should call at session start.
+     * Returns whether the user is known, their memories, connected
+     * people, reminders, conflicts, and a summary.
+     *
+     * @example
+     * ```typescript
+     * const user = await brain.users.identify({
+     *   userId: 'cmk123...',
+     *   displayName: 'Tom Santos',
+     * })
+     *
+     * if (!user.isKnown) {
+     *   // First encounter — get to know them
+     * } else {
+     *   // Returning user — reference what you know
+     *   // user.reminders — bring these up
+     *   // user.conflicts — address these
+     *   // user.connectedPeople — context about their org
+     * }
+     * ```
+     */
+    identify(input: IdentifyUserInput): Promise<UserIdentification>;
+    /**
+     * Register a person that the user mentioned.
+     *
+     * Creates the person node, their role, and bidirectional
+     * relationships to the user. One call does everything.
+     *
+     * @example
+     * ```typescript
+     * const result = await brain.users.registerPerson({
+     *   name: 'John Smith',
+     *   userId: 'cmk123...',
+     *   relationship: 'direct_report',
+     *   role: 'VP of Engineering',
+     * })
+     * ```
+     */
+    registerPerson(input: RegisterPersonInput): Promise<RegisterPersonResult>;
+    /**
+     * Record an emotional state or rapport signal about the user.
+     *
+     * @example
+     * ```typescript
+     * await brain.users.recordRapport({
+     *   userId: 'cmk123...',
+     *   type: 'frustration',
+     *   value: 'Frustrated about losing the EA candidate',
+     *   aboutPerson: 'Sarah Johnson',
+     * })
+     * ```
+     */
+    recordRapport(input: RecordRapportInput): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Dismiss a reminder after the agent has surfaced it.
+     */
+    dismissReminder(userId: string, reminderContent: string): Promise<{
+        success: boolean;
+    }>;
+}
+
+/**
+ * SubCortex Signals Namespace
+ *
+ * Records and queries emotional/rapport signals. Signals attach to
+ * the knowledge they relate to and provide temporal decay + trajectory.
+ *
+ * Signals are stored as assertions with `signal:{type}` predicates.
+ * The consumer sees them as a separate entity via this namespace.
+ */
+
+declare class SignalsNamespace {
+    private http;
+    private tenantId;
+    constructor(http: HttpTransport, tenantId: string);
+    /**
+     * Record an emotional signal about a user.
+     *
+     * @example
+     * ```typescript
+     * await brain.signals.record({
+     *   userId: 'cmk123',
+     *   type: 'frustration',
+     *   content: 'Frustrated about the hiring timeline',
+     *   intensity: 0.85,
+     *   aboutSubject: 'context:hiring-ea',
+     * })
+     * ```
+     */
+    record(input: RecordSignalInput): Promise<{
+        id: string;
+        resolved?: number;
+    }>;
+    /**
+     * Query signals for a user with computed decay and trajectory.
+     * Delegates to the engine's signal query endpoint for server-side computation.
+     *
+     * @example
+     * ```typescript
+     * const snapshot = await brain.signals.query('user:cmk123', {
+     *   windowHours: 72,
+     *   type: 'frustration',
+     * })
+     * ```
+     */
+    query(userSubject: string, options?: SignalQueryOptions): Promise<SignalSnapshot>;
+    /**
+     * Resolve a signal — mark it as resolved by a subsequent positive interaction.
+     * The resolved signal's effective intensity drops faster.
+     *
+     * @example
+     * ```typescript
+     * await brain.signals.resolve({
+     *   signalId: 'abc123',
+     *   resolvedBySignalId: 'def456',
+     * })
+     * ```
+     */
+    resolve(input: ResolveSignalInput): Promise<{
+        success: boolean;
+    }>;
+}
+
+/**
+ * SubCortexClient — the main entry point for the SubCortex SDK.
+ *
+ * @example
+ * ```typescript
+ * import { SubCortexClient } from '@subcortex-ai/sdk'
+ *
+ * const subcortex = new SubCortexClient({
+ *   endpoint: 'https://api.subcortex.example.com',
+ *   tenantId: 'my-tenant',
+ *   apiKey: 'scx_live_...',
+ * })
+ *
+ * // Create an assertion
+ * const assertion = await subcortex.assertions.create({
+ *   subject: 'user:alice',
+ *   predicate: 'name',
+ *   value: 'Alice Smith',
+ * })
+ *
+ * // Query by subject
+ * const facts = await subcortex.assertions.query('user:alice')
+ *
+ * // Create a relationship
+ * const rel = await subcortex.relationships.create({
+ *   fromSubject: 'user:alice',
+ *   toSubject: 'team:engineering',
+ *   relationshipType: 'belongs_to',
+ * })
+ * ```
+ */
+
+interface SubCortexClientOptions {
+    /** Base URL of the SubCortex REST API */
+    endpoint: string;
+    /** Tenant ID — required, used as default for all operations */
+    tenantId: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** JWT token for authentication (alternative to apiKey) */
+    token?: string;
+    /** Retry configuration */
+    retry?: Partial<RetryConfig>;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeoutMs?: number;
+    /** Custom fetch implementation (for testing or Cloudflare Workers) */
+    fetch?: typeof fetch;
+    /** Custom headers added to every request */
+    headers?: Record<string, string>;
+    /** AbortSignal for cancelling all pending requests */
+    signal?: AbortSignal;
+}
+/**
+ * An assertion — the atomic unit of knowledge in SubCortex.
+ *
+ * An assertion represents a single claim: "subject S has property P with value V."
+ * Assertions are content-addressable (same content = same ID), carry confidence
+ * scores, and have temporal bounds.
+ *
+ * @example
+ * ```typescript
+ * const fact = await subcortex.assertions.create({
+ *   subject: 'user:alice',
+ *   predicate: 'role',
+ *   value: 'Engineering Manager',
+ *   confidence: 0.99,
+ * })
+ * console.log(fact.id) // content-addressable BLAKE3 hash
+ * ```
+ */
+interface Assertion {
+    /** Content-addressable ID (BLAKE3 hash of subject + predicate + value + temporal bounds) */
+    id: string;
+    /** Tenant this assertion belongs to */
+    tenantId: string;
+    /** The subject this assertion is about (e.g., `"user:alice"`, `"entity:Project"`) */
+    subject: string;
+    /** The property being asserted (e.g., `"name"`, `"role"`, `"status"`) */
+    predicate: string;
+    /** The asserted value — can be a string, number, boolean, or object */
+    value: unknown;
+    /** Confidence score (0.0–1.0). Higher = more certain. */
+    confidence: number;
+    /** When this assertion became valid (ISO 8601) */
+    validFrom: string;
+    /** Whether this assertion has been superseded by a newer version */
+    isSuperseded: boolean;
+}
+/**
+ * Input for creating an assertion.
+ *
+ * @example
+ * ```typescript
+ * await subcortex.assertions.create({
+ *   subject: 'user:alice',
+ *   predicate: 'department',
+ *   value: 'Engineering',
+ *   confidence: 0.95,
+ * })
+ * ```
+ */
+interface CreateAssertionInput {
+    /** Subject of the assertion (e.g., `"user:alice"`, `"entity:Project"`) */
+    subject: string;
+    /** Predicate — what property is being asserted */
+    predicate: string;
+    /** The value being asserted */
+    value: unknown;
+    /** Confidence score 0.0–1.0 (default: server-side default, typically 0.95) */
+    confidence?: number;
+    /** Override the default tenant ID for this operation */
+    tenantId?: string;
+}
+/**
+ * Input for superseding (updating) an existing assertion.
+ *
+ * SubCortex assertions are immutable. To "update" a fact, you supersede it:
+ * the old assertion is marked as superseded and a new one is created.
+ *
+ * @example
+ * ```typescript
+ * await subcortex.assertions.supersede({
+ *   originalAssertionId: 'abc123...',
+ *   subject: 'user:alice',
+ *   predicate: 'role',
+ *   value: 'VP Engineering', // was "Engineering Manager"
+ * })
+ * ```
+ */
+interface SupersedeAssertionInput {
+    /** ID of the assertion being superseded */
+    originalAssertionId: string;
+    /** Subject of the new assertion */
+    subject: string;
+    /** Predicate of the new assertion */
+    predicate: string;
+    /** Updated value */
+    value: unknown;
+    /** Confidence for the new assertion */
+    confidence?: number;
+    /** Override the default tenant ID */
+    tenantId?: string;
+}
+/** What the SDK returns for a relationship. */
+interface Relationship {
+    id: string;
+    tenantId: string;
+    fromSubject: string;
+    toSubject: string;
+    relationshipType: string;
+    confidence: number;
+    validFrom: string;
+    weight: number | null;
+    properties: Record<string, string>;
+}
+/** Input for creating a relationship. */
+interface CreateRelationshipInput {
+    fromSubject: string;
+    toSubject: string;
+    relationshipType: string;
+    confidence?: number;
+    weight?: number;
+    properties?: Record<string, string>;
+    tenantId?: string;
+}
+/** Operations on assertions — the atomic units of knowledge in SubCortex. */
+declare class AssertionsNamespace {
+    private http;
+    private tenantId;
+    constructor(http: HttpTransport, tenantId: string);
+    /** Create an assertion in the knowledge graph. */
+    create(input: CreateAssertionInput): Promise<Assertion>;
+    /** Get an assertion by its content-addressable ID. */
+    get(assertionId: string, options?: {
+        tenantId?: string;
+    }): Promise<Assertion>;
+    /** Query assertions by subject. */
+    query(subject: string, options?: {
+        tenantId?: string;
+    }): Promise<Assertion[]>;
+    /** List all active assertions for the tenant. */
+    list(options?: {
+        tenantId?: string;
+    }): Promise<Assertion[]>;
+    /** Supersede an existing assertion with updated values. */
+    supersede(input: SupersedeAssertionInput): Promise<Assertion>;
+    /** Retract an assertion by closing its temporal bounds. */
+    retract(assertionId: string, options?: {
+        tenantId?: string;
+    }): Promise<Assertion>;
+}
+/** Operations on relationships — directional edges between subjects. */
+declare class RelationshipsNamespace {
+    private http;
+    private tenantId;
+    constructor(http: HttpTransport, tenantId: string);
+    /** Create a relationship between two subjects. */
+    create(input: CreateRelationshipInput): Promise<Relationship>;
+    /** Get relationships for a subject. */
+    query(subject: string, options?: {
+        tenantId?: string;
+    }): Promise<Relationship[]>;
+    /** List all relationships for the tenant. */
+    list(options?: {
+        tenantId?: string;
+    }): Promise<Relationship[]>;
+}
+/**
+ * Agent personality — defines how the agent communicates.
+ *
+ * @example
+ * ```typescript
+ * const personality: AgentPersonality = {
+ *   voice: "Friendly cubicle neighbor who knows the business inside out",
+ *   tone: "casual",
+ *   traits: ["curious", "witty", "empathetic"],
+ *   avoid: ["corporate speak", "jargon", "being verbose"],
+ * }
+ * ```
+ */
+interface AgentPersonality {
+    /** Overall personality description */
+    voice?: string;
+    /** Communication tone: `"casual"`, `"professional"`, `"playful"` */
+    tone?: string;
+    /** Personality traits */
+    traits?: string[];
+    /** Things the agent should avoid saying/doing */
+    avoid?: string[];
+}
+/**
+ * Composable instruction sections for an agent.
+ *
+ * Instructions are broken into sections so they can be independently
+ * configured. SubCortex assembles them into a single system prompt
+ * via {@link SubCortexClient.agents.getInstructions}.
+ */
+interface AgentInstructions {
+    /** How the agent speaks and presents itself */
+    personality?: string;
+    /** What to remember about users, how to categorize facts */
+    memoryGuidance?: string;
+    /** Domain-specific behavior rules (e.g., schema emergence) */
+    domainRules?: string;
+    /** Organization-specific additions */
+    custom?: string;
+    /** How to greet new vs returning users */
+    greetingRules?: string;
+}
+/**
+ * LLM model configuration for the agent.
+ */
+interface AgentModelConfig {
+    /** Provider: `"anthropic"`, `"openai"`, `"azure-openai"` */
+    provider?: string;
+    /** Model identifier (e.g., `"claude-opus-4-6"`, `"gpt-4-turbo"`) */
+    modelId?: string;
+    /** Inference temperature (0.0–2.0) */
+    temperature?: number;
+    /** Maximum response tokens */
+    maxTokens?: number;
+    /** Voice ID for voice agents (e.g., `"marin"`, `"echo"`) */
+    voiceId?: string;
+}
+/**
+ * A capability (tool/function) the agent can use.
+ *
+ * @example
+ * ```typescript
+ * const cap: AgentCapability = {
+ *   name: "registerUserFact",
+ *   description: "Store a learned fact about the user",
+ *   enabled: true,
+ * }
+ * ```
+ */
+interface AgentCapability {
+    /** Tool/function name */
+    name: string;
+    /** What this capability does */
+    description?: string;
+    /** Whether this capability is active */
+    enabled?: boolean;
+    /** Tool parameter schema (JSON Schema) */
+    parameters?: unknown;
+}
+/**
+ * Memory retention policy — controls how the agent manages its memories.
+ */
+interface AgentMemoryPolicy {
+    /** Max assertions per user subject (0 = unlimited) */
+    maxMemoriesPerUser?: number;
+    /** Auto-forget memories below this confidence (0.0 = keep everything) */
+    forgetConfidenceBelow?: number;
+    /** Days to retain memories (0 = forever) */
+    retainDays?: number;
+    /** Compress old memories into higher-level summaries */
+    autoSummarize?: boolean;
+}
+/**
+ * Full agent configuration — the agent's identity in SubCortex.
+ *
+ * This is what an agent retrieves at session start to know who it is,
+ * how to behave, what tools it has, and how to manage its memory.
+ *
+ * @example
+ * ```typescript
+ * const agent = await cortex.agents.create({
+ *   name: 'Aria',
+ *   description: 'AI assistant for customer support',
+ *   personality: { tone: 'casual', traits: ['curious', 'empathetic'] },
+ *   instructions: {
+ *     personality: 'You are the user\'s best friend at work...',
+ *     memoryGuidance: 'Remember names, roles, and org structure...',
+ *   },
+ *   model: { provider: 'openai', modelId: 'gpt-realtime-1.5', voiceId: 'marin' },
+ * })
+ * ```
+ */
+interface AgentConfig {
+    agentId: string;
+    tenantId: string;
+    name: string;
+    description: string;
+    personality: AgentPersonality;
+    instructions: AgentInstructions;
+    model: AgentModelConfig;
+    capabilities: AgentCapability[];
+    memoryPolicy: AgentMemoryPolicy;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Input for creating an agent. */
+interface CreateAgentInput {
+    name: string;
+    description?: string;
+    personality?: AgentPersonality;
+    instructions?: AgentInstructions;
+    model?: AgentModelConfig;
+    capabilities?: AgentCapability[];
+    memoryPolicy?: AgentMemoryPolicy;
+    tenantId?: string;
+}
+/** Input for updating an agent. */
+interface UpdateAgentInput {
+    name?: string;
+    description?: string;
+    personality?: AgentPersonality;
+    instructions?: AgentInstructions;
+    model?: AgentModelConfig;
+    capabilities?: AgentCapability[];
+    memoryPolicy?: AgentMemoryPolicy;
+    isActive?: boolean;
+}
+/** Composed instructions response. */
+interface ComposedInstructions {
+    composedInstructions: string;
+    agentName: string;
+    modelProvider: string;
+    modelId: string;
+    temperature: number;
+    voiceId: string;
+}
+/**
+ * Operations on agent configurations — the identity layer.
+ *
+ * Create, update, and retrieve agent profiles that define who an agent is,
+ * how it behaves, what tools it can use, and how it manages memory.
+ *
+ * @example
+ * ```typescript
+ * // Create an agent
+ * const agent = await subcortex.agents.create({
+ *   name: 'Aria',
+ *   description: 'AI assistant for customer support',
+ *   personality: { tone: 'casual', traits: ['curious', 'witty'] },
+ * })
+ *
+ * // Get composed system prompt at session start
+ * const { composedInstructions } = await subcortex.agents.getInstructions(agent.agentId)
+ * ```
+ */
+declare class AgentsNamespace {
+    private http;
+    private tenantId;
+    constructor(http: HttpTransport, tenantId: string);
+    /** Create a new agent. */
+    create(input: CreateAgentInput): Promise<AgentConfig>;
+    /** Get an agent by ID. */
+    get(agentId: string, options?: {
+        tenantId?: string;
+    }): Promise<AgentConfig>;
+    /** Update an agent. */
+    update(agentId: string, input: UpdateAgentInput, options?: {
+        tenantId?: string;
+    }): Promise<AgentConfig>;
+    /** Delete an agent. */
+    delete(agentId: string, options?: {
+        tenantId?: string;
+    }): Promise<void>;
+    /** List all agents for the tenant. */
+    list(options?: {
+        tenantId?: string;
+    }): Promise<AgentConfig[]>;
+    /** Get composed system instructions for an agent. */
+    getInstructions(agentId: string, options?: {
+        tenantId?: string;
+    }): Promise<ComposedInstructions>;
+}
+/** Input for storing a memory. */
+interface StoreMemoryInput {
+    subject: string;
+    predicate: string;
+    value: unknown;
+    confidence?: number;
+    tenantId?: string;
+    /** Agent ID — required for Thalamus routing (used as agentId in intake submission) */
+    agentId?: string;
+    /** Person this fact relates to */
+    personName?: string;
+    /** Skip Thalamus processing — write directly to assertion store. For bulk imports, migrations. */
+    raw?: boolean;
+    /** Conversational context for deep encoding */
+    context?: {
+        topic?: string;
+        emotionalState?: string;
+        sessionId?: string;
+        excerpt?: string;
+    };
+}
+/**
+ * Agent memory operations.
+ *
+ * By default, `store()` routes through the Thalamus cognitive intake
+ * pipeline for signal classification, contradiction detection, and
+ * deduplication. Use `raw: true` to bypass for bulk imports.
+ *
+ * @example
+ * ```typescript
+ * // Store via Thalamus (default — validated, deduped, conflict-checked)
+ * await subcortex.memory.store({
+ *   subject: 'user:alice',
+ *   predicate: 'role',
+ *   value: 'Engineering Manager',
+ *   confidence: 0.99,
+ *   agentId: 'agent_abc',
+ * })
+ *
+ * // Store raw (bypass Thalamus — for imports/migrations)
+ * await subcortex.memory.store({
+ *   subject: 'user:alice',
+ *   predicate: 'role',
+ *   value: 'Engineering Manager',
+ *   raw: true,
+ * })
+ *
+ * // Recall everything about a user
+ * const memories = await subcortex.memory.recall('user:alice')
+ * ```
+ */
+declare class MemoryNamespace {
+    private http;
+    private tenantId;
+    constructor(http: HttpTransport, tenantId: string);
+    /**
+     * Store a fact in the agent's memory.
+     *
+     * Routes through the Thalamus by default. The Thalamus will:
+     * - Classify the signal (reject noise)
+     * - Check for contradictions with existing assertions
+     * - Detect duplicates and reinforce instead of creating new
+     *
+     * Pass `raw: true` to bypass Thalamus for system operations.
+     */
+    store(input: StoreMemoryInput): Promise<Assertion | IntakeResult>;
+    /** Recall all memories for a subject. */
+    recall(subject: string, options?: {
+        tenantId?: string;
+    }): Promise<Assertion[]>;
+    /** Forget a specific memory (retract the assertion). */
+    forget(assertionId: string, options?: {
+        tenantId?: string;
+    }): Promise<Assertion>;
+}
+/** A candidate assertion submitted for Thalamus processing. */
+interface CandidateAssertion {
+    subject: string;
+    predicate: string;
+    value: unknown;
+    sourceConfidence: number;
+    validFrom?: string;
+    validUntil?: string | null;
+    provenance: 'human' | 'agent' | 'import' | 'derived';
+    personName?: string;
+}
+/** Full intake submission. */
+interface IntakeSubmission {
+    correlationId: string;
+    agentId: string;
+    candidates: CandidateAssertion[];
+    context?: {
+        topic?: string;
+        emotionalState?: string;
+        sessionId?: string;
+        excerpt?: string;
+    };
+    tenantId?: string;
+}
+/** Result of Thalamus processing. */
+interface IntakeResult {
+    correlationId: string;
+    processed: number;
+    accepted: number;
+    reinforced: number;
+    conflicts: number;
+    rejected: number;
+    items: IntakeResponseItem[];
+}
+/** A single intake response queue item. */
+interface IntakeResponseItem {
+    id: string;
+    correlationId: string;
+    agentId: string;
+    tenantId: string;
+    status: 'accepted' | 'reinforced' | 'conflict_detected' | 'needs_clarification' | 'rejected';
+    priority: number;
+    surfacingHint?: string;
+    expiresAt: string;
+    persistedAssertionIds: string[];
+    inferredBondIds: string[];
+    conflictingAssertionId?: string;
+    clarificationQuestions: string[];
+    rejectionReason?: string;
+    signalCategory?: string;
+    acknowledged: boolean;
+    createdAt: string;
+}
+/** Intake processing stats. */
+interface IntakeStats {
+    total: number;
+    accepted: number;
+    reinforced: number;
+    conflicts: number;
+    clarifications: number;
+    rejected: number;
+}
+/**
+ * Thalamus cognitive intake operations.
+ *
+ * Submit candidate assertions for processing through the Thalamus
+ * pipeline. The pipeline validates, deduplicates, detects contradictions,
+ * and enriches assertions before persisting them.
+ *
+ * @example
+ * ```typescript
+ * // Submit a fact for processing
+ * const result = await subcortex.intake.submit({
+ *   correlationId: 'corr-123',
+ *   agentId: 'agent_abc',
+ *   candidates: [{
+ *     subject: 'user:tommy',
+ *     predicate: 'role',
+ *     value: 'CTO',
+ *     sourceConfidence: 0.99,
+ *     provenance: 'human',
+ *   }],
+ * })
+ *
+ * // Check for conflicts or clarification requests
+ * const pending = await subcortex.intake.pending('agent_abc')
+ *
+ * // Acknowledge after handling
+ * await subcortex.intake.acknowledge(pending[0].id)
+ * ```
+ */
+declare class IntakeNamespace {
+    private http;
+    private tenantId;
+    constructor(http: HttpTransport, tenantId: string);
+    /** Submit candidate assertions for Thalamus processing. */
+    submit(input: IntakeSubmission): Promise<IntakeResult>;
+    /** Get pending intake results for an agent. */
+    pending(agentId: string, options?: {
+        status?: string[];
+        limit?: number;
+    }): Promise<IntakeResponseItem[]>;
+    /** Acknowledge an intake result (mark as consumed). */
+    acknowledge(itemId: string): Promise<void>;
+    /** Acknowledge all pending items for an agent. */
+    acknowledgeAll(agentId: string): Promise<{
+        acknowledged: number;
+    }>;
+    /** Get intake processing stats for an agent. */
+    stats(agentId: string): Promise<IntakeStats>;
+}
+declare class SubCortexClient {
+    /** Assertion operations (low-level knowledge primitives) */
+    readonly assertions: AssertionsNamespace;
+    /** Relationship operations */
+    readonly relationships: RelationshipsNamespace;
+    /** Agent identity & configuration */
+    readonly agents: AgentsNamespace;
+    /** Agent memory (semantic wrapper over assertions) */
+    readonly memory: MemoryNamespace;
+    /** Thalamus cognitive intake pipeline */
+    readonly intake: IntakeNamespace;
+    /** User rapport building operations */
+    readonly users: UsersNamespace;
+    /** Emotional signals — record, query, and resolve */
+    readonly signals: SignalsNamespace;
+    private readonly http;
+    constructor(options: SubCortexClientOptions);
+    /** Check SubCortex server health. */
+    health(): Promise<HealthResponse>;
+}
+
+/**
+ * SubCortex Context Formatting — v1.0 Schema
+ *
+ * Transforms structured UserIdentification data into XML optimized
+ * for model injection. Signals nest as children of the knowledge
+ * they relate to, not as a separate section.
+ *
+ * Section order = priority order (transformer attention bias):
+ * conflicts → reminders → contexts → identity → knowledge → relationships
+ *
+ * Why XML: Tag boundaries create hard attention delimiters for transformers.
+ * See docs/context-format-rationale.md for full analysis.
+ */
+
+declare const CONTEXT_SCHEMA_VERSION = "1.0";
+type ContextFormat = 'xml' | 'json' | 'summary';
+interface ContextFormatOptions {
+    /** Output format. Default: 'xml' */
+    format?: ContextFormat;
+    /** Include memories section. Default: true */
+    includeMemories?: boolean;
+    /** Include connected people. Default: true */
+    includeRelationships?: boolean;
+    /** Include reminders. Default: true */
+    includeReminders?: boolean;
+    /** Include conflicts. Default: true */
+    includeConflicts?: boolean;
+    /** Include active contexts. Default: true */
+    includeContexts?: boolean;
+    /** Include emotional signals. Default: true */
+    includeSignals?: boolean;
+    /** Minimum confidence threshold to include (0-1). Default: 0 */
+    minConfidence?: number;
+}
+/**
+ * Format a UserIdentification result for model injection.
+ */
+declare function formatContext(user: UserIdentification, options?: ContextFormatOptions): string;
+/**
+ * Transform UserIdentification into versioned XML optimized for model attention.
+ * Signals nest as children of the facts/contexts/people they relate to.
+ */
+declare function toContextXml(user: UserIdentification, options?: ContextFormatOptions): string;
+
+/**
+ * SubCortex SDK Error Hierarchy
+ *
+ * Typed error classes for programmatic error handling.
+ * Consumers can catch specific error types:
+ *
+ * ```typescript
+ * try {
+ *   await subcortex.assertions.create(...)
+ * } catch (e) {
+ *   if (e instanceof SubCortexNotFoundError) { ... }
+ *   if (e instanceof SubCortexRateLimitError) { await sleep(e.retryAfter) }
+ * }
+ * ```
+ */
+/** Base error for all SubCortex SDK errors. */
+declare class SubCortexError extends Error {
+    /** HTTP status code (0 for network errors) */
+    readonly statusCode: number;
+    /** Server-assigned request ID for debugging */
+    readonly requestId?: string;
+    /** Whether the request can be retried */
+    readonly retryable: boolean;
+    /** Raw response body */
+    readonly body?: string;
+    constructor(message: string, statusCode: number, options?: {
+        requestId?: string;
+        retryable?: boolean;
+        body?: string;
+    });
+}
+/** 400 — Bad request, validation failure. */
+declare class SubCortexValidationError extends SubCortexError {
+    /** Field-level validation errors if available */
+    readonly details?: Record<string, string>;
+    constructor(message: string, options?: {
+        requestId?: string;
+        body?: string;
+        details?: Record<string, string>;
+    });
+}
+/** 401 — Invalid or missing credentials. */
+declare class SubCortexAuthenticationError extends SubCortexError {
+    constructor(message: string, options?: {
+        requestId?: string;
+        body?: string;
+    });
+}
+/** 403 — Valid credentials but insufficient permissions. */
+declare class SubCortexAuthorizationError extends SubCortexError {
+    constructor(message: string, options?: {
+        requestId?: string;
+        body?: string;
+    });
+}
+/** 404 — Resource not found. */
+declare class SubCortexNotFoundError extends SubCortexError {
+    constructor(message: string, options?: {
+        requestId?: string;
+        body?: string;
+    });
+}
+/** 409 — Conflict (e.g., duplicate assertion). */
+declare class SubCortexConflictError extends SubCortexError {
+    constructor(message: string, options?: {
+        requestId?: string;
+        body?: string;
+    });
+}
+/** 429 — Rate limit exceeded. */
+declare class SubCortexRateLimitError extends SubCortexError {
+    /** Seconds to wait before retrying */
+    readonly retryAfter?: number;
+    constructor(message: string, options?: {
+        requestId?: string;
+        body?: string;
+        retryAfter?: number;
+    });
+}
+/** 5xx — Server-side error. */
+declare class SubCortexServerError extends SubCortexError {
+    constructor(message: string, statusCode: number, options?: {
+        requestId?: string;
+        body?: string;
+    });
+}
+/** Network-level failure (DNS, timeout, connection refused). */
+declare class SubCortexNetworkError extends SubCortexError {
+    readonly cause?: Error;
+    constructor(message: string, options?: {
+        cause?: Error;
+    });
+}
+/** Timeout — request exceeded the configured timeout. */
+declare class SubCortexTimeoutError extends SubCortexNetworkError {
+    constructor(timeoutMs: number);
+}
+
+export { type AgentCapability, type AgentConfig, type AgentInstructions, type AgentMemoryPolicy, type AgentModelConfig, type AgentPersonality, AgentsNamespace, type Assertion, AssertionsNamespace, type BatchResult, CONTEXT_SCHEMA_VERSION, type CandidateAssertion, type ComposedInstructions, ConfidenceLevel, type ConfidenceScore, ConfidenceScores, type ConflictItem, type ConnectedPerson, type ContextFormat, type ContextFormatOptions, type CreateAgentInput, type CreateAssertionInput, type CreateRelationshipInput, EntityPredicate, EntityRelationship, EventPredicate, type HealthResponse, type IdentifyUserInput, IdentityPredicate, IntakeNamespace, type IntakeResponseItem, type IntakeResult, type IntakeStats, type IntakeSubmission, MULTI_VALUE_PREDICATES, MemoryNamespace, MemoryPredicate, NEGATIVE_SIGNALS, OrgRelationship, POSITIVE_SIGNALS, type PaginatedResponse, Predicates, type Provenance, RELATIONSHIP_LABELS, REVERSE_RELATIONSHIPS, RapportPredicate, type RecordRapportInput, type RecordSignalInput, type RegisterPersonInput, type RegisterPersonResult, type Relationship, RelationshipTypes, RelationshipsNamespace, type ResolveSignalInput, type RetryConfig, SIGNAL_DECAY_CONFIG, SYSTEM_SIGNAL_TYPES, type SignalEntry, type SignalQueryOptions, type SignalSnapshot, type SignalType, SignalsNamespace, type StoreMemoryInput, SubCortexAuthenticationError, SubCortexAuthorizationError, SubCortexClient, type SubCortexClientOptions, SubCortexConflictError, SubCortexError, SubCortexNetworkError, SubCortexNotFoundError, SubCortexRateLimitError, SubCortexServerError, SubCortexTimeoutError, SubCortexValidationError, SubjectPrefix, type SupersedeAssertionInput, type SystemSignalType, type TemporalBounds, type Trajectory, type UpdateAgentInput, type UserIdentification, type UserMemory, UsersNamespace, WorkPredicate, confidenceToScore, formatContext, getDecayHalfLife, isValidSignalType, scoreToConfidence, subject, toContextXml };