@matamt-dbg/dsh-studio 0.0.0-stage → 0.2.1

package/package.json

@@ -1,6 +1,70 @@
 {
   "name": "@matamt-dbg/dsh-studio",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1",
+  "description": "DSH Studio: build, edit and apply DeepSeek Harness agent presets — tools, prompts, Configs and role-based subagents — from the web GUI.",
+  "keywords": [
+    "deepseek-harness",
+    "dsh-plugin",
+    "dsh-studio",
+    "agent-preset"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/matamt-dbg/dsh-studio.git"
+  },
+  "homepage": "https://github.com/matamt-dbg/dsh-studio#readme",
+  "bugs": {
+    "url": "https://github.com/matamt-dbg/dsh-studio/issues"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./policy": "./policy.js",
+    "./roles": "./roles.js",
+    "./batch": "./batch.js"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "policy.js",
+    "roles.js",
+    "batch.js",
+    "cordis.patch.yml"
+  ],
+  "dependencies": {
+    "js-yaml": "^4.3.2"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-app-boot": "0.2.0-rc.2 || 0.2.1-alpha.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2 || 0.2.1-alpha.2",
+    "@deepseek-ai/dsh": "0.2.0-rc.2 || 0.2.1-alpha.2",
+    "@deepseek-ai/dsh-scope": "0.2.0-rc.2 || 0.2.1-alpha.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2 || 0.2.1-alpha.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2 || 0.2.1-alpha.2",
+    "@deepseek-ai/dsh-jobs": "0.2.0-rc.2 || 0.2.1-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2 || 0.2.1-alpha.2",
+    "@deepseek-ai/cordis-plugin-include": "*"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ]
+    }
+  }
+}

package/policy.js

