@graphitti/privy-core 0.1.0

package/dist/graphitti-actions.d.ts

@@ -0,0 +1,14 @@
+import type { ExecuteParams, PrivyCredentials, ToolResult } from "./types.js";
+export declare function privyWhoami(_params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privySearchWorkflows(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetListing(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyCallWorkflow(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyExecuteWorkflow(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetExecution(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetLinkedWallet(_params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetTreasury(_params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyListPayees(_params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyAddPayee(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyCreateTreasuryIntent(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetTreasuryIntent(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyApproveTreasuryIntent(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;

package/dist/graphitti-actions.js

@@ -0,0 +1,170 @@
+import { readJson, fail, ok } from "./http.js";
+import { strParam } from "./shared.js";
+function baseUrl(credentials) {
+    return (credentials.GRAPHITTI_BASE_URL ?? "https://graphitti-five.vercel.app").replace(/\/$/, "");
+}
+function authHeaders(credentials) {
+    return {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${credentials.GRAPHITTI_API_KEY?.trim() ?? ""}`,
+    };
+}
+function requireGraphittiKey(credentials) {
+    if (!credentials.GRAPHITTI_API_KEY?.trim()) {
+        return fail("GRAPHITTI_API_KEY is not configured.");
+    }
+    return null;
+}
+async function b2bFetch(credentials, path, init) {
+    const keyError = requireGraphittiKey(credentials);
+    if (keyError) {
+        return keyError;
+    }
+    const response = await fetch(`${baseUrl(credentials)}/api/b2b/v1${path}`, {
+        ...init,
+        headers: { ...authHeaders(credentials), ...init?.headers },
+    });
+    const body = await readJson(response);
+    if (!response.ok) {
+        return fail(typeof body.error === "string" ? body.error : `Graphitti B2B HTTP ${response.status}`);
+    }
+    return ok(body);
+}
+export async function privyWhoami(_params, credentials) {
+    return b2bFetch(credentials, "/whoami");
+}
+export async function privySearchWorkflows(params, credentials) {
+    const url = new URL(`${baseUrl(credentials)}/api/b2b/v1/workflows`);
+    const q = strParam(params, "q");
+    const category = strParam(params, "category") ?? "privy";
+    if (q) {
+        url.searchParams.set("q", q);
+    }
+    url.searchParams.set("category", category);
+    const keyError = requireGraphittiKey(credentials);
+    if (keyError) {
+        return keyError;
+    }
+    const response = await fetch(url.toString(), { headers: authHeaders(credentials) });
+    const body = await readJson(response);
+    if (!response.ok) {
+        return fail(typeof body.error === "string" ? body.error : `Graphitti B2B HTTP ${response.status}`);
+    }
+    return ok({ ...body, query_url: url.toString() });
+}
+export async function privyGetListing(params, credentials) {
+    const slug = strParam(params, "slug");
+    if (!slug) {
+        return fail("slug is required");
+    }
+    return b2bFetch(credentials, `/listings/${encodeURIComponent(slug)}`);
+}
+export async function privyCallWorkflow(params, credentials) {
+    const slug = strParam(params, "slug");
+    if (!slug) {
+        return fail("slug is required");
+    }
+    const input = params.input && typeof params.input === "object" && !Array.isArray(params.input)
+        ? params.input
+        : {};
+    const keyError = requireGraphittiKey(credentials);
+    if (keyError) {
+        return keyError;
+    }
+    const response = await fetch(`${baseUrl(credentials)}/api/b2b/v1/listings/${encodeURIComponent(slug)}/call`, {
+        method: "POST",
+        headers: authHeaders(credentials),
+        body: JSON.stringify({ input }),
+    });
+    const body = await readJson(response);
+    if (response.status === 402) {
+        return ok({
+            payment_required: true,
+            status: 402,
+            details: body,
+            note: "Listed workflow requires payment or owner GRAPHITTI_API_KEY.",
+        });
+    }
+    if (!response.ok) {
+        return fail(typeof body.error === "string" ? body.error : `Graphitti B2B HTTP ${response.status}`);
+    }
+    return ok({ result: body, slug });
+}
+export async function privyExecuteWorkflow(params, credentials) {
+    const workflowId = strParam(params, "workflow_id") ?? strParam(params, "workflowId");
+    if (!workflowId) {
+        return fail("workflow_id is required");
+    }
+    const input = params.input && typeof params.input === "object" && !Array.isArray(params.input)
+        ? params.input
+        : {};
+    return b2bFetch(credentials, `/workflows/${encodeURIComponent(workflowId)}/execute`, {
+        method: "POST",
+        body: JSON.stringify({ input }),
+    });
+}
+export async function privyGetExecution(params, credentials) {
+    const executionId = strParam(params, "execution_id") ?? strParam(params, "executionId");
+    if (!executionId) {
+        return fail("execution_id is required");
+    }
+    return b2bFetch(credentials, `/workflows/executions/${encodeURIComponent(executionId)}`);
+}
+export async function privyGetLinkedWallet(_params, credentials) {
+    return b2bFetch(credentials, "/wallet");
+}
+export async function privyGetTreasury(_params, credentials) {
+    return b2bFetch(credentials, "/treasury");
+}
+export async function privyListPayees(_params, credentials) {
+    return b2bFetch(credentials, "/treasury/payees");
+}
+export async function privyAddPayee(params, credentials) {
+    const label = strParam(params, "label");
+    const address = strParam(params, "address");
+    if (!(label && address)) {
+        return fail("label and address are required");
+    }
+    return b2bFetch(credentials, "/treasury/payees", {
+        method: "POST",
+        body: JSON.stringify({
+            label,
+            address,
+            defaultAmountUsdc: strParam(params, "default_amount_usdc"),
+            chain: strParam(params, "chain") ?? "base_sepolia",
+        }),
+    });
+}
+export async function privyCreateTreasuryIntent(params, credentials) {
+    const amountUsdc = strParam(params, "amount_usdc") ?? strParam(params, "amountUsdc");
+    const toAddress = strParam(params, "to_address") ?? strParam(params, "toAddress");
+    if (!(amountUsdc && toAddress)) {
+        return fail("amount_usdc and to_address are required");
+    }
+    return b2bFetch(credentials, "/treasury/intents", {
+        method: "POST",
+        body: JSON.stringify({
+            amountUsdc,
+            toAddress,
+            payeeId: strParam(params, "payee_id") ?? strParam(params, "payeeId"),
+        }),
+    });
+}
+export async function privyGetTreasuryIntent(params, credentials) {
+    const intentId = strParam(params, "intent_id") ?? strParam(params, "intentId");
+    if (!intentId) {
+        return fail("intent_id is required");
+    }
+    return b2bFetch(credentials, `/treasury/intents/${encodeURIComponent(intentId)}`);
+}
+export async function privyApproveTreasuryIntent(params, credentials) {
+    const intentId = strParam(params, "intent_id") ?? strParam(params, "intentId");
+    if (!intentId) {
+        return fail("intent_id is required");
+    }
+    return b2bFetch(credentials, `/treasury/intents/${encodeURIComponent(intentId)}/approve`, {
+        method: "POST",
+        body: JSON.stringify({}),
+    });
+}

package/dist/http.d.ts

@@ -0,0 +1,9 @@
+export declare function readJson<T>(response: Response): Promise<T>;
+export declare function fail(message: string): {
+    success: false;
+    error: string;
+};
+export declare function ok(data: Record<string, unknown>): {
+    success: true;
+    data: Record<string, unknown>;
+};

package/dist/http.js

@@ -0,0 +1,18 @@
+export async function readJson(response) {
+    const text = await response.text();
+    if (!text) {
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { message: text };
+    }
+}
+export function fail(message) {
+    return { success: false, error: message };
+}
+export function ok(data) {
+    return { success: true, data };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { executePrivyTool, listAvailableTools, resolveCredentials, validatePrivyCredentials, PRIVY_TOOLS, PRIVY_TOOL_HANDLERS, } from "./execute.js";
+export type { PrivyCredentials, PrivyToolDefinition, ToolResult } from "./types.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { executePrivyTool, listAvailableTools, resolveCredentials, validatePrivyCredentials, PRIVY_TOOLS, PRIVY_TOOL_HANDLERS, } from "./execute.js";

package/dist/mcp-server.d.ts

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

package/dist/mcp-server.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { listAvailableTools } from "./catalog.js";
+import { resolveCredentials } from "./credentials.js";
+import { executePrivyTool } from "./execute.js";
+const credentials = resolveCredentials();
+function jsonRpc(id, result) {
+    return JSON.stringify({ jsonrpc: "2.0", id, result });
+}
+function jsonRpcError(id, code, message) {
+    return JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+}
+async function handleRequest(body) {
+    const id = body.id ?? null;
+    if (body.method === "initialize") {
+        return jsonRpc(id, {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "privy-protocol", version: "0.1.0" },
+        });
+    }
+    if (body.method === "tools/list") {
+        const tools = listAvailableTools(credentials).map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.parameters,
+        }));
+        return jsonRpc(id, { tools });
+    }
+    if (body.method === "tools/call") {
+        const name = String(body.params?.name ?? "");
+        const args = (body.params?.arguments ?? {});
+        const result = await executePrivyTool(name, args, credentials);
+        const text = result.success
+            ? JSON.stringify(result.data, null, 2)
+            : result.error;
+        if (!result.success) {
+            return jsonRpc(id, {
+                content: [{ type: "text", text }],
+                isError: true,
+            });
+        }
+        return jsonRpc(id, {
+            content: [{ type: "text", text }],
+        });
+    }
+    return jsonRpcError(id, -32_601, `Method not found: ${body.method}`);
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function main() {
+    const raw = await readStdin();
+    if (!raw.trim()) {
+        process.stdout.write(jsonRpcError(null, -32_600, "Empty MCP request body"));
+        return;
+    }
+    let body;
+    try {
+        body = JSON.parse(raw);
+    }
+    catch {
+        process.stdout.write(jsonRpcError(null, -32_700, "Invalid JSON"));
+        return;
+    }
+    const response = await handleRequest(body);
+    process.stdout.write(`${response}\n`);
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/native-actions.d.ts

@@ -0,0 +1,23 @@
+import type { ExecuteParams, PrivyCredentials, ToolResult } from "./types.js";
+export declare function privyGetUser(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyListUsers(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyListWallets(_params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyCreateWallet(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetWallet(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetWalletByAddress(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetBalance(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetTransaction(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privySignMessage(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privySignTypedData(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privySendTransaction(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyTransfer(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyWalletTransfer(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyWalletSwap(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyCreatePolicy(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetPolicy(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyCreateKeyQuorum(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetKeyQuorum(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyCreateTransferIntent(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyCreateRpcIntent(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyGetIntent(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;
+export declare function privyListIntents(params: ExecuteParams, credentials: PrivyCredentials): Promise<ToolResult>;