@gloriginmind/mcp 0.1.0

package/README.md

@@ -0,0 +1,95 @@
+# OriginMind MCP
+
+MCP server for OriginMind dual-auth skill routes. Auth is the same Bootstrap OAuth path as skills (`ORIGINMIND_API_KEY` → `~/.originmind/.env`). No MCP-specific OAuth.
+
+## Prerequisites
+
+Run Bootstrap OAuth once on the machine:
+
+```powershell
+. ./skills/create/scripts/setup-oauth.ps1
+```
+
+```bash
+source ./skills/create/scripts/setup-oauth.sh
+```
+
+Key is stored in `~/.originmind/.env`. Do **not** paste the key into `mcp.json`.
+
+## Cursor (`mcp.json`)
+
+```json
+{
+  "mcpServers": {
+    "originmind": {
+      "command": "npx",
+      "args": ["-y", "@gloriginmind/mcp"],
+      "env": {}
+    }
+  }
+}
+```
+
+Local checkout (this monorepo):
+
+```json
+{
+  "mcpServers": {
+    "originmind": {
+      "command": "node",
+      "args": ["path/to/OriAI_orchestrator/skills/mcp/dist/stdio.js"],
+      "env": {}
+    }
+  }
+}
+```
+
+If the key is missing, tools return a `MISSING_KEY` error pointing at OAuth setup.
+
+## Transports
+
+| Transport | Entry | Use |
+|-----------|-------|-----|
+| **stdio** | `originmind-mcp` / `dist/stdio.js` | Cursor |
+| **HTTP** | `originmind-mcp-http` / `dist/http.js` | LiveKit `MCPServerHTTP` (future) |
+
+HTTP defaults: `ORIGINMIND_MCP_HOST=127.0.0.1`, `ORIGINMIND_MCP_PORT=3920`, path `/mcp`, health `GET /health`.
+
+Per-request auth: prefer `Authorization: Bearer <session JWT>`; else fall back to `ORIGINMIND_API_KEY`.
+
+### LiveKit (documented, not wired this pass)
+
+When the HTTP server is running:
+
+```python
+from livekit.agents import mcp
+
+mcp.MCPServerHTTP(
+    url=f"http://127.0.0.1:{port}/mcp",
+    headers={"Authorization": f"Bearer {jwt}"},
+)
+```
+
+Do not attach alongside the existing `@function_tool`s until you choose which surface wins (avoids duplicate tools).
+
+## Tools
+
+**Read:** `list_projects`, `search_creative_dna`, `list_conversations`, `list_messages`, `get_transcript`  
+**Tasks:** `create_task`, `list_tasks`, `get_task`, `patch_task`  
+**Creations:** `list_creations`, `get_creation`, `create_creation`, `update_creation`  
+**References:** `list_references`, `create_reference`
+
+Same routes as [search-creative-dna/references/routes.md](../search-creative-dna/references/routes.md).
+
+**Creations** use the creations API (`list_creations` / `get_creation` / `create_creation` / `update_creation`). Notion tools are **not** exposed here (parked).
+
+## Dev
+
+```bash
+cd skills/mcp
+npm install   # may need corporate TLS workaround
+npm run build
+npm test
+npm start           # stdio
+npm run start:http  # HTTP
+```

package/dist/auth.d.ts

@@ -0,0 +1,18 @@
+export type AuthCred = {
+    kind: "api_key" | "bearer";
+    value: string;
+};
+/**
+ * Resolve auth for MCP → OriginMind API.
+ * Prefer explicit Bearer (HTTP/voice), else ORIGINMIND_API_KEY from env / ~/.originmind/.env / repo .env.
+ */
+export declare function resolveAuth(options?: {
+    authorizationHeader?: string | null;
+    cwd?: string;
+    /** Override machine env path; pass `null` to skip (~/.originmind/.env). */
+    machineEnvPath?: string | null;
+}): AuthCred | {
+    error: "MISSING_KEY";
+};
+export declare function authHeaders(cred: AuthCred): Record<string, string>;
+export declare const MISSING_KEY_MESSAGE = "MISSING_KEY: Run OriginMind Bootstrap OAuth first \u2014 . ./skills/create/scripts/setup-oauth.ps1 (or .sh). Key is saved to ~/.originmind/.env.";

