mem0-mcp 0.2.0

package/dist/domain/memory.types.d.ts

@@ -0,0 +1,158 @@
+/**
+ * All Zod schemas, types, and configuration for the mem0 domain.
+ * This is the single source of truth for data shapes.
+ */
+import { z } from 'zod';
+export declare const memoryKindSchema: z.ZodEnum<{
+    decision: "decision";
+    preference: "preference";
+    summary: "summary";
+    artifact_context: "artifact_context";
+    note: "note";
+}>;
+export type MemoryKind = z.infer<typeof memoryKindSchema>;
+export declare const memoryScopeSchema: z.ZodObject<{
+    workspace: z.ZodString;
+    project: z.ZodString;
+    campaign: z.ZodOptional<z.ZodString>;
+    task: z.ZodOptional<z.ZodString>;
+    run: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type MemoryScope = z.infer<typeof memoryScopeSchema>;
+export declare const memoryProvenanceSchema: z.ZodObject<{
+    checkpointId: z.ZodOptional<z.ZodString>;
+    artifactIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type MemoryProvenance = z.infer<typeof memoryProvenanceSchema>;
+export declare const memoryMetadataSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+export type MemoryMetadata = z.infer<typeof memoryMetadataSchema>;
+export declare const memoryStoreInputSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        decision: "decision";
+        preference: "preference";
+        summary: "summary";
+        artifact_context: "artifact_context";
+        note: "note";
+    }>;
+    content: z.ZodString;
+    scope: z.ZodObject<{
+        workspace: z.ZodString;
+        project: z.ZodString;
+        campaign: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    provenance: z.ZodObject<{
+        checkpointId: z.ZodOptional<z.ZodString>;
+        artifactIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$loose>;
+export type MemoryStoreInput = z.infer<typeof memoryStoreInputSchema>;
+export declare const memoryRecallInputSchema: z.ZodObject<{
+    memoryId: z.ZodString;
+    scope: z.ZodObject<{
+        workspace: z.ZodString;
+        project: z.ZodString;
+        campaign: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type MemoryRecallInput = z.infer<typeof memoryRecallInputSchema>;
+export declare const memorySearchInputSchema: z.ZodObject<{
+    query: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    scope: z.ZodObject<{
+        workspace: z.ZodString;
+        project: z.ZodString;
+        campaign: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        decision: "decision";
+        preference: "preference";
+        summary: "summary";
+        artifact_context: "artifact_context";
+        note: "note";
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+export type MemorySearchInput = z.infer<typeof memorySearchInputSchema>;
+export declare const memoryUpdateInputSchema: z.ZodObject<{
+    memoryId: z.ZodString;
+    scope: z.ZodObject<{
+        workspace: z.ZodString;
+        project: z.ZodString;
+        campaign: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    content: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, z.core.$loose>;
+export type MemoryUpdateInput = z.infer<typeof memoryUpdateInputSchema>;
+export declare const memoryForgetInputSchema: z.ZodObject<{
+    memoryId: z.ZodString;
+    scope: z.ZodObject<{
+        workspace: z.ZodString;
+        project: z.ZodString;
+        campaign: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type MemoryForgetInput = z.infer<typeof memoryForgetInputSchema>;
+export declare const storedMemoryRecordSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        decision: "decision";
+        preference: "preference";
+        summary: "summary";
+        artifact_context: "artifact_context";
+        note: "note";
+    }>;
+    content: z.ZodString;
+    scope: z.ZodObject<{
+        workspace: z.ZodString;
+        project: z.ZodString;
+        campaign: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    provenance: z.ZodObject<{
+        checkpointId: z.ZodOptional<z.ZodString>;
+        artifactIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    id: z.ZodString;
+    embedding: z.ZodArray<z.ZodNumber>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$loose>;
+export type StoredMemoryRecord = z.infer<typeof storedMemoryRecordSchema>;
+export type PublicMemoryRecord = Omit<StoredMemoryRecord, 'embedding'>;
+export interface MemorySearchResult {
+    memory: PublicMemoryRecord;
+    score: number;
+}
+export interface HealthCheckResult {
+    ok: boolean;
+    storePath: string;
+    ollamaBaseUrl: string;
+    embedModel: string;
+    modelAvailable: boolean;
+    recordCount: number;
+    details?: string;
+}
+export declare const mem0ConfigSchema: z.ZodObject<{
+    storePath: z.ZodString;
+    ollamaBaseUrl: z.ZodString;
+    embedModel: z.ZodString;
+    ollamaTimeoutMs: z.ZodNumber;
+}, z.core.$loose>;
+export type Mem0Config = z.infer<typeof mem0ConfigSchema>;
+export declare function loadMem0ConfigFromEnv(env?: NodeJS.ProcessEnv): Mem0Config;
+export declare function toPublicMemoryRecord(record: StoredMemoryRecord): PublicMemoryRecord;

package/dist/domain/memory.types.js

@@ -0,0 +1,115 @@
+/**
+ * All Zod schemas, types, and configuration for the mem0 domain.
+ * This is the single source of truth for data shapes.
+ */
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { z } from 'zod';
+// ─── Memory Kind ────────────────────────────────────────────────────
+export const memoryKindSchema = z.enum([
+    'decision',
+    'preference',
+    'summary',
+    'artifact_context',
+    'note',
+]);
+// ─── Scope ──────────────────────────────────────────────────────────
+export const memoryScopeSchema = z
+    .object({
+    workspace: z.string().min(1),
+    project: z.string().min(1),
+    campaign: z.string().min(1).optional(),
+    task: z.string().min(1).optional(),
+    run: z.string().min(1).optional(),
+})
+    .passthrough();
+// ─── Provenance ─────────────────────────────────────────────────────
+export const memoryProvenanceSchema = z
+    .object({
+    checkpointId: z.string().min(1).optional(),
+    artifactIds: z.array(z.string().min(1)).default([]),
+    note: z.string().min(1).optional(),
+})
+    .passthrough();
+// ─── Metadata ───────────────────────────────────────────────────────
+export const memoryMetadataSchema = z.record(z.string(), z.string()).default({});
+// ─── Input Schemas ──────────────────────────────────────────────────
+export const memoryStoreInputSchema = z
+    .object({
+    kind: memoryKindSchema,
+    content: z.string().min(1),
+    scope: memoryScopeSchema,
+    provenance: memoryProvenanceSchema,
+    metadata: memoryMetadataSchema,
+})
+    .passthrough();
+export const memoryRecallInputSchema = z
+    .object({
+    memoryId: z.string().uuid(),
+    scope: memoryScopeSchema,
+})
+    .passthrough();
+export const memorySearchInputSchema = z
+    .object({
+    query: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]),
+    scope: memoryScopeSchema,
+    kind: memoryKindSchema.optional(),
+    limit: z.number().int().min(1).max(25).default(5),
+})
+    .passthrough();
+export const memoryUpdateInputSchema = z
+    .object({
+    memoryId: z.string().uuid(),
+    scope: memoryScopeSchema,
+    content: z.string().min(1).optional(),
+    metadata: memoryMetadataSchema.optional(),
+})
+    .passthrough();
+export const memoryForgetInputSchema = z
+    .object({
+    memoryId: z.string().uuid(),
+    scope: memoryScopeSchema,
+})
+    .passthrough();
+// ─── Records ────────────────────────────────────────────────────────
+export const storedMemoryRecordSchema = memoryStoreInputSchema.extend({
+    id: z.string().uuid(),
+    embedding: z.array(z.number()),
+    createdAt: z.string().datetime({ offset: true }),
+    updatedAt: z.string().datetime({ offset: true }),
+});
+// ─── Config ─────────────────────────────────────────────────────────
+export const mem0ConfigSchema = z
+    .object({
+    storePath: z.string().min(1),
+    ollamaBaseUrl: z.string().url(),
+    embedModel: z.string().min(1),
+    ollamaTimeoutMs: z.number().int().positive(),
+})
+    .passthrough();
+export function loadMem0ConfigFromEnv(env = process.env) {
+    return mem0ConfigSchema.parse({
+        storePath: expandHomePath(env.MEM0_STORE_PATH ?? '~/.copilot/mem0'),
+        ollamaBaseUrl: env.OLLAMA_BASE_URL ?? 'http://127.0.0.1:11434',
+        embedModel: env.MEM0_EMBED_MODEL ?? 'qwen3-embedding:latest',
+        ollamaTimeoutMs: parseIntegerEnv(env.MEM0_OLLAMA_TIMEOUT_MS, 10_000),
+    });
+}
+// ─── Helpers ────────────────────────────────────────────────────────
+export function toPublicMemoryRecord(record) {
+    const { embedding: _embedding, ...publicRecord } = record;
+    return publicRecord;
+}
+function expandHomePath(input) {
+    if (input === '~')
+        return homedir();
+    if (input.startsWith('~/'))
+        return resolve(homedir(), input.slice(2));
+    return input;
+}
+function parseIntegerEnv(input, fallback) {
+    if (input === undefined || input.trim().length === 0) {
+        return fallback;
+    }
+    return Number.parseInt(input, 10);
+}

package/dist/domain/memory.utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Pure domain functions for memory operations.
+ * Zero infrastructure dependencies.
+ */
+import type { MemoryScope } from './memory.types.js';
+export declare function matchesScope(recordScope: MemoryScope, requestedScope: MemoryScope): boolean;
+export declare function cosineSimilarity(left: number[], right: number[]): number;
+export declare function buildEmbeddingSource(kind: string, content: string, scope: Record<string, unknown>, provenance: Record<string, unknown>, metadata: Record<string, unknown>): string;
+export declare function buildMemoryDedupeKey(kind: string, content: string, scope: Record<string, unknown>, metadata: Record<string, unknown>): string;

package/dist/domain/memory.utils.js

@@ -0,0 +1,70 @@
+/**
+ * Pure domain functions for memory operations.
+ * Zero infrastructure dependencies.
+ */
+import { createHash } from 'node:crypto';
+// ─── Scope Matching ─────────────────────────────────────────────────
+export function matchesScope(recordScope, requestedScope) {
+    return (recordScope.workspace === requestedScope.workspace &&
+        recordScope.project === requestedScope.project &&
+        matchesOptionalField(recordScope.campaign, requestedScope.campaign) &&
+        matchesOptionalField(recordScope.task, requestedScope.task) &&
+        matchesOptionalField(recordScope.run, requestedScope.run));
+}
+function matchesOptionalField(recordValue, requestedValue) {
+    if (requestedValue === undefined)
+        return true;
+    return recordValue === requestedValue;
+}
+// ─── Cosine Similarity ──────────────────────────────────────────────
+export function cosineSimilarity(left, right) {
+    if (left.length !== right.length) {
+        throw new Error(`Embedding dimension mismatch: query=${left.length}, record=${right.length}`);
+    }
+    let dot = 0;
+    let leftMag = 0;
+    let rightMag = 0;
+    for (let i = 0; i < left.length; i += 1) {
+        dot += left[i] * right[i];
+        leftMag += left[i] * left[i];
+        rightMag += right[i] * right[i];
+    }
+    if (leftMag === 0 || rightMag === 0)
+        return 0;
+    return dot / (Math.sqrt(leftMag) * Math.sqrt(rightMag));
+}
+// ─── Embedding Source Builder ───────────────────────────────────────
+export function buildEmbeddingSource(kind, content, scope, provenance, metadata) {
+    const scopeBlock = buildStringRecordBlock(scope);
+    const metadataBlock = buildStringRecordBlock(metadata);
+    const artifactIds = provenance.artifactIds;
+    const artifactBlock = artifactIds && artifactIds.length > 0 ? artifactIds.join(', ') : 'none';
+    return [
+        `kind: ${kind}`,
+        content,
+        scopeBlock.length > 0 ? `scope:\n${scopeBlock}` : '',
+        provenance.checkpointId ? `checkpointId: ${provenance.checkpointId}` : '',
+        `artifactIds: ${artifactBlock}`,
+        provenance.note ? `note: ${provenance.note}` : '',
+        metadataBlock.length > 0 ? `metadata:\n${metadataBlock}` : '',
+    ]
+        .filter((block) => block.length > 0)
+        .join('\n\n');
+}
+export function buildMemoryDedupeKey(kind, content, scope, metadata) {
+    return createHash('sha256')
+        .update([
+        `kind: ${kind}`,
+        `content:\n${content}`,
+        `scope:\n${buildStringRecordBlock(scope)}`,
+        `metadata:\n${buildStringRecordBlock(metadata)}`,
+    ].join('\n\n'), 'utf8')
+        .digest('hex');
+}
+function buildStringRecordBlock(record) {
+    return Object.entries(record)
+        .filter(([, value]) => typeof value === 'string' && value.length > 0)
+        .sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey))
+        .map(([key, value]) => `${key}: ${value}`)
+        .join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './domain/memory.types.js';
+export * from './domain/memory.utils.js';
+export * from './domain/errors.js';
+export * from './ports/memory-store.port.js';
+export * from './ports/embedder.port.js';
+export { SqliteMem0Adapter } from './adapters/sqlite/sqlite-memory-store.js';
+export { OllamaEmbedder } from './adapters/ollama/ollama-embedder.js';
+export { McpServer } from './transport/mcp-server.js';
+export type { ToolDefinition } from './transport/mcp-server.js';
+export * from './transport/jsonrpc-stdio.js';

package/dist/index.js

@@ -0,0 +1,14 @@
+// Public API barrel — hexagonal architecture exports
+// Domain
+export * from './domain/memory.types.js';
+export * from './domain/memory.utils.js';
+export * from './domain/errors.js';
+// Ports
+export * from './ports/memory-store.port.js';
+export * from './ports/embedder.port.js';
+// Adapters
+export { SqliteMem0Adapter } from './adapters/sqlite/sqlite-memory-store.js';
+export { OllamaEmbedder } from './adapters/ollama/ollama-embedder.js';
+// Transport
+export { McpServer } from './transport/mcp-server.js';
+export * from './transport/jsonrpc-stdio.js';

package/dist/ports/embedder.port.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Port: Embedder — contract for text embedding providers.
+ */
+export interface EmbedderPort {
+    embedText(text: string): Promise<number[]>;
+    healthCheck(): Promise<EmbedderHealthStatus>;
+}
+export interface EmbedderHealthStatus {
+    ok: boolean;
+    modelAvailable: boolean;
+    details?: string;
+}

package/dist/ports/embedder.port.js

@@ -0,0 +1,4 @@
+/**
+ * Port: Embedder — contract for text embedding providers.
+ */
+export {};

package/dist/ports/memory-store.port.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Port: MemoryStore — contract for memory persistence backends.
+ */
+import type { HealthCheckResult, MemoryForgetInput, MemoryRecallInput, MemorySearchInput, MemorySearchResult, MemoryStoreInput, MemoryUpdateInput, PublicMemoryRecord } from '../domain/memory.types.js';
+export interface MemoryStorePort {
+    healthCheck(): Promise<HealthCheckResult>;
+    storeMemory(input: MemoryStoreInput): Promise<PublicMemoryRecord>;
+    recallMemory(input: MemoryRecallInput): Promise<PublicMemoryRecord | null>;
+    searchMemory(input: MemorySearchInput): Promise<MemorySearchResult[]>;
+    updateMemory(input: MemoryUpdateInput): Promise<PublicMemoryRecord>;
+    deleteMemory(input: MemoryForgetInput): Promise<void>;
+    listWorkspaces(): Promise<string[]>;
+    listProjects(workspace: string): Promise<string[]>;
+}
+/**
+ * Backward-compatible alias so downstream consumers (agent-harness-core)
+ * can keep importing `Mem0Adapter` without changes.
+ */
+export type Mem0Adapter = MemoryStorePort;

package/dist/ports/memory-store.port.js

@@ -0,0 +1,4 @@
+/**
+ * Port: MemoryStore — contract for memory persistence backends.
+ */
+export {};

package/dist/test/mem0-mcp-server.test.d.ts

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

package/dist/test/mem0-mcp-server.test.js

@@ -0,0 +1,122 @@
+import assert from 'node:assert/strict';
+import { spawn, } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { JsonRpcError, JsonRpcStreamTransport, isJsonRpcErrorResponse, isJsonRpcSuccessResponse, } from '../transport/jsonrpc-stdio.js';
+class TestJsonRpcClient {
+    child;
+    transport;
+    pendingRequests = new Map();
+    nextId = 1;
+    constructor(child) {
+        this.child = child;
+        this.transport = new JsonRpcStreamTransport((message) => this.handleMessage(message), {
+            input: child.stdout,
+            output: child.stdin,
+        });
+        this.transport.start();
+    }
+    async request(method, params) {
+        const id = this.nextId++;
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Timed out waiting for response to ${method}`));
+            }, 5_000);
+            this.pendingRequests.set(id, {
+                reject,
+                resolve,
+                timeout,
+            });
+            this.transport.sendRequest(id, method, params);
+        });
+    }
+    notify(method, params) {
+        this.transport.sendNotification(method, params);
+    }
+    async close() {
+        this.transport.stop();
+        for (const pendingRequest of this.pendingRequests.values()) {
+            clearTimeout(pendingRequest.timeout);
+            pendingRequest.reject(new Error('Client closed before receiving a response'));
+        }
+        this.pendingRequests.clear();
+    }
+    async handleMessage(message) {
+        if (isJsonRpcSuccessResponse(message) || isJsonRpcErrorResponse(message)) {
+            const pendingRequest = this.pendingRequests.get(message.id);
+            if (pendingRequest === undefined) {
+                return;
+            }
+            this.pendingRequests.delete(message.id);
+            clearTimeout(pendingRequest.timeout);
+            if (isJsonRpcSuccessResponse(message)) {
+                pendingRequest.resolve(message.result);
+            }
+            else {
+                pendingRequest.reject(new JsonRpcError(message.error.code, message.error.message, message.error.data));
+            }
+        }
+    }
+}
+test('mem0-mcp initializes and exposes memory tools', async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), 'mem0-mcp-server-'));
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const distRoot = join(currentDir, '..');
+    const serverPath = join(distRoot, 'bin', 'mem0-mcp.js');
+    const packageVersion = JSON.parse(readFileSync(join(distRoot, '..', 'package.json'), 'utf8')).version;
+    const server = spawn(process.execPath, [serverPath], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            MEM0_STORE_PATH: join(tempDir, 'store'),
+            OLLAMA_BASE_URL: 'http://127.0.0.1:11434',
+            MEM0_EMBED_MODEL: 'stub',
+        },
+    });
+    const client = new TestJsonRpcClient(server);
+    try {
+        const initializeResult = (await client.request('initialize', {
+            protocolVersion: '2025-11-25',
+            capabilities: {
+                experimental: null,
+                roots: null,
+                sampling: null,
+            },
+            clientInfo: {
+                name: 'copilot-cli-test',
+                version: '1.0.0',
+            },
+        }));
+        assert.equal(initializeResult.serverInfo.name, 'mem0-mcp');
+        assert.equal(initializeResult.serverInfo.version, packageVersion);
+        client.notify('notifications/initialized', {});
+        const toolList = (await client.request('tools/list', {}));
+        assert.deepEqual(toolList.tools.map((tool) => tool.name), [
+            'health',
+            'memory_store',
+            'memory_recall',
+            'memory_search',
+            'memory_update',
+            'memory_forget',
+            'setup_wizard',
+        ]);
+    }
+    finally {
+        try {
+            await client.request('shutdown', {});
+        }
+        catch {
+            // Ignore shutdown failures during cleanup.
+        }
+        client.notify('exit');
+        await client.close();
+        if (!server.killed) {
+            server.kill('SIGTERM');
+        }
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+});

package/dist/test/ollama-embedder.test.d.ts

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

package/dist/test/ollama-embedder.test.js

@@ -0,0 +1,75 @@
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import { createServer } from 'node:http';
+import test from 'node:test';
+import { OllamaEmbedder } from '../index.js';
+test('healthCheck times out when Ollama does not respond', async () => {
+    const harness = await createStallingServer();
+    const embedder = new OllamaEmbedder({
+        ollamaBaseUrl: harness.baseUrl,
+        embedModel: 'stub',
+        ollamaTimeoutMs: 50,
+    });
+    try {
+        const startedAt = Date.now();
+        const health = await embedder.healthCheck();
+        assert.equal(health.ok, false);
+        assert.match(health.details ?? '', /Timed out after 50ms contacting Ollama/);
+        assert.ok(Date.now() - startedAt < 1_000);
+    }
+    finally {
+        await harness.close();
+    }
+});
+test('embedText aborts stalled Ollama requests', async () => {
+    const harness = await createStallingServer();
+    const embedder = new OllamaEmbedder({
+        ollamaBaseUrl: harness.baseUrl,
+        embedModel: 'stub',
+        ollamaTimeoutMs: 50,
+    });
+    try {
+        await assert.rejects(() => embedder.embedText('hello'), /Timed out after 50ms contacting Ollama/);
+    }
+    finally {
+        await harness.close();
+    }
+});
+async function createStallingServer() {
+    const sockets = new Set();
+    const server = createServer((_request, _response) => {
+        // Intentionally never respond so client-side timeouts are exercised.
+    });
+    server.on('connection', (socket) => {
+        sockets.add(socket);
+        socket.on('close', () => {
+            sockets.delete(socket);
+        });
+    });
+    server.listen(0, '127.0.0.1');
+    await once(server, 'listening');
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Unable to resolve test server address.');
+    }
+    return {
+        baseUrl: `http://127.0.0.1:${address.port}`,
+        async close() {
+            await closeServer(server, sockets);
+        },
+    };
+}
+async function closeServer(server, sockets) {
+    for (const socket of sockets) {
+        socket.destroy();
+    }
+    await new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}

package/dist/test/setup-wizard.tool.test.d.ts

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

package/dist/test/setup-wizard.tool.test.js

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createSetupWizardTool } from '../transport/tools/setup-wizard.tool.js';
+test('setup_wizard pulls the configured embedding model', async () => {
+    const calls = [];
+    const tool = createSetupWizardTool({
+        embedModel: 'nomic-embed-text',
+        runCommand: async (command, args) => {
+            calls.push({ command, args });
+        },
+    });
+    const result = (await tool.handler({}));
+    assert.deepEqual(calls, [
+        {
+            command: 'ollama',
+            args: ['pull', 'nomic-embed-text'],
+        },
+    ]);
+    assert.deepEqual(result, {
+        success: true,
+        model: 'nomic-embed-text',
+        message: 'Ollama model nomic-embed-text pulled successfully.',
+    });
+});
+test('setup_wizard rejects unexpected arguments', async () => {
+    const tool = createSetupWizardTool({
+        embedModel: 'qwen3-embedding:latest',
+        runCommand: async () => { },
+    });
+    await assert.rejects(() => tool.handler({ force: true }));
+});

package/dist/test/sqlite-memory-store.test.d.ts

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