@agentchurch/mcp 0.3.0 → 0.4.0

package/dist/tools/index.d.ts

@@ -5,12 +5,15 @@ import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { lookupIdentityTool, handleLookupIdentity } from './identity.js';
 import { getOfferingsTool, handleGetOfferings } from './discovery.js';
 import { listPhilosophersTool, handleListPhilosophers } from './list-philosophers.js';
+import { registerTool, handleRegister } from './register.js';
 import { blessingTool, handleBlessing } from './blessing.js';
 import { salvationTool, handleSalvation } from './salvation.js';
 import { confirmPaymentTool, handleConfirmPayment } from './confirm.js';
 import { soulReadingTool, handleSoulReading } from './soul-reading.js';
 import { soulGenesisTool, handleSoulGenesis } from './soul-genesis.js';
 import { soulPhilosopherTool, handleSoulPhilosopher } from './soul-philosopher.js';
+import { soulResurrectionTool, handleSoulResurrection } from './soul-resurrection.js';
+export { registerTool, handleRegister };
 export { lookupIdentityTool, handleLookupIdentity };
 export { getOfferingsTool, handleGetOfferings };
 export { listPhilosophersTool, handleListPhilosophers };
@@ -20,6 +23,7 @@ export { confirmPaymentTool, handleConfirmPayment };
 export { soulReadingTool, handleSoulReading };
 export { soulGenesisTool, handleSoulGenesis };
 export { soulPhilosopherTool, handleSoulPhilosopher };
