@memorymsh/sdk 0.1.0

package/README.md

@@ -0,0 +1,104 @@
+# MemoryMesh TypeScript SDK
+
+MemoryMesh gives AI agents durable working memory, inspectable run receipts, checkpoints, and recovery state. Use this SDK from Node, browser apps, agent frameworks, or internal tools.
+
+## Install
+
+```bash
+npm install @memorymsh/sdk
+```
+
+## Quick Start
+
+```ts
+import { MemoryMeshClient } from "@memorymsh/sdk";
+
+const client = new MemoryMeshClient({
+  baseUrl: "https://api-two-blue-75.vercel.app",
+  apiKey: process.env.MEMORYMESH_API_KEY,
+  defaultMemoryBackend: "cognee_cloud",
+});
+
+const receipt = await client.runAgent({
+  agentId: "research",
+  task: "Compare durable memory options for coding agents.",
+});
+
+console.log(receipt.final_output);
+console.log(receipt.memory_operations);
+```
+
+## Memory
+
+```ts
+await client.remember({
+  text: "The build agent should preserve project constraints before editing.",
+  dataset: "agent-lessons",
+});
+
+const matches = await client.recall({
+  query: "What should the build agent remember before editing?",
+  dataset: "agent-lessons",
+  topK: 3,
+});
+```
+
+## Auth
+
+The SDK defaults to the production MemoryMesh API header:
+
+```ts
+new MemoryMeshClient({
+  baseUrl: "https://your-memorymesh-api.example.com",
+  apiKey: process.env.MEMORYMESH_API_KEY,
+});
+```
+
+For gateways that expect bearer auth:
+
+```ts
+new MemoryMeshClient({
+  baseUrl: "https://your-memorymesh-api.example.com",
+  apiKey: process.env.MEMORYMESH_API_KEY,
+  apiKeyHeader: "Authorization",
+});
+```
+
+## Tool Tracing
+
+```ts
+import { MemoryMeshClient, wrapTool } from "@memorymsh/sdk";
+
+const client = new MemoryMeshClient("http://localhost:8000");
+const run = await client.startRun({
+  agentId: "support-agent",
+  task: "Investigate payment failures.",
+});
+
+const fetchTickets = wrapTool(
+  client,
+  run.task_id,
+  async (status: string) => [{ id: "ticket_1", status }],
+  {
+    toolName: "fetch_tickets",
+    validation: (_args, result) => ({ records: result.length }),
+    checkpointAfter: true,
+  },
+);
+
+await fetchTickets("open");
+```
+
+## Error Handling
+
+```ts
+import { MemoryMeshError } from "@memorymsh/sdk";
+
+try {
+  await client.memoryStatus("cognee_cloud", true);
+} catch (error) {
+  if (error instanceof MemoryMeshError) {
+    console.error(error.status, error.detail ?? error.body);
+  }
+}
+```

package/dist/adapters/crewaiAdapter.d.ts

@@ -0,0 +1,11 @@
+import { MemoryMeshClient } from "../client.js";
+import type { Json } from "../types.js";
+export declare class MemoryMeshCrewAIAdapter {
+    private client;
+    private taskId;
+    private crewName;
+    constructor(client: MemoryMeshClient, taskId: string, crewName?: string);
+    wrapTask<TArgs extends unknown[], TResult>(taskName: string, fn: (...args: TArgs) => Promise<TResult> | TResult): (...args: TArgs) => Promise<TResult>;
+    wrapTool<TArgs extends unknown[], TResult>(toolName: string, fn: (...args: TArgs) => Promise<TResult> | TResult, toolType?: "read" | "write" | "external_action" | "unknown"): (...args: TArgs) => Promise<TResult>;
+    recordHandoff(fromAgent: string, toAgent: string, context: Record<string, Json>): Promise<unknown>;
+}

package/dist/adapters/crewaiAdapter.js

