the-citadel 0.4.3 → 0.4.5

package/dist/config/schema.d.ts

@@ -25,6 +25,7 @@ export declare const ConfigSchema: z.ZodObject<{
             }>;
             model: z.ZodString;
             mcpTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            mcpResources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         }, z.core.$strip>;
         worker: z.ZodObject<{
             provider: z.ZodEnum<{
@@ -34,15 +35,7 @@ export declare const ConfigSchema: z.ZodObject<{
             }>;
             model: z.ZodString;
             mcpTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>;
-        supervisor: z.ZodObject<{
-            provider: z.ZodEnum<{
-                openai: "openai";
-                anthropic: "anthropic";
-                ollama: "ollama";
-            }>;
-            model: z.ZodString;
-            mcpTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            mcpResources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         }, z.core.$strip>;
         gatekeeper: z.ZodObject<{
             provider: z.ZodEnum<{
@@ -52,6 +45,7 @@ export declare const ConfigSchema: z.ZodObject<{
             }>;
             model: z.ZodString;
             mcpTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            mcpResources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{

package/dist/core/agent.d.ts

@@ -1,6 +1,7 @@
 import { generateText, type LanguageModel, type ModelMessage, type Tool } from "ai";
 import { z } from "zod";
 import type { AgentRole } from "../config/schema";
+import { type BeadsClient } from "./beads";
 export interface AgentContext {
     beadId?: string;
     [key: string]: unknown;
@@ -16,7 +17,8 @@ export declare abstract class CoreAgent {
     protected dynamicTools: Record<string, Tool>;
     protected schemas: Record<string, z.ZodTypeAny>;
     protected requiresExplicitCompletion: boolean;
-    constructor(role: AgentRole, model?: LanguageModel);
+    protected beadsClient?: BeadsClient;
+    constructor(role: AgentRole, model?: LanguageModel, beadsClient?: BeadsClient);
     /**
      * Override this to provide tools dynamically based on context.
      * These will be merged with registered static tools (like MCP tools).

package/dist/core/formula.d.ts

@@ -27,6 +27,7 @@ export declare const FormulaSchema: z.ZodObject<{
         default: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     prompts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    mcp_resources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     steps: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         title: z.ZodString;

package/dist/core/llm.d.ts

@@ -1,4 +1,4 @@
 import type { LanguageModel } from "ai";
-type AgentRole = "router" | "worker" | "supervisor" | "gatekeeper";
+type AgentRole = "router" | "worker" | "gatekeeper";
 export declare function getAgentModel(role: AgentRole): LanguageModel;
 export {};

package/dist/core/mcp-resource-provider.d.ts

@@ -0,0 +1,7 @@
+import type { InstructionContext, InstructionProvider } from "./instruction";
+export declare class MCPResourceProvider implements InstructionProvider {
+    name: string;
+    priority: number;
+    getInstructions(ctx: InstructionContext): Promise<string | null>;
+    private mergeResources;
+}

package/dist/core/queue.d.ts

@@ -19,7 +19,6 @@ export declare const TicketSchema: z.ZodObject<{
     target_role: z.ZodEnum<{
         router: "router";
         worker: "worker";
-        supervisor: "supervisor";
         gatekeeper: "gatekeeper";
     }>;
     assignee_id: z.ZodNullable<z.ZodString>;

package/dist/index.js

@@ -64994,22 +64994,20 @@ var ConfigSchema = exports_external.object({
     router: exports_external.object({
       provider: exports_external.enum(["openai", "anthropic", "ollama"]),
       model: exports_external.string(),
-      mcpTools: exports_external.array(exports_external.string()).optional()
+      mcpTools: exports_external.array(exports_external.string()).optional(),
+      mcpResources: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).optional()
     }),
     worker: exports_external.object({
       provider: exports_external.enum(["openai", "anthropic", "ollama"]),
       model: exports_external.string(),
-      mcpTools: exports_external.array(exports_external.string()).optional()
-    }),
-    supervisor: exports_external.object({
-      provider: exports_external.enum(["openai", "anthropic", "ollama"]),
-      model: exports_external.string(),
-      mcpTools: exports_external.array(exports_external.string()).optional()
+      mcpTools: exports_external.array(exports_external.string()).optional(),
+      mcpResources: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).optional()
     }),
     gatekeeper: exports_external.object({
       provider: exports_external.enum(["openai", "anthropic", "ollama"]),
       model: exports_external.string(),
-      mcpTools: exports_external.array(exports_external.string()).optional()
+      mcpTools: exports_external.array(exports_external.string()).optional(),
+      mcpResources: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).optional()
     })
   }),
   mcpServers: exports_external.record(exports_external.string(), exports_external.object({
@@ -81469,6 +81467,48 @@ class MCPService {
       arguments: args
     });
   }
+  async readResource(serverName, uri) {
+    const client = this.clients.get(serverName);
+    if (!client) {
+      logger.warn(`[MCP] Server ${serverName} not connected for resource ${uri}`);
+      return [];
+    }
+    try {
+      logger.info(`[MCP] Reading resource ${serverName}:${uri}`);
+      const result = await client.request({
+        method: "resources/read",
+        params: { uri }
+      }, ReadResourceRequestSchema);
+      return result.contents.map((content) => {
+        if ("text" in content && content.text) {
+          return content.text;
+        }
+        if ("blob" in content) {
+          logger.warn(`[MCP] Skipping binary resource content for ${uri}`);
+        }
+        return null;
+      }).filter((text2) => text2 !== null);
+    } catch (error48) {
+      logger.error(`[MCP] Failed to read resource ${serverName}:${uri}:`, error48);
+      return [];
+    }
+  }
+  async listResources(serverName) {
+    const client = this.clients.get(serverName);
+    if (!client) {
+      logger.warn(`[MCP] Server ${serverName} not connected for listResources`);
+      return [];
+    }
+    try {
+      const result = await client.request({
+        method: "resources/list"
+      }, ListResourcesRequestSchema);
+      return result.resources;
+    } catch (error48) {
+      logger.error(`[MCP] Failed to list resources for ${serverName}:`, error48);
+      return [];
+    }
+  }
   async shutdown() {
     for (const [name18, client] of this.clients) {
       try {
@@ -84768,6 +84808,7 @@ var FormulaSchema = exports_external.object({
   description: exports_external.string(),
   vars: exports_external.record(exports_external.string(), FormulaVariableSchema).optional(),
   prompts: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+  mcp_resources: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).optional(),
   steps: exports_external.array(FormulaStepSchema)
 });
 
@@ -84814,6 +84855,81 @@ function getFormulaRegistry(basePath) {
   return _registry;
 }
 
+// src/core/mcp-resource-provider.ts
+class MCPResourceProvider {
+  name = "mcp-resources";
+  priority = 25;
+  async getInstructions(ctx) {
+    const resourcesToFetch = {};
+    const config2 = getConfig();
+    const roleConfig = config2.agents[ctx.role];
+    if (roleConfig && "mcpResources" in roleConfig && roleConfig.mcpResources) {
+      this.mergeResources(resourcesToFetch, roleConfig.mcpResources);
+    }
+    if (ctx.beadId) {
+      try {
+        const bead = await getBeads().get(ctx.beadId);
+        const formulaLabel = bead.labels?.find((l) => l.startsWith("formula:"));
+        if (formulaLabel) {
+          const formulaName = formulaLabel.split(":")[1];
+          if (formulaName) {
+            const formula = getFormulaRegistry().get(formulaName);
+            if (formula?.mcp_resources) {
+              this.mergeResources(resourcesToFetch, formula.mcp_resources);
+            }
+          }
+        }
+        if (bead.context?.mcp_resources) {
+          this.mergeResources(resourcesToFetch, bead.context.mcp_resources);
+        }
+      } catch (err) {
+        logger.debug(`[MCPResourceProvider] Error fetching resources from bead/formula: ${err}`);
+      }
+    }
+    if (Object.keys(resourcesToFetch).length === 0)
+      return null;
+    const mcpService = getMCPService();
+    const results = [];
+    for (const [serverName, uris] of Object.entries(resourcesToFetch)) {
+      for (const uri of uris) {
+        try {
+          const contents = await mcpService.readResource(serverName, uri);
+          if (contents.length > 0) {
+            results.push(`## RESOURCE: ${serverName}:${uri}
+${contents.join(`
+
+`)}`);
+          }
+        } catch (err) {
+          logger.warn(`[MCPResourceProvider] Failed to fetch resource ${serverName}:${uri}: ${err}`);
+        }
+      }
+    }
+    if (results.length === 0)
+      return null;
+    return `
+# CONTEXT RESOURCES
+The following resources have been injected into your context for this task:
+
+${results.join(`
+
+--- 
+
+`)}
+`;
+  }
+  mergeResources(target, source) {
+    for (const [server, uris] of Object.entries(source)) {
+      if (!target[server]) {
+        target[server] = new Set;
+      }
+      for (const uri of uris) {
+        target[server].add(uri);
+      }
+    }
+  }
+}
+
 // src/core/instruction.ts
 class GlobalProvider {
   name = "global";
@@ -84966,6 +85082,7 @@ class InstructionService {
       new GlobalProvider,
       new BuiltinProvider,
       new RoleProvider,
+      new MCPResourceProvider,
       new FormulaProvider,
       new TagProvider,
       new ContextProvider
@@ -93792,9 +93909,11 @@ class CoreAgent {
   dynamicTools = {};
   schemas = {};
   requiresExplicitCompletion = false;
-  constructor(role, model) {
+  beadsClient;
+  constructor(role, model, beadsClient) {
     this.role = role;
     this.model = model || getAgentModel(role);
+    this.beadsClient = beadsClient;
   }
   async getDynamicTools(_context) {
     return {};
@@ -94195,7 +94314,8 @@ If you are still working, continue with your next step.`
 - **Input Tokens**: ${totalUsage.inputTokens}
 - **Output Tokens**: ${totalUsage.outputTokens}
 - **Total Tokens**: ${totalUsage.totalTokens}`;
-        getBeads().addComment(context2.beadId, summary).catch((err) => {
+        const client = this.beadsClient || getBeads();
+        client.addComment(context2.beadId, summary).catch((err) => {
           logger.warn(`[${this.role}] Failed to report token usage to bead ${context2.beadId}`, { error: err });
         });
       } catch (err) {
@@ -94388,7 +94508,7 @@ var TicketSchema = exports_external.object({
   bead_id: exports_external.string(),
   status: TicketStatusSchema,
   priority: exports_external.number().min(0).max(3),
-  target_role: exports_external.enum(["router", "worker", "supervisor", "gatekeeper"]),
+  target_role: exports_external.enum(["router", "worker", "gatekeeper"]),
   assignee_id: exports_external.string().nullable(),
   created_at: exports_external.number(),
   started_at: exports_external.number().nullable(),
@@ -96411,7 +96531,7 @@ var TicketSchema2 = exports_external.object({
   bead_id: exports_external.string(),
   status: TicketStatusSchema2,
   priority: exports_external.number().min(0).max(3),
-  target_role: exports_external.enum(["router", "worker", "supervisor", "gatekeeper"]),
+  target_role: exports_external.enum(["router", "worker", "gatekeeper"]),
   assignee_id: exports_external.string().nullable(),
   created_at: exports_external.number(),
   started_at: exports_external.number().nullable(),
@@ -97086,7 +97206,7 @@ export default {
             model: 'llama3:8b',
             mcpTools: ['filesystem:read_text_file', 'filesystem:list_directory']
         },
-        supervisor: { provider: 'ollama', model: 'llama3:8b' },
+
     },
     mcpServers: {
         filesystem: {

package/dist/services/mcp.d.ts

@@ -13,6 +13,8 @@ export declare class MCPService {
     initialize(): Promise<void>;
     getToolsForAgent(assignedTools?: string[]): Promise<MCPTool[]>;
     callTool(serverName: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    readResource(serverName: string, uri: string): Promise<string[]>;
+    listResources(serverName: string): Promise<unknown[]>;
     shutdown(): Promise<void>;
 }
 export declare function getMCPService(): MCPService;

package/dist/tools/worker.d.ts

@@ -20,7 +20,7 @@ export declare const createReportProgressTool: (_context: AgentContext) => impor
 }>;
 export declare const createDelegateTaskTool: (_context: AgentContext) => import("ai").Tool<{
     title: string;
-    priority: "low" | "normal" | "high" | "critical";
+    priority: "critical" | "low" | "normal" | "high";
     parentBeadId?: string | undefined;
     tags?: string[] | undefined;
     description?: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "the-citadel",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "A deterministic agent orchestration system for Knowledge Work",
   "module": "src/index.ts",
   "type": "module",