atproto-mcp 0.4.0 → 0.5.0

package/README.md

@@ -43,8 +43,7 @@ write operations, private data, feeds).
 > public-data mode — no credentials required.
 >
 > **Recent additions**: Batch operations for bulk actions, advanced analytics
-> and insights, intelligent content discovery, and a conversation-context
-> scratchpad resource.
+> and insights, and intelligent content discovery.
 
 ## Architecture
 
@@ -227,10 +226,10 @@ config:
   `get_timeline`)
 - All write operations (create, like, repost, follow, etc.)
 - Resources (timeline, profile, notifications) - these are listed but require
-  authentication to return data (the `conversation-context` scratchpad resource
-  is readable without auth and simply returns near-empty placeholder content)
-- Prompts (content composition, reply templates) - these are listed but require
-  authentication to be available
+  authentication to return data
+
+Prompts (content composition, reply templates) are pure text templates and work
+without authentication.
 
 **Important:** All tools, resources, and prompts are listed by the MCP server
 regardless of authentication state. Most tools and resources that require

package/dist/cli.d.ts

@@ -6,5 +6,12 @@
  * Main CLI function
  */
 declare function main(): Promise<void>;
+/**
+ * Detect whether a module is the process entry point. Node realpath-resolves
+ * import.meta.url for the main module, but argv[1] stays the literal invoked
+ * path — and npm installs bins as symlinks — so a naive string comparison
+ * against `file://${argv[1]}` breaks symlinked, relative, and space-containing
+ * paths. Compare realpath-resolved file URLs instead.
+ */
+export declare function isMainModule(importMetaUrl: string, argv1: string | undefined): boolean;
 export { main as runCli };
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -3,9 +3,9 @@
  * Command-line interface for the AT Protocol MCP Server
  */
 import { parseArgs } from 'node:util';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { ConfigurationError } from './types/index.js';
 import { AtpMcpServer } from './index.js';
 import { LogLevel, Logger } from './utils/logger.js';
