Typescript SDK reference

export interface ControlPlaneConfig {
  baseUrl: string;
  apiKey?: string;
  timeout?: number;
}

export interface TenantInfo {
  id: string;
  name: string;
  status: string;
  createdAt: string;
  updatedAt: string;
  config?: Record<string, unknown>;
}

export interface BackupInfo {
  id: string;
  tenantId: string;
  status: string;
  createdAt: string;
  sizeBytes?: number;
}

export interface MonitoringMetrics {
  memoryUsageBytes: number;
  storageUsageBytes: number;
  activeConnections: number;
  requestsPerSecond: number;
  latencyP50Ms: number;
  latencyP99Ms: number;
}

export class ControlPlaneClient

constructor(config: ControlPlaneConfig)

async listTenants(): Promise<TenantInfo[]>

async getTenant(id: string): Promise<TenantInfo>

async createTenant(name: string, config?: Record<string, unknown>): Promise<TenantInfo>

async deleteTenant(id: string): Promise<void>

async listBackups(tenantId?: string): Promise<BackupInfo[]>

async createBackup(tenantId: string): Promise<BackupInfo>

async restoreBackup(backupId: string, targetTenantId?: string): Promise<void>

async getMetrics(): Promise<MonitoringMetrics>

async healthCheck(): Promise<{ status: string }>

export function createControlPlane(config: ControlPlaneConfig): ControlPlaneClient

export function createControlPlaneFromEnv(): ControlPlaneClient

export type Result<T> = Promise<T>;

export interface NamespaceHeaders {
  tenantId?: string;
  reservoirId?: string;
  agentId?: string;
  dataspaceId?: string;
}

export interface SDKConfig {
  baseUrl: string;
  token?: string;
  timeoutMs?: number;
  namespace?: NamespaceHeaders;
}

export interface KeyspaceInfo {
  name: string;
  model: string;
  config?: Record<string, unknown>;
  created_at?: string;
  item_count?: number;
}

export interface EngineStats {
  keyspace_count: number;
  total_items: number;
  memory_usage_bytes: number;
  uptime_secs: number;
  [key: string]: unknown;
}

export interface TransactionInfo {
  tx_id: string;
  status: 'active' | 'committed' | 'aborted';
  started_at: string;
}

export interface DataspaceInfo {
  name: string;
  keyspaces: string[];
}

export interface BackupInfo {
  backup_id: string;
  name?: string;
  created_at: string;
  size_bytes: number;
  keyspaces: string[];
}

export interface ReplicationLink {
  link_id: string;
  target_url: string;
  mode: 'sync' | 'async';
  status: 'active' | 'paused' | 'error';
  keyspaces: string[];
  lag_ms?: number;
}

export interface KVItem {
  key: string;
  value: unknown;
  version?: number;
  metadata?: Record<string, unknown>;
}

export interface KVScanResult {
  items: KVItem[];
  cursor?: string;
  has_more: boolean;
}

export interface VectorIndexInfo {
  name: string;
  dimension: number;
  metric: 'cosine' | 'euclidean' | 'dot';
  count: number;
  config?: Record<string, unknown>;
}

export interface VectorSearchResult {
  id: string;
  score: number;
  metadata?: Record<string, unknown>;
  vector?: number[];
}

export interface EpisodicEvent {
  id?: string;
  event_type: string;
  content: unknown;
  timestamp?: string;
  metadata?: Record<string, unknown>;
  embedding?: number[];
}

export interface ProceduralWorkflow {
  id?: string;
  name: string;
  steps: WorkflowStep[];
  description?: string;
  metadata?: Record<string, unknown>;
}

export interface WorkflowStep {
  action: string;
  params?: Record<string, unknown>;
  conditions?: Record<string, unknown>;
}

export interface ResourceDocument {
  id?: string;
  name: string;
  content_type: string;
  content: string | ArrayBuffer;
  metadata?: Record<string, unknown>;
}

export interface VaultEntry {
  id?: string;
  key: string;
  value: unknown;
  sensitivity: 'low' | 'medium' | 'high' | 'critical';
  metadata?: Record<string, unknown>;
  expires_at?: string;
}

export interface CognitiveThought {
  id?: string;
  content: string;
  thought_type: string;
  confidence?: number;
  context?: Record<string, unknown>;
  timestamp?: string;
}

