@vellumai/assistant 0.8.2 → 0.8.3

package/src/runtime/routes/integrations/a2a.ts

@@ -0,0 +1,235 @@
+/**
+ * Route handlers for A2A integration config endpoints.
+ *
+ * GET    /v1/integrations/a2a/config          — get current A2A config status
+ * POST   /v1/integrations/a2a/config          — enable A2A channel
+ * DELETE /v1/integrations/a2a/config          — disable A2A channel
+ * POST   /v1/integrations/a2a/invite          — create a shareable A2A invite token
+ * POST   /v1/integrations/a2a/invite/complete — sender-side invite completion
+ * POST   /v1/integrations/a2a/invite/redeem   — receiver-side invite redemption
+ */
+
+import { isA2AEnabled } from "../../../a2a/feature-gate.js";
+import { getConfig } from "../../../config/loader.js";
+import {
+  clearA2AConfig,
+  completeA2AInvite,
+  createA2AInvite,
+  getA2AConfig,
+  redeemA2AInvite,
+  setA2AConfig,
+} from "../../../daemon/handlers/config-a2a.js";
+import { BadRequestError } from "../errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function assertA2AFlag(): void {
+  if (!isA2AEnabled(getConfig())) {
+    throw new BadRequestError("A2A channel is not available");
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+function handleGetA2AConfig() {
+  assertA2AFlag();
+  return getA2AConfig();
+}
+
+function handleSetA2AConfig() {
+  assertA2AFlag();
+  const result = setA2AConfig();
+  if (!result.success) {
+    throw new BadRequestError(result.error ?? "Failed to enable A2A");
+  }
+  return result;
+}
+
+function handleClearA2AConfig() {
+  assertA2AFlag();
+  return clearA2AConfig();
+}
+
+function handleCreateA2AInvite({ body = {} }: RouteHandlerArgs) {
+  assertA2AFlag();
+  const { expiresInHours } = body as { expiresInHours?: unknown };
+  if (expiresInHours !== undefined) {
+    if (
+      typeof expiresInHours !== "number" ||
+      !Number.isFinite(expiresInHours) ||
+      expiresInHours <= 0
+    ) {
+      throw new BadRequestError(
+        "expiresInHours must be a positive finite number",
+      );
+    }
+  }
+  const result = createA2AInvite({
+    expiresInHours: expiresInHours as number | undefined,
+  });
+  if (!result.success) {
+    throw new BadRequestError(result.error ?? "Failed to create A2A invite");
+  }
+  return result;
+}
+
+function handleCompleteA2AInvite({ body = {} }: RouteHandlerArgs) {
+  const { token, senderAssistantId, acceptor } = body as {
+    token?: unknown;
+    senderAssistantId?: unknown;
+    acceptor?: {
+      assistantId?: unknown;
+      displayName?: unknown;
+      gatewayUrl?: unknown;
+    };
+  };
+
+  if (typeof token !== "string" || !token) {
+    throw new BadRequestError(
+      "token is required and must be a non-empty string",
+    );
+  }
+  if (typeof senderAssistantId !== "string" || !senderAssistantId) {
+    throw new BadRequestError(
+      "senderAssistantId is required and must be a non-empty string",
+    );
+  }
+  if (
+    !acceptor ||
+    typeof acceptor.assistantId !== "string" ||
+    !acceptor.assistantId ||
+    typeof acceptor.displayName !== "string" ||
+    !acceptor.displayName ||
+    typeof acceptor.gatewayUrl !== "string" ||
+    !acceptor.gatewayUrl
+  ) {
+    throw new BadRequestError(
+      "acceptor must include non-empty assistantId, displayName, and gatewayUrl",
+    );
+  }
+
+  const result = completeA2AInvite({
+    token,
+    senderAssistantId,
+    acceptor: {
+      assistantId: acceptor.assistantId,
+      displayName: acceptor.displayName,
+      gatewayUrl: acceptor.gatewayUrl,
+    },
+  });
+  if (!result.success) {
+    throw new BadRequestError(result.error ?? "Failed to complete A2A invite");
+  }
+  return result;
+}
+
+function handleRedeemA2AInvite({ body = {} }: RouteHandlerArgs) {
+  const { sender } = body as {
+    sender?: {
+      assistantId?: unknown;
+      displayName?: unknown;
+      gatewayUrl?: unknown;
+    };
+  };
+
+  if (
+    !sender ||
+    typeof sender.assistantId !== "string" ||
+    !sender.assistantId ||
+    typeof sender.displayName !== "string" ||
+    !sender.displayName ||
+    typeof sender.gatewayUrl !== "string" ||
+    !sender.gatewayUrl
+  ) {
+    throw new BadRequestError(
+      "sender must include non-empty assistantId, displayName, and gatewayUrl",
+    );
+  }
+
+  const result = redeemA2AInvite({
+    sender: {
+      assistantId: sender.assistantId,
+      displayName: sender.displayName,
+      gatewayUrl: sender.gatewayUrl,
+    },
+  });
+  if (!result.success) {
+    throw new BadRequestError(result.error ?? "Failed to redeem A2A invite");
+  }
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "integrations_a2a_config_get",
+    endpoint: "integrations/a2a/config",
+    method: "GET",
+    summary: "Get A2A config",
+    description: "Check current A2A channel configuration status.",
+    tags: ["integrations"],
+    requirePolicyEnforcement: true,
+    handler: () => handleGetA2AConfig(),
+  },
+  {
+    operationId: "integrations_a2a_config_post",
+    endpoint: "integrations/a2a/config",
+    method: "POST",
+    summary: "Enable A2A channel",
+    description: "Enable the A2A channel for inter-assistant communication.",
+    tags: ["integrations"],
+    requirePolicyEnforcement: true,
+    handler: () => handleSetA2AConfig(),
+  },
+  {
+    operationId: "integrations_a2a_config_delete",
+    endpoint: "integrations/a2a/config",
+    method: "DELETE",
+    summary: "Disable A2A channel",
+    description: "Disable the A2A channel.",
+    tags: ["integrations"],
+    requirePolicyEnforcement: true,
+    handler: () => handleClearA2AConfig(),
+  },
+  {
+    operationId: "integrations_a2a_invite_post",
+    endpoint: "integrations/a2a/invite",
+    method: "POST",
+    summary: "Create A2A invite",
+    description:
+      "Create a shareable A2A invite token for link-based contact creation.",
+    tags: ["integrations"],
+    requirePolicyEnforcement: true,
+    handler: handleCreateA2AInvite,
+  },
+  {
+    operationId: "integrations_a2a_invite_complete_post",
+    endpoint: "integrations/a2a/invite/complete",
+    method: "POST",
+    summary: "Complete A2A invite (sender side)",
+    description:
+      "Called by the platform to finalize the sender side of a link-based A2A connection.",
+    tags: ["integrations"],
+    requirePolicyEnforcement: true,
+    handler: handleCompleteA2AInvite,
+  },
+  {
+    operationId: "integrations_a2a_invite_redeem_post",
+    endpoint: "integrations/a2a/invite/redeem",
+    method: "POST",
+    summary: "Redeem A2A invite (receiver side)",
+    description:
+      "Called by the platform to create a trusted contact on the receiver side of a link-based A2A connection.",
+    tags: ["integrations"],
+    requirePolicyEnforcement: true,
+    handler: handleRedeemA2AInvite,
+  },
+];

