@growthub/cli 0.13.4 → 0.13.5

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/metadata-graph/route.js

@@ -0,0 +1,184 @@
+/**
+ * GET /api/workspace/metadata-graph
+ *
+ * Growthub Workspace Metadata Graph V1 — read-only projection.
+ *
+ * Combines the governed workspace config and the live source-record sidecar
+ * into a typed metadata store and a node/edge graph. Consumers (the UI
+ * inspector, the workspace helper agent, and external operators) use this
+ * envelope to ask dependency questions without re-deriving widget/workflow
+ * contracts inside every component.
+ *
+ * Optional query parameters:
+ *   - staleKind: "object" | "field" | "sourceRecord" | "workflow" | "agentHost" | "widget"
+ *   - staleId:   the corresponding metadata id (for `field`, use
+ *                "<objectId>::<fieldId>")
+ *
+ *   When both are provided the response `stale.groups` and `stale.reasons`
+ *   reflect `selectStaleMetadataGroups({ kind, id })`. When omitted the
+ *   stale section returns the empty baseline.
+ *
+ * Authority invariants:
+ *   - GET only. PATCH / POST / PUT / DELETE are not exposed. Writes still
+ *     flow through the existing governed routes
+ *     (`PATCH /api/workspace`, `POST /api/workspace/refresh-sources`,
+ *     `POST /api/workspace/sandbox-run`).
+ *   - growthub.config.json remains the authoritative artifact.
+ *   - No secrets are returned. Field metadata derived from secret-shaped
+ *     column names is marked `isSecret: true` but no value is echoed.
+ *   - Failures during read OR projection fall back to an empty store with
+ *     warnings — this route never throws.
+ */
+
+import { NextResponse } from "next/server";
+import { readWorkspaceConfig, readWorkspaceSourceRecords } from "@/lib/workspace-config";
+import { buildWorkspaceMetadataStore } from "@/lib/workspace-metadata-store";
+import { buildWorkspaceMetadataGraph } from "@/lib/workspace-metadata-graph";
+import { selectStaleMetadataGroups } from "@/lib/workspace-metadata-selectors";
+
+const ENVELOPE_KIND = "growthub-workspace-metadata-graph-v1";
+const ENVELOPE_VERSION = 1;
+
+function emptyMetadataStore() {
+  return {
+    kind: "growthub-workspace-metadata-store-v1",
+    version: 1,
+    objects: [],
+    fields: [],
+    views: [],
+    filters: [],
+    sorts: [],
+    widgets: [],
+    dashboards: [],
+    workflows: [],
+    workflowNodes: [],
+    workflowActions: [],
+    runInputs: [],
+    agentHosts: [],
+    sandboxes: [],
+    integrations: [],
+    integrationEntities: [],
+    sourceRecords: [],
+    runs: [],
+    outputArtifacts: [],
+    workerKits: [],
+    pipelineHealth: [],
+    warnings: []
+  };
+}
+
+async function GET(request) {
+  const warnings = [];
+
+  let workspaceConfig = null;
+  try {
+    workspaceConfig = await readWorkspaceConfig();
+  } catch (error) {
+    warnings.push(`Failed to read workspace config: ${error?.message || "unknown error"}`);
+  }
+
+  let workspaceSourceRecords = {};
+  try {
+    workspaceSourceRecords = (await readWorkspaceSourceRecords()) || {};
+  } catch (error) {
+    warnings.push(`Failed to read source records sidecar: ${error?.message || "unknown error"}`);
+  }
+
+  // Defensive: helpers are designed to never throw on partial/unknown input,
+  // but the route must remain HTTP-200 even if an unexpected exception bubbles
+  // up (so the UI inspector and agents always get a typed envelope).
+  let metadataStore;
+  try {
+    metadataStore = buildWorkspaceMetadataStore({
+      workspaceConfig: workspaceConfig || {},
+      workspaceSourceRecords
+    });
+    warnings.push(...metadataStore.warnings);
+  } catch (error) {
+    warnings.push(`Failed to build metadata store: ${error?.message || "unknown error"}`);
+    metadataStore = emptyMetadataStore();
+  }
+
+  let graph;
+  try {
+    graph = buildWorkspaceMetadataGraph(metadataStore);
+    warnings.push(...graph.warnings);
+  } catch (error) {
+    warnings.push(`Failed to build metadata graph: ${error?.message || "unknown error"}`);
+    graph = { kind: "growthub-workspace-metadata-graph-v1", version: 1, nodes: [], edges: [], warnings: [] };
+  }
+
+  // Optional stale-group selector via query params.
+  let staleGroups = [];
+  let staleReasons = [];
+  try {
+    const url = request && request.url ? new URL(request.url) : null;
+    const staleKind = url ? (url.searchParams.get("staleKind") || "").trim() : "";
+    const staleId = url ? (url.searchParams.get("staleId") || "").trim() : "";
+    if (staleKind && staleId) {
+      const result = selectStaleMetadataGroups(metadataStore, { kind: staleKind, id: staleId });
+      staleGroups = Array.isArray(result?.groups) ? result.groups : [];
+      staleReasons = Array.isArray(result?.reasons) ? result.reasons : [];
+    }
+  } catch (error) {
+    warnings.push(`Failed to compute stale groups: ${error?.message || "unknown error"}`);
+  }
+
+  return NextResponse.json({
+    kind: ENVELOPE_KIND,
+    version: ENVELOPE_VERSION,
+    authority: {
+      config: "growthub.config.json",
+      sourceRecords: "growthub.source-records.json",
+      readOnlyProjection: true
+    },
+    metadata: {
+      objects: metadataStore.objects,
+      fields: metadataStore.fields,
+      views: metadataStore.views,
+      filters: metadataStore.filters,
+      sorts: metadataStore.sorts,
+      widgets: metadataStore.widgets,
+      dashboards: metadataStore.dashboards,
+      workflows: metadataStore.workflows,
+      workflowNodes: metadataStore.workflowNodes,
+      workflowActions: metadataStore.workflowActions,
+      runInputs: metadataStore.runInputs,
+      agentHosts: metadataStore.agentHosts,
+      sandboxes: metadataStore.sandboxes,
+      integrations: metadataStore.integrations,
+      integrationEntities: metadataStore.integrationEntities,
+      sourceRecords: metadataStore.sourceRecords,
+      runs: metadataStore.runs,
+      outputArtifacts: metadataStore.outputArtifacts,
+      workerKits: metadataStore.workerKits,
+      pipelineHealth: metadataStore.pipelineHealth
+    },
+    graph: {
+      nodes: graph.nodes,
+      edges: graph.edges
+    },
+    stale: {
+      groups: staleGroups,
+      reasons: staleReasons
+    },
+    warnings,
+    selectors: {
+      // Manifest of selectors the route honours. Only `selectStaleMetadataGroups`
+      // is wired through HTTP (via `?staleKind=&staleId=`). The remaining
+      // selectors are exposed as importable helpers for server-side consumers
+      // and the read-only inspector; they are NOT toggled through query
+      // params in V1.
+      httpEnabled: ["selectStaleMetadataGroups"],
+      helperOnly: [
+        "selectWidgetRequiredFields",
+        "selectWorkflowNodeInputSchema",
+        "selectObjectFilterableFields",
+        "selectObjectSortableFields",
+        "selectRunLineage"
+      ]
+    }
+  });
+}
+
+export { GET };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/sandbox-run/route.js

