@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/src/providers/modelsdev-reasoning.json

@@ -780,6 +780,57 @@
           ]
         }
       ]
+    },
+    "gpt-5.6-sol": {
+      "id": "gpt-5.6-sol",
+      "reasoning": true,
+      "reasoningOptions": [
+        {
+          "type": "effort",
+          "values": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ]
+    },
+    "gpt-5.6-terra": {
+      "id": "gpt-5.6-terra",
+      "reasoning": true,
+      "reasoningOptions": [
+        {
+          "type": "effort",
+          "values": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ]
+    },
+    "gpt-5.6-luna": {
+      "id": "gpt-5.6-luna",
+      "reasoning": true,
+      "reasoningOptions": [
+        {
+          "type": "effort",
+          "values": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ]
+        }
+      ]
     }
   },
   "openrouter": {

package/src/providers/pi-mono-mcp-client.ts

@@ -1,133 +1,2 @@
-/**
- * Minimal MCP client for Streamable HTTP transport.
- *
- * Connects to the swarm's HTTP MCP endpoint, performs the handshake,
- * discovers tools, and forwards tool calls. This avoids depending on
- * a separate MCP client library for pi-mono.
- */
-
-interface McpTool {
-  name: string;
-  description?: string;
-  inputSchema: Record<string, unknown>;
-}
-
-interface McpToolCallResult {
-  content: Array<{ type: string; text?: string }>;
-  isError?: boolean;
-}
-
-export class McpHttpClient {
-  private sessionId: string | null = null;
-  private nextId = 1;
-  /** Additional headers merged into every request (e.g. for installed MCP servers) */
-  public customHeaders: Record<string, string> = {};
-  /**
-   * When true, baseUrl is used as-is for requests (external MCP servers).
-   * When false (default), /mcp is appended (swarm convention).
-   */
-  public useRawUrl = false;
-
-  constructor(
-    private baseUrl: string,
-    private apiKey: string,
-    private agentId: string,
-    private taskId?: string,
-  ) {}
-
-  private async send(body: unknown): Promise<{ data: unknown; headers: Headers }> {
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      Accept: "application/json, text/event-stream",
-      Authorization: `Bearer ${this.apiKey}`,
-      "X-Agent-ID": this.agentId,
-      ...this.customHeaders,
-    };
-    if (this.taskId) {
-      headers["X-Source-Task-Id"] = this.taskId;
-    }
-    if (this.sessionId) {
-      headers["mcp-session-id"] = this.sessionId;
-    }
-
-    const url = this.useRawUrl ? this.baseUrl : `${this.baseUrl}/mcp`;
-    const res = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-    });
-
-    if (!res.ok) {
-      throw new Error(`MCP request failed: ${res.status} ${res.statusText}`);
-    }
-
-    // Capture session ID from response
-    const sid = res.headers.get("mcp-session-id");
-    if (sid) this.sessionId = sid;
-
-    // Handle SSE responses (extract JSON from event stream)
-    const contentType = res.headers.get("content-type") || "";
-    if (contentType.includes("text/event-stream")) {
-      const text = await res.text();
-      const dataLines = text
-        .split("\n")
-        .filter((l) => l.startsWith("data: "))
-        .map((l) => l.slice(6));
-      const lastData = dataLines[dataLines.length - 1];
-      return { data: lastData ? JSON.parse(lastData) : null, headers: res.headers };
-    }
-
-    const data = await res.json();
-    return { data, headers: res.headers };
-  }
-
-  /** Perform MCP initialize + initialized handshake */
-  async initialize(): Promise<void> {
-    const { data } = await this.send({
-      jsonrpc: "2.0",
-      id: this.nextId++,
-      method: "initialize",
-      params: {
-        protocolVersion: "2025-03-26",
-        capabilities: {},
-        clientInfo: { name: "agent-swarm-pi-mono", version: "1.0.0" },
-      },
-    });
-
-    if (!data || typeof data !== "object" || !("result" in (data as Record<string, unknown>))) {
-      throw new Error(`MCP initialize failed: ${JSON.stringify(data)}`);
-    }
-
-    // Send initialized notification (no response expected for notifications)
-    await this.send({
-      jsonrpc: "2.0",
-      method: "notifications/initialized",
-    });
-  }
-
-  /** Discover all available MCP tools */
-  async listTools(): Promise<McpTool[]> {
-    const { data } = await this.send({
-      jsonrpc: "2.0",
-      id: this.nextId++,
-      method: "tools/list",
-      params: {},
-    });
-
-    const result = data as { result?: { tools?: McpTool[] } };
-    return result?.result?.tools ?? [];
-  }
-
-  /** Call an MCP tool */
-  async callTool(name: string, args: Record<string, unknown>): Promise<McpToolCallResult> {
-    const { data } = await this.send({
-      jsonrpc: "2.0",
-      id: this.nextId++,
-      method: "tools/call",
-      params: { name, arguments: args },
-    });
-
-    const result = data as { result?: McpToolCallResult };
-    return result?.result ?? { content: [{ type: "text", text: "No result" }] };
-  }
-}
+export type { McpTool, McpToolCallResult } from "@/mcp-client/http-client";
+export { McpHttpClient } from "@/mcp-client/http-client";