package/src/runtime/routes/llm-call-sites-routes.ts

@@ -1,10 +1,20 @@
+import { resolveDefaultProfileKey } from "../../config/llm-resolver.js";
+import { loadConfig } from "../../config/loader.js";
 import { CALL_SITE_CATALOG, CALL_SITE_DOMAINS } from "../../config/schemas/call-site-catalog.js";
+import type { LLMCallSite } from "../../config/schemas/llm.js";
 import type { RouteDefinition } from "./types.js";
 
 async function handleGetCallSites() {
+  const { llm } = loadConfig();
   return {
     domains: CALL_SITE_DOMAINS,
-    callSites: CALL_SITE_CATALOG,
+    callSites: CALL_SITE_CATALOG.map((entry) => ({
+      ...entry,
+      defaultProfile: resolveDefaultProfileKey(
+        entry.id as LLMCallSite,
+        llm,
+      ),
+    })),
   };
 }
 

package/src/runtime/routes/subagents-routes.ts

@@ -188,6 +188,47 @@ function getSubagentDetail(
 // ---------------------------------------------------------------------------
 
 export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "reconcileSubagents",
+    endpoint: "subagents/reconcile",
+    method: "GET",
+    policyKey: "subagents",
+    summary: "Reconcile subagent live status",
+    description:
+      "Returns the live in-memory status of all subagents known to the daemon for a given parent conversation. Subagents not in the response are orphaned.",
+    tags: ["subagents"],
+    queryParams: [
+      {
+        name: "parentConversationId",
+        schema: { type: "string" },
+        description: "Parent conversation ID",
+      },
+    ],
+    responseBody: z.object({
+      subagents: z.record(
+        z.string(),
+        z.object({
+          status: z.string(),
+        }),
+      ),
+    }),
+    handler: ({ queryParams }) => {
+      const parentConversationId = queryParams?.parentConversationId;
+      if (!parentConversationId) {
+        throw new BadRequestError(
+          "parentConversationId query parameter is required",
+        );
+      }
+      const manager = getSubagentManager();
+      const children = manager.getChildrenOf(parentConversationId);
+      const subagents: Record<string, { status: string }> = {};
+      for (const child of children) {
+        subagents[child.config.id] = { status: child.status };
+      }
+      return { subagents };
+    },
+  },
+
   {
     operationId: "getSubagentDetail",
     endpoint: "subagents/:id",

package/src/subagent/manager.ts

@@ -903,6 +903,8 @@ export class SubagentManager {
           subagentId: info.subagentId,
           label: info.label,
           status: "running" as const,
+          conversationId: managed.state.conversationId,
+          objective: managed.state.config.objective,
         },
       },
     );

