thoth-agents 0.11.0 → 0.13.0

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
+};

package/dist/{chunk-RWQPMWEM.js → chunk-JLU3FSBT.js}

@@ -332,12 +332,27 @@ function checkExpectations(options, issue) {
       "Expected digest must be 64 lowercase hex characters."
     );
 }
+var isFenceLine = (line) => /^(?:`{3,}|~{3,})/.test(line);
+var isVerdictLine = (line) => line.startsWith("thoth-gate-verdict ");
+function unwrapSubagent(message, lines) {
+  if (!message.startsWith("<subagent ")) return message;
+  if (lines.at(-1) !== "</subagent>") return "";
+  const opener = lines.lastIndexOf("```thoth-result");
+  if (opener < 1) return "";
+  const header = lines.slice(0, opener).join("\n").trimEnd();
+  if (!header.includes('state="completed"') || lines.slice(0, opener).some((line) => isFenceLine(line) || isVerdictLine(line)))
+    return "";
+  return lines.slice(opener, -1).join("\n").trim();
+}
 function parseEnvelope(message) {
-  const trimmed = typeof message === "string" ? message.trim() : "";
+  const complete = typeof message === "string" ? message.trim() : "";
+  const lines = complete.split(/\r\n|\r|\n/);
+  const singleEnvelope = lines.filter(isFenceLine).length === 2 && !lines.some(isVerdictLine);
+  const trimmed = singleEnvelope ? unwrapSubagent(complete, lines) : "";
   const block = new RegExp(
     `^\`\`\`${result_contract_default.fence}\\r?\\n([\\s\\S]*?)\\r?\\n\`\`\`$`
   ).exec(trimmed);
-  if (!block || (trimmed.match(/^```.*$/gm) ?? []).length !== 2) {
+  if (!block) {
     return {
       issues: [
         {

package/dist/chunk-MIDGZE34.js

@@ -0,0 +1,107 @@
+// src/mcp/context7.ts
+var CONTEXT7_MCP_URL = "https://mcp.context7.com/mcp";
+var context7 = {
+  type: "remote",
+  url: CONTEXT7_MCP_URL,
+  headers: process.env.CONTEXT7_API_KEY ? { CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY } : void 0,
+  oauth: false
+};
+
+// src/mcp/exa.ts
+var exa = {
+  type: "local",
+  command: ["npx", "-y", "exa-mcp-server"]
+};
+
+// src/mcp/grep-app.ts
+var GREP_APP_MCP_URL = "https://mcp.grep.app";
+var grep_app = {
+  type: "remote",
+  url: GREP_APP_MCP_URL,
+  oauth: false
+};
+
+// src/utils/subprocess.ts
+import {
+  spawn as nodeSpawn,
+  spawnSync as nodeSpawnSync
+} from "child_process";
+import { Readable } from "stream";
+function emptyReadableStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function toWebReadable(stream) {
+  if (!stream) {
+    return emptyReadableStream();
+  }
+  return Readable.toWeb(
+    stream
+  );
+}
+function fallbackStdin() {
+  return {
+    write: () => void 0,
+    end: () => void 0
+  };
+}
+function spawn(command, options = {}) {
+  const child = nodeSpawn(command[0], command.slice(1), {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: [
+      options.stdin ?? "pipe",
+      options.stdout ?? "pipe",
+      options.stderr ?? "pipe"
+    ],
+    shell: options.shell,
+    windowsHide: options.windowsHide ?? true
+  });
+  const managed = {
+    stdin: child.stdin ?? fallbackStdin(),
+    stdout: toWebReadable(child.stdout),
+    stderr: toWebReadable(child.stderr),
+    exited: new Promise((resolve) => {
+      child.on("exit", (code) => {
+        managed.exitCode = code;
+        resolve(code ?? 1);
+      });
+      child.on("error", () => {
+        managed.exitCode = 1;
+        resolve(1);
+      });
+    }),
+    exitCode: child.exitCode,
+    kill: () => {
+      child.kill();
+    }
+  };
+  return managed;
+}
+function spawnSync(command, options = {}) {
+  const result = nodeSpawnSync(command[0], command.slice(1), {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: [
+      options.stdin ?? "ignore",
+      options.stdout ?? "pipe",
+      options.stderr ?? "pipe"
+    ],
+    shell: options.shell,
+    windowsHide: options.windowsHide ?? true
+  });
+  return { exitCode: result.status };
+}
+
+export {
+  CONTEXT7_MCP_URL,
+  context7,
+  exa,
+  GREP_APP_MCP_URL,
+  grep_app,
+  spawn,
+  spawnSync
+};

package/dist/{chunk-HACUJFKI.js → chunk-NOLDFT7O.js}

@@ -16,7 +16,7 @@ import {
   loadAgentPrompt,
   renderAgentRoutingDescription,
   renderRolePrompt
-} from "./chunk-DNPKVFOB.js";
+} from "./chunk-YCWGTDFE.js";
 
 // src/agents/designer.ts
 var DESIGNER_PROMPT = renderRolePrompt(
@@ -363,7 +363,7 @@ var SUBAGENT_FACTORIES = {
 function createAgents(config) {
   const protoSubAgents = Object.entries(SUBAGENT_FACTORIES).map(([name, factory]) => {
     const override = getAgentOverride(config, name);
-    const prompts = loadAgentPrompt(name, config?.preset);
+    const prompts = loadAgentPrompt(name);
     const model = getPrimaryModelForPrompt(override?.model) ?? DEFAULT_MODELS[name];
     const agent = factory(model, prompts.prompt, prompts.appendPrompt);
     agent.description = renderAgentRoutingDescription(getAgentRole(name));
@@ -379,7 +379,7 @@ function createAgents(config) {
     return agent;
   });
   const orchestratorOverride = getAgentOverride(config, "orchestrator");
-  const orchestratorPrompts = loadAgentPrompt("orchestrator", config?.preset);
+  const orchestratorPrompts = loadAgentPrompt("orchestrator");
   const orchestrator = createOrchestratorAgent(
     orchestratorOverride?.model ?? `openai/${OPENCODE_OPENAI_ORCHESTRATOR_PRESET.model}`,
     orchestratorPrompts.prompt,
@@ -455,234 +455,8 @@ var opencodeAdapter = {
   }
 };
 
-// src/utils/subprocess.ts
-import {
-  spawn as nodeSpawn,
-  spawnSync as nodeSpawnSync
-} from "child_process";
-import { Readable } from "stream";
-function emptyReadableStream() {
-  return new ReadableStream({
-    start(controller) {
-      controller.close();
-    }
-  });
-}
-function toWebReadable(stream) {
-  if (!stream) {
-    return emptyReadableStream();
-  }
-  return Readable.toWeb(
-    stream
-  );
-}
-function fallbackStdin() {
-  return {
-    write: () => void 0,
-    end: () => void 0
-  };
-}
-function spawn(command, options = {}) {
-  const child = nodeSpawn(command[0], command.slice(1), {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: [
-      options.stdin ?? "pipe",
-      options.stdout ?? "pipe",
-      options.stderr ?? "pipe"
-    ],
-    shell: options.shell,
-    windowsHide: options.windowsHide ?? true
-  });
-  const managed = {
-    stdin: child.stdin ?? fallbackStdin(),
-    stdout: toWebReadable(child.stdout),
-    stderr: toWebReadable(child.stderr),
-    exited: new Promise((resolve) => {
-      child.on("exit", (code) => {
-        managed.exitCode = code;
-        resolve(code ?? 1);
-      });
-      child.on("error", () => {
-        managed.exitCode = 1;
-        resolve(1);
-      });
-    }),
-    exitCode: child.exitCode,
-    kill: () => {
-      child.kill();
-    }
-  };
-  return managed;
-}
-function spawnSync(command, options = {}) {
-  const result = nodeSpawnSync(command[0], command.slice(1), {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: [
-      options.stdin ?? "ignore",
-      options.stdout ?? "pipe",
-      options.stderr ?? "pipe"
-    ],
-    shell: options.shell,
-    windowsHide: options.windowsHide ?? true
-  });
-  return { exitCode: result.status };
-}
-
-// src/cli/system.ts
-import { statSync } from "fs";
-var cachedOpenCodePath = null;
-var OPENCODE_PROBE_TIMEOUT_MS = 1500;
-function quoteWindowsShellCommand(command) {
-  if (!/[\s&()^<>"|]/.test(command)) {
-    return command;
-  }
-  return `"${command.replace(/"/g, '\\"')}"`;
-}
-function getOpenCodeVersionInvocation(opencodePath, platform = process.platform) {
-  const options = {
-    stdout: "pipe",
-    stderr: "pipe"
-  };
-  if (platform === "win32") {
-    return {
-      command: [`${quoteWindowsShellCommand(opencodePath)} --version`],
-      options: { ...options, shell: true }
-    };
-  }
-  return { command: [opencodePath, "--version"], options };
-}
-function getOpenCodePaths() {
-  const home = process.env.HOME || process.env.USERPROFILE || "";
-  return [
-    // PATH (try this first)
-    "opencode",
-    // User local installations (Linux & macOS)
-    `${home}/.local/bin/opencode`,
-    `${home}/.opencode/bin/opencode`,
-    `${home}/bin/opencode`,
-    // System-wide installations
-    "/usr/local/bin/opencode",
-    "/opt/opencode/bin/opencode",
-    "/usr/bin/opencode",
-    "/bin/opencode",
-    // macOS specific
-    "/Applications/OpenCode.app/Contents/MacOS/opencode",
-    `${home}/Applications/OpenCode.app/Contents/MacOS/opencode`,
-    // Homebrew (macOS & Linux)
-    "/opt/homebrew/bin/opencode",
-    "/home/linuxbrew/.linuxbrew/bin/opencode",
-    `${home}/homebrew/bin/opencode`,
-    // macOS user Library
-    `${home}/Library/Application Support/opencode/bin/opencode`,
-    // Snap (Linux)
-    "/snap/bin/opencode",
-    "/var/snap/opencode/current/bin/opencode",
-    // Flatpak (Linux)
-    "/var/lib/flatpak/exports/bin/ai.opencode.OpenCode",
-    `${home}/.local/share/flatpak/exports/bin/ai.opencode.OpenCode`,
-    // Nix (Linux/macOS)
-    "/nix/store/opencode/bin/opencode",
-    `${home}/.nix-profile/bin/opencode`,
-    "/run/current-system/sw/bin/opencode",
-    // Cargo (Rust toolchain)
-    `${home}/.cargo/bin/opencode`,
-    // npm/npx global
-    `${home}/.npm-global/bin/opencode`,
-    "/usr/local/lib/node_modules/opencode/bin/opencode",
-    // Yarn global
-    `${home}/.yarn/bin/opencode`,
-    // PNPM
-    `${home}/.pnpm-global/bin/opencode`
-  ];
-}
-function resolveOpenCodePath() {
-  if (cachedOpenCodePath) {
-    return cachedOpenCodePath;
-  }
-  const paths = getOpenCodePaths();
-  for (const opencodePath of paths) {
-    if (opencodePath === "opencode") continue;
-    try {
-      const stat = statSync(opencodePath);
-      if (stat.isFile()) {
-        cachedOpenCodePath = opencodePath;
-        return opencodePath;
-      }
-    } catch {
-    }
-  }
-  return "opencode";
-}
-async function isOpenCodeInstalled() {
-  const paths = getOpenCodePaths();
-  for (const opencodePath of paths) {
-    try {
-      const invocation = getOpenCodeVersionInvocation(opencodePath);
-      const proc = spawn(invocation.command, {
-        ...invocation.options,
-        windowsHide: true
-      });
-      let timer;
-      const timedOut = /* @__PURE__ */ Symbol("timeout");
-      try {
-        const outcome = await Promise.race([
-          proc.exited.then(() => proc.exitCode),
-          new Promise((resolve) => {
-            timer = setTimeout(
-              () => resolve(timedOut),
-              OPENCODE_PROBE_TIMEOUT_MS
-            );
-          })
-        ]);
-        if (outcome === timedOut) {
-          proc.kill();
-          continue;
-        }
-        if (outcome === 0) {
-          cachedOpenCodePath = opencodePath;
-          return true;
-        }
-      } finally {
-        if (timer) {
-          clearTimeout(timer);
-        }
-      }
-    } catch {
-    }
-  }
-  return false;
-}
-async function getOpenCodeVersion() {
-  const opencodePath = resolveOpenCodePath();
-  try {
-    const invocation = getOpenCodeVersionInvocation(opencodePath);
-    const proc = spawn(invocation.command, {
-      ...invocation.options,
-      windowsHide: true
-    });
-    const output = await new Response(proc.stdout).text();
-    await proc.exited;
-    if (proc.exitCode === 0) {
-      return output.trim();
-    }
-  } catch {
-  }
-  return null;
-}
-function getOpenCodePath() {
-  const path = resolveOpenCodePath();
-  return path === "opencode" ? null : path;
-}
-
 export {
   createAgents,
   renderOpenCodeAgentConfigs,
-  opencodeAdapter,
-  spawn,
-  spawnSync,
-  isOpenCodeInstalled,
-  getOpenCodeVersion,
-  getOpenCodePath
+  opencodeAdapter
 };

package/dist/{chunk-5WPP6IY7.js → chunk-VVYAQTYE.js}

@@ -19,7 +19,7 @@ import {
   renderAgentRoutingDescription,
   renderPromptSection,
   renderRolePrompt
-} from "./chunk-DNPKVFOB.js";
+} from "./chunk-YCWGTDFE.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);