@@ -73,7 +73,7 @@ const CLI_OPTIONS = {
     },
     host: {
         type: 'string',
-        short: 'h',
+        short: 'H',
         description: 'Server host (default: localhost)',
     },
     service: {
@@ -93,6 +93,7 @@ const CLI_OPTIONS = {
     },
     help: {
         type: 'boolean',
+        short: 'h',
         description: 'Show help message',
     },
     version: {
@@ -118,11 +119,11 @@ currently have no effect.
 
 Options:
   -p, --port <number>        Server port (reserved; stdio transport ignores it)
-  -h, --host <string>        Server host (reserved; stdio transport ignores it)
+  -H, --host <string>        Server host (reserved; stdio transport ignores it)
   -s, --service <url>        AT Protocol service URL (default: https://bsky.social)
   -a, --auth <method>        Authentication method: app-password|oauth (optional)
   -l, --log-level <level>    Log level: debug|info|warn|error (default: info)
-      --help                 Show this help message
+  -h, --help                 Show this help message
   -v, --version              Show version information
 
 🔓 Unauthenticated Mode (Default):
@@ -311,12 +312,29 @@ async function main() {
         process.exit(1);
     }
 }
+/**
+ * Detect whether a module is the process entry point. Node realpath-resolves
+ * import.meta.url for the main module, but argv[1] stays the literal invoked
+ * path — and npm installs bins as symlinks — so a naive string comparison
+ * against `file://${argv[1]}` breaks symlinked, relative, and space-containing
+ * paths. Compare realpath-resolved file URLs instead.
+ */
+export function isMainModule(importMetaUrl, argv1) {
+    if (argv1 == null || argv1 === '') {
+        return false;
+    }
+    try {
+        return importMetaUrl === pathToFileURL(realpathSync(argv1)).href;
+    }
+    catch {
+        return false;
+    }
+}
 // Run CLI if this file is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (isMainModule(import.meta.url, process.argv[1])) {
     main().catch(error => {
         console.error('Fatal error:', error);
         process.exit(1);
     });
 }
 export { main as runCli };
-//# sourceMappingURL=cli.js.map

package/dist/health-check.d.ts

@@ -11,4 +11,3 @@
  * and reporting them would be misleading.
  */
 export {};
-//# sourceMappingURL=health-check.d.ts.map

package/dist/health-check.js

@@ -10,6 +10,7 @@
  * connection counts of the running server — a fresh process cannot observe those
  * and reporting them would be misleading.
  */
+import { isMainModule } from './cli.js';
 import { AtpMcpServer } from './index.js';
 function healthCheck() {
     try {
@@ -47,7 +48,6 @@ function healthCheck() {
     }
 }
 // Run health check if this script is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (isMainModule(import.meta.url, process.argv[1])) {
     void healthCheck();
 }
-//# sourceMappingURL=health-check.js.map

package/dist/index.d.ts

@@ -131,4 +131,3 @@ export declare class AtpMcpServer {
  *   await server.start();
  */
 export default AtpMcpServer;
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -8,7 +8,7 @@
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { ErrorCode, ListResourceTemplatesRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { ConfigurationError, ValidationError } from './types/index.js';
@@ -21,57 +21,108 @@ import { createPrompts } from './prompts/index.js';
 import { PerformanceMonitor } from './utils/performance.js';
 import { SecurityManager } from './utils/security.js';
 /**
- * Pure read tools (no writes to the network). readOnlyHint:true lets clients
- * auto-approve them. Curated explicitly per tool — NOT derived from auth mode,
- * which encodes auth requirement, not destructiveness.
+ * MCP spec error code for "Resource not found" (resources/read with an unknown
+ * URI). Not part of the SDK's ErrorCode enum, which only covers the generic
+ * JSON-RPC codes.
  */
-const READ_ONLY_TOOLS = new Set([
-    'analyze_account',
-    'analyze_image',
-    'analyze_moderation_status',
-    'discover',
-    'discover_communities',
-    'find_influential_users',
-    'find_similar_users',
-    'generate_link_preview',
-    'get_author_feed',
-    'get_custom_feed',
-    'get_list',
-    'get_notifications',
-    'get_post_context',
-    'get_timeline',
-    'get_user_connections',
-    'get_user_profile',
-    'get_user_summary',
-    'search_actors',
-    'search_posts',
-]);
+const RESOURCE_NOT_FOUND_ERROR_CODE = -32002;
 /**
- * Tools whose effect is irreversible or removes/limits data (deletes, blocks,
- * mutes, reports, removals, token revocation). destructiveHint:true lets clients
- * surface confirmation UI and withhold auto-approval.
+ * Explicit per-tool annotation hints, advertised verbatim in tools/list.
+ *
+ * Per MCP spec defaults, clients assume the worst case for any hint a server
+ * omits on a non-read-only tool (destructiveHint: true, idempotentHint:
+ * false), so every write tool carries both hints explicitly.
+ *
+ * - readOnlyHint: pure reads (no writes to the network). Curated explicitly
+ *   per tool — NOT derived from auth mode, which encodes auth requirement,
+ *   not destructiveness. destructive/idempotent hints are only meaningful for
+ *   write tools and are omitted on read-only entries.
+ * - destructiveHint: the tool may delete or overwrite existing data/state
+ *   (record deletes, list removals, profile overwrites, blocks, irreversible
+ *   moderation reports). Purely additive, reversible writes carry an explicit
+ *   false.
+ * - idempotentHint: repeating the call with identical arguments has no
+ *   additional effect. Claimed only where verified — an implementation-level
+ *   dedup/no-op path, or set/clear semantics of the underlying XRPC endpoint.
  */
-const DESTRUCTIVE_TOOLS = new Set([
-    'block_user',
-    'delete_post',
-    'mute_user',
-    'remove_from_list',
-    'report_content',
-    'report_user',
-    'unfollow_user',
-    'unlike_post',
-    'unrepost',
-]);
+const TOOL_ANNOTATIONS = {
+    // Pure read tools.
+    analyze_account: { readOnlyHint: true },
+    analyze_image: { readOnlyHint: true },
+    analyze_moderation_status: { readOnlyHint: true },
+    discover: { readOnlyHint: true },
+    discover_communities: { readOnlyHint: true },
+    find_influential_users: { readOnlyHint: true },
+    find_similar_users: { readOnlyHint: true },
+    generate_link_preview: { readOnlyHint: true },
+    get_author_feed: { readOnlyHint: true },
+    get_custom_feed: { readOnlyHint: true },
+    get_list: { readOnlyHint: true },
+    get_notifications: { readOnlyHint: true },
+    get_post_context: { readOnlyHint: true },
+    get_timeline: { readOnlyHint: true },
+    get_user_connections: { readOnlyHint: true },
+    get_user_profile: { readOnlyHint: true },
+    get_user_summary: { readOnlyHint: true },
+    search_actors: { readOnlyHint: true },
+    search_posts: { readOnlyHint: true },
+    // Additive, reversible writes. Idempotency notes name the verified
+    // dedup/no-op path in the implementation.
+    // add_to_list has no dedup: duplicate listitem records are possible.
+    add_to_list: { destructiveHint: false, idempotentHint: false },
+    // batch_action only supports follow/like/repost (no quote text), and every
+    // path dedups per target via authoritative viewer state.
+    batch_action: { destructiveHint: false, idempotentHint: true },
+    create_list: { destructiveHint: false, idempotentHint: false },
+    create_post: { destructiveHint: false, idempotentHint: false },
+    create_thread: { destructiveHint: false, idempotentHint: false },
+    // Dedups via viewer.following.
+    follow_user: { destructiveHint: false, idempotentHint: true },
+    // Dedups via viewer.like.
+    like_post: { destructiveHint: false, idempotentHint: true },
+    // seenAt defaults to "now", so repeated calls advance the seen marker.
+    mark_notifications_seen: { destructiveHint: false, idempotentHint: false },
+    // app.bsky.graph.muteActor sets server-side state; repeating it is a no-op.
+    mute_user: { destructiveHint: false, idempotentHint: true },
+    reply_to_post: { destructiveHint: false, idempotentHint: false },
+    // Plain reposts dedup via viewer.repost, but quote text creates a new post
+    // on every call, so the tool as a whole is not idempotent.
+    repost: { destructiveHint: false, idempotentHint: false },
+    upload_image: { destructiveHint: false, idempotentHint: false },
+    upload_video: { destructiveHint: false, idempotentHint: false },
+    // Destructive writes: may delete or overwrite data/state. These hints let
+    // clients surface confirmation UI and withhold auto-approval.
+    // Blocking imposes hard bidirectional restrictions and has no dedup
+    // (duplicate block records are possible).
+    block_user: { destructiveHint: true, idempotentHint: false },
+    delete_post: { destructiveHint: true, idempotentHint: false },
+    // "Not in list" resolves to an explicit success:false no-op.
+    remove_from_list: { destructiveHint: true, idempotentHint: true },
+    // Reports are irreversible moderation actions against third parties; each
+    // call files a new report.
+    report_content: { destructiveHint: true, idempotentHint: false },
+    report_user: { destructiveHint: true, idempotentHint: false },
+    // "Not blocked" resolves to an explicit success:false no-op.
+    unblock_user: { destructiveHint: true, idempotentHint: true },
+    unfollow_user: { destructiveHint: true, idempotentHint: false },
+    unlike_post: { destructiveHint: true, idempotentHint: false },
+    // app.bsky.graph.unmuteActor clears server-side state; repeating is a no-op.
+    unmute_user: { destructiveHint: true, idempotentHint: true },
+    unrepost: { destructiveHint: true, idempotentHint: false },
+    // Overwrites profile fields; the read-merge-write (CAS-guarded) converges
+    // to the same record for identical arguments.
+    update_profile: { destructiveHint: true, idempotentHint: true },
+};
 /**
  * Build the advertised annotations for a tool. openWorldHint is true for every
  * tool (they all reach a live network). A per-tool `schema.annotations` override
- * wins over these defaults.
+ * wins over these defaults. Tools missing from TOOL_ANNOTATIONS fall back to
+ * the MCP client-side worst-case defaults (destructive, non-idempotent).
  */
 function computeToolAnnotations(method, override) {
     return {
         openWorldHint: true,
-        ...(READ_ONLY_TOOLS.has(method) ? { readOnlyHint: true } : {}),
-        ...(DESTRUCTIVE_TOOLS.has(method) ? { destructiveHint: true } : {}),
+        ...(TOOL_ANNOTATIONS[method] ?? {}),
         ...(override ?? {}),
     };
 }
@@ -176,10 +227,12 @@ export class AtpMcpServer {
                 inputSchema: tool.schema.params
                     ? this.zodToJsonSchema(tool.schema.params)
                     : { type: 'object', properties: {} },
-                // Advertise an output schema when the tool declares one. This is purely
-                // descriptive metadata in the tools/list payload; because tools/call
-                // responses are built by this custom handler (not the SDK's high-level
-                // registerTool), it does not trigger structuredContent validation.
+                // Advertise the tool's declared output schema. This is a binding
+                // contract, not decoration: spec-compliant clients (including the
+                // official SDK's Client.callTool) validate every tools/call
+                // structuredContent against this schema and hard-fail on mismatch,
+                // so each outputSchema literal must track its tool's actual return
+                // shape (see the structuredContent note in the tools/call handler).
                 ...(tool.schema.outputSchema ? { outputSchema: tool.schema.outputSchema } : {}),
                 annotations: computeToolAnnotations(tool.schema.method, tool.schema.annotations),
             })),
@@ -251,10 +304,13 @@ export class AtpMcpServer {
                 //   to re-parse the pretty-printed string. SDK structuredContent must be a
                 //   JSON object, so bare arrays/primitives are wrapped under `result`.
                 //
-                // NOTE: we intentionally do NOT declare per-tool `outputSchema` — doing so
-                // makes the SDK REQUIRE and validate structuredContent on every call and
-                // throw on any non-conforming object. structuredContent here is additive
-                // and best-effort.
+                // NOTE: per-tool `outputSchema` IS advertised in tools/list (see
+                // registerTools above), and SDK clients validate structuredContent
+                // against it, failing the call on any drift. structuredContent is
+                // therefore a contract, not best-effort: tools that declare an
+                // outputSchema must return a conforming object. (Server-side, this
+                // custom handler performs no validation of its own — the SDK only
+                // auto-validates when tools are registered via registerTool.)
                 const structuredContent = result != null && typeof result === 'object' && !Array.isArray(result)
                     ? result
                     : { result };
@@ -311,6 +367,13 @@ export class AtpMcpServer {
                 mimeType: resource.mimeType,
             })),
         }));