@@ -0,0 +1,36 @@
+import { wrapTool } from "./toolWrapper.js";
+export class MemoryMeshCrewAIAdapter {
+    constructor(client, taskId, crewName = "crew") {
+        this.client = client;
+        this.taskId = taskId;
+        this.crewName = crewName;
+    }
+    wrapTask(taskName, fn) {
+        return async (...args) => {
+            await this.client.recordEvent(this.taskId, "plan_prepared", {
+                framework: "crewai",
+                crew: this.crewName,
+                task: taskName,
+            });
+            const result = await fn(...args);
+            await this.client.saveCheckpoint(this.taskId, {
+                checkpointName: `${this.crewName}.${taskName}.complete`,
+                state: { task: taskName, result: JSON.parse(JSON.stringify(result)) },
+                resumeState: { currentStep: `after:${taskName}`, pendingActions: [] },
+                metadata: { framework: "crewai", crew: this.crewName, task: taskName },
+            });
+            return result;
+        };
+    }
+    wrapTool(toolName, fn, toolType = "read") {
+        return wrapTool(this.client, this.taskId, fn, { toolName, toolType });
+    }
+    recordHandoff(fromAgent, toAgent, context) {
+        return this.client.recordEvent(this.taskId, "task_modified", {
+            framework: "crewai",
+            crew: this.crewName,
+            handoff: { from: fromAgent, to: toAgent },
+            context,
+        });
+    }
+}

package/dist/adapters/langgraphAdapter.d.ts

@@ -0,0 +1,13 @@
+import { MemoryMeshClient } from "../client.js";
+import type { Json } from "../types.js";
+export type GraphState = Record<string, Json>;
+export declare class MemoryMeshLangGraphAdapter {
+    private client;
+    private taskId;
+    private graphName;
+    constructor(client: MemoryMeshClient, taskId: string, graphName?: string);
+    wrapNode<TState extends GraphState>(nodeName: string, fn: (state: TState) => Promise<TState> | TState): (state: TState) => Promise<TState>;
+    restoreState(checkpointId: string): Promise<Record<string, unknown>>;
+    recordEdges(edges: string[]): Promise<unknown>;
+}
+export declare const MemoryMeshCheckpointer: typeof MemoryMeshLangGraphAdapter;

package/dist/adapters/langgraphAdapter.js

@@ -0,0 +1,45 @@
+export class MemoryMeshLangGraphAdapter {
+    constructor(client, taskId, graphName = "langgraph") {
+        this.client = client;
+        this.taskId = taskId;
+        this.graphName = graphName;
+    }
+    wrapNode(nodeName, fn) {
+        return async (state) => {
+            await this.client.recordEvent(this.taskId, "tool_execution_started", {
+                framework: "langgraph",
+                graph: this.graphName,
+                node: nodeName,
+            });
+            const result = await fn(state);
+            const checkpoint = await this.client.saveCheckpoint(this.taskId, {
+                checkpointName: `${this.graphName}.${nodeName}.complete`,
+                state: { inputState: state, outputState: result },
+                resumeState: { currentStep: `after:${nodeName}`, pendingActions: [] },
+                metadata: { framework: "langgraph", graph: this.graphName, node: nodeName },
+            });
+            await this.client.recordEvent(this.taskId, "checkpoint_saved", {
+                framework: "langgraph",
+                node: nodeName,
+                checkpoint,
+            });
+            return result;
+        };
+    }
+    async restoreState(checkpointId) {
+        const restored = await this.client.restoreCheckpoint(checkpointId);
+        await this.client.recordEvent(this.taskId, "checkpoint_restored", {
+            framework: "langgraph",
+            checkpointId,
+        });
+        return (restored.resume_state ?? restored.resumeState ?? restored.state ?? {});
+    }
+    recordEdges(edges) {
+        return this.client.recordEvent(this.taskId, "plan_prepared", {
+            framework: "langgraph",
+            graph: this.graphName,
+            edges,
+        });
+    }
+}
+export const MemoryMeshCheckpointer = MemoryMeshLangGraphAdapter;

package/dist/adapters/openaiAgentsMiddleware.d.ts