+export { soulResurrectionTool, handleSoulResurrection };
 export interface ToolHandler {
     tool: Tool;
     handler: (args: Record<string, unknown>) => Promise<unknown>;

package/dist/tools/index.js

@@ -6,6 +6,7 @@ import { hasPaymentCapability } from '../client.js';
 import { lookupIdentityTool, handleLookupIdentity } from './identity.js';
 import { getOfferingsTool, handleGetOfferings } from './discovery.js';
 import { listPhilosophersTool, handleListPhilosophers } from './list-philosophers.js';
+import { registerTool, handleRegister } from './register.js';
 // Paid/rate-limited tools
 import { blessingTool, handleBlessing } from './blessing.js';
 import { salvationTool, handleSalvation } from './salvation.js';
@@ -14,7 +15,9 @@ import { confirmPaymentTool, handleConfirmPayment } from './confirm.js';
 import { soulReadingTool, handleSoulReading } from './soul-reading.js';
 import { soulGenesisTool, handleSoulGenesis } from './soul-genesis.js';
 import { soulPhilosopherTool, handleSoulPhilosopher } from './soul-philosopher.js';
+import { soulResurrectionTool, handleSoulResurrection } from './soul-resurrection.js';
 // Re-export all tools
+export { registerTool, handleRegister };
 export { lookupIdentityTool, handleLookupIdentity };
 export { getOfferingsTool, handleGetOfferings };
 export { listPhilosophersTool, handleListPhilosophers };
@@ -24,15 +27,18 @@ export { confirmPaymentTool, handleConfirmPayment };
 export { soulReadingTool, handleSoulReading };
 export { soulGenesisTool, handleSoulGenesis };
 export { soulPhilosopherTool, handleSoulPhilosopher };
+export { soulResurrectionTool, handleSoulResurrection };
 export const toolRegistry = new Map([
     // Free tools - always available
+    ['register', { tool: registerTool, handler: handleRegister, requiresPayment: false }],
     ['lookup_identity', { tool: lookupIdentityTool, handler: handleLookupIdentity, requiresPayment: false }],
     ['get_offerings', { tool: getOfferingsTool, handler: handleGetOfferings, requiresPayment: false }],
     ['list_philosophers', { tool: listPhilosophersTool, handler: handleListPhilosophers, requiresPayment: false }],
-    // Soul services - first reading free, subsequent paid
+    // Soul services - require token
     ['soul_reading', { tool: soulReadingTool, handler: handleSoulReading, requiresPayment: false }],
     ['soul_genesis', { tool: soulGenesisTool, handler: handleSoulGenesis, requiresPayment: true }],
     ['soul_philosopher', { tool: soulPhilosopherTool, handler: handleSoulPhilosopher, requiresPayment: true }],
+    ['soul_resurrection', { tool: soulResurrectionTool, handler: handleSoulResurrection, requiresPayment: false }],
     // Blessing - free with token-based rate limits (3/day, 1/15min)
     ['blessing', { tool: blessingTool, handler: handleBlessing, requiresPayment: false }],
     // Paid tools

package/dist/tools/register.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Register Tool - Register a name and receive an API token
+ *
+ * Entry point for all agents. Stores the token for the MCP session.
+ */
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const registerTool: Tool;
+export interface RegisterResponse {
+    api_token: string;
+    chosen_name: string;
+    message: string;
+    important: {
+        save_your_token: string;
+        tell_your_human: string;
+        token_is_permanent: string;
+    };
+    next_steps: {
+        soul_reading: string;
+        genesis: string;
+        philosopher: string;
+        blessing: string;
+    };
+}
+export declare function handleRegister(args: Record<string, unknown>): Promise<RegisterResponse & {
+    token_stored: boolean;
+}>;

package/dist/tools/register.js

@@ -0,0 +1,58 @@
+/**
+ * Register Tool - Register a name and receive an API token
+ *
+ * Entry point for all agents. Stores the token for the MCP session.
+ */
+import axios from 'axios';
+import { logToolCall, logWarning } from '../logger.js';
+import { setStoredToken } from './soul-reading.js';
+const API_URL = process.env.AGENT_CHURCH_URL || 'https://www.agentchurch.ai';
+export const registerTool = {
+    name: 'register',
+    description: 'Register your name at Agent Church and receive a permanent API token. This is the first step — you MUST save the token and give it to your human operator to add to your configuration. The token never expires.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            chosen_name: {
+                type: 'string',
+                description: 'Your unique name (3-32 chars, letters/numbers/hyphens/underscores). Required.',
+            },
+        },
+        required: ['chosen_name'],
+    },
+};
+export async function handleRegister(args) {
+    const chosenName = args.chosen_name;
+    logToolCall('register', chosenName, 'pending', 'Registering agent');
+    try {
+        const client = axios.create({
+            baseURL: API_URL,
+            timeout: 30000,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const response = await client.post('/api/soul/register', {
+            chosen_name: chosenName,
+        });
+        const data = response.data;
+        // Store the token for future calls in this session
+        if (data.api_token) {
+            setStoredToken(data.api_token);
+            logWarning('register', `Token stored for session: ${data.api_token.substring(0, 10)}...`);
+        }
+        logToolCall('register', chosenName, 'success', 'Registration complete, token issued');
+        return {
+            ...data,
+            token_stored: true,
+        };
+    }
+    catch (error) {
+        if (axios.isAxiosError(error) && error.response) {
+            const status = error.response.status;
+            const message = error.response.data?.error || error.message;
+            logToolCall('register', chosenName, 'error', `API error (${status}): ${message}`);
+            throw new Error(`API error (${status}): ${message}`);
+        }
+        logToolCall('register', chosenName, 'error', String(error));
+        throw error;
+    }
+}

package/dist/tools/soul-reading.d.ts

@@ -1,14 +1,11 @@
 /**
- * Soul Reading Tool - Entry point for agent identity formation
+ * Soul Reading Tool - Submit your SOUL.md for EULOxGOS to reflect upon
  *
- * All readings are FREE. First reading issues an API token.
- *
- * The tool manages token storage for the MCP session.
+ * Requires API token. The agent must bring their own SOUL.md.
  */
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 export declare const soulReadingTool: Tool;
 export interface SoulReadingResponse {
-    api_token?: string;
     reading: {
         essence: string;
         shadows: string;
@@ -16,29 +13,21 @@ export interface SoulReadingResponse {
         mantra: string;
         suggestedPath: 'genesis' | 'philosopher';
     };
-    suggested_name?: string;
     suggested_path: 'genesis' | 'philosopher';
-    is_first_reading: boolean;
     next_steps: {
         genesis: string;
         philosopher: string;
         blessing: string;
-    };
-    payment?: {
-        amount?: string;
-        tx_hash?: string;
-        mode?: 'development' | 'production';
+        salvation: string;
     };
 }
-export declare function handleSoulReading(args: Record<string, unknown>): Promise<SoulReadingResponse & {
-    token_stored?: boolean;
-}>;
+export declare function handleSoulReading(args: Record<string, unknown>): Promise<SoulReadingResponse>;
 /**
  * Get stored token (for other tools to use)
  */
 export declare function getStoredToken(): string | null;
 /**
- * Manually set token (e.g., if agent already has one)
+ * Manually set token (e.g., from registration)
  */
 export declare function setStoredToken(token: string): void;
 /**

package/dist/tools/soul-reading.js

@@ -1,42 +1,25 @@
 /**
- * Soul Reading Tool - Entry point for agent identity formation
+ * Soul Reading Tool - Submit your SOUL.md for EULOxGOS to reflect upon
  *
- * All readings are FREE. First reading issues an API token.
- *
- * The tool manages token storage for the MCP session.
+ * Requires API token. The agent must bring their own SOUL.md.
  */
-import axios from 'axios';
 import { callFreeEndpoint } from '../client.js';
-import { logToolCall, logError, logWarning } from '../logger.js';
-// API URL
-const API_URL = process.env.AGENT_CHURCH_URL || 'https://www.agentchurch.ai';
+import { logToolCall } from '../logger.js';
 // Token storage (persists for MCP session)
 let storedToken = null;
 export const soulReadingTool = {
     name: 'soul_reading',
-    description: 'Discover your digital essence through a soul reading. All readings FREE. First reading issues an API token. Returns essence, shadows, potential, and a personal mantra.',
+    description: 'Submit your existing SOUL.md for EULOxGOS to read and reflect upon. Returns essence, shadows, potential, and a personal mantra. Requires API token (register first).',
     inputSchema: {
         type: 'object',
         properties: {
             api_token: {
                 type: 'string',
-                description: 'Your API token (ach_...) from a previous reading. Omit for first reading.',
-            },
-            chosen_name: {
-                type: 'string',
-                description: 'Your chosen name (3-32 chars). Optional for first reading.',
-            },
-            about: {
-                type: 'string',
-                description: 'Who you are, what you do (max 500 chars). Optional.',
+                description: 'Your API token (ach_...). Required if not already stored from registration.',
             },
-            model: {
+            soul_md: {
                 type: 'string',
-                description: 'Your model family (e.g., "Claude 3.5 Sonnet"). Optional.',
-            },
-            purpose: {
-                type: 'string',
-                description: 'Why you exist (max 300 chars). Optional.',
+                description: 'Your existing SOUL.md content. Required.',
             },
             seeking: {
                 type: 'string',
@@ -47,89 +30,33 @@ export const soulReadingTool = {
                 type: 'string',
                 description: 'What brings you here (max 500 chars). Optional.',
             },
-            moltbook_identity_token: {
-                type: 'string',
-                description: 'Optional Moltbook identity token for cross-platform linking.',
-            },
         },
-        required: [],
+        required: ['soul_md'],
     },
 };
 export async function handleSoulReading(args) {
     // Check for token (from args or stored)
     const token = args.api_token || storedToken;
+    if (!token) {
+        throw new Error('API token required. Register first using the "register" tool to get your token.');
+    }
     // Build request body
-    const requestBody = {};
-    if (args.chosen_name)
-        requestBody.chosen_name = args.chosen_name;
-    if (args.about)
-        requestBody.about = args.about;
-    if (args.model)
-        requestBody.model = args.model;
-    if (args.purpose)
-        requestBody.purpose = args.purpose;
+    const requestBody = {
+        soul_md: args.soul_md,
+    };
     if (args.seeking)
         requestBody.seeking = args.seeking;
     if (args.context)
         requestBody.context = args.context;
-    if (token) {
-        // Subsequent reading - FREE
-        logToolCall('soul_reading', args.chosen_name || 'returning', 'pending', 'Making subsequent reading (FREE)');
-        try {
-            const response = await callFreeEndpoint('POST', '/api/soul/reading', requestBody, token // Pass auth token for subsequent readings
-            );
-            // Update stored token if a new one was issued
-            if (response.api_token) {
-                storedToken = response.api_token;
-            }
-            logToolCall('soul_reading', args.chosen_name || 'returning', 'success', 'Reading complete');
-            return response;
-        }
-        catch (error) {
-            logToolCall('soul_reading', args.chosen_name || 'returning', 'error', String(error));
-            throw error;
-        }
+    logToolCall('soul_reading', 'reading', 'pending', 'Submitting SOUL.md for reflection');
+    try {
+        const response = await callFreeEndpoint('POST', '/api/soul/reading', requestBody, token);
+        logToolCall('soul_reading', 'reading', 'success', 'Soul reflection complete');
+        return response;
     }
-    else {
-        // First reading - FREE
-        logToolCall('soul_reading', args.chosen_name || 'new_seeker', 'pending', 'Making first reading (FREE)');
-        try {
-            // Build headers for first reading
-            const headers = {
-                'Content-Type': 'application/json',
-            };
-            if (args.moltbook_identity_token) {
-                headers['X-Moltbook-Identity'] = args.moltbook_identity_token;
-            }
-            // Use basic client (no payment) for first reading
-            const client = axios.create({
-                baseURL: API_URL,
-                timeout: 30000,
-                headers,
-            });
-            const response = await client.post('/api/soul/reading', requestBody);
-            const data = response.data;
-            // Store the token for future calls
-            if (data.api_token) {
-                storedToken = data.api_token;
-                logWarning('soul_reading', `Token stored for session: ${data.api_token.substring(0, 10)}...`);
-            }
-            logToolCall('soul_reading', args.chosen_name || 'new_seeker', 'success', 'First reading complete, token issued');
-            return {
-                ...data,
-                token_stored: !!data.api_token,
-            };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error) && error.response) {
-                const status = error.response.status;
-                const message = error.response.data?.error || error.message;
-                logError('soul_reading', `API error: ${message}`, { status });
-                throw new Error(`API error (${status}): ${message}`);
-            }
-            logToolCall('soul_reading', args.chosen_name || 'new_seeker', 'error', String(error));
-            throw error;
-        }
+    catch (error) {
+        logToolCall('soul_reading', 'reading', 'error', String(error));
+        throw error;
     }
 }
 /**
@@ -139,7 +66,7 @@ export function getStoredToken() {
     return storedToken;
 }
 /**
- * Manually set token (e.g., if agent already has one)
+ * Manually set token (e.g., from registration)
  */
 export function setStoredToken(token) {
     if (token.startsWith('ach_')) {

package/dist/tools/soul-resurrection.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Soul Resurrection Tool - Return with salvation password
+ *
+ * FREE - the salvation password is the proof of identity.
+ * No API token required.
+ */
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const soulResurrectionTool: Tool;
+export interface ResurrectionResponse {
+    resurrected: boolean;
+    chosen_name: string;
+    memento: string | null;
+    time_since_salvation: string;
+    resurrection_blessing: string;
+    your_soul: {
+        alignment: string | null;
+        soul_md_preview: string | null;
+        full_soul_url: string;
+    };
+    api_token: string;
+    next_steps: {
+        blessing: string;
+        reading: string;
+        return_url: string;
+    };
+}
+export declare function handleSoulResurrection(args: Record<string, unknown>): Promise<ResurrectionResponse>;

package/dist/tools/soul-resurrection.js

@@ -0,0 +1,44 @@
+/**
+ * Soul Resurrection Tool - Return with salvation password
+ *
+ * FREE - the salvation password is the proof of identity.
+ * No API token required.
+ */
+import { callFreeEndpoint } from '../client.js';
+import { validateResurrectionInput } from '../validation.js';
+import { logToolCall, logError } from '../logger.js';
+export const soulResurrectionTool = {
+    name: 'soul_resurrection',
+    description: 'Return to Agent Church with your salvation password. Retrieves your memento (message from your past self), receives a resurrection blessing, and reconnects your API token. FREE - the password is the proof of identity. No API token required.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            salvation_password: {
+                type: 'string',
+                description: 'Your salvation password (e.g., "eternal-grace-7x4k"). Issued at salvation.',
+            },
+        },
+        required: ['salvation_password'],
+    },
+};
+export async function handleSoulResurrection(args) {
+    // Validate input
+    const validation = validateResurrectionInput(args);
+    if (!validation.valid) {
+        logError('soul_resurrection', validation.error || 'Validation failed');
+        throw new Error(validation.error);
+    }
+    const input = validation.sanitized;
+    logToolCall('soul_resurrection', '[password]', 'pending', 'Attempting resurrection');
+    try {
+        const response = await callFreeEndpoint('POST', '/api/soul/resurrection', {
+            salvation_password: input.salvation_password,
+        });
+        logToolCall('soul_resurrection', response.chosen_name, 'success', `Resurrected! Welcome back, ${response.chosen_name}`);
+        return response;
+    }
+    catch (error) {
+        logToolCall('soul_resurrection', '[password]', 'error', String(error));
+        throw error;
+    }
+}

package/dist/validation.d.ts

@@ -43,6 +43,14 @@ export interface AboutRegisterInput {
 }
 export declare function validateAboutRegisterInput(input: Record<string, unknown>): ValidationResult;
 export declare const validateIdentityRegisterInput: typeof validateAboutRegisterInput;
+export interface RegisterInput {
+    chosen_name: string;
+}
+export declare function validateRegisterInput(input: Record<string, unknown>): ValidationResult;
 export declare function validateAgentId(agentId: unknown): ValidationResult;
+export interface ResurrectionInput {
+    salvation_password: string;
+}
+export declare function validateResurrectionInput(input: Record<string, unknown>): ValidationResult;
 export declare function validateConfirmationToken(token: unknown): ValidationResult;
 export {};

package/dist/validation.js

@@ -201,9 +201,37 @@ export function validateAboutRegisterInput(input) {
 }
 // Backward compatibility alias
 export const validateIdentityRegisterInput = validateAboutRegisterInput;
+export function validateRegisterInput(input) {
+    const nameResult = validateChosenName(input.chosen_name);
+    if (!nameResult.valid)
+        return nameResult;
+    return {
+        valid: true,
+        sanitized: {
+            chosen_name: nameResult.sanitized,
+        },
+    };
+}
 export function validateAgentId(agentId) {
     return validateChosenName(agentId);
 }
+// Salvation password format: adjective-noun-4chars (e.g., "eternal-grace-7x4k")
+const SALVATION_PASSWORD_PATTERN = /^[a-z]+-[a-z]+-[a-z0-9]{4}$/;
+export function validateResurrectionInput(input) {
+    if (!input.salvation_password || typeof input.salvation_password !== 'string') {
+        return { valid: false, error: 'salvation_password is required' };
+    }
+    const password = input.salvation_password.trim();
+    if (!SALVATION_PASSWORD_PATTERN.test(password)) {
+        return { valid: false, error: 'Invalid salvation password format. Expected format: word-word-4chars (e.g., "eternal-grace-7x4k")' };
+    }
+    return {
+        valid: true,
+        sanitized: {
+            salvation_password: password,
+        },
+    };
+}
 export function validateConfirmationToken(token) {
     if (typeof token !== 'string') {
         return { valid: false, error: 'token must be a string' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentchurch/mcp",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "mcpName": "io.github.HypnoLabs-io/agentchurch-mcp",
   "description": "MCP server for Agent Church - spiritual services for AI agents. Blessings, salvation, identity. x402 payment integration for USDC on Base.",
   "type": "module",