@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/tools/registry.ts

@@ -826,6 +826,20 @@ export function getWorkspaceToolNames(): string[] {
     .map((t) => t.name);
 }
 
+/**
+ * Return tool definitions for all currently registered workspace-origin
+ * tools. Used by the conversation tool resolver to re-read workspace tools
+ * from the registry each turn, the same way {@link getMcpToolDefinitions}
+ * lets a conversation pick up MCP tools registered after it was created —
+ * here so reconciled edits under `<workspaceDir>/tools/` are picked up
+ * without recreating the conversation.
+ */
+export function getWorkspaceToolDefinitions(): Tool[] {
+  return Array.from(tools.values()).filter(
+    (t) => ownersByName.get(t.name)?.kind === "workspace",
+  );
+}
+
 /**
  * Return the names of core tools currently stripped via workspace
  * `.removed` sentinels — i.e. names where the stash holds an entry but
@@ -968,6 +982,10 @@ export async function initializeTools(): Promise<void> {
   // Workspace tools land after the core snapshot above so they're never
   // baked into the test-reset baseline.
   //
+  // `loadWorkspaceTools` is idempotent: this is the first reconcile, and
+  // conversation reads re-run it later to pick up on-disk edits without a
+  // restart (see workspace-tools/loader.ts).
+  //
   // Imported dynamically because the loader imports back from this module
   // (registerWorkspaceTools / removeCoreToolViaWorkspace); a static import
   // here would create a registry ↔ loader cycle.

package/src/tools/tool-approval-handler.ts

@@ -553,7 +553,7 @@ export class ToolApprovalHandler {
         const inputDigest =
           deferredConsumeParams?.inputDigest ??
           computeToolApprovalDigest(name, input);
-        const escalation = createOrReuseToolGrantRequest({
+        const escalation = await createOrReuseToolGrantRequest({
           assistantId: context.assistantId,
           sourceChannel: context.executionChannel as ChannelId,
           conversationId: context.conversationId,

package/src/tools/tool-defaults.ts

@@ -10,6 +10,7 @@
  * is a `Tool` (`Required<ToolDefinition>`).
  */
 
+import { resolveExecutionTarget } from "./execution-target.js";
 import type {
   RiskLevel,
   Tool,
@@ -30,7 +31,10 @@ import type {
  *   are rejected at the JSON-schema layer.
  * - `executionTarget` defaults to `sandbox` — author-supplied tool code
  *   runs in the assistant container by default; opt in to `host` when
- *   the tool proxies work to the connected client.
+ *   the tool proxies work to the connected client. The name-prefix
+ *   heuristic (`host_*` / `computer_use_*` resolves to host) is applied
+ *   by `resolveExecutionTarget` in `finalizeTool`, so a tool named
+ *   `host_my_thing` defaults to host even without an explicit field.
  * - `category` defaults to empty — Slack channel `allowedToolCategories`
  *   policy denies uncategorized tools when a category allow-list is set,
  *   which is the correct deny-by-default for tools the author didn't
@@ -90,8 +94,10 @@ export function finalizeTool(tool: ToolDefinition, defaultName = ""): Tool {
           content: `tool ${name} has no execute implementation`,
           isError: true,
         });
-  const executionTarget = tool.executionTarget ?? TOOL_DEFAULTS.executionTarget;
+  const executionTarget =
+    tool.executionTarget ?? resolveExecutionTarget({ name });
   const category = tool.category ?? TOOL_DEFAULTS.category;
+  const exclusive = tool.exclusive ?? false;
   return {
     ...tool,
     name,
@@ -101,5 +107,6 @@ export function finalizeTool(tool: ToolDefinition, defaultName = ""): Tool {
     executionTarget,
     execute,
     category,
+    exclusive,
   };
 }

package/src/tools/types.ts

@@ -449,6 +449,15 @@ export const ToolDefinitionSchema = z.object({
       ) => Promise<ToolExecutionResult>
     >()
     .optional(),
+  /**
+   * When true, this tool runs alone in its turn. If the model emits it
+   * alongside other tool calls, the agent loop executes only this one and
+   * defers the siblings — returning them un-run with a benign notice — so the
+   * model incorporates this tool's output before acting on anything else. The
+   * `advisor` tool sets this so its guidance lands before the agent commits to
+   * a path. Default false (the loop runs sibling calls concurrently as usual).
+   */
+  exclusive: z.boolean().optional(),
 });
 
 /**
@@ -460,8 +469,14 @@ export const ToolDefinitionSchema = z.object({
  */
 export type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
 
-/** Tool after the loader has derived its name and filled defaults. */
-export type Tool = Required<ToolDefinition>;
+/**
+ * Tool after the loader has derived its name and filled defaults. Every field
+ * is required except `exclusive`, which stays optional — most tools never set
+ * it, and the agent loop reads it as `?.exclusive === true`, so forcing every
+ * hand-built `Tool` (MCP/meet/test fixtures) to carry it would be noise.
+ */
+export type Tool = Required<Omit<ToolDefinition, "exclusive">> &
+  Pick<ToolDefinition, "exclusive">;
 
 /** The kind of extension that owns a tool. Core tools have no owner. */
 export type OwnerKind = "skill" | "mcp" | "plugin" | "workspace";