package/src/tools/memory/register.ts

@@ -6,7 +6,6 @@ import {
   type RememberInput,
 } from "../../memory/graph/tool-handlers.js";
 import {
-  getRememberDescription,
   graphRecallDefinition,
   graphRememberDefinition,
 } from "../../memory/graph/tools.js";
@@ -19,19 +18,12 @@ import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 class RememberTool implements Tool {
   name = "remember";
-  // Surfaced in registry listings. The flag-aware description used during
-  // actual tool dispatch is computed lazily in `getDefinition()` below so it
-  // tracks config changes across daemon lifetime without needing a tool
-  // re-registration pass.
   description = graphRememberDefinition.description;
   category = "memory";
   defaultRiskLevel = RiskLevel.Low;
 
   getDefinition(): ToolDefinition {
-    return {
-      ...graphRememberDefinition,
-      description: getRememberDescription(getConfig()),
-    };
+    return graphRememberDefinition;
   }
 
   async execute(

package/src/tools/registry.ts

@@ -10,7 +10,7 @@ import { hostFileWriteTool } from "./host-filesystem/write.js";
 import { hostShellTool } from "./host-terminal/host-shell.js";
 import { toProviderSafeToolName } from "./provider-tool-name.js";
 import { registerSystemTools } from "./system/register.js";
-import type { PluginTool, Tool } from "./types.js";
+import type { LoadedPluginTool, Tool } from "./types.js";
 import { allUiSurfaceTools } from "./ui-surface/definitions.js";
 import { registerUiSurfaceTools } from "./ui-surface/registry.js";
 
@@ -193,7 +193,7 @@ export function registerSkillTools(newTools: Tool[]): Tool[] {
  */
 export function registerPluginTools(
   pluginName: string,
-  newTools: PluginTool[],
+  newTools: LoadedPluginTool[],
 ): Tool[] {
   const stamped: Tool[] = newTools.map((pluginTool) => {
     const { input_schema, ...rest } = pluginTool;

package/src/tools/types.ts

@@ -376,16 +376,51 @@ export interface Tool {
 
 /**
  * Plugin-facing tool shape. The narrow surface plugin authors implement;
- * differs from {@link Tool} in three ways:
+ * differs from {@link Tool} in four ways:
  * - Plugins declare `input_schema` as a top-level field instead of
  *   implementing `getDefinition()`. The registration boundary synthesizes
  *   `getDefinition()` from `{name, description, input_schema}` before the
  *   tool enters the internal registry.
+ * - `name` is derived from the tool file's basename by the external plugin
+ *   loader.
  * - `category` is registry-owned and stamped to `"plugin"` when the tool is
  *   registered.
  * - All ownership stamps (`origin`, `ownerPluginId`, etc.) are set
  *   authoritatively by the bootstrap; plugin authors leave them blank.
+ *
+ * Every author-visible field is optional. The loader fills the four
+ * normally-required slots (`description`, `defaultRiskLevel`,
+ * `input_schema`, `execute`) with documented defaults when a plugin omits
+ * them — see `applyPluginToolDefaults` in `external-plugin-loader.ts`.
+ * A nameless, body-less `export default {}` is a valid (if useless) tool;
+ * misconfigured tools surface at call time rather than blocking plugin
+ * load.
+ */
+export type PluginTool = Omit<
+  Tool,
+  "category" | "getDefinition" | "name" | "description" | "defaultRiskLevel"
+> & {
+  description?: string;
+  defaultRiskLevel?: RiskLevel;
+  input_schema?: object;
+  execute?: (
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ) => Promise<ToolExecutionResult>;
+};
+
+/**
+ * Plugin tool after the external loader has derived its registry name and
+ * filled defaults for any author-omitted fields. All four normally-required
+ * slots are guaranteed present.
  */
-export type PluginTool = Omit<Tool, "category" | "getDefinition"> & {
+export type LoadedPluginTool = PluginTool & {
+  name: string;
+  description: string;
+  defaultRiskLevel: RiskLevel;
   input_schema: object;
+  execute: (
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ) => Promise<ToolExecutionResult>;
 };

package/src/workspace/migrations/087-memory-router-balanced-profile.ts

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+// Upgrade callSites.memoryRouter from the 077-seeded
+// {model: "claude-sonnet-4-6", contextWindow: {maxInputTokens: 1_000_000}}
+// shape to {profile: "balanced"} so the router rides the workspace's active
+// inference profile (with thinking enabled, higher effort, etc.) instead of a
+// bare model pin.
+//
+// Two skip conditions guard against runtime regressions:
+//
+//   1. BYOK / non-Anthropic workspaces. `balanced` resolves to the managed
+//      Anthropic connection (see seedInferenceProfiles), which off-platform
+//      installs explicitly disable. Forcing `balanced` there would make
+//      getConfiguredProvider("memoryRouter") return null and silently
+//      disable memory injection. Detect this by inspecting llm.default.provider
+//      — same heuristic migration 077 used to gate its seed.
+//
+//   2. User-customized memoryRouter config. If the existing entry isn't the
+//      exact 077-seeded shape (and isn't already {profile: "balanced"}), the
+//      user — or a platform overlay — chose those values deliberately. Match
+//      077's pattern of preserving any prior config.
+export const memoryRouterBalancedProfileMigration: WorkspaceMigration = {
+  id: "087-memory-router-balanced-profile",
+  description:
+    "Set callSites.memoryRouter to { profile: 'balanced' }, dropping the seeded model and contextWindow override",
+  run(workspaceDir: string): void {
+    if (process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH) return;
+
+    const configPath = join(workspaceDir, "config.json");
+    const configExisted = existsSync(configPath);
+
+    let config: Record<string, unknown> = {};
+    if (configExisted) {
+      try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+        config = raw as Record<string, unknown>;
+      } catch {
+        return;
+      }
+    }
+
+    const llm = readObject(config.llm) ?? {};
+
+    const explicitProvider = readString(readObject(llm.default)?.provider);
+    if (explicitProvider !== undefined && explicitProvider !== "anthropic") {
+      return;
+    }
+
+    const callSites = readObject(llm.callSites) ?? {};
+    const existing = readObject(callSites.memoryRouter);
+
+    if (existing !== null && !isSeededBy077(existing)) {
+      return;
+    }
+
+    callSites.memoryRouter = { profile: "balanced" };
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only.
+  },
+};
+
+// True when the entry looks exactly like what migration 077 wrote: a model pin
+// of claude-sonnet-4-6 plus the 1M-token context window, and nothing else.
+function isSeededBy077(entry: Record<string, unknown>): boolean {
+  const keys = Object.keys(entry);
+  if (keys.length !== 2) return false;
+  if (entry.model !== "claude-sonnet-4-6") return false;
+  const contextWindow = readObject(entry.contextWindow);
+  if (contextWindow === null) return false;
+  const cwKeys = Object.keys(contextWindow);
+  return cwKeys.length === 1 && contextWindow.maxInputTokens === 1_000_000;
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}

package/src/workspace/migrations/registry.ts

@@ -84,6 +84,7 @@ import { systemPromptPrefixToFileMigration } from "./083-system-prompt-prefix-to
 import { removeLegacySkillsIndexMigration } from "./084-remove-legacy-skills-index.js";
 import { memoryV2Bm25BReembedDisabledV2PagesMigration } from "./085-memory-v2-bm25-b-reembed-disabled-v2-pages.js";
 import { revertStaleGeminiMisRewritesMigration } from "./086-revert-stale-gemini-mis-rewrites.js";
+import { memoryRouterBalancedProfileMigration } from "./087-memory-router-balanced-profile.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -179,4 +180,5 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   removeLegacySkillsIndexMigration,
   memoryV2Bm25BReembedDisabledV2PagesMigration,
   revertStaleGeminiMisRewritesMigration,
+  memoryRouterBalancedProfileMigration,
 ];