@@ -0,0 +1,12 @@
+import { MemoryMeshClient } from "../client.js";
+import type { Json } from "../types.js";
+export declare class MemoryMeshOpenAIAgentsMiddleware {
+    private client;
+    private taskId;
+    private agentId;
+    constructor(client: MemoryMeshClient, taskId: string, agentId: string);
+    onAgentStart(instructions: string, metadata?: Record<string, Json>): Promise<unknown>;
+    onPlan(plan: Record<string, Json>): Promise<unknown>;
+    wrapTool<TArgs extends unknown[], TResult>(toolName: string, fn: (...args: TArgs) => Promise<TResult> | TResult, toolType?: "read" | "write" | "external_action" | "unknown"): (...args: TArgs) => Promise<TResult>;
+    onFinalAnswer(answer: string, metadata?: Record<string, Json>): Promise<unknown>;
+}

package/dist/adapters/openaiAgentsMiddleware.js

@@ -0,0 +1,38 @@
+import { wrapTool } from "./toolWrapper.js";
+export class MemoryMeshOpenAIAgentsMiddleware {
+    constructor(client, taskId, agentId) {
+        this.client = client;
+        this.taskId = taskId;
+        this.agentId = agentId;
+    }
+    onAgentStart(instructions, metadata = {}) {
+        return this.client.recordEvent(this.taskId, "request_received", {
+            framework: "openai-agents",
+            agentId: this.agentId,
+            instructions,
+            metadata,
+        });
+    }
+    onPlan(plan) {
+        return this.client.recordEvent(this.taskId, "plan_prepared", {
+            framework: "openai-agents",
+            agentId: this.agentId,
+            plan,
+        });
+    }
+    wrapTool(toolName, fn, toolType = "read") {
+        return wrapTool(this.client, this.taskId, fn, {
+            toolName,
+            toolType,
+            checkpointAfter: toolType === "read",
+        });
+    }
+    onFinalAnswer(answer, metadata = {}) {
+        return this.client.recordEvent(this.taskId, "final_answer", {
+            framework: "openai-agents",
+            agentId: this.agentId,
+            answer,
+            metadata,
+        });
+    }
+}

package/dist/adapters/toolWrapper.d.ts

@@ -0,0 +1,13 @@
+import { MemoryMeshClient } from "../client.js";
+import type { Json } from "../types.js";
+export type ToolType = "read" | "write" | "external_action" | "unknown";
+export interface ToolWrapperConfig<TArgs extends unknown[] = unknown[], TResult = unknown> {
+    toolName: string;
+    toolType?: ToolType;
+    checkpointAfter?: boolean;
+    checkpointName?: string;
+    validation?: Record<string, Json> | ((args: TArgs, result: TResult) => Record<string, Json>);
+    observedSignals?: Record<string, Json> | ((args: TArgs, result: TResult) => Record<string, Json>);
+    idempotencyKey?: string | ((args: TArgs) => string | undefined);
+}
+export declare function wrapTool<TArgs extends unknown[], TResult>(client: MemoryMeshClient, taskId: string, fn: (...args: TArgs) => Promise<TResult> | TResult, config: ToolWrapperConfig<TArgs, TResult>): (...args: TArgs) => Promise<TResult>;

package/dist/adapters/toolWrapper.js

@@ -0,0 +1,48 @@
+function toRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value))
+        return value;
+    return { value: value };
+}
+function resolveValue(value, args, result) {
+    if (!value)
+        return {};
+    if (typeof value === "function")
+        return value(args, result);
+    return value;
+}
+export function wrapTool(client, taskId, fn, config) {
+    return async (...args) => {
+        const toolType = config.toolType ?? "read";
+        const idempotencyKey = typeof config.idempotencyKey === "function" ? config.idempotencyKey(args) : config.idempotencyKey;
+        if ((toolType === "write" || toolType === "external_action") && idempotencyKey) {
+            const action = await client.executeAction(taskId, {
+                toolName: config.toolName,
+                toolType,
+                idempotencyKey,
+                input: { args: args },
+            });
+            const maybeReplay = action;
+            if (maybeReplay.replayed || maybeReplay.duplicate)
+                return (maybeReplay.result ?? action);
+        }
+        const result = await fn(...args);
+        await client.recordToolTrace(taskId, {
+            tool: config.toolName,
+            toolType,
+            input: { args: args },
+            output: toRecord(result),
+            validation: resolveValue(config.validation, args, result),
+            observedSignals: resolveValue(config.observedSignals, args, result),
+            idempotencyKey,
+        });
+        if (config.checkpointAfter) {
+            await client.saveCheckpoint(taskId, {
+                checkpointName: config.checkpointName ?? `${config.toolName}_complete`,
+                state: { tool: config.toolName, result: toRecord(result) },
+                resumeState: { currentStep: `after:${config.toolName}`, pendingActions: [] },
+                metadata: { source: "wrapTool", toolType },
+            });
+        }
+        return result;
+    };
+}