package/dist/auth.js

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function readKeyFromFile(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    const lines = fs.readFileSync(filePath, "utf8").split(/\r?\n/);
+    for (const line of lines) {
+        const m = line.match(/^\s*ORIGINMIND_API_KEY\s*=\s*(.+)\s*$/);
+        if (m) {
+            return m[1].trim().replace(/^["']|["']$/g, "");
+        }
+    }
+    return null;
+}
+function findRepoRoot(start) {
+    let dir = start;
+    while (dir) {
+        for (const marker of [".env", ".env.local", ".git"]) {
+            if (fs.existsSync(path.join(dir, marker)))
+                return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return start;
+}
+/**
+ * Resolve auth for MCP → OriginMind API.
+ * Prefer explicit Bearer (HTTP/voice), else ORIGINMIND_API_KEY from env / ~/.originmind/.env / repo .env.
+ */
+export function resolveAuth(options) {
+    const header = options?.authorizationHeader?.trim();
+    if (header) {
+        const bearer = header.match(/^Bearer\s+(.+)$/i);
+        if (bearer?.[1]) {
+            return { kind: "bearer", value: bearer[1].trim() };
+        }
+        if (header.startsWith("om_live_")) {
+            return { kind: "api_key", value: header };
+        }
+    }
+    if (process.env.ORIGINMIND_API_KEY?.trim()) {
+        return { kind: "api_key", value: process.env.ORIGINMIND_API_KEY.trim() };
+    }
+    if (options?.machineEnvPath !== null) {
+        const machinePath = options?.machineEnvPath ?? path.join(os.homedir(), ".originmind", ".env");
+        const machineKey = readKeyFromFile(machinePath);
+        if (machineKey) {
+            return { kind: "api_key", value: machineKey };
+        }
+    }
+    const root = findRepoRoot(options?.cwd ?? process.cwd());
+    for (const name of [".env", ".env.local"]) {
+        const key = readKeyFromFile(path.join(root, name));
+        if (key)
+            return { kind: "api_key", value: key };
+    }
+    return { error: "MISSING_KEY" };
+}
+export function authHeaders(cred) {
+    if (cred.kind === "bearer") {
+        return { Authorization: `Bearer ${cred.value}` };
+    }
+    return { "X-OriAI-Api-Key": cred.value };
+}
+export const MISSING_KEY_MESSAGE = "MISSING_KEY: Run OriginMind Bootstrap OAuth first — . ./skills/create/scripts/setup-oauth.ps1 (or .sh). Key is saved to ~/.originmind/.env.";

package/dist/client.d.ts

@@ -0,0 +1,28 @@
+import { type AuthCred } from "./auth.js";
+export declare const DEFAULT_BASE_URL = "https://api.originmind.ai";
+export declare class ApiError extends Error {
+    status: number;
+    body: string;
+    constructor(message: string, status: number, body: string);
+}
+export declare class OriginMindClient {
+    private cred;
+    private baseUrl;
+    constructor(cred: AuthCred, baseUrl?: string);
+    request<T = unknown>(method: string, path: string, options?: {
+        query?: Record<string, string | undefined>;
+        body?: unknown;
+    }): Promise<T>;
+    get<T = unknown>(path: string, query?: Record<string, string | undefined>): Promise<T>;
+    post<T = unknown>(path: string, body?: unknown): Promise<T>;
+    patch<T = unknown>(path: string, body?: unknown): Promise<T>;
+    postMultipart<T = unknown>(path: string, options: {
+        fields: Record<string, string>;
+        file: {
+            fieldName: string;
+            filename: string;
+            contentType: string;
+            body: string;
+        };
+    }): Promise<T>;
+}

package/dist/client.js

@@ -0,0 +1,91 @@
+import { authHeaders } from "./auth.js";
+export const DEFAULT_BASE_URL = "https://api.originmind.ai";
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "ApiError";
+    }
+}
+export class OriginMindClient {
+    cred;
+    baseUrl;
+    constructor(cred, baseUrl = process.env.ORIGINMIND_API_BASE_URL?.replace(/\/$/, "") || DEFAULT_BASE_URL) {
+        this.cred = cred;
+        this.baseUrl = baseUrl;
+    }
+    async request(method, path, options) {
+        const url = new URL(path.startsWith("http") ? path : `${this.baseUrl}${path}`);
+        if (options?.query) {
+            for (const [k, v] of Object.entries(options.query)) {
+                if (v !== undefined && v !== "")
+                    url.searchParams.set(k, v);
+            }
+        }
+        const headers = {
+            Accept: "application/json",
+            ...authHeaders(this.cred),
+        };
+        if (options?.body !== undefined) {
+            headers["Content-Type"] = "application/json";
+        }
+        const res = await fetch(url, {
+            method,
+            headers,
+            body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            throw new ApiError(`OriginMind API ${method} ${url.pathname}: ${res.status}`, res.status, text);
+        }
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    get(path, query) {
+        return this.request("GET", path, { query });
+    }
+    post(path, body) {
+        return this.request("POST", path, { body });
+    }
+    patch(path, body) {
+        return this.request("PATCH", path, { body });
+    }
+    async postMultipart(path, options) {
+        const url = new URL(path.startsWith("http") ? path : `${this.baseUrl}${path}`);
+        const form = new FormData();
+        for (const [k, v] of Object.entries(options.fields)) {
+            form.append(k, v);
+        }
+        const blob = new Blob([options.file.body], { type: options.file.contentType });
+        form.append(options.file.fieldName, blob, options.file.filename);
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                ...authHeaders(this.cred),
+            },
+            body: form,
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            throw new ApiError(`OriginMind API POST ${url.pathname}: ${res.status}`, res.status, text);
+        }
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+}

package/dist/http.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/http.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Streamable HTTP MCP for LiveKit Agents (MCPServerHTTP) and other HTTP clients.
+ * Auth: prefer Authorization Bearer on each request; else ORIGINMIND_API_KEY / ~/.originmind/.env.
+ *
+ * Voice wiring is deferred — run this process and point LiveKit at:
+ *   MCPServerHTTP(url=f"http://127.0.0.1:{port}/mcp", headers={"Authorization": f"Bearer {jwt}"})
+ */
+import { createServer } from "node:http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer as createMcpServer } from "./tools.js";
+const port = Number(process.env.ORIGINMIND_MCP_PORT || 3920);
+const host = process.env.ORIGINMIND_MCP_HOST || "127.0.0.1";
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (c) => chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c)));
+        req.on("end", () => {
+            if (chunks.length === 0) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        req.on("error", reject);
+    });
+}
+async function handleMcp(req, res) {
+    const authHeader = typeof req.headers.authorization === "string" ? req.headers.authorization : null;
+    const server = createMcpServer({
+        getAuthorizationHeader: () => authHeader,
+    });
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+    });
+    res.on("close", () => {
+        void transport.close();
+        void server.close();
+    });
+    try {
+        await server.connect(transport);
+        const body = req.method === "POST" ? await readJsonBody(req) : undefined;
+        await transport.handleRequest(req, res, body);
+    }
+    catch (err) {
+        console.error("MCP HTTP error:", err);
+        if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32603, message: "Internal server error" },
+                id: null,
+            }));
+        }
+    }
+}
+async function main() {
+    const httpServer = createServer(async (req, res) => {
+        const url = new URL(req.url || "/", `http://${host}:${port}`);
+        if (req.method === "GET" && url.pathname === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true, service: "originmind-mcp" }));
+            return;
+        }
+        if (url.pathname === "/mcp" || url.pathname === "/") {
+            await handleMcp(req, res);
+            return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "not_found" }));
+    });
+    httpServer.listen(port, host, () => {
+        console.error(`OriginMind MCP HTTP listening on http://${host}:${port}/mcp (health: /health)`);
+    });
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/stdio.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/stdio.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./tools.js";
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/tools.d.ts