export interface CognitiveDecision {
  id?: string;
  question: string;
  options: string[];
  selected: string;
  reasoning?: string;
  confidence?: number;
  timestamp?: string;
}

export interface CognitiveInteraction {
  id?: string;
  interaction_type: string;
  input: unknown;
  output: unknown;
  duration_ms?: number;
  metadata?: Record<string, unknown>;
  timestamp?: string;
}

export interface HybridRetrievalResult {
  id: string;
  content: unknown;
  score: number;
  source: 'episodic' | 'semantic' | 'procedural' | 'resource';
  metadata?: Record<string, unknown>;
}

export interface ModelInfo {
  model_id: string;
  model_type: 'embedding' | 'classification' | 'generation';
  loaded: boolean;
  config?: Record<string, unknown>;
}

export interface EmbeddingResult {
  embeddings: number[][];
}

export interface SNNArchitecture {
  layers: SNNLayer[];
  connections: SNNConnection[];
}

export interface SNNLayer {
  name: string;
  neuron_type: 'lif' | 'izhikevich' | 'adaptive';
  size: number;
  params?: Record<string, unknown>;
}

export interface SNNConnection {
  from: string;
  to: string;
  weight_init?: 'random' | 'uniform' | 'normal';
  params?: Record<string, unknown>;
}

export interface SNNNetwork {
  network_id: string;
  architecture: SNNArchitecture;
  compiled: boolean;
}

export interface SNNStepResult {
  spikes: Record<string, number[]>;
  voltages?: Record<string, number[]>;
  time_step: number;
}

export interface NSRetrievalResult {
  items: NSRetrievedItem[];
  total_score: number;
}

export interface NSRetrievedItem {
  id: string;
  content: unknown;
  neural_score: number;
  symbolic_score: number;
  combined_score: number;
  path?: string[];
}

export interface NSPath {
  nodes: string[];
  edges: string[];
  cost: number;
}

export interface CheckpointInfo {
  checkpoint_id: string;
  name?: string;
  created_at: string;
  components: string[];
  metadata?: Record<string, unknown>;
}

export interface ComponentInfo {
  name: string;
  component_type: 'model' | 'embeddings' | 'custom';
  registered_at: string;
  ewc_importance?: number;
}

export interface MHNNetwork {
  id: string;
  dimension: number;
  capacity: number;
  beta: number;
  pattern_count: number;
}

export interface MHNRetrievalResult {
  key?: string;
  pattern: number[];
  score: number;
  metadata?: Record<string, unknown>;
}

export class AkashaError extends Error

constructor(public readonly code: number, message: string, public readonly details?: unknown)

export class HttpClient

constructor(cfg: SDKConfig)

async stream(path: string, body?: unknown, headers?: HeadersInit): Promise<Response>

async request<T>(method: string, path: string, body?: unknown, headers?: HeadersInit): Result<T>

get<T>(path: string, headers?: HeadersInit)

post<T>(path: string, body?: unknown, headers?: HeadersInit)

put<T>(path: string, body?: unknown, headers?: HeadersInit)

patch<T>(path: string, body?: unknown, headers?: HeadersInit)

delete<T>(path: string, headers?: HeadersInit)

export class CoreClient

constructor(private readonly http: HttpClient)

stats(): Result<EngineStats>

listKeyspaces(): Result<KeyspaceInfo[]>

createKeyspace(name: string, model: string, config?: Record<string, unknown>): Result<KeyspaceInfo>

getKeyspace(name: string): Result<KeyspaceInfo | null>

deleteKeyspace(name: string): Result<boolean>

store(keyspace: string, item: Record<string, unknown>): Result<{ id: string }>

get(keyspace: string, itemId: string): Result<Record<string, unknown> | null>

delete(keyspace: string, itemId: string): Result<boolean>

query<T = Record<string, unknown>>(keyspace: string, query: Record<string, unknown>, limit = 100, offset = 0): Result<T[]>

textSearch(query: string, keyspaces?: string[], limit = 100): Result<{ id: string; keyspace: string; score: number }[]>

beginTransaction(): Result<TransactionInfo>

commitTransaction(txId: string): Result<{ ok: boolean }>

abortTransaction(txId: string): Result<{ ok: boolean }>

listDataspaces(): Result<DataspaceInfo[]>

switchNamespace(namespace: string): Result<{ ok: boolean }>

