@matamt-dbg/dsh-studio 0.2.2 → 0.2.8

package/policy.js

@@ -39,7 +39,34 @@ function applyExecutionDefaults(args, defaults) {
 }
 
 // src/host/preset-policy.ts
-import { scopeOf } from "@deepseek-ai/dsh-scope";
+import { scopeChainOf, scopeOf } from "@deepseek-ai/dsh-scope";
+
+// src/tool-prompt-sections.ts
+var toolPromptSections = {
+  bash: ["tool:bash"],
+  pwsh: ["tool:pwsh"],
+  read: ["tool:read"],
+  write: ["tool:write"],
+  edit: ["tool:edit"],
+  glob: ["tool:glob"],
+  grep: ["tool:grep"],
+  job_list: ["tool:jobs"],
+  job_output: ["tool:jobs"],
+  job_kill: ["tool:jobs"],
+  web_fetch: ["tool:web_fetch"],
+  web_search: ["tool:web_search"],
+  get_goal: ["tool:goal"],
+  create_goal: ["tool:goal"],
+  update_goal: ["tool:goal"],
+  workflow: ["tool:workflow"]
+};
+function sectionsOnlyFor(hidden, kept) {
+  const owned = (names2) => new Set(names2.flatMap((name2) => toolPromptSections[name2] ?? []));
+  const still = owned(kept);
+  return [...owned(hidden)].filter((section) => !still.has(section));
+}
+
+// src/host/preset-policy.ts
 var POLICY_SECTION_ORDERS = Object.freeze({
   "tool:jobs": "TOOL_JOBS",
   "tool:bash": "TOOL_BASH",
@@ -51,7 +78,8 @@ var POLICY_SECTION_ORDERS = Object.freeze({
   "tool:grep": "TOOL_GREP",
   "tool:web_fetch": "TOOL_WEB_FETCH",
   "tool:web_search": "TOOL_WEB_SEARCH",
-  "tool:goal": "TOOL_GOAL"
+  "tool:goal": "TOOL_GOAL",
+  "tool:workflow": "TOOL_WORKFLOW"
 });
 var own2 = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 var record2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
@@ -69,6 +97,26 @@ function validatePolicy(config) {
   for (const [name2, text] of Object.entries(config.sections)) {
     if (!own2(POLICY_SECTION_ORDERS, name2) || typeof text !== "string") throw new Error(`Unsupported policy section: ${name2}`);
   }
+  if (config.childToolFilter !== void 0) {
+    const deny = record2(config.childToolFilter) ? config.childToolFilter.deny : void 0;
+    if (!Array.isArray(deny) || deny.some((name2) => typeof name2 !== "string" || !name2)) throw new Error("Invalid subagent tool filter");
+    for (const name2 of deny) if (!config.tools.includes(name2)) throw new Error(`Subagent tool filter requires selected tool: ${name2}`);
+  }
+}
+function childPolicy(config, hidden) {
+  const deny = new Set(hidden);
+  if (!deny.size) return config;
+  const keep = (entries) => Object.fromEntries(Object.entries(entries).filter(([name2]) => !deny.has(name2)));
+  const { childToolFilter: _filter, execution, ...rest } = config;
+  const tools = config.tools.filter((name2) => !deny.has(name2));
+  const blank = Object.fromEntries(sectionsOnlyFor([...deny], tools).filter((name2) => own2(POLICY_SECTION_ORDERS, name2)).map((name2) => [name2, ""]));
+  return {
+    ...rest,
+    tools,
+    toolOverrides: keep(config.toolOverrides),
+    sections: { ...config.sections, ...blank },
+    ...execution ? { execution: (({ batch, ...value }) => ({ ...value, defaults: keep(execution.defaults), ...batch && !deny.has(batch.tool) ? { batch } : {} }))(execution) } : {}
+  };
 }
 function patchParameter(parameters, path, description) {
   const segments = path.split(".");
@@ -82,11 +130,20 @@ function patchParameter(parameters, path, description) {
 function installPolicy(ctx, scopeKey, config) {
   validatePolicy(config);
   if (scopeOf(ctx) !== scopeKey) throw new Error("Studio policy requires its owning scoped context");
+  if (config.tools.includes("run_code") || ctx.tools.get("run_code", scopeKey) !== void 0) {
+    throw new Error("Studio policy does not support PTC presentation or the reserved run_code tool; configure this preset with native tool presentation");
+  }
   const missing = config.tools.filter((name2) => ctx.tools.get(name2, scopeKey) === void 0);
-  if (missing.length) console.warn(`Studio policy: ${missing.length} selected tool(s) unavailable on this host, skipped: ${missing.join(", ")}`);
-  const available = config.tools.filter((name2) => !missing.includes(name2));
-  const selected = new Set(available);
-  const definitions = available.map((name2) => {
+  if (missing.length) throw new Error(`Studio policy selected tools unavailable: ${missing.join(", ")}`);
+  const restoreProbe = ctx.tools.restrict({ allow: [] });
+  try {
+    const local = ctx.tools.schemas(scopeKey);
+    if (local.length) throw new Error(`Studio policy does not support own-scope tools: ${local.map((tool) => tool.name).join(", ")}; register providers in an ancestor preset scope. Public API cannot hide late own-scope schemas; dynamic own-scope providers are unsupported`);
+  } finally {
+    restoreProbe();
+  }
+  const selected = new Set(config.tools);
+  const definitions = config.tools.map((name2) => {
     const definition = ctx.tools.get(name2, scopeKey);
     const override = config.toolOverrides[name2];
     const defaults = config.execution?.defaults[name2];
@@ -120,9 +177,7 @@ function installPolicy(ctx, scopeKey, config) {
     for (const release of disposers.splice(0).reverse()) release();
   };
   try {
-    disposers.push(ctx.tools.restrict({ allow: available }));
-    const excess = ctx.tools.schemas(scopeKey).filter((tool) => !selected.has(tool.name));
-    if (excess.length) throw new Error(`Unselected scoped tools must be removed from preset plugins: ${excess.map((tool) => tool.name).join(", ")}`);
+    disposers.push(ctx.tools.restrict({ allow: [...selected] }));
     disposers.push(ctx.tools.guard((execution) => selected.has(execution.name) ? void 0 : "Tool excluded by Studio preset policy"));
     for (const definition of definitions) disposers.push(ctx.tools.register(definition));
     for (const [name2, text] of Object.entries(config.sections)) disposers.push(ctx.systemPrompt.section({ name: name2, order: ctx.systemPrompt.getSectionOrder(POLICY_SECTION_ORDERS[name2]), text, interpolate: false }));
@@ -137,23 +192,91 @@ var name = "studio-preset-policy";
 var inject = ["tools", "systemPrompt"];
 function apply(ctx, config) {
   validatePolicy(config);
+  const registry = ctx.get("agents");
+  const hideable = config.childToolFilter?.deny ?? [];
+  const policyFor = (agent) => {
+    if (!hideable.length) return config;
+    const provided = (name2) => scopeOf(ctx) === void 0 || ctx.tools.get(name2, scopeOf(ctx)) !== void 0;
+    const hidden = hideable.filter((name2) => agent.ctx.tools.get(name2, agent) === void 0 && provided(name2));
+    return hidden.length ? childPolicy(config, hidden) : config;
+  };
   const installed = /* @__PURE__ */ new Map();
+  const installing = /* @__PURE__ */ new Set();
+  const install = (agent) => {
+    if (installed.has(agent) || installing.has(agent)) return;
+    installing.add(agent);
+    try {
+      installed.set(agent, installPolicy(agent.ctx, agent, policyFor(agent)));
+    } finally {
+      installing.delete(agent);
+    }
+  };
+  const remove = (agent) => {
+    installed.get(agent)?.();
+    installed.delete(agent);
+  };
   ctx.on("agent/created", ({ agent }) => {
-    if (!installed.has(agent)) installed.set(agent, installPolicy(agent.ctx, agent, config));
+    install(agent);
     return void 0;
   });
   ctx.on("agent/disposed", ({ agent }) => {
-    installed.get(agent)?.();
-    installed.delete(agent);
+    remove(agent);
+  });
+  const composition = scopeOf(ctx);
+  const agents = registry;
+  if (composition === void 0 || agents === void 0) {
+    ctx.effect(() => () => {
+      for (const dispose of installed.values()) dispose();
+      installed.clear();
+    });
+    return;
+  }
+  const belongs = (agent) => scopeChainOf(scopeOf(agent.ctx)).includes(composition);
+  const blocked = /* @__PURE__ */ new Map();
+  const unblock = (agent) => {
+    blocked.get(agent)?.release();
+    blocked.delete(agent);
+  };
+  const block = (agent, error) => {
+    const reason = `Studio preset policy could not be installed: ${error instanceof Error ? error.message : String(error)}`;
+    const current = blocked.get(agent);
+    if (current?.reason === reason) return;
+    current?.release();
+    blocked.set(agent, { release: agent.ctx.tools.guard(() => reason), reason });
+  };
+  const reconcile = () => {
+    const live = agents.list();
+    for (const agent of live) {
+      if (!belongs(agent)) {
+        remove(agent);
+        unblock(agent);
+        continue;
+      }
+      if (installed.has(agent)) continue;
+      try {
+        install(agent);
+        unblock(agent);
+      } catch (error) {
+        block(agent, error);
+      }
+    }
+    for (const agent of [...blocked.keys()]) if (!live.includes(agent)) unblock(agent);
+  };
+  ctx.on("tools/change", reconcile);
+  ctx.on("agent/disposed", ({ agent }) => {
+    unblock(agent);
   });
+  reconcile();
   ctx.effect(() => () => {
     for (const dispose of installed.values()) dispose();
     installed.clear();
+    for (const agent of [...blocked.keys()]) unblock(agent);
   });
 }
 export {
   POLICY_SECTION_ORDERS,
   apply,
+  childPolicy,
   inject,
   installPolicy,
   name,

package/roles.js

@@ -50,11 +50,27 @@ function parseRoles(input) {
     if (!/^[a-zA-Z0-9_-]+$/.test(reasoning)) throw new Error("Role reasoning must be inherit or an effort identifier");
     if (spawn !== "fresh" && spawn !== "fork") throw new Error("Role spawn must be fresh or fork");
     seen.add(role);
-    return { name: name2, role, model, reasoning, spawn, persona, ..."overrides" in value ? { overrides: structuredClone(value.overrides) } : {} };
+    const filter = value.toolFilter;
+    if (filter !== void 0 && (!object(filter) || !Array.isArray(filter.deny) || filter.deny.some((name3) => typeof name3 !== "string" || !name3) || filter.mode !== void 0 && filter.mode !== "extend" && filter.mode !== "replace")) throw new Error("Invalid role tool filter");
+    return {
+      name: name2,
+      role,
+      model,
+      reasoning,
+      spawn,
+      persona,
+      ...filter !== void 0 ? { toolFilter: { mode: filter.mode ?? "replace", deny: [...new Set(filter.deny)] } } : {},
+      ..."overrides" in value ? { overrides: structuredClone(value.overrides) } : {}
+    };
   });
 }
 function executableRoles(roles) {
-  return roles.map(({ name: name2, role, model, reasoning, spawn, persona }) => ({ name: name2, role, model, reasoning, spawn, persona }));
+  return roles.map(({ name: name2, role, model, reasoning, spawn, persona, toolFilter }) => ({ name: name2, role, model, reasoning, spawn, persona, ...toolFilter ? { toolFilter } : {} }));
+}
+function roleToolFilter(role, presetDefault = []) {
+  const own = role?.toolFilter;
+  if (!own) return [...presetDefault];
+  return own.mode === "replace" ? [...own.deny] : [.../* @__PURE__ */ new Set([...presetDefault, ...own.deny])];
 }
 
 // src/package-name.ts
@@ -72,6 +88,9 @@ var inject = ["tools", "subagents", "llm"];
 var PARENT_ROLE = { name: "Subagent", role: "subagent", model: "inherit", reasoning: "inherit", spawn: "fresh", persona: "" };
 function apply(ctx, config) {
   const roles = executableRoles(parseRoles(config.roles));
+  const deny = config.toolFilter?.deny;
+  if (deny !== void 0 && (!Array.isArray(deny) || deny.some((name2) => typeof name2 !== "string" || !name2))) throw new Error("Invalid subagent tool filter");
+  const presetDefault = deny ?? [];
   ctx.tools.register(defineTool({
     name: ROLE_TOOL,
     description: roles.length ? "Discover saved specialist roles or delegate a task to one. Calls return a native child agent id; the child reports back through normal subagent delivery." : "Delegate a self-contained task to a subagent that starts with the same model and settings as you. Calls return a native child agent id; the child reports back through normal subagent delivery.",
@@ -102,6 +121,8 @@ function apply(ctx, config) {
       }
       if (role.reasoning !== "inherit") agentOptions.reasoningEffort = ReasoningEffortId2(role.reasoning);
       const maxDepth = ctx.subagents.resolveMaxDepth();
+      const hidden = roleToolFilter(roles.length ? role : void 0, presetDefault);
+      const toolFilter = hidden.length ? { deny: hidden } : void 0;
       const spec = {
         provider: role.spawn === "fork" ? "fork" : "spawn",
         label: role.name,
@@ -110,7 +131,8 @@ function apply(ctx, config) {
           prompt: [{ type: "text", text: args.task }],
           ...Object.keys(agentOptions).length ? { agentOptions } : {},
           ...role.persona ? { persona: role.persona } : {},
-          ...maxDepth === void 0 ? {} : { maxDepth }
+          ...maxDepth === void 0 ? {} : { maxDepth },
+          ...toolFilter ? { toolFilter } : {}
         },
         signal: exec.signal
       };