package/src/providers/reasoning-effort.ts

@@ -14,8 +14,8 @@
 
 import reasoningSnapshotJson from "./modelsdev-reasoning.json";
 
-/** Closed, normalized enum. `minimal` and `max` are intentionally out of scope for v1 (see plan). */
-export const REASONING_EFFORT_LEVELS = ["off", "low", "medium", "high", "xhigh"] as const;
+/** Closed, normalized enum. `minimal` remains out of scope; GPT-5.6 Codex adds `max`. */
+export const REASONING_EFFORT_LEVELS = ["off", "low", "medium", "high", "xhigh", "max"] as const;
 export type ReasoningEffort = (typeof REASONING_EFFORT_LEVELS)[number];
 
 /** The four local harnesses this feature covers (Devin / claude-managed are out of scope). */
@@ -74,13 +74,14 @@ const SNAPSHOT = reasoningSnapshotJson as ReasoningSnapshot;
 /** Shared-safe subset accepted by all four harnesses on at least their default models (see research doc). */
 const FALLBACK_LEVELS: ReasoningEffort[] = ["low", "medium", "high"];
 
-/** models.dev `reasoning_options[].type === "effort"` value → our normalized enum. `minimal`/`max` intentionally dropped. */
+/** models.dev `reasoning_options[].type === "effort"` value → our normalized enum. `minimal` intentionally dropped. */
 const EFFORT_VALUE_MAP: Partial<Record<string, ReasoningEffort>> = {
   none: "off",
   low: "low",
   medium: "medium",
   high: "high",
   xhigh: "xhigh",
+  max: "max",
 };
 
 function splitProviderModel(model: string): { providerId: string; modelId: string } {
@@ -143,6 +144,10 @@ function applyHarnessOverrides(
     }
   }
 