analyze(keyspace?: string): Result<Record<string, unknown>>

compact(keyspace?: string): Result<Record<string, unknown>>

reindex(keyspace?: string): Result<Record<string, unknown>>

clearCache(): Result<{ ok: boolean }>

createBackup(name?: string, keyspaces?: string[]): Result<BackupInfo>

listBackups(): Result<BackupInfo[]>

restoreBackup(backupId: string): Result<{ ok: boolean }>

deleteBackup(backupId: string): Result<boolean>

createReplicationLink(targetUrl: string, keyspaces?: string[], mode: 'sync' | 'async' = 'async'): Result<ReplicationLink>

stopReplication(linkId: string): Result<{ ok: boolean }>

getReplicationStatus(linkId?: string): Result<{ links: ReplicationLink[] }>

export class GraphClient

constructor(private readonly http: HttpClient)

cypher<T = unknown>(query: string): Result<T[]>

search(text: string, limit = 10): Result<{ entity_id: string; score: number }[]>

ensurePropertyIndex(property: string): Result<{ ok: boolean }>

indexStats(): Result<Record<string, unknown>>

pagerank(damping_factor?: number): Result<Record<string, unknown>>

microtheorySwitch(name: string): Result<{ ok: boolean }>

microtheoryKeyspace(name: string): Result<{ keyspace: string }>

export class AnalyticsClient

constructor(private readonly http: HttpClient)

sql<T = unknown>(query: string): Result<T[]>

registerSource(name: string, kind: 'csv'|'parquet'|'core', spec: Record<string, unknown>): Result<{ ok: boolean }>

options(opts: Record<string, unknown>): Result<{ ok: boolean }>

cacheClear(): Result<{ ok: boolean }>

cacheStats(): Result<Record<string, unknown>>

export class MlClient

constructor(private readonly http: HttpClient)

embed(text: string): Result<{ vector: number[] }>

generate(modelId: string, prompt: string, maxTokens = 256, temperature = 0.7): Result<{ text: string }>

async *generateStream(modelId: string, prompt: string, maxTokens = 256, temperature = 0.7): AsyncGenerator<string, void, void>

export class KVClient

constructor(private readonly http: HttpClient)

get(key: string): Result<KVItem | null>

set(key: string, value: unknown, metadata?: Record<string, unknown>): Result<{ ok: boolean; version: number }>

remove(key: string): Result<boolean>

exists(key: string): Result<boolean>

scan(prefix?: string, cursor?: string, limit = 100): Result<KVScanResult>

mget(keys: string[]): Result<KVItem[]>

mset(items: { key: string; value: unknown; metadata?: Record<string, unknown> }[]): Result<{ ok: boolean }>

incr(key: string, delta = 1): Result<{ value: number }>

setex(key: string, value: unknown, ttlSecs: number): Result<{ ok: boolean }>

export class VectorClient

constructor(private readonly http: HttpClient)

createIndex(name: string, dimension: number, metric: 'cosine' | 'euclidean' | 'dot' = 'cosine', config?: Record<string, unknown>): Result<VectorIndexInfo>

listIndices(): Result<VectorIndexInfo[]>

deleteIndex(name: string): Result<boolean>

add(indexName: string, vectors: number[][], ids: string[], metadata?: Record<string, unknown>[]): Result<{ added: number }>

search(indexName: string, query: number[], topK = 10, filter?: Record<string, unknown>): Result<VectorSearchResult[]>

deleteVectors(indexName: string, ids: string[]): Result<{ deleted: number }>

getStats(indexName: string): Result<Record<string, unknown>>

save(indexName: string, path: string): Result<{ ok: boolean }>

load(indexName: string, path: string): Result<{ ok: boolean }>

export class EpisodicMemoryClient

constructor(private readonly http: HttpClient)

insert(event: Omit<EpisodicEvent, 'id'>): Result<{ id: string }>

get(id: string): Result<EpisodicEvent | null>

update(id: string, event: Partial<EpisodicEvent>): Result<{ ok: boolean }>

remove(id: string): Result<boolean>

search(query: string, limit = 10, eventTypes?: string[]): Result<EpisodicEvent[]>

range(startTime: string, endTime: string, limit = 100, eventTypes?: string[]): Result<EpisodicEvent[]>

recent(limit = 10, eventTypes?: string[]): Result<EpisodicEvent[]>

