thoth-agents 0.12.0 → 0.13.1

package/README.md

@@ -291,8 +291,17 @@ npx thoth-agents@latest
 ```
 
 Choose models your harness and provider account can access. OpenCode ships the
-**OpenAI preset**; per-role overrides let you customize it. Other harnesses use
-their own model configuration and capability rules.
+**`openai` model profile**. Run `/subagents-model` inside OpenCode to edit named
+model/variant profiles for all six roles, including orchestrator. Selection is
+session → project pin → global active → read-only `default`. Profiles live in
+`<opencode-config-dir>/thoth/profiles.json` and
+`<project>/.opencode/thoth/profiles.json`; the CLI manages global profiles only.
+Other harnesses use their own model configuration and capability rules.
+
+In OpenCode, `/subagents-tools` edits global/project allow/ask/deny overrides for
+the five specialists, independently of model profiles. Project entries replace
+global entries per role; `subagent` stays locked. See the
+[tool-permission guide and limits](docs/provider-configurations.md#manage-tool-permissions-inside-opencode).
 
 See [Provider Configuration](docs/provider-configurations.md) and
 [Codex Model Customization](docs/codex-model-customization.md).

package/dist/{chunk-7F33WUSD.js → chunk-422L76R5.js}

@@ -19,7 +19,7 @@ import {
   renderAgentRoutingDescription,
   renderPromptSection,
   renderRolePrompt
-} from "./chunk-NY2IPJ7V.js";
+} from "./chunk-HFBCW4MD.js";
 
 // src/harness/writers/pi-agent.ts
 var PI_MANAGED_OWNER = "thoth-agents";
@@ -733,7 +733,7 @@ function renderConfiguredRolePrompt({
   config,
   model
 }) {
-  const promptOverrides = loadAgentPrompt(role, config?.preset);
+  const promptOverrides = loadAgentPrompt(role);
   const override = getAgentOverride(config, role);
   const modelSection = createModelFamilySection(role, model);
   const stepSection = createStepBudgetSection(override?.steps, role);

package/dist/chunk-6O4GKDS7.js

@@ -0,0 +1,207 @@
+// src/opencode/profile-rpc.ts
+import { z } from "zod";
+var ProfileRoleSchema = z.enum([
+  "orchestrator",
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "worker"
+]);
+var ProfileScopeSchema = z.enum(["global", "project"]);
+var SelectionScopeSchema = z.enum([
+  "session",
+  "project",
+  "global",
+  "default"
+]);
+var RoleModelSchema = z.object({
+  model: z.string().regex(/^[^/\s#]+\/[^\s#]+$/).optional(),
+  variant: z.string().regex(/^[^\s#]+$/).optional()
+});
+var ProfileSchema = z.object({
+  agents: z.partialRecord(ProfileRoleSchema, RoleModelSchema)
+});
+var name = z.string().trim().min(1);
+var session = z.object({ sessionID: z.string().min(1) });
+var optionalSession = session.partial();
+var target = z.object({ scope: ProfileScopeSchema, name });
+var selectionScope = z.enum(["session", "project", "global"]);
+var ProfileEntrySchema = target.extend({
+  source: ProfileScopeSchema,
+  shadowed: z.boolean(),
+  profile: ProfileSchema,
+  /** Opaque per-profile token, including absence. Never construct in the client. */
+  revision: z.string()
+});
+var ProfileStateSchema = z.object({
+  profiles: z.array(ProfileEntrySchema),
+  defaultProfile: ProfileSchema,
+  roles: z.array(ProfileRoleSchema),
+  selections: z.object({
+    session: name.optional(),
+    project: name.optional(),
+    global: name.optional()
+  }),
+  effective: z.object({
+    name,
+    source: ProfileScopeSchema.optional(),
+    selectedBy: SelectionScopeSchema,
+    profile: ProfileSchema
+  }),
+  orchestrator: RoleModelSchema.optional(),
+  providers: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      models: z.array(
+        z.object({
+          id: z.string(),
+          name: z.string(),
+          variants: z.array(z.string())
+        })
+      )
+    })
+  ),
+  warnings: z.array(z.string())
+});
+var ProfileErrorSchema = z.object({
+  code: z.enum([
+    "PROFILE_CONFLICT",
+    "PROFILE_SHADOWED",
+    "INVALID_REQUEST",
+    "MODEL_UNAVAILABLE",
+    "OPERATION_FAILED"
+  ]),
+  message: z.string()
+});
+function result(value) {
+  return z.discriminatedUnion("ok", [
+    z.object({ ok: z.literal(true), value }),
+    z.object({ ok: z.literal(false), error: ProfileErrorSchema })
+  ]);
+}
+var profileRpc = {
+  id: "thoth-model-profiles",
+  methods: {
+    state: { input: optionalSession, output: result(ProfileStateSchema) },
+    create: {
+      input: target.extend({ profile: ProfileSchema }),
+      output: result(z.object({ revision: z.string() }))
+    },
+    save: {
+      input: target.extend({
+        profile: ProfileSchema,
+        baseRevision: z.string()
+      }),
+      output: result(z.object({ revision: z.string() }))
+    },
+    rename: {
+      input: target.extend({ newName: name }),
+      output: result(z.object({}))
+    },
+    delete: { input: target, output: result(z.object({})) },
+    activate: {
+      input: optionalSession.extend({ scope: selectionScope, name }),
+      output: result(ProfileStateSchema)
+    },
+    clear: {
+      input: optionalSession.extend({ scope: selectionScope }),
+      output: result(ProfileStateSchema)
+    },
+    capture: { input: session, output: result(RoleModelSchema) }
+  },
+  events: {}
+};
+
+// src/opencode/tool-rpc.ts
+import { z as z2 } from "zod";
+var ToolRoleSchema = z2.enum([
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "worker"
+]);
+var ToolScopeSchema = z2.enum(["global", "project"]);
+var ToolEffectSchema = z2.enum(["allow", "ask", "deny"]);
+var ToolOriginSchema = z2.enum(["default", "global", "project"]);
+var ActionOverrideSchema = z2.object({
+  action: z2.string().min(1).refine((action) => action.trim().length > 0, "Action must not be blank"),
+  effect: ToolEffectSchema
+});
+var scopeState = z2.object({
+  present: z2.boolean(),
+  /** Opaque whole-file revision, including when this role is absent. */
+  revision: z2.string(),
+  /** Ordered entries, including duplicates and patterns matching no inventory action. */
+  overrides: z2.array(
+    ActionOverrideSchema.extend({ matchCount: z2.number().int().nonnegative() })
+  )
+});
+var ToolStateSchema = z2.object({
+  specialists: z2.array(ToolRoleSchema),
+  inventory: z2.array(
+    z2.object({
+      action: z2.string(),
+      tools: z2.array(z2.string()),
+      locked: z2.boolean()
+    })
+  ),
+  roles: z2.array(
+    z2.object({
+      role: ToolRoleSchema,
+      effectiveScope: ToolOriginSchema,
+      global: scopeState,
+      project: scopeState,
+      actions: z2.array(
+        z2.object({
+          action: z2.string(),
+          effect: ToolEffectSchema,
+          /** Effect from shipped role rules alone, before any scope overrides. */
+          baseEffect: ToolEffectSchema,
+          origin: ToolOriginSchema,
+          locked: z2.boolean()
+        })
+      )
+    })
+  ),
+  warnings: z2.array(z2.string())
+});
+var ToolErrorSchema = z2.object({
+  code: z2.enum(["TOOLS_CONFLICT", "INVALID_REQUEST", "OPERATION_FAILED"]),
+  message: z2.string()
+});
+var result2 = z2.discriminatedUnion("ok", [
+  z2.object({ ok: z2.literal(true), value: ToolStateSchema }),
+  z2.object({ ok: z2.literal(false), error: ToolErrorSchema })
+]);
+var target2 = z2.object({
+  scope: ToolScopeSchema,
+  role: ToolRoleSchema,
+  baseRevision: z2.string()
+});
+var toolRpc = {
+  id: "thoth-tool-permissions",
+  methods: {
+    state: { input: z2.object({}), output: result2 },
+    save: {
+      input: target2.extend({
+        overrides: z2.array(
+          ActionOverrideSchema.refine(
+            (entry) => entry.action !== "subagent",
+            "The subagent action is locked"
+          )
+        )
+      }),
+      output: result2
+    },
+    reset: { input: target2, output: result2 }
+  },
+  events: {}
+};
+
+export {
+  profileRpc,
+  toolRpc
+};