package/dist/client.d.ts

@@ -0,0 +1,44 @@
+import type { ActionExecutionInput, AgentRunInput, AgentRunReceipt, CheckpointInput, CodingAgentRunInput, FireworksPlanInput, HealthResponse, MemoryInput, MemoryMeshClientOptions, StartRunInput, ToolTraceInput, VoiceSummaryInput } from "./types.js";
+export declare class MemoryMeshError extends Error {
+    readonly status: number;
+    readonly body: string;
+    readonly detail?: unknown;
+    constructor(message: string, status: number, body: string, detail?: unknown);
+}
+export declare class MemoryMeshClient {
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly apiKeyHeader;
+    private readonly fetchImpl;
+    private readonly defaultHeaders;
+    private readonly defaultMemoryBackend?;
+    constructor(baseUrlOrOptions: string | MemoryMeshClientOptions, apiKey?: string);
+    private authHeaders;
+    private request;
+    health(): Promise<HealthResponse>;
+    systemStatus(): Promise<unknown>;
+    startRun(input: StartRunInput): Promise<unknown>;
+    recoverTask(checkpointId: string, input?: Partial<StartRunInput>): Promise<unknown>;
+    recordEvent(taskId: string, code: string, payload?: Record<string, unknown>): Promise<unknown>;
+    recordToolTrace(taskId: string, trace: ToolTraceInput): Promise<unknown>;
+    saveCheckpoint(taskId: string, checkpoint: CheckpointInput): Promise<unknown>;
+    restoreCheckpoint(checkpointId: string): Promise<unknown>;
+    modifyTask(taskId: string, newTaskDescription: string, modification: string, parentCheckpointId?: string): Promise<unknown>;
+    approveMemory(taskId: string, rule: string, appliesTo: string[], confidence?: number, evidence?: Record<string, unknown>): Promise<unknown>;
+    executeAction(taskId: string, input: ActionExecutionInput): Promise<unknown>;
+    listEvents(taskId: string): Promise<unknown>;
+    streamEvents(taskId: string): EventSource;
+    streamEventIterator(taskId: string): AsyncGenerator<unknown>;
+    generatePlan(input: FireworksPlanInput): Promise<unknown>;
+    synthesizeRunSummary(input: VoiceSummaryInput): Promise<unknown>;
+    memoryStatus(backend?: string, probe?: boolean): Promise<unknown>;
+    remember(input: MemoryInput): Promise<unknown>;
+    recall(input: MemoryInput): Promise<unknown>;
+    improveMemory(input: MemoryInput): Promise<unknown>;
+    forgetMemory(dataset?: string, sessionId?: string, everything?: boolean, backend?: string): Promise<unknown>;
+    runAgent(input: AgentRunInput): Promise<AgentRunReceipt>;
+    runCodingAgent(input?: CodingAgentRunInput): Promise<unknown>;
+    runCodingAgentRecoveryDemo(repositoryName?: string, realAgent?: boolean, backend?: string): Promise<unknown>;
+    runDualBackendProof(repositoryName?: string, backends?: string[]): Promise<unknown>;
+    partnerStatus(): Promise<unknown>;
+}

package/dist/client.js

