@desplega.ai/agent-swarm 1.103.0 → 1.104.0

package/src/tools/credential-bindings/tool.ts

@@ -0,0 +1,238 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById } from "@/be/db";
+import {
+  disableCredentialBinding,
+  importLegacyCredentialBindings,
+  listRelationalCredentialBindings,
+  upsertCredentialBinding,
+} from "@/be/script-connections";
+import {
+  CredentialBindingSchema,
+  placeholderForConfigKey,
+} from "@/scripts-runtime/credential-broker";
+import { createToolRegistrar } from "@/tools/utils";
+
+const credentialBindingsOutputSchema = z.object({
+  yourAgentId: z.string().uuid().optional(),
+  success: z.boolean(),
+  message: z.string(),
+  bindings: z.array(CredentialBindingSchema),
+});
+
+const credentialBindingsInputSchema = z.object({
+  action: z
+    .enum(["list", "upsert", "disable", "import-legacy"])
+    .describe("List, add/update, disable, or import legacy JSON bindings."),
+  id: z.string().uuid().optional(),
+  configKey: z.string().min(1).max(255).optional(),
+  allowedHosts: z.array(z.string().min(1)).min(1).optional(),
+  headerTemplate: z.string().min(1).optional(),
+  queryTemplate: z.string().min(1).optional(),
+  scope: z.enum(["global", "agent", "repo"]).default("global").optional(),
+  scopeId: z.string().uuid().nullable().optional(),
+});
+
+export const registerCredentialBindingsTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "credential-bindings",
+    {
+      title: "Credential Bindings",
+      description:
+        "Lead-only management for scripts-runtime credential broker bindings. Bindings map config keys to allowed egress hosts; scripts consume them only through fetch-layer placeholder substitution.",
+      annotations: { idempotentHint: true },
+      inputSchema: credentialBindingsInputSchema,
+      outputSchema: credentialBindingsOutputSchema,
+    },
+    async (args, requestInfo) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: 'Agent ID not found. Set the "X-Agent-ID" header.' }],
+          structuredContent: {
+            success: false,
+            message: 'Agent ID not found. Set the "X-Agent-ID" header.',
+            bindings: [],
+          },
+        };
+      }
+
+      const agent = getAgentById(requestInfo.agentId);
+      if (!agent?.isLead) {
+        return {
+          content: [{ type: "text", text: "Only the lead can manage credential bindings." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "Only the lead can manage credential bindings.",
+            bindings: [],
+          },
+        };
+      }
+
+      const bindings = listRelationalCredentialBindings({ includeInactive: true });
+
+      if (args.action === "list") {
+        return {
+          content: [
+            {
+              type: "text",
+              text:
+                bindings.length === 0
+                  ? "No configured credential bindings."
+                  : `Found ${bindings.length} credential binding(s).`,
+            },
+          ],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message:
+              bindings.length === 0
+                ? "No configured credential bindings."
+                : `Found ${bindings.length} credential binding(s).`,
+            bindings,
+          },
+        };
+      }
+
+      if (args.action === "import-legacy") {
+        const imported = importLegacyCredentialBindings();
+        const nextBindings = listRelationalCredentialBindings({ includeInactive: true });
+        return {
+          content: [{ type: "text", text: `Imported ${imported} legacy credential binding(s).` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: `Imported ${imported} legacy credential binding(s).`,
+            bindings: nextBindings,
+          },
+        };
+      }
+
+      if (args.action === "disable") {
+        const disabled = args.id ? disableCredentialBinding(args.id) : null;
+        if (!disabled) {
+          return {
+            content: [{ type: "text", text: "Credential binding id not found." }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: "Credential binding id not found.",
+              bindings,
+            },
+          };
+        }
+
+        const nextBindings = listRelationalCredentialBindings({ includeInactive: true });
+        return {
+          content: [{ type: "text", text: `Credential binding ${disabled.configKey} disabled.` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: `Credential binding ${disabled.configKey} disabled.`,
+            bindings: nextBindings,
+          },
+        };
+      }
+
+      if (!args.configKey) {
+        return {
+          content: [{ type: "text", text: "configKey is required for upsert." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "configKey is required for upsert.",
+            bindings,
+          },
+        };
+      }
+
+      const scope = args.scope ?? "global";
+      const scopeId = scope === "global" ? null : (args.scopeId ?? null);
+      if (scope !== "global" && !scopeId) {
+        return {
+          content: [{ type: "text", text: `scopeId is required for ${scope} bindings.` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `scopeId is required for ${scope} bindings.`,
+            bindings,
+          },
+        };
+      }
+
+      if (!args.allowedHosts || (!args.headerTemplate && !args.queryTemplate)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "allowedHosts and at least one of headerTemplate or queryTemplate are required for upsert.",
+            },
+          ],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message:
+              "allowedHosts and at least one of headerTemplate or queryTemplate are required for upsert.",
+            bindings,
+          },
+        };
+      }
+
+      const placeholder = placeholderForConfigKey(args.configKey);
+      if (args.headerTemplate && !args.headerTemplate.includes(placeholder)) {
+        return {
+          content: [{ type: "text", text: `headerTemplate must include ${placeholder}.` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `headerTemplate must include ${placeholder}.`,
+            bindings,
+          },
+        };
+      }
+      if (args.queryTemplate && !args.queryTemplate.includes(placeholder)) {
+        return {
+          content: [{ type: "text", text: `queryTemplate must include ${placeholder}.` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `queryTemplate must include ${placeholder}.`,
+            bindings,
+          },
+        };
+      }
+
+      const nextBinding = CredentialBindingSchema.parse({
+        configKey: args.configKey,
+        allowedHosts: args.allowedHosts,
+        headerTemplate: args.headerTemplate,
+        queryTemplate: args.queryTemplate,
+        scope,
+        scopeId,
+        active: true,
+      });
+
+      upsertCredentialBinding({
+        id: args.id,
+        configKey: nextBinding.configKey,
+        allowedHosts: nextBinding.allowedHosts,
+        headerTemplate: nextBinding.headerTemplate,
+        queryTemplate: nextBinding.queryTemplate,
+        scope: nextBinding.scope,
+        scopeId: nextBinding.scopeId ?? null,
+        active: true,
+      });
+      const nextBindings = listRelationalCredentialBindings({ includeInactive: true });
+
+      return {
+        content: [{ type: "text", text: `Credential binding ${args.configKey} saved.` }],
+        structuredContent: {
+          yourAgentId: requestInfo.agentId,
+          success: true,
+          message: `Credential binding ${args.configKey} saved.`,
+          bindings: nextBindings,
+        },
+      };
+    },
+  );
+};