+        // Register resources/templates/list handler. The declared resources
+        // capability invites clients to probe this method; without a handler the
+        // SDK answers -32601 Method not found. No URI templates are offered (all
+        // resources have fixed URIs), so the list is empty.
+        this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
+            resourceTemplates: [],
+        }));
         // Register resources/read handler
         this.server.setRequestHandler(z.object({
             method: z.literal('resources/read'),
@@ -321,7 +384,9 @@ export class AtpMcpServer {
             try {
                 const resource = resources.find(r => r.uri === request.params.uri);
                 if (!resource) {
-                    throw new McpError(ErrorCode.InvalidParams, `Resource not found: ${request.params.uri}`, {
+                    // The MCP spec reserves -32002 for "Resource not found"; the SDK's
+                    // ErrorCode enum does not (yet) name it, so use the literal.
+                    throw new McpError(RESOURCE_NOT_FOUND_ERROR_CODE, `Resource not found: ${request.params.uri}`, {
                         uri: request.params.uri,
                     });
                 }
@@ -331,13 +396,22 @@ export class AtpMcpServer {
                     throw new McpError(ErrorCode.InternalError, `Resource not available: ${request.params.uri}`, { uri: request.params.uri });
                 }
                 const content = await resource.read();
+                // Per the MCP resource content schema, each item is either text
+                // contents or base64 blob contents. Binary payloads must be passed
+                // through as a blob, not coerced to empty text.
                 return {
                     contents: [
-                        {
-                            uri: content.uri,
-                            mimeType: content.mimeType,
-                            text: content.text ?? '',
-                        },
+                        content.blob
+                            ? {
+                                uri: content.uri,
+                                mimeType: content.mimeType,
+                                blob: Buffer.from(content.blob).toString('base64'),
+                            }
+                            : {
+                                uri: content.uri,
+                                mimeType: content.mimeType,
+                                text: content.text ?? '',
+                            },
                     ],
                 };
             }
@@ -376,11 +450,10 @@ export class AtpMcpServer {
                         name: request.params.name,
                     });
                 }
-                // Check if prompt is available
-                const isAvailable = prompt.isAvailable();
-                if (!isAvailable) {
-                    throw new McpError(ErrorCode.InternalError, `Prompt not available: ${request.params.name}`, { name: request.params.name });
-                }
+                // No availability/auth gate here: prompts are pure text templates
+                // that never touch the AT Protocol client. Required arguments are
+                // enforced inside prompt.get(), which throws an InvalidParams
+                // McpError that toHandlerMcpError passes through verbatim.
                 const messages = await prompt.get(request.params.arguments ?? {});
                 return { messages };
             }
@@ -465,8 +538,14 @@ export class AtpMcpServer {
         }
         catch (error) {
             this.logger.error('Failed to start AT Protocol MCP Server', error);
-            // Cleanup on failure
-            await this.cleanup();
+            // Cleanup on failure — but never let a failing cleanup mask the
+            // original startup error, which is the one the caller must see.
+            try {
+                await this.cleanup();
+            }
+            catch (cleanupError) {
+                this.logger.error('Cleanup after failed startup also failed', cleanupError);
+            }
             if (error instanceof ConfigurationError) {
                 throw error;
             }
@@ -600,4 +679,3 @@ export class AtpMcpServer {
  *   await server.start();
  */
 export default AtpMcpServer;
-//# sourceMappingURL=index.js.map

package/dist/prompts/index.d.ts

@@ -34,9 +34,18 @@ export declare abstract class BasePrompt implements IMcpPrompt {
     protected logger: Logger;
     constructor(atpClient: AtpClient, loggerName: string);
     /**
-     * Check if the prompt is available
+     * Check if the prompt is available.
+     *
+     * Prompts are pure text templates: they never call the AT Protocol client,
+     * so they are available regardless of authentication state.
      */
     isAvailable(): boolean;
+    /**
+     * Read a declared-required string argument, rejecting missing/blank values
+     * with the spec invalid-params error instead of silently substituting a
+     * placeholder.
+     */
+    protected requireStringArg(args: Record<string, unknown> | undefined, name: string): string;
     /**
      * Generate the prompt content
      */
@@ -47,7 +56,7 @@ export declare abstract class BasePrompt implements IMcpPrompt {
  */
 export declare class ContentCompositionPrompt extends BasePrompt {
     readonly name = "content_composition";
-    readonly description = "Generate engaging social media post content with proper formatting and hashtags. Requires authentication.";
+    readonly description = "Generate engaging social media post content with proper formatting and hashtags. Pure text template; works without authentication.";
     readonly arguments: {
         name: string;
         description: string;
@@ -61,7 +70,7 @@ export declare class ContentCompositionPrompt extends BasePrompt {
  */
 export declare class ReplyTemplatePrompt extends BasePrompt {
     readonly name = "reply_template";
-    readonly description = "Generate thoughtful reply templates for different types of posts. Requires authentication.";
+    readonly description = "Generate thoughtful reply templates for different types of posts. Pure text template; works without authentication.";
     readonly arguments: {
         name: string;
         description: string;
@@ -74,4 +83,3 @@ export declare class ReplyTemplatePrompt extends BasePrompt {
  * Create all MCP prompts for AT Protocol content assistance
  */
 export declare function createPrompts(atpClient: AtpClient): BasePrompt[];
-//# sourceMappingURL=index.d.ts.map

package/dist/prompts/index.js

@@ -1,6 +1,7 @@
 /**
  * MCP Prompts for AT Protocol content creation assistance
  */
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
 import { Logger } from '../utils/logger.js';
 /**
  * Base class for MCP prompts
@@ -13,15 +14,25 @@ export class BasePrompt {
         this.logger = new Logger(loggerName);
     }
     /**
-     * Check if the prompt is available
+     * Check if the prompt is available.
+     *
+     * Prompts are pure text templates: they never call the AT Protocol client,
+     * so they are available regardless of authentication state.
      */
     isAvailable() {
-        try {
-            return this.atpClient.isAuthenticated();
-        }
-        catch {
-            return false;
+        return true;
+    }
+    /**
+     * Read a declared-required string argument, rejecting missing/blank values
+     * with the spec invalid-params error instead of silently substituting a
+     * placeholder.
+     */
+    requireStringArg(args, name) {
+        const value = args?.[name];
+        if (typeof value !== 'string' || value.trim() === '') {
+            throw new McpError(ErrorCode.InvalidParams, `Missing required argument "${name}" for prompt "${this.name}"`, { prompt: this.name, argument: name });
         }
+        return value;
     }
 }
 /**
@@ -29,7 +40,7 @@ export class BasePrompt {
  */
 export class ContentCompositionPrompt extends BasePrompt {
     name = 'content_composition';
-    description = 'Generate engaging social media post content with proper formatting and hashtags. Requires authentication.';
+    description = 'Generate engaging social media post content with proper formatting and hashtags. Pure text template; works without authentication.';
     arguments = [
         {
             name: 'topic',
@@ -56,7 +67,7 @@ export class ContentCompositionPrompt extends BasePrompt {
         super(atpClient, 'ContentCompositionPrompt');
     }
     async get(args) {
-        const topic = args?.['topic'] ?? 'general topic';
+        const topic = this.requireStringArg(args, 'topic');
         const tone = args?.['tone'] ?? 'casual';
         const length = args?.['length'] ?? 'medium';
         const includeHashtags = args?.['include_hashtags'] !== false;
@@ -104,7 +115,7 @@ Please provide the post text ready to publish.`,
  */
 export class ReplyTemplatePrompt extends BasePrompt {
     name = 'reply_template';
-    description = 'Generate thoughtful reply templates for different types of posts. Requires authentication.';
+    description = 'Generate thoughtful reply templates for different types of posts. Pure text template; works without authentication.';
     arguments = [
         {
             name: 'original_post',
@@ -126,7 +137,7 @@ export class ReplyTemplatePrompt extends BasePrompt {
         super(atpClient, 'ReplyTemplatePrompt');
     }
     async get(args) {
-        const originalPost = args?.['original_post'] ?? 'the original post';
+        const originalPost = this.requireStringArg(args, 'original_post');
         const replyType = args?.['reply_type'] ?? 'supportive';
         const relationship = args?.['relationship'] ?? 'stranger';
         const replyTypeGuidance = {
@@ -191,4 +202,3 @@ export function createPrompts(atpClient) {
     logger.info(`Created ${prompts.length} AT Protocol MCP prompts`);
     return prompts;
 }
-//# sourceMappingURL=index.js.map

package/dist/resources/base.d.ts

@@ -35,4 +35,3 @@ export declare abstract class BaseResource implements IMcpResource {
      */
     isAvailable(): Promise<boolean>;
 }
-//# sourceMappingURL=base.d.ts.map

package/dist/resources/base.js

@@ -24,4 +24,3 @@ export class BaseResource {
         }
     }
 }
-//# sourceMappingURL=base.js.map

package/dist/resources/conversation-context-resource.d.ts

@@ -41,14 +41,14 @@ interface IConversationContext {
 /**
  * Conversation Context Resource
  *
- * This resource maintains state across LLM interactions, tracking:
- * - Posts that have been discussed in the conversation
- * - Active threads being followed
- * - Users that have been mentioned
- * - Search queries performed
- * - Recent actions taken
+ * In-memory store for conversation state (discussed posts, active threads,
+ * mentioned users, searches, recent actions), exposed as an MCP resource.
  *
- * This helps LLMs maintain context and provide more coherent, contextual responses.
+ * NOT REGISTERED with the MCP server (see createResources): MCP has no
+ * client-write mechanism for resources, and no tool currently calls the
+ * static add* methods, so the resource would always read as empty. The class
+ * is retained so a future change can populate it from tool handlers and
+ * re-register it.
  */
 export declare class ConversationContextResource extends BaseResource {
     readonly uri = "atproto://conversation-context";
@@ -110,4 +110,3 @@ export declare class ConversationContextResource extends BaseResource {
     static getContext(): IConversationContext;
 }
 export {};
-//# sourceMappingURL=conversation-context-resource.d.ts.map

package/dist/resources/conversation-context-resource.js

@@ -5,22 +5,21 @@ import { BaseResource } from './base.js';
 /**
  * Conversation Context Resource
  *
- * This resource maintains state across LLM interactions, tracking:
- * - Posts that have been discussed in the conversation
- * - Active threads being followed
- * - Users that have been mentioned
- * - Search queries performed
- * - Recent actions taken
+ * In-memory store for conversation state (discussed posts, active threads,
+ * mentioned users, searches, recent actions), exposed as an MCP resource.
  *
- * This helps LLMs maintain context and provide more coherent, contextual responses.
+ * NOT REGISTERED with the MCP server (see createResources): MCP has no
+ * client-write mechanism for resources, and no tool currently calls the
+ * static add* methods, so the resource would always read as empty. The class
+ * is retained so a future change can populate it from tool handlers and
+ * re-register it.
  */
 export class ConversationContextResource extends BaseResource {
     uri = 'atproto://conversation-context';
     name = 'Conversation Context';
-    description = 'Scratchpad for conversation state (recently discussed posts, active threads, mentioned ' +
-        'users, recent actions). NOTE: the server does not yet populate this automatically during ' +
-        'tool calls, so it is empty unless a client explicitly writes to it; treat empty arrays as ' +
-        '"not tracked", not "nothing happened".';
+    description = 'Server-side scratchpad of conversation state (recently discussed posts, active threads, ' +
+        'mentioned users, recent actions). Populated only by server-side tool integrations; in the ' +
+        'current release nothing writes to it, so it always reads as empty arrays.';
     mimeType = 'application/json';
     static context = {
         recentlyDiscussedPosts: [],
@@ -177,4 +176,3 @@ export class ConversationContextResource extends BaseResource {
         return this.context;
     }
 }
-//# sourceMappingURL=conversation-context-resource.js.map

package/dist/resources/index.d.ts

@@ -37,10 +37,8 @@ export declare class NotificationsResource extends BaseResource {
     constructor(atpClient: AtpClient);
     read(): Promise<IResourceContent>;
 }
-import { ConversationContextResource } from './conversation-context-resource.js';
-export { ConversationContextResource };
+export { ConversationContextResource } from './conversation-context-resource.js';
 /**
  * Create all MCP resources for AT Protocol data
  */
 export declare function createResources(atpClient: AtpClient): BaseResource[];
-//# sourceMappingURL=index.d.ts.map