export class ProceduralMemoryClient

constructor(private readonly http: HttpClient)

store(workflow: Omit<ProceduralWorkflow, 'id'>): Result<{ id: string }>

get(id: string): Result<ProceduralWorkflow | null>

getByName(name: string): Result<ProceduralWorkflow | null>

list(limit = 100, offset = 0): Result<ProceduralWorkflow[]>

update(id: string, workflow: Partial<ProceduralWorkflow>): Result<{ ok: boolean }>

remove(id: string): Result<boolean>

run(id: string, params?: Record<string, unknown>): Result<{ result: unknown; steps_done: number }>

export class ResourceMemoryClient

constructor(private readonly http: HttpClient)

upload(resource: Omit<ResourceDocument, 'id'>): Result<{ id: string }>

get(id: string): Result<ResourceDocument | null>

list(contentType?: string, limit = 100, offset = 0): Result<ResourceDocument[]>

search(query: string, contentTypes?: string[], limit = 10): Result<ResourceDocument[]>

remove(id: string): Result<boolean>

updateMetadata(id: string, metadata: Record<string, unknown>): Result<{ ok: boolean }>

export class VaultMemoryClient

constructor(private readonly http: HttpClient)

store(entry: Omit<VaultEntry, 'id'>): Result<{ id: string }>

get(key: string): Result<VaultEntry | null>

listKeys(sensitivity?: 'low' | 'medium' | 'high' | 'critical'): Result<string[]>

remove(key: string): Result<boolean>

rotateKey(): Result<{ ok: boolean; rotated_at: string }>

export class CognitiveMemoryClient

constructor(private readonly http: HttpClient)

thought(thought: Omit<CognitiveThought, 'id'>): Result<{ id: string }>

decision(decision: Omit<CognitiveDecision, 'id'>): Result<{ id: string }>

interaction(interaction: Omit<CognitiveInteraction, 'id'>): Result<{ id: string }>

getSession(sessionId: string, limit = 100): Result<{ thoughts: CognitiveThought[]; decisions: CognitiveDecision[]; interactions: CognitiveInteraction[] }>

query(query: string, types?: ('thought' | 'decision' | 'interaction')[], limit = 10): Result<{ items: (CognitiveThought | CognitiveDecision | CognitiveInteraction)[] }>

getReasoningChain(decisionId: string): Result<{ thoughts: CognitiveThought[]; decision: CognitiveDecision }>

export class MemoryClient

public readonly episodic: EpisodicMemoryClient;

public readonly procedural: ProceduralMemoryClient;

public readonly resources: ResourceMemoryClient;

public readonly vault: VaultMemoryClient;

public readonly cognitive: CognitiveMemoryClient;

constructor(private readonly http: HttpClient)

hybridRetrieval(query: string, limit = 10, sources?: ('episodic' | 'semantic' | 'procedural' | 'resource')[]): Result<HybridRetrievalResult[]>

stats(): Result<Record<string, unknown>>

export class AkashaClient

public readonly core: CoreClient;

public readonly kv: KVClient;

public readonly graph: GraphClient;

public readonly vector: VectorClient;

public readonly analytics: AnalyticsClient;

public readonly ml: MlClient;

public readonly memory: MemoryClient;

public readonly router: RouterClient;

public readonly snn: SnnClient;

public readonly ns: NsClient;

public readonly continual: ContinualClient;

public readonly mhn: MhnClient;

public readonly brain: CognitiveBrain;

constructor(cfg: SDKConfig)

export function resolveAkashaBase(input: string): string

export async function connect(uri: string, opts?: Omit<SDKConfig, 'baseUrl'>): Promise<AkashaClient>

export interface AkashaResolvedEndpoint {
  protocol: string;
  address: string;
  tls: boolean;
  alpn?: string;
  region?: string;
  path?: string;
}

export interface AkashaResolved {
  baseUrl: string;
  endpoints: AkashaResolvedEndpoint[];
  grpcAddress?: string;
}

export async function resolveAkasha(uri: string): Promise<AkashaResolved>

export class RouterClient

constructor()

async connect(address: string): Promise<void>

registerCapability(req: any): Promise<any>

queryCapabilities(req: any): Promise<any>

routeTask(req: any): Promise<any>

export class SnnClient

constructor(private readonly http: HttpClient)

build(architecture: SNNArchitecture, name?: string): Result<SNNNetwork>