@@ -0,0 +1,159 @@
+// src/execution-defaults.ts
+function batchLimitFields(tool, parameters) {
+  if (tool !== "read_batch" || parameters.type !== "object" || !record(parameters.properties)) return [];
+  return Object.entries(parameters.properties).flatMap(([name2, schema]) => record(schema) && schema.type === "array" && Number.isSafeInteger(schema.maxItems) && schema.maxItems > 0 && (schema.minItems === void 0 || Number.isSafeInteger(schema.minItems) && schema.minItems >= 0) ? [name2] : []);
+}
+function validateBatchLimit(parameters, batch) {
+  if (!batchLimitFields(batch.tool, parameters).includes(batch.parameter)) throw new Error("Unsupported batch limit");
+  const schema = parameters.properties[batch.parameter];
+  if (!Number.isSafeInteger(batch.maxItems) || batch.maxItems < 1 || batch.maxItems > schema.maxItems || batch.maxItems < (typeof schema.minItems === "number" ? schema.minItems : 0)) throw new Error("Batch limit must tighten the published bounds");
+}
+var record = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var names = /* @__PURE__ */ new Set(["timeoutMs", "timeout_ms"]);
+var annotations = ["description", "title", "default", "examples"];
+var bounds = ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"];
+function executionDefaultFields(parameters) {
+  if (parameters.type !== "object" || !record(parameters.properties) || Object.keys(parameters).some((key) => !["type", "properties", "required", "additionalProperties", ...annotations].includes(key)) || parameters.required !== void 0 && (!Array.isArray(parameters.required) || parameters.required.some((key) => typeof key !== "string"))) return [];
+  return Object.entries(parameters.properties).flatMap(([name2, schema]) => {
+    if (!names.has(name2) || parameters.required?.includes(name2) || !record(schema) || !["number", "integer"].includes(String(schema.type)) || Object.keys(schema).some((key) => !["type", ...annotations, ...bounds, "enum", "const"].includes(key)) || bounds.some((key) => own(schema, key) && (typeof schema[key] !== "number" || !Number.isFinite(schema[key]) || key === "multipleOf" && schema[key] <= 0)) || own(schema, "const") && (typeof schema.const !== "number" || !Number.isFinite(schema.const)) || own(schema, "enum") && (!Array.isArray(schema.enum) || !schema.enum.length || schema.enum.some((value) => typeof value !== "number" || !Number.isFinite(value)))) return [];
+    return [name2];
+  });
+}
+function validateExecutionDefaults(value) {
+  if (!record(value) || Object.keys(value).some((key) => !["defaults", "batch"].includes(key)) || !record(value.defaults)) throw new Error("Invalid execution defaults");
+  if (value.batch !== void 0 && (!record(value.batch) || Object.keys(value.batch).some((key) => !["tool", "parameter", "maxItems"].includes(key)) || value.batch.tool !== "read_batch" || typeof value.batch.parameter !== "string" || !value.batch.parameter || ["__proto__", "prototype", "constructor"].includes(value.batch.parameter) || !Number.isSafeInteger(value.batch.maxItems) || value.batch.maxItems < 1)) throw new Error("Invalid batch limit");
+  for (const [tool, fields] of Object.entries(value.defaults)) {
+    if (!tool || ["__proto__", "prototype", "constructor"].includes(tool) || !record(fields)) throw new Error("Invalid execution defaults");
+    for (const [field, number] of Object.entries(fields)) if (!names.has(field) || typeof number !== "number" || !Number.isFinite(number) || number <= 0) throw new Error(`Invalid execution default: ${tool}.${field}`);
+  }
+}
+function validateExecutionDefault(parameters, field, value) {
+  if (!executionDefaultFields(parameters).includes(field)) throw new Error(`Unsupported execution default: ${field}`);
+  const schema = parameters.properties[field];
+  if (!Number.isFinite(value) || value <= 0 || schema.type === "integer" && !Number.isInteger(value) || typeof schema.minimum === "number" && value < schema.minimum || typeof schema.maximum === "number" && value > schema.maximum || typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum || typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum || typeof schema.multipleOf === "number" && !Number.isInteger(value / schema.multipleOf) || Array.isArray(schema.enum) && !schema.enum.includes(value) || own(schema, "const") && value !== schema.const) throw new Error(`Execution default outside schema: ${field}`);
+}
+function applyExecutionDefaults(args, defaults) {
+  if (!record(args)) return args;
+  return { ...Object.fromEntries(Object.entries(defaults).filter(([field]) => !own(args, field))), ...args };
+}
+
+// src/host/preset-policy.ts
+import { scopeOf } from "@deepseek-ai/dsh-scope";
+var POLICY_SECTION_ORDERS = Object.freeze({
+  "tool:jobs": "TOOL_JOBS",
+  "tool:bash": "TOOL_BASH",
+  "tool:pwsh": "TOOL_PWSH",
+  "tool:read": "TOOL_READ",
+  "tool:write": "TOOL_WRITE",
+  "tool:edit": "TOOL_EDIT",
+  "tool:glob": "TOOL_GLOB",
+  "tool:grep": "TOOL_GREP",
+  "tool:web_fetch": "TOOL_WEB_FETCH",
+  "tool:web_search": "TOOL_WEB_SEARCH",
+  "tool:goal": "TOOL_GOAL"
+});
+var own2 = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+var record2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function validatePolicy(config) {
+  if (!record2(config) || !Array.isArray(config.tools) || config.tools.some((name2) => typeof name2 !== "string" || !name2) || new Set(config.tools).size !== config.tools.length || !record2(config.toolOverrides) || !record2(config.sections) || typeof config.prompt !== "string") throw new Error("Invalid Studio policy");
+  if (config.execution !== void 0) {
+    validateExecutionDefaults(config.execution);
+    for (const name2 of Object.keys(config.execution.defaults)) if (!config.tools.includes(name2)) throw new Error(`Execution default requires selected tool: ${name2}`);
+    if (config.execution.batch && !config.tools.includes(config.execution.batch.tool)) throw new Error("Batch limit requires selected tool");
+  }
+  for (const [name2, override] of Object.entries(config.toolOverrides)) {
+    if (!config.tools.includes(name2)) throw new Error(`Override requires selected tool: ${name2}`);
+    if (!record2(override) || Object.keys(override).some((key) => !["description", "parameters"].includes(key)) || override.description !== void 0 && typeof override.description !== "string" || override.parameters !== void 0 && (!record2(override.parameters) || Object.values(override.parameters).some((value) => typeof value !== "string"))) throw new Error(`Invalid override: ${name2}`);
+  }
+  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}`);
+  }
+}
+function patchParameter(parameters, path, description) {
+  const segments = path.split(".");
+  let node = parameters;
+  for (const segment of segments) {
+    if (!segment || ["__proto__", "prototype", "constructor"].includes(segment) || !record2(node.properties) || !own2(node.properties, segment) || !record2(node.properties[segment])) throw new Error(`Unknown parameter path: ${path}`);
+    node = node.properties[segment];
+  }
+  node.description = description;
+}
+function installPolicy(ctx, scopeKey, config) {
+  validatePolicy(config);
+  if (scopeOf(ctx) !== scopeKey) throw new Error("Studio policy requires its owning scoped context");
+  const selected = new Set(config.tools);
+  const definitions = config.tools.map((name2) => {
+    const definition = ctx.tools.get(name2, scopeKey);
+    if (!definition) throw new Error(`Unavailable selected tool: ${name2}`);
+    const override = config.toolOverrides[name2];
+    const defaults = config.execution?.defaults[name2];
+    const batch = config.execution?.batch?.tool === name2 ? config.execution.batch : void 0;
+    if (!override && !defaults && !batch) return void 0;
+    const parameters = structuredClone(definition.parameters);
+    for (const [path, description] of Object.entries(override?.parameters ?? {})) patchParameter(parameters, path, description);
+    for (const [field, value] of Object.entries(defaults ?? {})) {
+      validateExecutionDefault(parameters, field, value);
+      parameters.properties[field].default = value;
+    }
+    if (batch) {
+      validateBatchLimit(parameters, batch);
+      parameters.properties[batch.parameter].maxItems = batch.maxItems;
+    }
+    const stableDefaults = { ...defaults };
+    const stableBatch = batch && { ...batch };
+    return {
+      ...definition,
+      parameters,
+      ...override?.description === void 0 ? {} : { description: override.description },
+      ...defaults || batch ? { execute(args, exec) {
+        const effective = applyExecutionDefaults(args, stableDefaults);
+        if (stableBatch && record2(effective) && Array.isArray(effective[stableBatch.parameter]) && effective[stableBatch.parameter].length > stableBatch.maxItems) throw new Error(`Studio batch limit exceeded: ${stableBatch.maxItems}`);
+        return definition.execute.call(definition, effective, exec);
+      } } : {}
+    };
+  }).filter((definition) => definition !== void 0);
+  const disposers = [];
+  const dispose = () => {
+    for (const release of disposers.splice(0).reverse()) release();
+  };
+  try {
+    disposers.push(ctx.tools.restrict({ allow: config.tools }));
+    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.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 }));
+    disposers.push(ctx.systemPrompt.section({ name: "studio:additional", order: Number.MAX_SAFE_INTEGER, text: config.prompt, interpolate: false }));
+    return dispose;
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+}
+var name = "studio-preset-policy";
+var inject = ["tools", "systemPrompt"];
+function apply(ctx, config) {
+  validatePolicy(config);
+  const installed = /* @__PURE__ */ new Map();
+  ctx.on("agent/created", ({ agent }) => {
+    if (!installed.has(agent)) installed.set(agent, installPolicy(agent.ctx, agent, config));
+    return void 0;
+  });
+  ctx.on("agent/disposed", ({ agent }) => {
+    installed.get(agent)?.();
+    installed.delete(agent);
+  });
+  ctx.effect(() => () => {
+    for (const dispose of installed.values()) dispose();
+    installed.clear();
+  });
+}
+export {
+  POLICY_SECTION_ORDERS,
+  apply,
+  inject,
+  installPolicy,
+  name,
+  validatePolicy
+};

package/roles.js

@@ -0,0 +1,129 @@
+// src/host/role-validation.ts
+import { ReasoningEffortId } from "@deepseek-ai/dsh-llm";
+async function validateRoleModel(llm, role, signal) {
+  signal?.throwIfAborted();
+  if (role.model === "inherit") return;
+  if (!llm) throw new Error("Studio role model validation unavailable: LLM service is not mounted.");
+  const slash = role.model.indexOf("/");
+  const provider = role.model.slice(0, slash);
+  const model = role.model.slice(slash + 1);
+  if (!llm.listProviders().some((item) => item.id === provider)) {
+    throw new Error(`Studio role "${role.role}": provider "${provider}" is not registered. Select an available model in Studio, save and reapply the preset.`);
+  }
+  try {
+    await llm.resolveCallConfig({
+      provider,
+      model,
+      ...role.reasoning === "inherit" ? {} : { reasoningEffort: ReasoningEffortId(role.reasoning) }
+    }, signal);
+  } catch {
+    signal?.throwIfAborted();
+    throw new Error(`Studio role "${role.role}": could not validate model "${role.model}" and reasoning settings. Check provider availability and model settings, then retry. No child was started.`);
+  }
+  signal?.throwIfAborted();
+}
+
+// src/host/role-tool.ts
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { ReasoningEffortId as ReasoningEffortId2 } from "@deepseek-ai/dsh-llm";
+
+// src/role-settings.ts
+var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function parseRoles(input) {
+  if (!Array.isArray(input) || input.length > 50) throw new Error("Studio agents must be an array of at most 50 roles");
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((value) => {
+    if (!object(value)) throw new Error("Invalid Studio role");
+    const text = (key, fallback, max) => {
+      const v = value[key] ?? fallback;
+      if (typeof v !== "string" || v.length > max) throw new Error(`Invalid role ${key}`);
+      return key === "persona" ? v : v.trim();
+    };
+    const name2 = text("name", "", 120);
+    const role = text("role", name2, 120);
+    const model = text("model", "inherit", 512);
+    const reasoning = text("reasoning", "inherit", 120);
+    const spawn = text("spawn", "fresh", 10);
+    const persona = text("persona", "", 32e3);
+    if (!name2 || !role || seen.has(role)) throw new Error("Role names and unique role identifiers are required");
+    if (model !== "inherit" && !/^[^\s/]+\/\S+$/.test(model)) throw new Error("Role model must be inherit or provider/model");
+    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) } : {} };
+  });
+}
+function executableRoles(roles) {
+  return roles.map(({ name: name2, role, model, reasoning, spawn, persona }) => ({ name: name2, role, model, reasoning, spawn, persona }));
+}
+
+// src/package-name.ts
+var PACKAGE_NAME = "@matamt-dbg/dsh-studio";
+var POLICY_PLUGIN = `${PACKAGE_NAME}/policy`;
+var ROLE_PLUGIN = `${PACKAGE_NAME}/roles`;
+var BATCH_PLUGIN = `${PACKAGE_NAME}/batch`;
+
+// src/delegation.ts
+var ROLE_TOOL = "subagent_role";
+
+// src/host/role-tool.ts
+var name = "studio-role";
+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));
+  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.",
+    parameters: {
+      action: { type: "string", enum: ["list", "call"], required: true, description: "list discovers role identifiers and settings; call delegates a task." },
+      role: { type: "string", description: roles.length ? "Saved role identifier, required for call." : "Not needed; no specialist roles are defined, so every call starts a child matching the parent." },
+      task: { type: "string", description: "Self-contained task for the specialist, required for call. Fork roles also inherit the conversation." }
+    },
+    output: {
+      schema: { type: "object", additionalProperties: false, properties: { result: { type: "string", required: true } } },
+      render: (_args, value) => [{ type: "text", text: value.result }]
+    },
+    isConcurrencySafe: () => true,
+    async execute(args, exec) {
+      if (args.action === "list") return { result: JSON.stringify({ roles: roles.map(({ persona: _persona, ...role2 }) => role2) }) };
+      if (args.action !== "call") throw new Error("Unknown Studio role action");
+      const role = roles.length ? roles.find((role2) => role2.role === args.role) : PARENT_ROLE;
+      if (!role) throw new Error("Unknown Studio role; use action=list to discover roles");
+      if (typeof args.task !== "string" || !args.task.trim()) throw new Error("Role call requires a task");
+      if (!exec.agent) throw new Error("Studio role call requires a calling agent");
+      exec.signal.throwIfAborted();
+      await validateRoleModel(ctx.llm, role, exec.signal);
+      const agentOptions = {};
+      if (role.model !== "inherit") {
+        const slash = role.model.indexOf("/");
+        agentOptions.provider = role.model.slice(0, slash);
+        agentOptions.model = role.model.slice(slash + 1);
+      }
+      if (role.reasoning !== "inherit") agentOptions.reasoningEffort = ReasoningEffortId2(role.reasoning);
+      const maxDepth = ctx.subagents.resolveMaxDepth();
+      const spec = {
+        provider: role.spawn === "fork" ? "fork" : "spawn",
+        label: role.name,
+        request: {
+          parent: exec.agent,
+          prompt: [{ type: "text", text: args.task }],
+          ...Object.keys(agentOptions).length ? { agentOptions } : {},
+          ...role.persona ? { persona: role.persona } : {},
+          ...maxDepth === void 0 ? {} : { maxDepth }
+        },
+        signal: exec.signal
+      };
+      const native = ctx.subagents;
+      const started = typeof native.startActivation === "function" ? await native.startActivation({ ...spec, delivery: "parent" }) : native.startContinuable ? await native.startContinuable(spec) : (() => {
+        throw new Error("This DSH runtime lacks a native child start API");
+      })();
+      return { result: JSON.stringify({ kind: "activation", subagentId: started.childId, role: role.role }) };
+    }
+  }));
+}
+export {
+  apply,
+  inject,
+  name
+};