@@ -392,6 +392,12 @@ function buildRunResponse({
     base.runInputs = runInputs;
     base.inputSummary = summarizeRunInputs(runInputs);
   }
+  if (result && typeof result === "object" && result.swarm && typeof result.swarm === "object") {
+    base.swarm = result.swarm;
+  }
+  if (result && typeof result === "object" && Array.isArray(result.logTree)) {
+    base.logTree = result.logTree;
+  }
   base.exports = {
     available: ["download-json", "copy-output", "download-stdout", "download-stderr", "download-log-node"],
     external: []
@@ -558,11 +564,28 @@ async function POST(request) {
       workspaceConfig,
       row: rowForRun,
       timeoutMs,
-      runInputs: normalizedRunInputs
+      runInputs: normalizedRunInputs,
+      executionContext: {
+        runId,
+        ranAt,
+        runtime,
+        agentHost,
+        adapterId,
+        env,
+        envRefSlugs,
+        envRefsMissing,
+        envRefsResolved,
+        networkAllow,
+        allowList,
+        instructions,
+        command,
+        timeoutMs,
+        sandboxName: rowForRun.Name || name
+      }
     });
     if (graphResult !== null) {
       result = graphResult;
-      effectiveAdapterId = "orchestration-graph";
+      effectiveAdapterId = String(graphResult?.adapterMeta?.adapter || "").trim() || "orchestration-graph";
     }
   }
 

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/data-model/components/AgentSwarmPanel.jsx