package/src/tools/memory-edit.ts

@@ -0,0 +1,148 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
+import { storeLinks } from "@/be/memory/link-resolver";
+import { createToolRegistrar } from "@/tools/utils";
+import { AgentMemorySchema, AgentMemoryScopeSchema } from "@/types";
+
+export const registerMemoryEditTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "memory-edit",
+    {
+      title: "Edit a memory",
+      description:
+        "Edit a single memory in place while preserving its ID, usefulness posterior, and audit history. Two modes: 'replace' overwrites the entire content (requires `content`); 'exact' performs a surgical find-and-replace of `oldString` with `newString` within the existing content (fails if `oldString` is missing or ambiguous). Use 'replace' for full rewrites, 'exact' for targeted edits.",
+      annotations: { destructiveHint: true },
+
+      inputSchema: z.object({
+        memoryId: z.uuid().optional().describe("The memory ID to edit."),
+        key: z.string().min(1).optional().describe("Structured key alternative to memoryId."),
+        scope: AgentMemoryScopeSchema.optional().describe("Required when editing by key."),
+        mode: z
+          .enum(["replace", "exact"])
+          .default("replace")
+          .describe(
+            "'replace' overwrites the entire memory content; 'exact' finds a unique substring (oldString) and replaces it with newString.",
+          ),
+        content: z
+          .string()
+          .min(1)
+          .optional()
+          .describe("Full replacement content. Required for 'replace' mode, ignored in 'exact'."),
+        oldString: z
+          .string()
+          .min(1)
+          .optional()
+          .describe(
+            "Substring to find in existing content. Required for 'exact' mode. Must appear exactly once.",
+          ),
+        newString: z
+          .string()
+          .optional()
+          .describe(
+            "Replacement for oldString. Required for 'exact' mode. Can be empty to delete.",
+          ),
+        intent: z.string().min(1).describe("Why you are editing this memory."),
+        expectedVersion: z.number().int().min(1).optional(),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+        memory: AgentMemorySchema.optional(),
+        changed: z.boolean().optional(),
+        previousVersion: z.number().int().optional(),
+        version: z.number().int().optional(),
+      }),
+    },
+    async (
+      { memoryId, key, scope, mode, content, oldString, newString, intent, expectedVersion },
+      requestInfo,
+      _meta,
+    ) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID required to edit memories." }],
+          structuredContent: {
+            yourAgentId: undefined,
+            success: false,
+            message: "Agent ID required. Are you registered in the swarm?",
+          },
+        };
+      }
+
+      if (!memoryId && !(key && scope)) {
+        return {
+          content: [{ type: "text", text: "memoryId or key+scope required." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "memoryId or key+scope required.",
+          },
+        };
+      }
+
+      try {
+        const store = getMemoryStore();
+        const result = store.edit({
+          id: memoryId,
+          key,
+          scope,
+          agentId: requestInfo.agentId,
+          mode,
+          content,
+          oldString,
+          newString,
+          intent,
+          expectedVersion,
+          changedByAgentId: requestInfo.agentId,
+        });
+
+        if (result.changed) {
+          const provider = getEmbeddingProvider();
+          const embedding = await provider.embed(result.memory.content);
+          if (embedding) store.updateEmbedding(result.memory.id, embedding, provider.name);
+          try {
+            storeLinks(result.memory.id, requestInfo.agentId, result.memory.content);
+          } catch (err) {
+            console.error(
+              `[memory-edit] Link resolution failed for ${result.memory.id}:`,
+              (err as Error).message,
+            );
+          }
+        }
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.changed
+                ? `Memory "${result.memory.id}" edited to version ${result.version}.`
+                : `Memory "${result.memory.id}" unchanged.`,
+            },
+          ],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: result.changed
+              ? `Memory edited to version ${result.version}.`
+              : "Memory unchanged.",
+            memory: result.memory,
+            changed: result.changed,
+            previousVersion: result.previousVersion,
+            version: result.version,
+          },
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Memory edit failed: ${(err as Error).message}` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `Memory edit failed: ${(err as Error).message}`,
+          },
+        };
+      }
+    },
+  );
+};

package/src/tools/memory-search.ts

@@ -54,6 +54,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
               source: AgentMemorySourceSchema,
               scope: AgentMemoryScopeSchema,
               similarity: z.number().optional(),
+              retrievalSource: z.enum(["vec", "fts", "hybrid", "fallback"]).optional(),
               createdAt: z.string(),
               rateHint: z.string().optional(),
             }),
@@ -82,14 +83,15 @@ export const registerMemorySearchTool = (server: McpServer) => {
       const store = getMemoryStore();
       const queryEmbedding = await provider.embed(query);
 
-      if (queryEmbedding) {
-        const candidateLimit = limit * CANDIDATE_SET_MULTIPLIER;
-        const candidates = store.search(queryEmbedding, requestInfo.agentId, {
-          scope: scope as "agent" | "swarm" | "all",
-          limit: candidateLimit,
-          source,
-          isLead,
-        });
+      const candidateLimit = limit * CANDIDATE_SET_MULTIPLIER;
+      const candidates = store.search(queryEmbedding ?? new Float32Array(0), requestInfo.agentId, {
+        scope: scope as "agent" | "swarm" | "all",
+        limit: candidateLimit,
+        source,
+        isLead,
+        queryText: query,
+      });
+      if (candidates.length > 0) {
         const ranked = rerank(candidates, { limit });
 
         // Retrieval bridge — when called inside a task scope, log one
@@ -101,7 +103,11 @@ export const registerMemorySearchTool = (server: McpServer) => {
             recordRetrievals(
               requestInfo.sourceTaskId,
               requestInfo.agentId,
-              ranked.map((r) => ({ memoryId: r.id, similarity: r.similarity })),
+              ranked.map((r) => ({
+                memoryId: r.id,
+                similarity: r.similarity,
+                retrievalSource: r.retrievalSource,
+              })),
               requestInfo.sessionId,
               { intent, contextKey: requestInfo.contextKey, eventType: "search" },
             );
@@ -118,6 +124,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
           source: r.source,
           scope: r.scope,
           similarity: r.similarity,
+          retrievalSource: r.retrievalSource,
           createdAt: r.createdAt,
           ...(inTaskContext && NUDGE_ELIGIBLE_SOURCES.has(r.source as AgentMemorySource)
             ? { rateHint: rateHintFor(r.id) }
@@ -145,7 +152,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
         };
       }
 
-      // Fallback: list recent memories (no OPENAI_API_KEY)
+      // Fallback: list recent memories (no OPENAI_API_KEY and no FTS hit)
       const recent = store.list(requestInfo.agentId, {
         scope: scope as "agent" | "swarm" | "all",
         limit,

package/src/tools/schedules/delete-schedule.ts

@@ -6,6 +6,7 @@ import {
   getScheduledTaskById,
   getScheduledTaskByName,
 } from "@/be/db";
+import { createEvent } from "@/be/events";
 import { createToolRegistrar } from "@/tools/utils";
 
 export const registerDeleteScheduleTool = (server: McpServer) => {
@@ -14,7 +15,7 @@ export const registerDeleteScheduleTool = (server: McpServer) => {
     {
       title: "Delete Scheduled Task",
       description:
-        "Delete a scheduled task permanently. Only the creator or lead agent can delete schedules.",
+        "Delete a scheduled task permanently. Any registered agent can delete schedules.",
       annotations: { destructiveHint: true },
 
       inputSchema: z.object({
@@ -71,17 +72,13 @@ export const registerDeleteScheduleTool = (server: McpServer) => {
         };
       }
 
-      // Check authorization (creator or lead)
       const caller = getAgentById(requestInfo.agentId);
-      const isCreator = schedule.createdByAgentId === requestInfo.agentId;
-      const isLead = caller?.isLead === true;
-
-      if (!isCreator && !isLead) {
+      if (!caller) {
         return {
-          content: [{ type: "text", text: "Only the creator or lead can delete this schedule." }],
+          content: [{ type: "text", text: "Agent not found." }],
           structuredContent: {
             success: false,
-            message: "Only the creator or lead can delete this schedule.",
+            message: "Agent not found.",
           },
         };
       }
@@ -99,6 +96,19 @@ export const registerDeleteScheduleTool = (server: McpServer) => {
           };
         }
 
+        createEvent({
+          category: "system",
+          event: "schedule.deleted",
+          source: "api",
+          agentId: requestInfo.agentId,
+          data: {
+            scheduleId: schedule.id,
+            name: schedule.name,
+            deletedByAgentId: requestInfo.agentId,
+            createdByAgentId: schedule.createdByAgentId,
+          },
+        });
+
         return {
           content: [{ type: "text", text: `Deleted schedule "${schedule.name}".` }],
           structuredContent: {

package/src/tools/schedules/update-schedule.ts

@@ -51,8 +51,7 @@ export const registerUpdateScheduleTool = (server: McpServer) => {
     {
       title: "Update Scheduled Task",
       annotations: { idempotentHint: true },
-      description:
-        "Update an existing scheduled task. Only the creator or lead agent can update schedules.",
+      description: "Update an existing scheduled task. Any registered agent can update schedules.",
       inputSchema: updateScheduleInputSchema,
       outputSchema: z.object({
         yourAgentId: z.string().uuid().optional(),
@@ -132,17 +131,13 @@ export const registerUpdateScheduleTool = (server: McpServer) => {
         };
       }
 
-      // Check authorization (creator or lead)
       const caller = getAgentById(requestInfo.agentId);
-      const isCreator = schedule.createdByAgentId === requestInfo.agentId;
-      const isLead = caller?.isLead === true;
-
-      if (!isCreator && !isLead) {
+      if (!caller) {
         return {
-          content: [{ type: "text", text: "Only the creator or lead can update this schedule." }],
+          content: [{ type: "text", text: "Agent not found." }],
           structuredContent: {
             success: false,
-            message: "Only the creator or lead can update this schedule.",
+            message: "Agent not found.",
           },
         };
       }

package/src/tools/script-connections/index.ts

@@ -0,0 +1 @@
+export { registerScriptConnectionsTool } from "./tool";