@@ -0,0 +1,181 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+export type ToolAuthContext = {
+    /** Per-request Authorization header (HTTP transport). */
+    getAuthorizationHeader?: () => string | null | undefined;
+};
+/** Zod shapes exported for unit tests. */
+export declare const toolSchemas: {
+    list_projects: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    search_creative_dna: z.ZodObject<{
+        project_id: z.ZodString;
+        query: z.ZodString;
+        vectorK: z.ZodOptional<z.ZodNumber>;
+        neighborLimit: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+        project_id: string;
+        vectorK?: number | undefined;
+        neighborLimit?: number | undefined;
+    }, {
+        query: string;
+        project_id: string;
+        vectorK?: number | undefined;
+        neighborLimit?: number | undefined;
+    }>;
+    list_conversations: z.ZodObject<{
+        project_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        project_id: string;
+    }, {
+        project_id: string;
+    }>;
+    list_messages: z.ZodObject<{
+        conversation_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        conversation_id: string;
+    }, {
+        conversation_id: string;
+    }>;
+    get_transcript: z.ZodObject<{
+        conversation_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        conversation_id: string;
+    }, {
+        conversation_id: string;
+    }>;
+    create_task: z.ZodObject<{
+        project_id: z.ZodString;
+        conversation_id: z.ZodString;
+        task_type: z.ZodEnum<["research", "ingest", "execute"]>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        project_id: string;
+        conversation_id: string;
+        task_type: "research" | "ingest" | "execute";
+        params?: Record<string, unknown> | undefined;
+    }, {
+        project_id: string;
+        conversation_id: string;
+        task_type: "research" | "ingest" | "execute";
+        params?: Record<string, unknown> | undefined;
+    }>;
+    list_tasks: z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<["pending", "in_progress", "completed", "failed"]>>;
+        task_type: z.ZodOptional<z.ZodEnum<["research", "ingest", "execute"]>>;
+        project_id: z.ZodOptional<z.ZodString>;
+        conversation_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status?: "pending" | "in_progress" | "completed" | "failed" | undefined;
+        project_id?: string | undefined;
+        conversation_id?: string | undefined;
+        task_type?: "research" | "ingest" | "execute" | undefined;
+    }, {
+        status?: "pending" | "in_progress" | "completed" | "failed" | undefined;
+        project_id?: string | undefined;
+        conversation_id?: string | undefined;
+        task_type?: "research" | "ingest" | "execute" | undefined;
+    }>;
+    get_task: z.ZodObject<{
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+    }, {
+        id: string;
+    }>;
+    patch_task: z.ZodObject<{
+        id: z.ZodString;
+        action: z.ZodEnum<["claim", "complete", "fail", "consume"]>;
+        conversation_id: z.ZodOptional<z.ZodString>;
+        results: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        action: "claim" | "complete" | "fail" | "consume";
+        error?: string | undefined;
+        conversation_id?: string | undefined;
+        results?: Record<string, unknown> | undefined;
+    }, {
+        id: string;
+        action: "claim" | "complete" | "fail" | "consume";
+        error?: string | undefined;
+        conversation_id?: string | undefined;
+        results?: Record<string, unknown> | undefined;
+    }>;
+    list_creations: z.ZodObject<{
+        project_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        project_id: string;
+    }, {
+        project_id: string;
+    }>;
+    get_creation: z.ZodObject<{
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+    }, {
+        id: string;
+    }>;
+    create_creation: z.ZodObject<{
+        project_id: z.ZodString;
+        title: z.ZodString;
+        content: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<["draft", "saved", "finalized"]>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "draft" | "saved" | "finalized";
+        project_id: string;
+        title: string;
+        content: string;
+    }, {
+        project_id: string;
+        title: string;
+        content: string;
+        status?: "draft" | "saved" | "finalized" | undefined;
+    }>;
+    update_creation: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<["draft", "saved", "finalized"]>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status?: "draft" | "saved" | "finalized" | undefined;
+        title?: string | undefined;
+        content?: string | undefined;
+    }, {
+        id: string;
+        status?: "draft" | "saved" | "finalized" | undefined;
+        title?: string | undefined;
+        content?: string | undefined;
+    }>;
+    list_references: z.ZodObject<{
+        project_id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        project_id: string;
+    }, {
+        project_id: string;
+    }>;
+    create_reference: z.ZodObject<{
+        project_id: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<["url", "youtube", "text", "voice", "document"]>>;
+        title: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "text" | "url" | "youtube" | "voice" | "document";
+        project_id: string;
+        title?: string | undefined;
+        content?: string | undefined;
+        url?: string | undefined;
+        filename?: string | undefined;
+    }, {
+        project_id: string;
+        kind?: "text" | "url" | "youtube" | "voice" | "document" | undefined;
+        title?: string | undefined;
+        content?: string | undefined;
+        url?: string | undefined;
+        filename?: string | undefined;
+    }>;
+};
+export declare function createServer(authCtx?: ToolAuthContext): McpServer;

