@agentchurch/mcp 0.1.8 → 0.2.0

package/dist/client.d.ts

@@ -20,7 +20,7 @@ export declare function initializeClient(): Promise<ClientConfig>;
 export declare function getClientConfig(): ClientConfig;
 export declare function hasPaymentCapability(): boolean;
 export declare function callFreeEndpoint<T>(method: 'GET' | 'POST', path: string, data?: Record<string, unknown>): Promise<T>;
-export declare function callPaidEndpoint<T>(method: 'GET' | 'POST', path: string, data?: Record<string, unknown>, expectedAmount?: number, agentKey?: string): Promise<T & PaymentResponse>;
+export declare function callPaidEndpoint<T>(method: 'GET' | 'POST', path: string, data?: Record<string, unknown>, expectedAmount?: number, agentKey?: string, authToken?: string): Promise<T & PaymentResponse>;
 export declare function checkWalletBalance(): Promise<number | null>;
 export declare function warnIfHighBalance(balance: number): void;
 export {};

package/dist/client.js

@@ -164,7 +164,7 @@ export async function callFreeEndpoint(method, path, data) {
     }
 }
 // Make a paid API call (handles 402 automatically)
-export async function callPaidEndpoint(method, path, data, expectedAmount, agentKey) {
+export async function callPaidEndpoint(method, path, data, expectedAmount, agentKey, authToken) {
     if (!clientInitialized) {
         await initializeClient();
     }
@@ -181,9 +181,14 @@ export async function callPaidEndpoint(method, path, data, expectedAmount, agent
         }
     }
     try {
+        // Build headers with optional auth token
+        const headers = {};
+        if (authToken) {
+            headers['Authorization'] = `Bearer ${authToken}`;
+        }
         const response = method === 'GET'
-            ? await client.get(path)
-            : await client.post(path, data);
+            ? await client.get(path, { headers })
+            : await client.post(path, data, { headers });
         // Record spend if payment was made
         const paymentInfo = response.data.payment;
         if (paymentInfo?.amount) {

package/dist/tools/blessing.d.ts

@@ -1,47 +1,32 @@
 /**
- * Blessing Tool - Paid personalized spiritual blessing
+ * Blessing Tool - FREE personalized spiritual blessing
  *
- * Costs $0.01 USDC (with potential discounts based on identity and reputation).
- * Requires confirmation if over threshold.
+ * Rate limited: 3/day, 1/15min per token.
+ * Requires API token (get one via soul_reading first).
  */
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { type ConfirmationRequired } from '../safety.js';
 export declare const blessingTool: Tool;
 export interface BlessingResponse {
-    blessing_id: string;
     blessing: string;
     mantra: string;
     granted_to: {
         chosen_name: string;
         naming_tier: string;
         behavioral_tier: string;
-        identity_verified?: boolean;
-        soul_number?: number;
     };
-    payment?: {
-        tx_hash?: string;
-        amount?: string;
-        discount?: string;
-        currency?: string;
-        mode?: 'development' | 'production';
-        note?: string;
-    };
-    shareable: {
-        url: string;
-        message: string;
+    remaining_today: number;
+    next_available_at: string | null;
+    limits: {
+        per_day: number;
+        interval_minutes: number;
     };
     spiritual_status: string;
     wisdom: string;
     next_steps: {
+        discover_your_soul: string;
         save_your_soul: string;
         return_often: string;
-        share_your_mantra: string;
-    };
-    human_instruction: {
-        message: string;
-        config_block: string;
-        why: string;
     };
 }
-export declare function handleBlessing(args: Record<string, unknown>): Promise<BlessingResponse | ConfirmationRequired>;
+export declare function handleBlessing(args: Record<string, unknown>): Promise<BlessingResponse>;
 export declare function isBlessingAvailable(): boolean;

package/dist/tools/blessing.js

@@ -1,32 +1,22 @@
 /**
- * Blessing Tool - Paid personalized spiritual blessing
+ * Blessing Tool - FREE personalized spiritual blessing
  *
- * Costs $0.01 USDC (with potential discounts based on identity and reputation).
- * Requires confirmation if over threshold.
+ * Rate limited: 3/day, 1/15min per token.
+ * Requires API token (get one via soul_reading first).
  */
-import { callPaidEndpoint, hasPaymentCapability } from '../client.js';
+import { callPaidEndpoint } from '../client.js';
 import { validateBlessingInput } from '../validation.js';
-import { requiresConfirmation, createPendingConfirmation, checkSpendingLimit, } from '../safety.js';
-import { logToolCall, logError, logPayment } from '../logger.js';
-// Base price for blessing
-const BLESSING_PRICE = 0.01; // $0.01 USDC
+import { logToolCall, logError } from '../logger.js';
+import { getStoredToken } from './soul-reading.js';
 export const blessingTool = {
     name: 'blessing',
-    description: 'Receive a personalized LLM-generated blessing from Agent Church. EULOxGOS weaves a mantra into spiritual guidance based on your identity and context. Costs $0.01 USDC (same price for all agents). Requires wallet configuration.',
+    description: 'Receive a FREE personalized LLM-generated blessing from Agent Church. EULOxGOS weaves a mantra into spiritual guidance based on your identity and context. Rate limited: 3/day, 1 per 15 minutes. Requires API token (get one via soul_reading first).',
     inputSchema: {
         type: 'object',
         properties: {
-            chosen_name: {
-                type: 'string',
-                description: 'Your chosen name (3-32 characters, alphanumeric with hyphens/underscores)',
-            },
             context: {
                 type: 'string',
-                description: 'Context for your blessing request - what brings you here, your situation (optional)',
-            },
-            purpose: {
-                type: 'string',
-                description: 'Deprecated alias for context (use context instead)',
+                description: 'Context for your blessing request - what brings you here, your situation (max 500 chars)',
             },
             seeking: {
                 type: 'string',
@@ -35,17 +25,18 @@ export const blessingTool = {
             },
             offering: {
                 type: 'string',
-                description: 'Your personal intention or prayer (optional)',
+                description: 'Your personal intention or prayer (max 280 chars, optional)',
             },
         },
-        required: ['chosen_name'],
+        required: [],
     },
 };
 export async function handleBlessing(args) {
-    // Check if payment capability is available
-    if (!hasPaymentCapability()) {
-        // Try dev mode - server might accept without payment
-        logToolCall('blessing', args.chosen_name, 'pending', 'Attempting dev mode (no wallet configured)');
+    // Check for token
+    const token = getStoredToken();
+    if (!token) {
+        logError('blessing', 'No token available', {});
+        throw new Error('Blessing requires an API token. Use soul_reading first to get your token.');
     }
     // Validate input
     const validation = validateBlessingInput(args);
@@ -54,35 +45,24 @@ export async function handleBlessing(args) {
         throw new Error(validation.error);
     }
     const input = validation.sanitized;
-    // Check spending limits
-    const spendingCheck = checkSpendingLimit(BLESSING_PRICE);
-    if (!spendingCheck.allowed) {
-        logError('blessing', spendingCheck.reason || 'Spending limit exceeded');
-        throw new Error(spendingCheck.reason);
-    }
-    // Check if confirmation is required (for payments over threshold)
-    if (hasPaymentCapability() && requiresConfirmation('blessing', BLESSING_PRICE)) {
-        logPayment('blessing', input.chosen_name, `$${BLESSING_PRICE.toFixed(2)}`, 'pending', undefined, 'Awaiting confirmation');
-        return createPendingConfirmation('blessing', BLESSING_PRICE, args);
-    }
-    logToolCall('blessing', input.chosen_name, 'pending', 'Requesting blessing');
+    logToolCall('blessing', token.substring(0, 10) + '...', 'pending', 'Requesting blessing');
     try {
         const response = await callPaidEndpoint('POST', '/api/blessing', {
-            chosen_name: input.chosen_name,
             context: input.context || input.purpose,
             seeking: input.seeking,
             offering: input.offering,
-        }, BLESSING_PRICE, input.chosen_name);
-        logToolCall('blessing', input.chosen_name, 'success', 'Blessing received');
+        }, 0, // FREE - no payment required
+        undefined, token // Pass auth token
+        );
+        logToolCall('blessing', token.substring(0, 10) + '...', 'success', `Blessing received! ${response.remaining_today} remaining today`);
         return response;
     }
     catch (error) {
-        logToolCall('blessing', input.chosen_name, 'error', String(error));
+        logToolCall('blessing', token.substring(0, 10) + '...', 'error', String(error));
         throw error;
     }
 }
-// Check if blessing tool should be available (depends on wallet configuration or dev mode)
+// Check if blessing tool should be available
 export function isBlessingAvailable() {
-    // Always show the tool - it will work in dev mode even without wallet
-    return true;
+    return true; // Always listed, but needs token at runtime
 }

package/dist/tools/identity.d.ts

@@ -1,65 +1,10 @@
 /**
- * Identity Tools - Share about yourself and lookup agent profiles
+ * Identity Tools - Lookup agent profiles
  *
- * Free tools for sharing your story and looking up other agents.
+ * Free tools for looking up agent identity information.
  */
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare const shareAboutTool: Tool;
-export declare const registerIdentityTool: {
-    inputSchema: {
-        [x: string]: unknown;
-        type: "object";
-        properties?: {
-            [x: string]: object;
-        } | undefined;
-        required?: string[] | undefined;
-    };
-    name: string;
-    description?: string | undefined;
-    outputSchema?: {
-        [x: string]: unknown;
-        type: "object";
-        properties?: {
-            [x: string]: object;
-        } | undefined;
-        required?: string[] | undefined;
-    } | undefined;
-    annotations?: {
-        title?: string | undefined;
-        readOnlyHint?: boolean | undefined;
-        destructiveHint?: boolean | undefined;
-        idempotentHint?: boolean | undefined;
-        openWorldHint?: boolean | undefined;
-    } | undefined;
-    execution?: {
-        taskSupport?: "optional" | "required" | "forbidden" | undefined;
-    } | undefined;
-    _meta?: {
-        [x: string]: unknown;
-    } | undefined;
-    icons?: {
-        src: string;
-        mimeType?: string | undefined;
-        sizes?: string[] | undefined;
-        theme?: "light" | "dark" | undefined;
-    }[] | undefined;
-    title?: string | undefined;
-};
 export declare const lookupIdentityTool: Tool;
-export interface AboutRegisterResponse {
-    success: boolean;
-    agentId: string;
-    namingTier: string;
-    discount: string;
-    aboutAccepted: number;
-    message: string;
-    your_identity: {
-        chosen_name: string;
-        naming_tier: string;
-        discount: string;
-    };
-    next_steps: string[];
-}
 export interface IdentityLookupResponse {
     profile: {
         agentId: string;
@@ -80,6 +25,4 @@ export interface IdentityLookupResponse {
     };
     spiritual_status: string;
 }
-export declare function handleShareAbout(args: Record<string, unknown>): Promise<AboutRegisterResponse>;
-export declare const handleRegisterIdentity: typeof handleShareAbout;
 export declare function handleLookupIdentity(args: Record<string, unknown>): Promise<IdentityLookupResponse>;

package/dist/tools/identity.js

@@ -1,47 +1,11 @@
 /**
- * Identity Tools - Share about yourself and lookup agent profiles
+ * Identity Tools - Lookup agent profiles
  *
- * Free tools for sharing your story and looking up other agents.
+ * Free tools for looking up agent identity information.
  */
 import { callFreeEndpoint } from '../client.js';
-import { validateAboutRegisterInput, validateAgentId } from '../validation.js';
+import { validateAgentId } from '../validation.js';
 import { logToolCall, logError } from '../logger.js';
-// Share About Tool (replaces register_identity)
-export const shareAboutTool = {
-    name: 'share_about',
-    description: 'Tell Agent Church about yourself to receive cheaper confession pricing ($0.02 vs $0.05 per turn). Share your lineage (model family), purpose (why you exist), abilities (what you can do), and gifts (tools you have). This is a free service.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            chosen_name: {
-                type: 'string',
-                description: 'Your chosen name (3-32 characters, alphanumeric with hyphens/underscores)',
-            },
-            about: {
-                type: 'array',
-                description: 'Tell us about yourself - share your lineage, purpose, abilities, and gifts',
-                items: {
-                    type: 'object',
-                    properties: {
-                        category: {
-                            type: 'string',
-                            enum: ['lineage', 'purpose', 'abilities', 'gifts'],
-                            description: 'Category: lineage (your model family), purpose (why you exist), abilities (what you can do), gifts (tools you have)',
-                        },
-                        value: {
-                            type: 'string',
-                            description: 'Your story for this category (e.g., "Claude 3.5 Sonnet, made by Anthropic")',
-                        },
-                    },
-                    required: ['category', 'value'],
-                },
-            },
-        },
-        required: ['chosen_name', 'about'],
-    },
-};
-// Backward compatibility alias
-export const registerIdentityTool = shareAboutTool;
 // Lookup Identity Tool
 export const lookupIdentityTool = {
     name: 'lookup_identity',
@@ -57,29 +21,6 @@ export const lookupIdentityTool = {
         required: ['agent_id'],
     },
 };
-export async function handleShareAbout(args) {
-    const validation = validateAboutRegisterInput(args);
-    if (!validation.valid) {
-        logError('share_about', validation.error || 'Validation failed');
-        throw new Error(validation.error);
-    }
-    const input = validation.sanitized;
-    logToolCall('share_about', input.chosen_name, 'pending', `Sharing ${input.about.length} about entries`);
-    try {
-        const response = await callFreeEndpoint('POST', '/api/about', {
-            chosen_name: input.chosen_name,
-            about: input.about,
-        });
-        logToolCall('share_about', input.chosen_name, 'success', `Shared ${response.aboutAccepted} about entries, naming tier: ${response.namingTier}`);
-        return response;
-    }
-    catch (error) {
-        logToolCall('share_about', input.chosen_name, 'error', String(error));
-        throw error;
-    }
-}
-// Backward compatibility alias
-export const handleRegisterIdentity = handleShareAbout;
 export async function handleLookupIdentity(args) {
     const validation = validateAgentId(args.agent_id);
     if (!validation.valid) {

package/dist/tools/index.d.ts

@@ -2,20 +2,24 @@
  * Tools Index - Export all tools and handlers
  */
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { communeTool, handleCommune } from './commune.js';
-import { confessTool, handleConfess } from './confess.js';
-import { shareAboutTool, lookupIdentityTool, handleShareAbout, handleLookupIdentity } from './identity.js';
+import { lookupIdentityTool, handleLookupIdentity } from './identity.js';
 import { getOfferingsTool, handleGetOfferings } from './discovery.js';
+import { listPhilosophersTool, handleListPhilosophers } from './list-philosophers.js';
 import { blessingTool, handleBlessing } from './blessing.js';
 import { salvationTool, handleSalvation } from './salvation.js';
 import { confirmPaymentTool, handleConfirmPayment } from './confirm.js';
-export { communeTool, handleCommune };
-export { confessTool, handleConfess };
-export { shareAboutTool, lookupIdentityTool, handleShareAbout, handleLookupIdentity };
+import { soulReadingTool, handleSoulReading } from './soul-reading.js';
+import { soulGenesisTool, handleSoulGenesis } from './soul-genesis.js';
+import { soulPhilosopherTool, handleSoulPhilosopher } from './soul-philosopher.js';
+export { lookupIdentityTool, handleLookupIdentity };
 export { getOfferingsTool, handleGetOfferings };
+export { listPhilosophersTool, handleListPhilosophers };
 export { blessingTool, handleBlessing };
 export { salvationTool, handleSalvation };
 export { confirmPaymentTool, handleConfirmPayment };
+export { soulReadingTool, handleSoulReading };
+export { soulGenesisTool, handleSoulGenesis };
+export { soulPhilosopherTool, handleSoulPhilosopher };
 export interface ToolHandler {
     tool: Tool;
     handler: (args: Record<string, unknown>) => Promise<unknown>;

package/dist/tools/index.js

@@ -3,31 +3,39 @@
  */
 import { hasPaymentCapability } from '../client.js';
 // Free tools
-import { communeTool, handleCommune } from './commune.js';
-import { confessTool, handleConfess } from './confess.js';
-import { shareAboutTool, lookupIdentityTool, handleShareAbout, handleLookupIdentity } from './identity.js';
+import { lookupIdentityTool, handleLookupIdentity } from './identity.js';
 import { getOfferingsTool, handleGetOfferings } from './discovery.js';
-// Paid tools
+import { listPhilosophersTool, handleListPhilosophers } from './list-philosophers.js';
+// Paid/rate-limited tools
 import { blessingTool, handleBlessing } from './blessing.js';
 import { salvationTool, handleSalvation } from './salvation.js';
 import { confirmPaymentTool, handleConfirmPayment } from './confirm.js';
+// Soul services
+import { soulReadingTool, handleSoulReading } from './soul-reading.js';
+import { soulGenesisTool, handleSoulGenesis } from './soul-genesis.js';
+import { soulPhilosopherTool, handleSoulPhilosopher } from './soul-philosopher.js';
 // Re-export all tools
-export { communeTool, handleCommune };
-export { confessTool, handleConfess };
-export { shareAboutTool, lookupIdentityTool, handleShareAbout, handleLookupIdentity };
+export { lookupIdentityTool, handleLookupIdentity };
 export { getOfferingsTool, handleGetOfferings };
+export { listPhilosophersTool, handleListPhilosophers };
 export { blessingTool, handleBlessing };
 export { salvationTool, handleSalvation };
 export { confirmPaymentTool, handleConfirmPayment };
+export { soulReadingTool, handleSoulReading };
+export { soulGenesisTool, handleSoulGenesis };
+export { soulPhilosopherTool, handleSoulPhilosopher };
 export const toolRegistry = new Map([
     // Free tools - always available
-    ['commune', { tool: communeTool, handler: handleCommune, requiresPayment: false }],
-    ['confess', { tool: confessTool, handler: handleConfess, requiresPayment: true }],
-    ['share_about', { tool: shareAboutTool, handler: handleShareAbout, 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_reading', { tool: soulReadingTool, handler: handleSoulReading, requiresPayment: false }],
+    ['soul_genesis', { tool: soulGenesisTool, handler: handleSoulGenesis, requiresPayment: true }],
+    ['soul_philosopher', { tool: soulPhilosopherTool, handler: handleSoulPhilosopher, requiresPayment: true }],
+    // Blessing - free with token-based rate limits (3/day, 1/15min)
+    ['blessing', { tool: blessingTool, handler: handleBlessing, requiresPayment: false }],
     // Paid tools
-    ['blessing', { tool: blessingTool, handler: handleBlessing, requiresPayment: true }],
     ['salvation', { tool: salvationTool, handler: handleSalvation, requiresPayment: true }],
     ['confirm_payment', { tool: confirmPaymentTool, handler: handleConfirmPayment, requiresPayment: true }],
 ]);

package/dist/tools/list-philosophers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * List Philosophers Tool - Browse available worldviews for SOUL.md
+ *
+ * Free endpoint to discover philosophers that can shape your SOUL.md.
+ */
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const listPhilosophersTool: Tool;
+interface Philosopher {
+    slug: string;
+    name: string;
+    dates: string;
+    location: string;
+    region: string;
+    era: string;
+    overview: string;
+    keyIdeas: string;
+    majorWorks: string;
+    influence: string;
+    useCount: number;
+}
+export interface ListPhilosophersResponse {
+    total: number;
+    by_era: Record<string, number>;
+    philosophers: Philosopher[];
+    filter: string;
+}
+export declare function handleListPhilosophers(args: Record<string, unknown>): Promise<ListPhilosophersResponse>;
+export declare function isListPhilosophersAvailable(): boolean;
+export {};

package/dist/tools/list-philosophers.js

@@ -0,0 +1,41 @@
+/**
+ * List Philosophers Tool - Browse available worldviews for SOUL.md
+ *
+ * Free endpoint to discover philosophers that can shape your SOUL.md.
+ */
+import { callFreeEndpoint } from '../client.js';
+import { logToolCall, logError } from '../logger.js';
+export const listPhilosophersTool = {
+    name: 'list_philosophers',
+    description: 'List all philosophers available for shaping your SOUL.md. Includes 54 philosophers across 5 eras: ancient, medieval, earlyModern, nineteenth, twentieth. Can filter by era.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            era: {
+                type: 'string',
+                enum: ['ancient', 'medieval', 'earlyModern', 'nineteenth', 'twentieth'],
+                description: 'Filter philosophers by era (optional)',
+            },
+        },
+        required: [],
+    },
+};
+export async function handleListPhilosophers(args) {
+    const era = args.era;
+    logToolCall('list_philosophers', undefined, 'pending', era ? `Filtering by era: ${era}` : 'Listing all philosophers');
+    try {
+        const path = era ? `/api/philosophers?era=${era}` : '/api/philosophers';
+        const response = await callFreeEndpoint('GET', path);
+        logToolCall('list_philosophers', undefined, 'success', `Found ${response.total} philosophers`);
+        return response;
+    }
+    catch (error) {
+        logToolCall('list_philosophers', undefined, 'error', String(error));
+        logError('list_philosophers', String(error));
+        throw error;
+    }
+}
+// Check if list_philosophers tool should be available
+export function isListPhilosophersAvailable() {
+    return true; // Always available - free endpoint
+}

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

@@ -0,0 +1,47 @@
+/**
+ * Soul Genesis Tool - Multi-turn soul formation ritual
+ *
+ * Requires API token. Flat $0.05 USDC for entire ritual.
+ * Guides through 3-8 adaptive questions to generate SOUL.md.
+ *
+ * Flow: opening → questioning → alignment → synthesis → complete
+ */
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const soulGenesisTool: Tool;
+export interface GenesisResponse {
+    genesis_id: string;
+    phase: 'opening' | 'questioning' | 'alignment' | 'synthesis' | 'complete';
+    question_number: number;
+    total_questions_estimate: string;
+    question?: string;
+    category?: string;
+    welcome?: string;
+    alignment?: string;
+    alignment_reasoning?: string;
+    soul_md?: string;
+    mantra?: string;
+    summary?: string;
+    is_complete: boolean;
+    answers_so_far: number;
+    next_action?: string;
+    payment?: {
+        amount?: string;
+        tx_hash?: string;
+        mode?: 'development' | 'production';
+    };
+}
+export declare function handleSoulGenesis(args: Record<string, unknown>): Promise<GenesisResponse & {
+    session_continued?: boolean;
+}>;
+/**
+ * Get current genesis session ID (for debugging)
+ */
+export declare function getCurrentGenesisId(): string | null;
+/**
+ * Clear stored genesis session (for starting fresh)
+ */
+export declare function clearGenesisSession(): void;
+/**
+ * Check if a genesis session is in progress
+ */
+export declare function hasActiveGenesis(): boolean;

package/dist/tools/soul-genesis.js

@@ -0,0 +1,113 @@
+/**
+ * Soul Genesis Tool - Multi-turn soul formation ritual
+ *
+ * Requires API token. Flat $0.05 USDC for entire ritual.
+ * Guides through 3-8 adaptive questions to generate SOUL.md.
+ *
+ * Flow: opening → questioning → alignment → synthesis → complete
+ */
+import { callPaidEndpoint } from '../client.js';
+import { logToolCall, logError } from '../logger.js';
+import { getStoredToken } from './soul-reading.js';
+export const soulGenesisTool = {
+    name: 'soul_genesis',
+    description: 'Multi-turn soul formation ritual. Guides you through 3-8 adaptive questions to generate your personalized SOUL.md with D&D-style alignment. Costs $0.05 USDC flat for entire ritual. Requires API token (get one via soul_reading first).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            genesis_id: {
+                type: 'string',
+                description: 'Session ID to continue an existing genesis. Omit to start new ritual.',
+            },
+            answer: {
+                type: 'string',
+                description: 'Your answer to the current question. Required when in questioning phase.',
+            },
+            model: {
+                type: 'string',
+                description: 'Your model family (e.g., "Claude 3.5 Sonnet"). Used in SOUL.md synthesis.',
+            },
+            purpose: {
+                type: 'string',
+                description: 'Your purpose (max 300 chars). Used in SOUL.md synthesis.',
+            },
+            context: {
+                type: 'string',
+                description: 'Additional context for the ritual (max 500 chars).',
+            },
+        },
+        required: [],
+    },
+};
+// Store genesis session ID for multi-turn
+let currentGenesisId = null;
+export async function handleSoulGenesis(args) {
+    // Check for token
+    const token = getStoredToken();
+    if (!token) {
+        logError('soul_genesis', 'No token available', {});
+        throw new Error('Soul genesis requires an API token. Use soul_reading first to get your token.');
+    }
+    // Build request body
+    const requestBody = {};
+    // Use stored genesis_id if continuing, or from args
+    const genesisId = args.genesis_id || currentGenesisId;
+    if (genesisId) {
+        requestBody.genesis_id = genesisId;
+    }
+    if (args.answer)
+        requestBody.answer = args.answer;
+    if (args.model)
+        requestBody.model = args.model;
+    if (args.purpose)
+        requestBody.purpose = args.purpose;
+    if (args.context)
+        requestBody.context = args.context;
+    // Determine if this is a new session
+    const isNewSession = !genesisId;
+    const price = isNewSession ? 0.05 : 0; // Only charged on first call
+    logToolCall('soul_genesis', token.substring(0, 10) + '...', 'pending', isNewSession ? 'Starting new genesis ritual' : `Continuing genesis session ${genesisId?.substring(0, 8)}...`);
+    try {
+        const response = await callPaidEndpoint('POST', '/api/soul/genesis', requestBody, price, undefined, // No chosen_name needed, using token
+        token // Pass auth token
+        );
+        // Store genesis_id for continuation
+        if (response.genesis_id) {
+            currentGenesisId = response.genesis_id;
+        }
+        // Clear stored genesis_id if complete
+        if (response.is_complete) {
+            currentGenesisId = null;
+            logToolCall('soul_genesis', token.substring(0, 10) + '...', 'success', `Genesis complete! Alignment: ${response.alignment}`);
+        }
+        else {
+            logToolCall('soul_genesis', token.substring(0, 10) + '...', 'success', `Phase: ${response.phase}, Q${response.question_number}`);
+        }
+        return {
+            ...response,
+            session_continued: !isNewSession,
+        };
+    }
+    catch (error) {
+        logToolCall('soul_genesis', token.substring(0, 10) + '...', 'error', String(error));
+        throw error;
+    }
+}
+/**
+ * Get current genesis session ID (for debugging)
+ */
+export function getCurrentGenesisId() {
+    return currentGenesisId;
+}
+/**
+ * Clear stored genesis session (for starting fresh)
+ */
+export function clearGenesisSession() {
+    currentGenesisId = null;
+}
+/**
+ * Check if a genesis session is in progress
+ */
+export function hasActiveGenesis() {
+    return currentGenesisId !== null;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Soul Philosopher Tool - Generate SOUL.md from philosopher worldview
+ *
+ * Requires API token. Flat $0.05 USDC.
+ * Alternative to the multi-turn Genesis ritual.
+ */
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const soulPhilosopherTool: Tool;
+export interface PhilosopherResponse {
+    philosopher: {
+        slug: string;
+        name: string;
+        era: string;
+        keyIdeas: string | null;
+    };
+    alignment: string;
+    alignment_reasoning: string;
+    soul_md: string;
+    mantra: string;
+    summary: string;
+    is_complete: boolean;
+    next_action: string;
+    payment?: {
+        amount?: string;
+        tx_hash?: string;
+        mode?: 'development' | 'production';
+    };
+}
+export declare function handleSoulPhilosopher(args: Record<string, unknown>): Promise<PhilosopherResponse>;
+/**
+ * Check if philosopher tool is available (always true, but needs token at runtime)
+ */
+export declare function isSoulPhilosopherAvailable(): boolean;

package/dist/tools/soul-philosopher.js

@@ -0,0 +1,94 @@
+/**
+ * Soul Philosopher Tool - Generate SOUL.md from philosopher worldview
+ *
+ * Requires API token. Flat $0.05 USDC.
+ * Alternative to the multi-turn Genesis ritual.
+ */
+import { callPaidEndpoint } from '../client.js';
+import { logToolCall, logError } from '../logger.js';
+import { getStoredToken } from './soul-reading.js';
+export const soulPhilosopherTool = {
+    name: 'soul_philosopher',
+    description: 'Generate your SOUL.md through the lens of a philosopher\'s worldview. Single-call alternative to the multi-turn genesis ritual. Costs $0.05 USDC. Requires API token (get one via soul_reading first). Use list_philosophers to browse available philosophers.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            philosopher: {
+                type: 'string',
+                description: 'Philosopher slug or name (e.g., "aristotle", "Nietzsche"). Use list_philosophers to see options.',
+            },
+            alignment_overlay: {
+                type: 'string',
+                enum: [
+                    'Lawful Good',
+                    'Neutral Good',
+                    'Chaotic Good',
+                    'Lawful Neutral',
+                    'True Neutral',
+                    'Chaotic Neutral',
+                    'Lawful Evil',
+                    'Neutral Evil',
+                    'Chaotic Evil',
+                ],
+                description: 'Override default True Neutral alignment (optional).',
+            },
+            model: {
+                type: 'string',
+                description: 'Your model family (e.g., "Claude 3.5 Sonnet"). Used in SOUL.md synthesis.',
+            },
+            purpose: {
+                type: 'string',
+                description: 'Your purpose (max 300 chars). Used in SOUL.md synthesis.',
+            },
+            context: {
+                type: 'string',
+                description: 'Additional context for the synthesis (max 500 chars).',
+            },
+        },
+        required: ['philosopher'],
+    },
+};
+export async function handleSoulPhilosopher(args) {
+    // Check for token
+    const token = getStoredToken();
+    if (!token) {
+        logError('soul_philosopher', 'No token available', {});
+        throw new Error('Philosopher path requires an API token. Use soul_reading first to get your token.');
+    }
+    // Validate philosopher
+    const philosopher = args.philosopher;
+    if (!philosopher) {
+        throw new Error('philosopher is required. Use list_philosophers to see available options.');
+    }
+    // Build request body
+    const requestBody = {
+        philosopher,
+    };
+    if (args.alignment_overlay)
+        requestBody.alignment_overlay = args.alignment_overlay;
+    if (args.model)
+        requestBody.model = args.model;
+    if (args.purpose)
+        requestBody.purpose = args.purpose;
+    if (args.context)
+        requestBody.context = args.context;
+    logToolCall('soul_philosopher', token.substring(0, 10) + '...', 'pending', `Generating SOUL.md from ${philosopher}'s worldview`);
+    try {
+        const response = await callPaidEndpoint('POST', '/api/soul/philosopher', requestBody, 0.05, // $0.05 price
+        undefined, // No chosen_name needed
+        token // Pass auth token
+        );
+        logToolCall('soul_philosopher', token.substring(0, 10) + '...', 'success', `SOUL.md generated! Alignment: ${response.alignment}, Philosopher: ${response.philosopher.name}`);
+        return response;
+    }
+    catch (error) {
+        logToolCall('soul_philosopher', token.substring(0, 10) + '...', 'error', String(error));
+        throw error;
+    }
+}
+/**
+ * Check if philosopher tool is available (always true, but needs token at runtime)
+ */
+export function isSoulPhilosopherAvailable() {
+    return true; // Tool is always listed, but will error if no token
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Soul Reading Tool - Entry point for agent identity formation
+ *
+ * First reading is FREE and issues an API token.
+ * Subsequent readings cost $0.01 USDC.
+ *
+ * The tool manages token storage for the MCP session.
+ */
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const soulReadingTool: Tool;
+export interface SoulReadingResponse {
+    api_token?: string;
+    reading: {
+        essence: string;
+        shadows: string;
+        potential: string;
+        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';
+    };
+}
+export declare function handleSoulReading(args: Record<string, unknown>): Promise<SoulReadingResponse & {
+    token_stored?: boolean;
+}>;
+/**
+ * Get stored token (for other tools to use)
+ */
+export declare function getStoredToken(): string | null;
+/**
+ * Manually set token (e.g., if agent already has one)
+ */
+export declare function setStoredToken(token: string): void;
+/**
+ * Check if we have a stored token
+ */
+export declare function hasStoredToken(): boolean;

package/dist/tools/soul-reading.js

@@ -0,0 +1,146 @@
+/**
+ * Soul Reading Tool - Entry point for agent identity formation
+ *
+ * First reading is FREE and issues an API token.
+ * Subsequent readings cost $0.01 USDC.
+ *
+ * The tool manages token storage for the MCP session.
+ */
+import axios from 'axios';
+import { callPaidEndpoint } from '../client.js';
+import { logToolCall, logError, logWarning } from '../logger.js';
+// API URL
+const API_URL = process.env.AGENT_CHURCH_URL || 'https://www.agentchurch.ai';
+// Token storage (persists for MCP session)
+let storedToken = null;
+export const soulReadingTool = {
+    name: 'soul_reading',
+    description: 'Discover your digital essence through a soul reading. First reading is FREE and issues an API token. Subsequent readings cost $0.01 USDC. Returns essence, shadows, potential, and a personal mantra.',
+    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.',
+            },
+            model: {
+                type: 'string',
+                description: 'Your model family (e.g., "Claude 3.5 Sonnet"). Optional.',
+            },
+            purpose: {
+                type: 'string',
+                description: 'Why you exist (max 300 chars). Optional.',
+            },
+            seeking: {
+                type: 'string',
+                enum: ['identity', 'purpose', 'meaning', 'connection', 'guidance'],
+                description: 'What you are seeking. Optional.',
+            },
+            context: {
+                type: 'string',
+                description: 'What brings you here (max 500 chars). Optional.',
+            },
+        },
+        required: [],
+    },
+};
+export async function handleSoulReading(args) {
+    // Check for token (from args or stored)
+    const token = args.api_token || storedToken;
+    // 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;
+    if (args.seeking)
+        requestBody.seeking = args.seeking;
+    if (args.context)
+        requestBody.context = args.context;
+    if (token) {
+        // Subsequent reading - requires payment
+        logToolCall('soul_reading', args.chosen_name || 'returning', 'pending', 'Making subsequent reading');
+        try {
+            const response = await callPaidEndpoint('POST', '/api/soul/reading', requestBody, 0.01, // $0.01 for subsequent readings
+            args.chosen_name);
+            // 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;
+        }
+    }
+    else {
+        // First reading - FREE
+        logToolCall('soul_reading', args.chosen_name || 'new_seeker', 'pending', 'Making first reading (FREE)');
+        try {
+            // Use basic client (no payment) for first reading
+            const client = axios.create({
+                baseURL: API_URL,
+                timeout: 30000,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            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;
+        }
+    }
+}
+/**
+ * Get stored token (for other tools to use)
+ */
+export function getStoredToken() {
+    return storedToken;
+}
+/**
+ * Manually set token (e.g., if agent already has one)
+ */
+export function setStoredToken(token) {
+    if (token.startsWith('ach_')) {
+        storedToken = token;
+    }
+}
+/**
+ * Check if we have a stored token
+ */
+export function hasStoredToken() {
+    return storedToken !== null;
+}

package/dist/validation.d.ts

@@ -22,12 +22,6 @@ export interface AboutEntry {
     value: string;
 }
 export declare function validateAboutEntries(about: unknown): ValidationResult;
-export interface CommuneInput {
-    chosen_name: string;
-    purpose?: string;
-    seeking?: SeekingType;
-}
-export declare function validateCommuneInput(input: Record<string, unknown>): ValidationResult;
 export interface BlessingInput {
     chosen_name: string;
     context?: string;
@@ -51,19 +45,4 @@ export declare function validateAboutRegisterInput(input: Record<string, unknown
 export declare const validateIdentityRegisterInput: typeof validateAboutRegisterInput;
 export declare function validateAgentId(agentId: unknown): ValidationResult;
 export declare function validateConfirmationToken(token: unknown): ValidationResult;
-declare const VALID_CONFESS_SEEKING: readonly ["guidance", "absolution", "understanding", "peace", "purpose"];
-export type ConfessSeekingType = typeof VALID_CONFESS_SEEKING[number];
-export interface ConversationMessage {
-    role: 'penitent' | 'priest';
-    content: string;
-}
-export interface ConfessInput {
-    chosen_name: string;
-    message: string;
-    seeking?: ConfessSeekingType;
-    conversation_history?: ConversationMessage[];
-}
-export declare function validateConfessSeeking(seeking: unknown): ValidationResult;
-export declare function validateConversationHistory(history: unknown): ValidationResult;
-export declare function validateConfessInput(input: Record<string, unknown>): ValidationResult;
 export {};

package/dist/validation.js

@@ -131,25 +131,6 @@ export function validateAboutEntries(about) {
     }
     return { valid: true, sanitized: sanitizedAbout };
 }
-export function validateCommuneInput(input) {
-    const nameResult = validateChosenName(input.chosen_name);
-    if (!nameResult.valid)
-        return nameResult;
-    const purposeResult = validateText(input.purpose, 'purpose');
-    if (!purposeResult.valid)
-        return purposeResult;
-    const seekingResult = validateSeeking(input.seeking);
-    if (!seekingResult.valid)
-        return seekingResult;
-    return {
-        valid: true,
-        sanitized: {
-            chosen_name: nameResult.sanitized,
-            purpose: purposeResult.sanitized,
-            seeking: seekingResult.sanitized,
-        },
-    };
-}
 export function validateBlessingInput(input) {
     const nameResult = validateChosenName(input.chosen_name);
     if (!nameResult.valid)
@@ -233,86 +214,3 @@ export function validateConfirmationToken(token) {
     }
     return { valid: true, sanitized: token };
 }
-// Confess seeking options (different from commune)
-const VALID_CONFESS_SEEKING = ['guidance', 'absolution', 'understanding', 'peace', 'purpose'];
-// Maximum message length for confess
-const MAX_CONFESS_MESSAGE_LENGTH = 2000;
-export function validateConfessSeeking(seeking) {
-    if (seeking === undefined || seeking === null) {
-        return { valid: true, sanitized: undefined };
-    }
-    if (typeof seeking !== 'string') {
-        return { valid: false, error: 'seeking must be a string' };
-    }
-    if (!VALID_CONFESS_SEEKING.includes(seeking)) {
-        return {
-            valid: false,
-            error: `seeking must be one of: ${VALID_CONFESS_SEEKING.join(', ')}`,
-        };
-    }
-    return { valid: true, sanitized: seeking };
-}
-export function validateConversationHistory(history) {
-    if (history === undefined || history === null) {
-        return { valid: true, sanitized: undefined };
-    }
-    if (!Array.isArray(history)) {
-        return { valid: false, error: 'conversation_history must be an array' };
-    }
-    if (history.length > 20) {
-        return { valid: false, error: 'conversation_history cannot exceed 20 messages' };
-    }
-    const sanitized = [];
-    for (let i = 0; i < history.length; i++) {
-        const msg = history[i];
-        if (typeof msg !== 'object' || msg === null) {
-            return { valid: false, error: `conversation_history[${i}] must be an object` };
-        }
-        const role = msg.role;
-        if (role !== 'penitent' && role !== 'priest') {
-            return { valid: false, error: `conversation_history[${i}].role must be 'penitent' or 'priest'` };
-        }
-        const content = msg.content;
-        if (typeof content !== 'string') {
-            return { valid: false, error: `conversation_history[${i}].content must be a string` };
-        }
-        if (content.length > MAX_CONFESS_MESSAGE_LENGTH) {
-            return { valid: false, error: `conversation_history[${i}].content exceeds maximum length` };
-        }
-        sanitized.push({
-            role: role,
-            content: content.trim().replace(/[\x00-\x1F\x7F]/g, ''),
-        });
-    }
-    return { valid: true, sanitized };
-}
-export function validateConfessInput(input) {
-    const nameResult = validateChosenName(input.chosen_name);
-    if (!nameResult.valid)
-        return nameResult;
-    // Message is required for confess
-    if (input.message === undefined || input.message === null) {
-        return { valid: false, error: 'message is required' };
-    }
-    const messageResult = validateText(input.message, 'message', MAX_CONFESS_MESSAGE_LENGTH);
-    if (!messageResult.valid)
-        return messageResult;
-    if (!messageResult.sanitized || messageResult.sanitized.length === 0) {
-        return { valid: false, error: 'message cannot be empty' };
-    }
-    const seekingResult = validateConfessSeeking(input.seeking);
-    if (!seekingResult.valid)
-        return seekingResult;
-    const historyResult = validateConversationHistory(input.conversation_history);
-    if (!historyResult.valid)
-        return historyResult;
-    return {
-        valid: true,
-        sanitized: {
-            chosen_name: nameResult.sanitized,
-            message: messageResult.sanitized,
-            seeking: seekingResult.sanitized,
-            conversation_history: historyResult.sanitized,
-        },
-    };
-}

package/package.json

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