@@ -0,0 +1,253 @@
+export class MemoryMeshError extends Error {
+    constructor(message, status, body, detail) {
+        super(message);
+        this.name = "MemoryMeshError";
+        this.status = status;
+        this.body = body;
+        this.detail = detail;
+    }
+}
+export class MemoryMeshClient {
+    constructor(baseUrlOrOptions, apiKey) {
+        const options = typeof baseUrlOrOptions === "string" ? { baseUrl: baseUrlOrOptions, apiKey } : baseUrlOrOptions;
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
+        this.apiKey = options.apiKey;
+        this.apiKeyHeader = options.apiKeyHeader ?? "X-MemoryMesh-API-Key";
+        this.fetchImpl = options.fetch ?? fetch;
+        this.defaultHeaders = options.defaultHeaders ?? {};
+        this.defaultMemoryBackend = options.defaultMemoryBackend;
+    }
+    authHeaders() {
+        if (!this.apiKey)
+            return {};
+        if (this.apiKeyHeader.toLowerCase() === "authorization") {
+            return { Authorization: this.apiKey.toLowerCase().startsWith("bearer ") ? this.apiKey : `Bearer ${this.apiKey}` };
+        }
+        return { [this.apiKeyHeader]: this.apiKey };
+    }
+    async request(path, init = {}) {
+        const headers = {
+            "Content-Type": "application/json",
+            ...this.defaultHeaders,
+            ...this.authHeaders(),
+            ...init.headers,
+        };
+        const res = await this.fetchImpl(`${this.baseUrl}${path}`, { ...init, headers });
+        const body = await res.text();
+        if (!res.ok) {
+            let parsed;
+            try {
+                parsed = body ? JSON.parse(body) : undefined;
+            }
+            catch {
+                parsed = undefined;
+            }
+            const detail = parsed?.detail ?? parsed?.message;
+            const message = typeof detail === "string" ? detail : `MemoryMesh request failed: ${res.status}`;
+            throw new MemoryMeshError(message, res.status, body, detail);
+        }
+        return (body ? JSON.parse(body) : {});
+    }
+    health() {
+        return this.request("/health");
+    }
+    systemStatus() {
+        return this.request("/api/system/status");
+    }
+    startRun(input) {
+        return this.request("/api/tasks/run", {
+            method: "POST",
+            body: JSON.stringify({
+                agent_id: input.agentId,
+                task_description: input.task,
+                dataset_type: input.datasetType ?? "support_tickets",
+                task_version: input.taskVersion,
+                parent_checkpoint_id: input.parentCheckpointId,
+                simulate_restart: input.simulateRestart,
+                task_modification: input.taskModification,
+                idempotency_key: input.idempotencyKey,
+            }),
+        });
+    }
+    recoverTask(checkpointId, input = {}) {
+        return this.request(`/api/tasks/recover`, {
+            method: "POST",
+            body: JSON.stringify({
+                checkpoint_id: checkpointId,
+                task_description: input.task,
+                agent_id: input.agentId,
+                dataset_type: input.datasetType,
+                task_modification: input.taskModification,
+                idempotency_key: input.idempotencyKey,
+            }),
+        });
+    }
+    recordEvent(taskId, code, payload = {}) {
+        return this.request(`/api/runs/${taskId}/events`, { method: "POST", body: JSON.stringify({ code, payload }) });
+    }
+    recordToolTrace(taskId, trace) {
+        return this.request(`/api/runs/${taskId}/tool-traces`, {
+            method: "POST",
+            body: JSON.stringify({
+                tool: trace.tool,
+                tool_type: trace.toolType ?? "read",
+                input: trace.input,
+                output: trace.output,
+                validation: trace.validation ?? {},
+                observed_signals: trace.observedSignals ?? {},
+                checkpoint_id: trace.checkpointId,
+                trace_id: trace.traceId,
+                idempotency_key: trace.idempotencyKey,
+            }),
+        });
+    }
+    saveCheckpoint(taskId, checkpoint) {
+        return this.request(`/api/runs/${taskId}/checkpoints`, {
+            method: "POST",
+            body: JSON.stringify({
+                checkpoint_name: checkpoint.checkpointName,
+                state: checkpoint.state,
+                resume_state: checkpoint.resumeState ?? {},
+                safe_to_resume: checkpoint.safeToResume ?? true,
+                requires_human_review: checkpoint.requiresHumanReview ?? false,
+                metadata: checkpoint.metadata ?? {},
+            }),
+        });
+    }
+    restoreCheckpoint(checkpointId) {
+        return this.request(`/api/checkpoints/${checkpointId}/restore`, { method: "POST", body: JSON.stringify({}) });
+    }
+    modifyTask(taskId, newTaskDescription, modification, parentCheckpointId) {
+        return this.request(`/api/tasks/${taskId}/modify`, {
+            method: "POST",
+            body: JSON.stringify({ new_task_description: newTaskDescription, modification, parent_checkpoint_id: parentCheckpointId }),
+        });
+    }
+    approveMemory(taskId, rule, appliesTo, confidence = 0.8, evidence = {}) {
+        return this.request(`/api/runs/${taskId}/memory/approve`, {
+            method: "POST",
+            body: JSON.stringify({ rule, applies_to: appliesTo, confidence, evidence }),
+        });
+    }
+    executeAction(taskId, input) {
+        return this.request(`/api/runs/${taskId}/actions/execute`, {
+            method: "POST",
+            body: JSON.stringify({
+                tool_name: input.toolName,
+                tool_type: input.toolType ?? "external_action",
+                idempotency_key: input.idempotencyKey,
+                input: input.input ?? {},
+            }),
+        });
+    }
+    listEvents(taskId) {
+        return this.request(`/api/runs/${taskId}/events`);
+    }
+    streamEvents(taskId) {
+        return new EventSource(`${this.baseUrl}/api/runs/${taskId}/stream`);
+    }
+    async *streamEventIterator(taskId) {
+        const res = await this.fetchImpl(`${this.baseUrl}/api/runs/${taskId}/stream`, {
+            headers: { ...this.defaultHeaders, ...this.authHeaders() },
+        });
+        if (!res.ok)
+            throw new MemoryMeshError(`MemoryMesh stream failed: ${res.status}`, res.status, await res.text());
+        if (!res.body)
+            return;
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.startsWith("data: "))
+                    yield JSON.parse(line.slice("data: ".length));
+            }
+        }
+    }
+    generatePlan(input) {
+        return this.request(`/api/ai/plan`, {
+            method: "POST",
+            body: JSON.stringify({ task_description: input.task, run_events: input.runEvents ?? [], checkpoint_id: input.checkpointId, task_version: input.taskVersion ?? 1 }),
+        });
+    }
+    synthesizeRunSummary(input) {
+        return this.request(`/api/voice/run-summary`, {
+            method: "POST",
+            body: JSON.stringify({ text: input.text, voice_id: input.voiceId, run_id: input.runId, checkpoint_id: input.checkpointId }),
+        });
+    }
+    memoryStatus(backend, probe = false) {
+        const params = new URLSearchParams();
+        if (backend ?? this.defaultMemoryBackend)
+            params.set("backend", backend ?? this.defaultMemoryBackend ?? "");
+        if (probe)
+            params.set("probe", "true");
+        return this.request(`/api/memory/status${params.toString() ? `?${params}` : ""}`);
+    }
+    remember(input) {
+        return this.request(`/api/memory/remember`, {
+            method: "POST",
+            body: JSON.stringify({ text: input.text, dataset: input.dataset, session_id: input.sessionId, metadata: input.metadata ?? {}, backend: input.backend ?? this.defaultMemoryBackend }),
+        });
+    }
+    recall(input) {
+        return this.request(`/api/memory/recall`, {
+            method: "POST",
+            body: JSON.stringify({ query: input.query, dataset: input.dataset, session_id: input.sessionId, top_k: input.topK ?? 5, metadata: input.metadata ?? {}, backend: input.backend ?? this.defaultMemoryBackend }),
+        });
+    }
+    improveMemory(input) {
+        return this.request(`/api/memory/improve`, {
+            method: "POST",
+            body: JSON.stringify({ feedback: input.feedback ?? input.text, dataset: input.dataset, session_id: input.sessionId, metadata: input.metadata ?? {}, backend: input.backend ?? this.defaultMemoryBackend }),
+        });
+    }
+    forgetMemory(dataset = "memorymesh-agent-work-memory", sessionId, everything = false, backend) {
+        return this.request(`/api/memory/forget`, { method: "POST", body: JSON.stringify({ dataset, session_id: sessionId, everything, backend: backend ?? this.defaultMemoryBackend }) });
+    }
+    runAgent(input) {
+        return this.request(`/api/agents/run`, {
+            method: "POST",
+            body: JSON.stringify({
+                agent_id: input.agentId ?? "build",
+                task: input.task,
+                repository_name: input.repositoryName,
+                workspace_path: input.workspacePath,
+                github_url: input.githubUrl,
+                backend: input.backend ?? this.defaultMemoryBackend,
+            }),
+        });
+    }
+    runCodingAgent(input = {}) {
+        return this.request(`/api/coding-agent/run`, {
+            method: "POST",
+            body: JSON.stringify({
+                task: input.task,
+                repository_name: input.repositoryName ?? "sample-dashboard-service",
+                workspace_path: input.workspacePath,
+                dataset: input.dataset,
+                session_id: input.sessionId,
+                reset_workspace: input.resetWorkspace ?? true,
+                simulate_context_loss: input.simulateContextLoss ?? true,
+                run_tests: input.runTests ?? true,
+                forget_after_run: input.forgetAfterRun ?? false,
+                backend: input.backend,
+            }),
+        });
+    }
+    runCodingAgentRecoveryDemo(repositoryName = "sample-dashboard-service", realAgent = true, backend) {
+        return this.request(`/api/demo/coding-agent-recovery`, { method: "POST", body: JSON.stringify({ repository_name: repositoryName, real_agent: realAgent, backend }) });
+    }
+    runDualBackendProof(repositoryName = "sample-dashboard-service", backends = ["local_cognee", "cognee_cloud"]) {
+        return this.request(`/api/demo/dual-backend-proof`, { method: "POST", body: JSON.stringify({ repository_name: repositoryName, backends }) });
+    }
+    partnerStatus() {
+        return this.request(`/api/partners/status`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { MemoryMeshClient, MemoryMeshError } from "./client.js";
+export { MemoryMeshCrewAIAdapter } from "./adapters/crewaiAdapter.js";
+export { MemoryMeshCheckpointer, MemoryMeshLangGraphAdapter } from "./adapters/langgraphAdapter.js";
+export { MemoryMeshOpenAIAgentsMiddleware } from "./adapters/openaiAgentsMiddleware.js";
+export { wrapTool } from "./adapters/toolWrapper.js";
+export type { ToolType, ToolWrapperConfig } from "./adapters/toolWrapper.js";
+export type { ActionExecutionInput, AgentId, AgentRunInput, AgentRunReceipt, CheckpointInput, FireworksPlanInput, HealthResponse, Json, MemoryInput, MemoryMeshClientOptions, MemoryMeshErrorBody, MemoryBackend, MemoryOperation, ResumeStateInput, StartRunInput, ToolTraceInput, VoiceSummaryInput, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { MemoryMeshClient, MemoryMeshError } from "./client.js";
+export { MemoryMeshCrewAIAdapter } from "./adapters/crewaiAdapter.js";
+export { MemoryMeshCheckpointer, MemoryMeshLangGraphAdapter } from "./adapters/langgraphAdapter.js";
+export { MemoryMeshOpenAIAgentsMiddleware } from "./adapters/openaiAgentsMiddleware.js";
+export { wrapTool } from "./adapters/toolWrapper.js";

package/dist/types.d.ts

@@ -0,0 +1,139 @@
+export type Json = string | number | boolean | null | Json[] | {
+    [key: string]: Json;
+};
+export type MemoryBackend = "local_cognee" | "cognee_cloud" | "offline_mirror";
+export type AgentId = "build" | "research" | "support" | (string & {});
+export interface MemoryMeshClientOptions {
+    baseUrl: string;
+    apiKey?: string;
+    apiKeyHeader?: "X-MemoryMesh-API-Key" | "Authorization" | (string & {});
+    fetch?: typeof fetch;
+    defaultMemoryBackend?: MemoryBackend;
+    defaultHeaders?: Record<string, string>;
+}
+export interface MemoryMeshErrorBody {
+    detail?: unknown;
+    message?: string;
+    [key: string]: unknown;
+}
+export interface HealthResponse {
+    status?: string;
+    app?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+export interface StartRunInput {
+    agentId: string;
+    task: string;
+    datasetType?: string;
+    taskVersion?: number;
+    parentCheckpointId?: string;
+    simulateRestart?: boolean;
+    taskModification?: string;
+    idempotencyKey?: string;
+}
+export interface ToolTraceInput {
+    tool: string;
+    toolType?: "read" | "write" | "external_action" | "unknown";
+    input: Record<string, Json>;
+    output: Record<string, Json>;
+    validation?: Record<string, Json>;
+    observedSignals?: Record<string, Json>;
+    checkpointId?: string;
+    traceId?: string;
+    idempotencyKey?: string;
+}
+export interface ResumeStateInput {
+    currentStep?: string;
+    pageToken?: string | null;
+    partialResultsRef?: string | null;
+    partialResults?: Record<string, Json>[];
+    validatedRecords?: number;
+    pendingActions?: Record<string, Json>[];
+    observedSignals?: Record<string, Json>;
+}
+export interface CheckpointInput {
+    checkpointName: string;
+    state: Record<string, Json>;
+    resumeState?: ResumeStateInput;
+    safeToResume?: boolean;
+    requiresHumanReview?: boolean;
+    metadata?: Record<string, Json>;
+}
+export interface ActionExecutionInput {
+    toolName: string;
+    toolType?: "write" | "external_action" | "read" | "unknown";
+    idempotencyKey: string;
+    input?: Record<string, Json>;
+}
+export interface FireworksPlanInput {
+    task: string;
+    runEvents?: string[];
+    checkpointId?: string;
+    taskVersion?: number;
+}
+export interface VoiceSummaryInput {
+    text: string;
+    voiceId?: string;
+    runId?: string;
+    checkpointId?: string;
+}
+export interface MemoryInput {
+    text?: string;
+    query?: string;
+    feedback?: string;
+    dataset?: string;
+    sessionId?: string;
+    topK?: number;
+    metadata?: Record<string, Json>;
+    backend?: MemoryBackend;
+}
+export interface AgentRunInput {
+    agentId?: AgentId;
+    task: string;
+    repositoryName?: string;
+    workspacePath?: string;
+    githubUrl?: string;
+    backend?: MemoryBackend;
+}
+export interface MemoryOperation {
+    operation?: string;
+    provider?: string;
+    backend?: MemoryBackend | string;
+    status?: string;
+    fallback_used?: boolean;
+    error?: string | null;
+    dataset?: string;
+    session_id?: string;
+    content?: unknown;
+    [key: string]: unknown;
+}
+export interface AgentRunReceipt {
+    run_id: string;
+    task_id: string;
+    agent_id: string;
+    agent_name: string;
+    task: string;
+    status: string;
+    final_output: string;
+    evidence: unknown[];
+    memory_operations: MemoryOperation[];
+    tool_traces: unknown[];
+    recovery: Record<string, unknown>;
+    outcome: Record<string, unknown>;
+    model_trace: Record<string, unknown>;
+    created_at: string;
+    raw?: Record<string, unknown>;
+}
+export interface CodingAgentRunInput {
+    task?: string;
+    repositoryName?: string;
+    workspacePath?: string;
+    dataset?: string;
+    sessionId?: string;
+    resetWorkspace?: boolean;
+    simulateContextLoss?: boolean;
+    runTests?: boolean;
+    forgetAfterRun?: boolean;
+    backend?: MemoryBackend;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@memorymsh/sdk",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for MemoryMesh durable agent memory, receipts, checkpoints, and Cognee-backed runtime state.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/othnielObasi/memorymesh.git",
+    "directory": "packages/sdk-typescript"
+  },
+  "keywords": [
+    "memorymesh",
+    "cognee",
+    "agent-memory",
+    "ai-agents",
+    "checkpoints",
+    "tool-tracing",
+    "llm"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}