@@ -0,0 +1,326 @@
+"use client";
+
+import { useMemo } from "react";
+import { Plus, Trash2 } from "lucide-react";
+import { HOST_AUTH_CATALOG } from "@/lib/sandbox-agent-host-catalog";
+
+function getHostOptions() {
+  return Object.entries(HOST_AUTH_CATALOG || {}).map(([slug, host]) => ({
+    value: slug,
+    label: host?.label || slug
+  }));
+}
+
+function patchOrchestrator(graph, patch) {
+  const nodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
+  return {
+    ...graph,
+    nodes: nodes.map((node) =>
+      node?.type === "thinAdapter"
+        ? { ...node, config: { ...(node.config || {}), ...patch } }
+        : node
+    )
+  };
+}
+
+function patchSynthesis(graph, patch) {
+  const nodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
+  return {
+    ...graph,
+    nodes: nodes.map((node) =>
+      node?.type === "tool-result"
+        ? { ...node, config: { ...(node.config || {}), ...patch } }
+        : node
+    )
+  };
+}
+
+function patchSubagent(graph, nodeId, patch) {
+  const nodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
+  return {
+    ...graph,
+    nodes: nodes.map((node) =>
+      node?.type === "ai-agent" && String(node.id) === String(nodeId)
+        ? {
+            ...node,
+            label: patch.role != null ? String(patch.role) : node.label,
+            config: { ...(node.config || {}), ...patch }
+          }
+        : node
+    )
+  };
+}
+
+function addSubagent(graph, defaults = {}) {
+  const nodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
+  const edges = Array.isArray(graph?.edges) ? graph.edges : [];
+  const existing = new Set(nodes.map((n) => String(n?.id || "")));
+  let id = `subagent-${nodes.filter((n) => n?.type === "ai-agent").length + 1}`;
+  let index = 2;
+  while (existing.has(id)) {
+    id = `subagent-${index}`;
+    index += 1;
+  }
+  const node = {
+    id,
+    type: "ai-agent",
+    label: defaults.role || "Subagent",
+    subtitle: "Swarm subagent",
+    config: {
+      role: defaults.role || "Subagent",
+      description: defaults.description || "",
+      taskPrompt: defaults.taskPrompt || "",
+      tools: Array.isArray(defaults.tools) ? defaults.tools : [],
+      agentHost: defaults.agentHost || "",
+      required: true,
+      canReadWorkspace: true,
+      canWriteDraft: false,
+      networkAccess: false,
+      maxTokens: 0,
+      timeoutMs: 0
+    }
+  };
+  const nextEdges = [...edges];
+  if (nodes.some((n) => n?.type === "thinAdapter")) {
+    nextEdges.push({ from: "orchestrator", to: id, passes: "subtask-assignment" });
+  }
+  if (nodes.some((n) => n?.type === "tool-result")) {
+    const synth = nodes.find((n) => n?.type === "tool-result");
+    nextEdges.push({ from: id, to: synth.id, passes: "subtask-result" });
+  }
+  return { ...graph, nodes: [...nodes, node], edges: nextEdges };
+}
+
+function removeSubagent(graph, nodeId) {
+  const id = String(nodeId);
+  return {
+    ...graph,
+    nodes: (Array.isArray(graph?.nodes) ? graph.nodes : []).filter((n) => String(n.id) !== id),
+    edges: (Array.isArray(graph?.edges) ? graph.edges : []).filter(
+      (edge) => String(edge.from) !== id && String(edge.to) !== id
+    )
+  };
+}
+
+function patchSwarmConfig(graph, patch) {
+  const base = graph?.swarm && typeof graph.swarm === "object" ? graph.swarm : {};
+  return { ...graph, swarm: { ...base, ...patch } };
+}
+
+export function AgentSwarmPanel({ graph, onGraphChange, disabled }) {
+  const hostOptions = useMemo(getHostOptions, []);
+  if (!graph || typeof graph !== "object") return null;
+
+  const orchestrator = (Array.isArray(graph.nodes) ? graph.nodes : []).find((n) => n?.type === "thinAdapter") || null;
+  const subagents = (Array.isArray(graph.nodes) ? graph.nodes : []).filter((n) => n?.type === "ai-agent");
+  const synthesis = (Array.isArray(graph.nodes) ? graph.nodes : []).find((n) => n?.type === "tool-result") || null;
+  const swarmCfg = graph.swarm && typeof graph.swarm === "object" ? graph.swarm : {};
+  const weights = swarmCfg.rewardWeights || { parallel: 0.25, finish: 0.35, outcome: 0.4 };
+
+  function patchGraph(updater) {
+    if (typeof updater !== "function") return;
+    onGraphChange?.(updater);
+  }
+
+  return (
+    <div className="dm-orchestration-config dm-agent-swarm-panel">
+      <div className="dm-orchestration-config__pane">
+        <div className="dm-orchestration-config__section">
+          <span>Orchestrator</span>
+          <label className="dm-orchestration-config__field">
+            <span>Prompt</span>
+            <textarea
+              rows={3}
+              value={orchestrator?.config?.prompt || ""}
+              disabled={disabled || !orchestrator}
+              onChange={(e) => patchGraph((g) => patchOrchestrator(g, { prompt: e.target.value }))}
+            />
+          </label>
+        </div>
+
+        <div className="dm-orchestration-config__section">
+          <div className="dm-agent-swarm-panel__row">
+            <span>Subagents · {subagents.length}</span>
+            <button
+              type="button"
+              className="dm-btn-outline"
+              disabled={disabled}
+              onClick={() => patchGraph((g) => addSubagent(g))}
+            >
+              <Plus size={12} aria-hidden="true" /> Add
+            </button>
+          </div>
+          {subagents.length === 0 && (
+            <p className="dm-orchestration-config__hint">Add at least one subagent.</p>
+          )}
+          {subagents.map((node) => {
+            const cfg = node.config || {};
+            return (
+              <div key={node.id} className="dm-agent-swarm-panel__subagent">
+                <div className="dm-agent-swarm-panel__row">
+                  <input
+                    className="dm-agent-swarm-panel__role"
+                    placeholder="Role"
+                    value={cfg.role || node.label || ""}
+                    disabled={disabled}
+                    onChange={(e) => patchGraph((g) => patchSubagent(g, node.id, { role: e.target.value }))}
+                  />
+                  <button
+                    type="button"
+                    className="dm-btn-ghost"
+                    disabled={disabled}
+                    onClick={() => patchGraph((g) => removeSubagent(g, node.id))}
+                    aria-label={`Remove ${cfg.role || node.id}`}
+                  >
+                    <Trash2 size={12} aria-hidden="true" />
+                  </button>
+                </div>
+                <label className="dm-orchestration-config__field">
+                  <span>Description</span>
+                  <input
+                    placeholder="One-sentence charter"
+                    value={cfg.description || ""}
+                    disabled={disabled}
+                    onChange={(e) => patchGraph((g) => patchSubagent(g, node.id, { description: e.target.value }))}
+                  />
+                </label>
+                <label className="dm-orchestration-config__field">
+                  <span>Task</span>
+                  <textarea
+                    rows={2}
+                    value={cfg.taskPrompt || ""}
+                    disabled={disabled}
+                    onChange={(e) => patchGraph((g) => patchSubagent(g, node.id, { taskPrompt: e.target.value }))}
+                  />
+                </label>
+                <label className="dm-orchestration-config__field">
+                  <span>Tools</span>
+                  <input
+                    placeholder="read, summarize"
+                    value={Array.isArray(cfg.tools) ? cfg.tools.join(", ") : ""}
+                    disabled={disabled}
+                    onChange={(e) => patchGraph((g) => patchSubagent(g, node.id, {
+                      tools: e.target.value.split(",").map((t) => t.trim()).filter(Boolean)
+                    }))}
+                  />
+                </label>
+                <label className="dm-orchestration-config__field">
+                  <span>Max tokens</span>
+                  <input
+                    type="number"
+                    min="0"
+                    placeholder="0 = inherit"
+                    value={cfg.maxTokens || 0}
+                    disabled={disabled}
+                    onChange={(e) => patchGraph((g) => patchSubagent(g, node.id, { maxTokens: Math.max(0, Number(e.target.value) || 0) }))}
+                  />
+                </label>
+                <label className="dm-orchestration-config__field">
+                  <span>Agent host</span>
+                  <select
+                    value={cfg.agentHost || ""}
+                    disabled={disabled}
+                    onChange={(e) => patchGraph((g) => patchSubagent(g, node.id, { agentHost: e.target.value }))}
+                  >
+                    <option value="">Inherit</option>
+                    {hostOptions.map((opt) => (
+                      <option key={opt.value} value={opt.value}>{opt.label}</option>
+                    ))}
+                  </select>
+                </label>
+                <label className="dm-orchestration-config__field dm-orchestration-config__field-inline">
+                  <input
+                    type="checkbox"
+                    checked={cfg.required !== false}
+                    disabled={disabled}
+                    onChange={(e) => patchGraph((g) => patchSubagent(g, node.id, { required: e.target.checked }))}
+                  />
+                  <span>Required</span>
+                </label>
+                <label
+                  className="dm-orchestration-config__field dm-orchestration-config__field-inline"
+                  title="Network is granted only when both this and the row's networkAllow are on."
+                >
+                  <input
+                    type="checkbox"
+                    checked={cfg.networkAccess === true}
+                    disabled={disabled}
+                    onChange={(e) => patchGraph((g) => patchSubagent(g, node.id, { networkAccess: e.target.checked }))}
+                  />
+                  <span>Network</span>
+                </label>
+              </div>
+            );
+          })}
+        </div>
+
+        <div className="dm-orchestration-config__section">
+          <span>Concurrency & reward</span>
+          <label className="dm-orchestration-config__field">
+            <span>Max concurrency</span>
+            <input
+              type="number"
+              min="1"
+              value={swarmCfg.maxConcurrency ?? subagents.length}
+              disabled={disabled}
+              onChange={(e) => patchGraph((g) => patchSwarmConfig(g, { maxConcurrency: Math.max(1, Number(e.target.value) || 1) }))}
+            />
+          </label>
+          <div className="dm-agent-swarm-panel__weights">
+            {[
+              ["parallel", "Parallel"],
+              ["finish", "Finish"],
+              ["outcome", "Outcome"]
+            ].map(([key, label]) => (
+              <label key={key} className="dm-orchestration-config__field">
+                <span>{label}</span>
+                <input
+                  type="number"
+                  step="0.05"
+                  min="0"
+                  max="1"
+                  value={weights[key] ?? 0}
+                  disabled={disabled}
+                  onChange={(e) =>
+                    patchGraph((g) =>
+                      patchSwarmConfig(g, {
+                        rewardWeights: { ...weights, [key]: Number(e.target.value) || 0 }
+                      })
+                    )
+                  }
+                />
+              </label>
+            ))}
+          </div>
+          <label className="dm-orchestration-config__field">
+            <span>Outcome criteria</span>
+            <textarea
+              rows={2}
+              value={swarmCfg.outcomeCriteria || ""}
+              disabled={disabled}
+              onChange={(e) => patchGraph((g) => patchSwarmConfig(g, { outcomeCriteria: e.target.value }))}
+            />
+          </label>
+          <p className="dm-orchestration-config__hint">
+            Outcome is parsed from the synthesizer's last <code>OUTCOME_SCORE: 0–1</code>; otherwise falls back to required-completion.
+          </p>
+        </div>
+
+        {synthesis && (
+          <div className="dm-orchestration-config__section">
+            <span>Synthesizer</span>
+            <label className="dm-orchestration-config__field">
+              <span>Prompt</span>
+              <textarea
+                rows={2}
+                value={synthesis?.config?.outcomePrompt || ""}
+                disabled={disabled}
+                onChange={(e) => patchGraph((g) => patchSynthesis(g, { outcomePrompt: e.target.value }))}
+              />
+            </label>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/data-model/components/OrchestrationGraphEmptyCanvas.jsx

@@ -5,6 +5,7 @@ import { useState } from "react";
 export function OrchestrationGraphEmptyCanvas({
   onStartFromRegistry,
   onStartBlank,
+  onStartAgentSwarm,
   onPasteGraph,
   disabled
 }) {
@@ -23,6 +24,11 @@ export function OrchestrationGraphEmptyCanvas({
           <button type="button" className="dm-btn-outline" disabled={disabled} onClick={onStartBlank}>
             Start blank
           </button>
+          {onStartAgentSwarm && (
+            <button type="button" className="dm-btn-outline" disabled={disabled} onClick={onStartAgentSwarm}>
+              Add Agent Swarm
+            </button>
+          )}
         </div>
         <details
           className="dm-orchestration-canvas__paste"

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/data-model/components/OrchestrationNodeConfigPanel.jsx

@@ -897,7 +897,94 @@ export function OrchestrationNodeConfigPanel({
         </div>
       )}
 
-      {activeTab === "configuration" && type === "ai-agent" && (
+      {activeTab === "configuration" && type === "ai-agent" && (config.role || config.taskPrompt || config.required != null) && (
+        <div className="dm-orchestration-config__pane">
+          <label className="dm-orchestration-config__field">
+            <span>Role</span>
+            <input
+              value={config.role || node.label || ""}
+              disabled={disabled}
+              onChange={(e) => patchConfig({ role: e.target.value, __nodePatch: { label: e.target.value } })}
+            />
+          </label>
+          <label className="dm-orchestration-config__field">
+            <span>Description</span>
+            <input
+              placeholder="One-sentence charter"
+              value={config.description || ""}
+              disabled={disabled}
+              onChange={(e) => patchConfig({ description: e.target.value })}
+            />
+          </label>
+          <label className="dm-orchestration-config__field">
+            <span>Task</span>
+            <textarea
+              rows={4}
+              value={config.taskPrompt || ""}
+              disabled={disabled}
+              onChange={(e) => patchConfig({ taskPrompt: e.target.value })}
+            />
+          </label>
+          <label className="dm-orchestration-config__field">
+            <span>Tools</span>
+            <input
+              placeholder="read, summarize"
+              value={Array.isArray(config.tools) ? config.tools.join(", ") : ""}
+              disabled={disabled}
+              onChange={(e) => patchConfig({
+                tools: e.target.value.split(",").map((t) => t.trim()).filter(Boolean)
+              })}
+            />
+          </label>
+          <label className="dm-orchestration-config__field">
+            <span>Max tokens</span>
+            <input
+              type="number"
+              min="0"
+              placeholder="0 = inherit"
+              value={config.maxTokens || 0}
+              disabled={disabled}
+              onChange={(e) => patchConfig({ maxTokens: Math.max(0, Number(e.target.value) || 0) })}
+            />
+          </label>
+          <label className="dm-orchestration-config__field">
+            <span>Agent host</span>
+            <select
+              value={config.agentHost || ""}
+              disabled={disabled}
+              onChange={(e) => patchConfig({ agentHost: e.target.value })}
+            >
+              <option value="">Inherit</option>
+              {Object.entries(HOST_AUTH_CATALOG || {}).map(([slug, host]) => (
+                <option key={slug} value={slug}>{host?.label || slug}</option>
+              ))}
+            </select>
+          </label>
+          <label className="dm-orchestration-config__field dm-orchestration-config__field-inline">
+            <input
+              type="checkbox"
+              checked={config.required !== false}
+              disabled={disabled}
+              onChange={(e) => patchConfig({ required: e.target.checked })}
+            />
+            <span>Required</span>
+          </label>
+          <label
+            className="dm-orchestration-config__field dm-orchestration-config__field-inline"
+            title="Network is granted only when both this and the row's networkAllow are on."
+          >
+            <input
+              type="checkbox"
+              checked={config.networkAccess === true}
+              disabled={disabled}
+              onChange={(e) => patchConfig({ networkAccess: e.target.checked })}
+            />
+            <span>Network</span>
+          </label>
+        </div>
+      )}
+
+      {activeTab === "configuration" && type === "ai-agent" && !(config.role || config.taskPrompt || config.required != null) && (
         <div className="dm-orchestration-config__pane">
           <label className="dm-orchestration-config__field">
             <span>Model</span>