package/dist/tools.js

@@ -0,0 +1,176 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { MISSING_KEY_MESSAGE, resolveAuth } from "./auth.js";
+import { ApiError, OriginMindClient } from "./client.js";
+function textResult(payload) {
+    const text = typeof payload === "string" ? payload : JSON.stringify(payload, null, 2);
+    return { content: [{ type: "text", text }] };
+}
+function errorResult(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+}
+function clientFor(ctx) {
+    const auth = resolveAuth({ authorizationHeader: ctx.getAuthorizationHeader?.() ?? null });
+    if ("error" in auth)
+        return { error: MISSING_KEY_MESSAGE };
+    return new OriginMindClient(auth);
+}
+async function runTool(ctx, fn) {
+    const client = clientFor(ctx);
+    if ("error" in client)
+        return errorResult(client.error);
+    try {
+        const data = await fn(client);
+        return textResult(data);
+    }
+    catch (err) {
+        if (err instanceof ApiError) {
+            return errorResult(`${err.message}\n${err.body}`);
+        }
+        return errorResult(err instanceof Error ? err.message : String(err));
+    }
+}
+/** Zod shapes exported for unit tests. */
+export const toolSchemas = {
+    list_projects: z.object({}),
+    search_creative_dna: z.object({
+        project_id: z.string().min(1),
+        query: z.string().min(1),
+        vectorK: z.number().int().min(1).max(20).optional(),
+        neighborLimit: z.number().int().min(1).max(5).optional(),
+    }),
+    list_conversations: z.object({
+        project_id: z.string().min(1),
+    }),
+    list_messages: z.object({
+        conversation_id: z.string().uuid(),
+    }),
+    get_transcript: z.object({
+        conversation_id: z.string().uuid(),
+    }),
+    create_task: z.object({
+        project_id: z.string().min(1),
+        conversation_id: z.string().uuid(),
+        task_type: z.enum(["research", "ingest", "execute"]),
+        params: z.record(z.unknown()).optional(),
+    }),
+    list_tasks: z.object({
+        status: z.enum(["pending", "in_progress", "completed", "failed"]).optional(),
+        task_type: z.enum(["research", "ingest", "execute"]).optional(),
+        project_id: z.string().optional(),
+        conversation_id: z.string().uuid().optional(),
+    }),
+    get_task: z.object({
+        id: z.string().uuid(),
+    }),
+    patch_task: z.object({
+        id: z.string().uuid(),
+        action: z.enum(["claim", "complete", "fail", "consume"]),
+        conversation_id: z.string().uuid().optional(),
+        results: z.record(z.unknown()).optional(),
+        error: z.string().optional(),
+    }),
+    list_creations: z.object({
+        project_id: z.string().min(1),
+    }),
+    get_creation: z.object({
+        id: z.string().uuid(),
+    }),
+    create_creation: z.object({
+        project_id: z.string().min(1),
+        title: z.string().min(1),
+        content: z.string().min(1),
+        status: z.enum(["draft", "saved", "finalized"]).default("saved"),
+    }),
+    update_creation: z.object({
+        id: z.string().uuid(),
+        title: z.string().optional(),
+        content: z.string().optional(),
+        status: z.enum(["draft", "saved", "finalized"]).optional(),
+    }),
+    list_references: z.object({
+        project_id: z.string().min(1),
+    }),
+    create_reference: z.object({
+        project_id: z.string().min(1),
+        kind: z.enum(["url", "youtube", "text", "voice", "document"]).default("document"),
+        title: z.string().min(1).optional(),
+        content: z.string().optional(),
+        url: z.string().url().optional(),
+        filename: z.string().optional(),
+    }),
+};
+export function createServer(authCtx = {}) {
+    const server = new McpServer({
+        name: "originmind",
+        version: "0.1.0",
+    });
+    server.tool("list_projects", "List OriginMind projects for the authenticated user (GET /api/v1/projects).", toolSchemas.list_projects.shape, async () => runTool(authCtx, (c) => c.get("/api/v1/projects")));
+    server.tool("search_creative_dna", "Search Creative DNA for a project (POST /api/v1/projects/{id}/query).", toolSchemas.search_creative_dna.shape, async (args) => runTool(authCtx, (c) => c.post(`/api/v1/projects/${encodeURIComponent(args.project_id)}/query`, {
+        query: args.query,
+        ...(args.vectorK !== undefined ? { vectorK: args.vectorK } : {}),
+        ...(args.neighborLimit !== undefined ? { neighborLimit: args.neighborLimit } : {}),
+    })));
+    server.tool("list_conversations", "List conversations for a project (GET /api/v1/projects/{id}/conversations).", toolSchemas.list_conversations.shape, async (args) => runTool(authCtx, (c) => c.get(`/api/v1/projects/${encodeURIComponent(args.project_id)}/conversations`)));
+    server.tool("list_messages", "List messages for a conversation (GET /api/v1/messages/{conversationId}).", toolSchemas.list_messages.shape, async (args) => runTool(authCtx, (c) => c.get(`/api/v1/messages/${encodeURIComponent(args.conversation_id)}`)));
+    server.tool("get_transcript", "Get plain-text transcript for a conversation (GET /api/v1/conversations/{id}/transcript).", toolSchemas.get_transcript.shape, async (args) => runTool(authCtx, (c) => c.get(`/api/v1/conversations/${encodeURIComponent(args.conversation_id)}/transcript`)));
+    server.tool("create_task", "Create a research/execute/ingest task (POST /api/v1/tasks).", toolSchemas.create_task.shape, async (args) => runTool(authCtx, (c) => c.post("/api/v1/tasks", {
+        project_id: args.project_id,
+        conversation_id: args.conversation_id,
+        task_type: args.task_type,
+        ...(args.params !== undefined ? { params: args.params } : {}),
+    })));
+    server.tool("list_tasks", "List tasks with optional filters (GET /api/v1/tasks).", toolSchemas.list_tasks.shape, async (args) => runTool(authCtx, (c) => c.get("/api/v1/tasks", {
+        status: args.status,
+        task_type: args.task_type,
+        project_id: args.project_id,
+        conversation_id: args.conversation_id,
+    })));
+    server.tool("get_task", "Get a task by id (GET /api/v1/tasks/{id}).", toolSchemas.get_task.shape, async (args) => runTool(authCtx, (c) => c.get(`/api/v1/tasks/${encodeURIComponent(args.id)}`)));
+    server.tool("patch_task", "Claim, complete, fail, or consume a task (PATCH /api/v1/tasks/{id}).", toolSchemas.patch_task.shape, async (args) => runTool(authCtx, (c) => c.patch(`/api/v1/tasks/${encodeURIComponent(args.id)}`, {
+        action: args.action,
+        ...(args.conversation_id !== undefined ? { conversation_id: args.conversation_id } : {}),
+        ...(args.results !== undefined ? { results: args.results } : {}),
+        ...(args.error !== undefined ? { error: args.error } : {}),
+    })));
+    server.tool("list_creations", "List creations for a project (GET /api/v1/creations?project_id=...).", toolSchemas.list_creations.shape, async (args) => runTool(authCtx, (c) => c.get("/api/v1/creations", { project_id: args.project_id })));
+    server.tool("get_creation", "Get a creation by id (GET /api/v1/creations/{id}).", toolSchemas.get_creation.shape, async (args) => runTool(authCtx, (c) => c.get(`/api/v1/creations/${encodeURIComponent(args.id)}`)));
+    server.tool("create_creation", "Create a saved creative document (POST /api/v1/creations). Not for source code.", toolSchemas.create_creation.shape, async (args) => runTool(authCtx, (c) => c.post("/api/v1/creations", {
+        project_id: args.project_id,
+        title: args.title,
+        content: args.content,
+        status: args.status ?? "saved",
+    })));
+    server.tool("update_creation", "Update a creation (PATCH /api/v1/creations/{id}). Do not PATCH finalized rows.", toolSchemas.update_creation.shape, async (args) => runTool(authCtx, (c) => c.patch(`/api/v1/creations/${encodeURIComponent(args.id)}`, {
+        ...(args.title !== undefined ? { title: args.title } : {}),
+        ...(args.content !== undefined ? { content: args.content } : {}),
+        ...(args.status !== undefined ? { status: args.status } : {}),
+    })));
+    server.tool("list_references", "List references for a project (GET /api/v1/references?project_id=...).", toolSchemas.list_references.shape, async (args) => runTool(authCtx, (c) => c.get("/api/v1/references", { project_id: args.project_id })));
+    server.tool("create_reference", "Create a reference on the shelf (POST /api/v1/references). kind=document uploads markdown multipart; url/youtube/text/voice use JSON. Notion is not exposed via MCP.", toolSchemas.create_reference.shape, async (args) => runTool(authCtx, async (c) => {
+        const kind = args.kind ?? "document";
+        if (kind === "document") {
+            if (!args.content?.trim()) {
+                throw new Error("content is required for kind=document (markdown body).");
+            }
+            const name = args.filename?.trim() || `${(args.title || "note").replace(/[^\w.-]+/g, "-")}.md`;
+            return c.postMultipart("/api/v1/references", {
+                fields: { project_id: args.project_id },
+                file: {
+                    fieldName: "file",
+                    filename: name.endsWith(".md") ? name : `${name}.md`,
+                    contentType: "text/markdown",
+                    body: args.content,
+                },
+            });
+        }
+        return c.post("/api/v1/references", {
+            project_id: args.project_id,
+            kind,
+            ...(args.url !== undefined ? { url: args.url } : {}),
+            ...(args.content !== undefined ? { content: args.content } : {}),
+            ...(args.title !== undefined ? { link_title: args.title } : {}),
+        });
+    }));
+    return server;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@gloriginmind/mcp",
+  "version": "0.1.0",
+  "description": "OriginMind MCP server — dual-auth skill routes via Bootstrap OAuth API key",
+  "type": "module",
+  "bin": {
+    "originmind-mcp": "dist/stdio.js",
+    "originmind-mcp-http": "dist/http.js"
+  },
+  "main": "./dist/stdio.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/stdio.js",
+    "start:http": "node dist/http.js",
+    "test": "tsx --test src/**/*.test.ts"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OriginMind-ai/OriginMindAI-skill.git",
+    "directory": "skills/mcp"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.9.3"
+  }
+}