compile(networkId: string, optimizations?: string[]): Result<{ ok: boolean; compilation_time_ms: number }>

step(networkId: string, inputs: Record<string, number[]>, dt = 1.0): Result<SNNStepResult>

trainBptt(networkId: string, data: { inputs: number[][]; targets: number[][] }, epochs = 100, learningRate = 0.01): Result<{ final_loss: number; epochs_run: number }>

getState(networkId: string, include?: ('voltages' | 'spikes' | 'weights')[]): Result<{ state: Record<string, unknown> }>

reset(networkId: string): Result<{ ok: boolean }>

list(): Result<SNNNetwork[]>

remove(networkId: string): Result<boolean>

export class NsClient

constructor(private readonly http: HttpClient)

retrieve(query: string, limit = 10, neuralWeight = 0.5): Result<NSRetrievalResult>

findPaths(startNode: string, endNode: string, maxDepth = 5, algorithm: 'bfs' | 'dijkstra' | 'astar' = 'bfs'): Result<{ paths: NSPath[] }>

prefetchStart(pattern: string, depth = 2): Result<{ prefetch_id: string }>

prefetchStop(prefetchId: string): Result<{ ok: boolean }>

cacheStats(): Result<{ hit_rate: number; size_bytes: number; entry_count: number }>

cacheClear(): Result<{ ok: boolean; cleared_entries: number }>

addKnowledge(subject: string, predicate: string, object: string, confidence = 1.0): Result<{ id: string }>

queryKnowledge(pattern: { subject?: string; predicate?: string; object?: string }, limit = 100): Result<{ triples: { subject: string; predicate: string; object: string; confidence: number }[] }>

export class ContinualClient

constructor(private readonly http: HttpClient)

createCheckpoint(name?: string, components?: string[], metadata?: Record<string, unknown>): Result<CheckpointInfo>

getCheckpointStatus(checkpointId?: string): Result<CheckpointInfo>

listCheckpoints(): Result<CheckpointInfo[]>

recover(checkpointId: string, components?: string[], strategy: 'full' | 'selective' | 'merge' = 'full'): Result<{ ok: boolean; recovered_components: string[] }>

registerComponent(name: string, state: Record<string, unknown>, componentType: 'model' | 'embeddings' | 'custom' = 'model', ewcImportance?: number): Result<{ ok: boolean }>

unregisterComponent(name: string): Result<boolean>

listComponents(): Result<ComponentInfo[]>

deleteCheckpoint(checkpointId: string): Result<boolean>

export class MhnClient

constructor(private readonly http: HttpClient)

create(dimension: number, capacity = 1000, beta = 1.0, name?: string, config?: Record<string, unknown>): Result<MHNNetwork>

store(networkId: string, patterns: number[][], keys?: string[], metadata?: Record<string, unknown>[]): Result<{ stored: number }>

retrieve(networkId: string, query: number[], topK = 1, iterations = 1, includeScores = true): Result<MHNRetrievalResult[]>

deletePattern(networkId: string, key: string): Result<boolean>

getStats(networkId: string): Result<{ pattern_count: number; capacity: number; capacity_usage: number; dimension: number }>

clear(networkId: string): Result<{ ok: boolean; cleared: number }>

list(): Result<MHNNetwork[]>

deleteNetwork(networkId: string): Result<boolean>

systemInfo(): Result<{ version: string; device: string; memory_usage_bytes: number }>

export interface McpMemoryContext {
  source?: string;
  timestamp?: string;
  importance?: number;
  tags?: string[];
}

export interface McpStoredMemory {
  stored: boolean;
  memory_id: string;
  memory_type: string;
  was_duplicate: boolean;
  duplicate_of?: string;
  importance: number;
  related_ids: string[];
  contradiction_warning?: string;
}

export interface McpRetrievedMemory {
  id: string;
  content: string;
  memory_type: string;
  relevance: number;
  confidence: number;
  importance: number;
  timestamp: string;
  tags: string[];
}

export interface McpReflectionResult {
  topic: string;
  insights: string[];
  patterns: string[];
  connections: number;
  recommendations: string[];
}

export interface McpIntrospectionResult {
  total_memories: number;
  by_type: Record<string, number>;
  health: string;
  oldest_memory: string | null;
  newest_memory: string | null;
  avg_importance: number;
}