+  if (harness !== "codex") {
+    result = result.filter((l) => l !== "max");
+  }
+
   if (harness === "codex") {
     // The cache already tends to encode this correctly per model (verified:
     // `gpt-5.1-codex` excludes xhigh, `gpt-5.1-codex-max` includes it). This
@@ -173,7 +178,7 @@ function pickDefault(levels: ReasoningEffort[]): ReasoningEffort | null {
  *     models absent from the snapshot) → unsupported.
  *  2. `reasoning: false` → unsupported, regardless of the override table.
  *  3. `reasoning_options` has a usable `type: "effort"` entry → levels come
- *     from its `values` (mapped/filtered — `none`→`off`, `minimal`/`max` dropped).
+ *     from its `values` (mapped/filtered — `none`→`off`, `minimal` dropped).
  *  4. Otherwise (`reasoning: true`, no usable effort entry) → the shared-safe
  *     fallback subset `{low, medium, high}`.
  *  5. Harness-specific override table applied on top for known quirks.
@@ -222,7 +227,7 @@ function applyPiEffort(level: ReasoningEffort): ReasoningEffortApplication {
 }
 
 /** Level → numeric thinking budget, only used for Opencode's Anthropic provider (see below). Internal transport detail, not a user-facing knob. */
-const ANTHROPIC_BUDGET_TOKENS_BY_LEVEL: Record<Exclude<ReasoningEffort, "off">, number> = {
+const ANTHROPIC_BUDGET_TOKENS_BY_LEVEL: Record<Exclude<ReasoningEffort, "off" | "max">, number> = {
   low: 4096,
   medium: 10240,
   high: 32768,
@@ -238,6 +243,7 @@ function buildOpencodeReasoningOptions(
     // qualitative level — translate internally (see "What We're NOT Doing" in
     // the plan: no numeric budget surface for operators, only this
     // adapter-internal transport detail).
+    if (level === "max") return { reasoningEffort: level };
     return { thinking: { type: "enabled", budgetTokens: ANTHROPIC_BUDGET_TOKENS_BY_LEVEL[level] } };
   }
   if (providerId === "openrouter") {

package/src/rbac/admission.ts

@@ -0,0 +1,68 @@
+import type { PermissionVerb } from "./permissions";
+
+export type AdmissionGrant = {
+  grantsAll: boolean;
+  verbs: {
+    has(verb: PermissionVerb): boolean;
+  };
+};
+
+export type AdmissionRbac = { permission: PermissionVerb } | { ungated: string };
+
+export type AdmissionDecision =
+  | { allow: true; verb?: PermissionVerb }
+  | { allow: false; reason: string; verb?: PermissionVerb };
+
+export function isRbacEnabled(): boolean {
+  return process.env.RBAC_ENABLED === "true";
+}
+
+export function decideAdmission(input: {
+  method: string;
+  rbac: AdmissionRbac | undefined;
+  routeKnown: boolean;
+  grant: AdmissionGrant;
+}): AdmissionDecision {
+  if (input.grant.grantsAll) {
+    return { allow: true };
+  }
+
+  if (input.rbac && "permission" in input.rbac) {
+    const verb = input.rbac.permission;
+    if (input.grant.verbs.has(verb)) {
+      return { allow: true, verb };
+    }
+    return { allow: false, reason: `admission: missing permission '${verb}'`, verb };
+  }
+
+  const method = input.method.toUpperCase();
+  if (method === "GET" || method === "HEAD") {
+    return { allow: true };
+  }
+
+  return { allow: false, reason: "admission: route has no permission verb (operator-only)" };
+}
+
+export function decideToolAdmission(input: {
+  rbac: AdmissionRbac | undefined;
+  readOnly: boolean;
+  grant: AdmissionGrant;
+}): AdmissionDecision {
+  if (input.grant.grantsAll) {
+    return { allow: true };
+  }
+
+  if (input.rbac && "permission" in input.rbac) {
+    const verb = input.rbac.permission;
+    if (input.grant.verbs.has(verb)) {
+      return { allow: true, verb };
+    }
+    return { allow: false, reason: `admission: missing permission '${verb}'`, verb };
+  }
+
+  if (input.readOnly) {
+    return { allow: true };
+  }
+
+  return { allow: false, reason: "admission: tool has no permission verb (operator-only)" };
+}

package/src/rbac/index.ts

@@ -4,6 +4,8 @@
  * Import from here at call sites: `import { can } from "@/rbac"`.
  */
 
+export type { AdmissionDecision, AdmissionGrant, AdmissionRbac } from "./admission";
+export { decideAdmission, decideToolAdmission, isRbacEnabled } from "./admission";
 export type { AuditSink } from "./can";
 export { can, clearAuditSink, setAuditSink } from "./can";
 export type { LegacyRule } from "./legacy-policy";

package/src/rbac/legacy-policy.ts

@@ -147,10 +147,12 @@ export const LEGACY_POLICY = {
   "agent.profile.update.any": leadOnly,
   "agent.context.read.any": leadOnly,
   "task.cancel.any": leadOrTaskCreator,
+  "task.create.own": anyAuthenticated,
   "task.read.own": requesterOwnsTask,
   "task.cancel.own": requesterOwnsTask,
   "task.action.own": requesterOwnsTask,
   "task.fs.mutate": taskFsMutate,
+  "favorite.write.own": anyAuthenticated,
   "memory.learning.inject": leadOnly,
   "memory.delete.any": memoryOwnerOrLeadSwarm,
   "channel.delete": leadOnly,
@@ -163,6 +165,7 @@ export const LEGACY_POLICY = {
   "integration.slack.update": leadOnly,
   "credential-binding.manage": leadOnly,
   "script-connection.manage": leadOnly,
+  "script-connection.invoke": anyAuthenticated,
   "config.credential-bindings.write": leadOnly,
   "config.write.any": leadOnly,
   "config.delete.any": leadOnly,
@@ -179,7 +182,16 @@ export const LEGACY_POLICY = {
   "mcp-server.uninstall.any": leadOnly,
   "mcp-server.delete.any": leadOrResourceOwner,
   "mcp-server.update.any": leadOrResourceOwner,
+  "mcp-server.read.secrets": leadOnly,
+  "mcp-oauth.authorize.any": anyAuthenticated,
   "kv.write.any": leadOrOwnNamespace,
+  "page.delete.any": leadOrResourceOwner,
   "script.global.write": leadOnly,
   "script.global.delete": leadOnly,
+  "script.search": anyAuthenticated,
+  "script.api.read.secrets": leadOnly,
+  "script.api.create": leadOnly,
+  "script.api.update": leadOnly,
+  "script.api.rotate": leadOnly,
+  "script.api.delete": leadOnly,
 } as const satisfies Record<PermissionVerb, LegacyRule>;

package/src/rbac/permissions.ts

@@ -33,6 +33,10 @@ export const PERMISSIONS = {
     description: "Cancel any task (beyond tasks the caller created).",
     namespace: "task",
   },
+  "task.create.own": {
+    description: "Create a task the caller owns.",
+    namespace: "task",
+  },
   "task.read.own": {
     description: "Read details of a task the principal requested.",
     namespace: "task",
@@ -49,6 +53,10 @@ export const PERMISSIONS = {
     description: "Mutate a task's filesystem artifacts and attachments.",
     namespace: "task",
   },
+  "favorite.write.own": {
+    description: "Set a favorite the caller owns.",
+    namespace: "favorite",
+  },
   "memory.learning.inject": {
     description: "Inject a learning into another agent's memory.",
     namespace: "memory",
@@ -97,6 +105,10 @@ export const PERMISSIONS = {
     description: "Manage script connections.",
     namespace: "script-connection",
   },
+  "script-connection.invoke": {
+    description: "Invoke a script MCP connection through the server-side proxy.",
+    namespace: "script-connection",
+  },
   "config.credential-bindings.write": {
     description: "Write the SCRIPT_CREDENTIAL_BINDINGS swarm-config key.",
     namespace: "config",
@@ -161,10 +173,22 @@ export const PERMISSIONS = {
     description: "Update an MCP server the caller does not own.",
     namespace: "mcp-server",
   },
+  "mcp-server.read.secrets": {
+    description: "Read resolved MCP server secret env/header values.",
+    namespace: "mcp-server",
+  },
+  "mcp-oauth.authorize.any": {
+    description: "Start an MCP-server OAuth authorize flow for a caller-supplied user scope.",
+    namespace: "mcp-oauth",
+  },
   "kv.write.any": {
     description: "Write another agent's task:agent: KV namespace.",
     namespace: "kv",
   },
+  "page.delete.any": {
+    description: "Delete a page the caller does not own.",
+    namespace: "page",
+  },
   "script.global.write": {
     description: "Create or update a global-scope script.",
     namespace: "script",
@@ -173,6 +197,30 @@ export const PERMISSIONS = {
     description: "Delete a global-scope script.",
     namespace: "script",
   },
+  "script.search": {
+    description: "Search reusable scripts visible to the caller.",
+    namespace: "script",
+  },
+  "script.api.read.secrets": {
+    description: "Reveal an external script API endpoint bearer token.",
+    namespace: "script",
+  },
+  "script.api.create": {
+    description: "Expose a script as an external HTTP API endpoint.",
+    namespace: "script",
+  },
+  "script.api.update": {
+    description: "Update an external script API endpoint.",
+    namespace: "script",
+  },
+  "script.api.rotate": {
+    description: "Rotate an external script API endpoint bearer token.",
+    namespace: "script",
+  },
+  "script.api.delete": {
+    description: "Delete an external script API endpoint.",
+    namespace: "script",
+  },
 } as const satisfies Record<string, { description: string; namespace: string }>;
 
 export type PermissionVerb = keyof typeof PERMISSIONS;

package/src/scheduler/scheduler.ts

@@ -7,6 +7,10 @@ import {
   getWorkflow,
   updateScheduledTask,
 } from "@/be/db";
+import {
+  getScriptApiConnectionDescriptors,
+  getScriptMcpConnectionDescriptors,
+} from "@/be/script-connections";
 import { buildScriptCredentialBindings } from "@/be/script-credential-broker";
 import { getScript } from "@/be/scripts/db";
 import { runScript } from "@/scripts-runtime/loader";
@@ -56,6 +60,7 @@ export function createStandaloneScheduleTask(
     modelTier: schedule.modelTier,
     scheduleId: schedule.id,
     source: "schedule",
+    requestedByUserId: schedule.createdBy,
     contextKey: scheduleContextKey({ scheduleId: schedule.id }),
   });
 }
@@ -81,7 +86,9 @@ async function executeScheduleScript(schedule: ScheduledTask): Promise<void> {
     args: schedule.scriptArgs ?? {},
     fsMode: "none",
     agentId,
-    egressSecrets: buildScriptCredentialBindings({ agentId }),
+    egressSecrets: await buildScriptCredentialBindings({ agentId }),
+    apiConnections: getScriptApiConnectionDescriptors({ agentId }),
+    mcpConnections: getScriptMcpConnectionDescriptors({ agentId }),
     timeoutMs: 60_000,
   });
 
@@ -136,6 +143,7 @@ export async function dispatchScheduleTarget(
       };
       const runId = await startWorkflowExecution(workflow, triggerData, registry, {
         triggerType: "schedule",
+        requestedByUserId: schedule.createdBy,
       });
       console.log(
         `[Scheduler] Schedule "${schedule.name}" → triggered workflow "${workflow.name}"`,