@vellumai/assistant 0.8.4 → 0.8.6

package/src/skills/validate-input.ts

@@ -0,0 +1,177 @@
+/**
+ * Pure JSON-schema input validator for skill tool calls.
+ *
+ * Deliberate strict subset of JSON Schema: it covers only the keywords
+ * actually used by `assistant/src/config/bundled-skills/**\/TOOLS.json`
+ * (required / type / enum / items.type) plus unknown-key detection. Anything
+ * else (`$ref`, `oneOf`, `anyOf`, `allOf`, `format`, `pattern`, `minimum`,
+ * `maximum`, object-shape `additionalProperties`, etc.) is silently skipped so
+ * a richer schema can never cause us to reject a legitimate call.
+ *
+ * Each error message is written to be agent-readable and self-correcting
+ * (e.g. `surface_id is required`, `mode must be one of "replace", "append"`).
+ */
+
+import { isPlainObject } from "../util/object.js";
+
+export interface InputValidationSuccess {
+  ok: true;
+}
+
+export interface InputValidationFailure {
+  ok: false;
+  /** Human-readable messages, one per problem. */
+  errors: string[];
+}
+
+export type InputValidationResult =
+  | InputValidationSuccess
+  | InputValidationFailure;
+
+type SupportedType =
+  | "string"
+  | "number"
+  | "integer"
+  | "boolean"
+  | "array"
+  | "object";
+
+const SUPPORTED_TYPES: ReadonlySet<string> = new Set([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "array",
+  "object",
+]);
+
+function matchesType(value: unknown, type: SupportedType): boolean {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainObject(value);
+  }
+}
+
+function quoteList(values: readonly string[]): string {
+  return values.map((v) => `"${v}"`).join(", ");
+}
+
+/**
+ * Validate a tool input object against the (optional) JSON-schema definition
+ * declared on the tool entry. Returns `{ ok: true }` if the input is valid (or
+ * if there is nothing actionable to validate); otherwise returns a list of
+ * human-readable error strings.
+ *
+ * Pure: never mutates `input` or `schema`, no I/O.
+ */
+export function validateInputAgainstSchema(
+  _toolName: string,
+  input: Record<string, unknown>,
+  schema: Record<string, unknown> | undefined,
+): InputValidationResult {
+  // Skip when there's no schema or no properties block — matches today's
+  // lenient behaviour for tools that declare only `{ type: "object" }`.
+  if (!schema) return { ok: true };
+  const properties = schema.properties;
+  if (!isPlainObject(properties)) return { ok: true };
+
+  const errors: string[] = [];
+  const knownKeys = Object.keys(properties);
+  const knownKeySet = new Set(knownKeys);
+
+  // 1. Required fields — presence-only check per JSON Schema spec.
+  // `required` only requires the property to be present; `null` is a valid
+  // value when the schema allows it (e.g. `type: ["string", "null"]`).
+  const required = schema.required;
+  if (Array.isArray(required)) {
+    for (const key of required) {
+      if (typeof key !== "string") continue;
+      if (!(key in input)) {
+        errors.push(`${key} is required`);
+      }
+    }
+  }
+
+  // 2. Per-property checks: type, enum, items.type.
+  for (const [key, rawSubSchema] of Object.entries(properties)) {
+    if (!(key in input)) continue;
+    const value = input[key];
+    // Skip type-checking for absent values; presence is enforced by the
+    // `required` check above. Note: `null` IS a present value and is
+    // type-checked below — only schemas that explicitly opt in to null via
+    // a union type (`type: ["string","null"]`) bypass the check, handled
+    // by the `Array.isArray(declaredType)` skip immediately below.
+    if (value === undefined) continue;
+    if (!isPlainObject(rawSubSchema)) continue;
+
+    const declaredType = rawSubSchema.type;
+    // Skip union types (e.g. `["string", "null"]`) — same lenient treatment
+    // we give `oneOf`/`anyOf`/`$ref`. We only validate single-type schemas.
+    if (Array.isArray(declaredType)) continue;
+    if (typeof declaredType === "string" && SUPPORTED_TYPES.has(declaredType)) {
+      const type = declaredType as SupportedType;
+      if (!matchesType(value, type)) {
+        errors.push(`${key} must be ${typeArticle(type)} ${type}`);
+        // No point checking enum/items if the base type is wrong.
+        continue;
+      }
+
+      // 2a. Enum (string enums are the only shape used today).
+      const enumValues = rawSubSchema.enum;
+      if (Array.isArray(enumValues) && enumValues.length > 0) {
+        if (!enumValues.includes(value)) {
+          errors.push(
+            `${key} must be one of ${quoteList(enumValues.map(String))}`,
+          );
+        }
+      }
+
+      // 2b. Array items.type — per-element check.
+      if (type === "array" && isPlainObject(rawSubSchema.items)) {
+        const itemType = rawSubSchema.items.type;
+        if (
+          typeof itemType === "string" &&
+          SUPPORTED_TYPES.has(itemType) &&
+          Array.isArray(value)
+        ) {
+          const itemTypeName = itemType as SupportedType;
+          value.forEach((element, index) => {
+            if (!matchesType(element, itemTypeName)) {
+              errors.push(
+                `${key}[${index}] must be ${typeArticle(itemTypeName)} ${itemTypeName}`,
+              );
+            }
+          });
+        }
+      }
+    }
+  }
+
+  // 3. Unknown keys — parity with the previous `validateNoUnknownParams`.
+  const unknownKeys = Object.keys(input).filter((k) => !knownKeySet.has(k));
+  for (const key of unknownKeys) {
+    errors.push(
+      `Unknown parameter "${key}". Supported: ${quoteList(knownKeys)}`,
+    );
+  }
+
+  if (errors.length === 0) return { ok: true };
+  return { ok: false, errors };
+}
+
+function typeArticle(type: SupportedType): "a" | "an" {
+  // `integer`, `array`, `object` start with a vowel sound.
+  return type === "integer" || type === "array" || type === "object"
+    ? "an"
+    : "a";
+}

package/src/subagent/manager.ts

@@ -365,6 +365,7 @@ export class SubagentManager {
       label: config.label,
       objective: config.objective,
       isFork: config.fork ?? false,
+      parentToolUseId: config.parentToolUseId,
     } as ServerMessage);
 
     log.info(
@@ -435,7 +436,9 @@ export class SubagentManager {
             "⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯",
           ].join("\n")
         : objective;
-      const messageId = await conversation.persistUserMessage(message, []);
+      const { id: messageId } = await conversation.persistUserMessage({
+        content: message,
+      });
       await conversation.runAgentLoop(message, messageId, undefined, {
         callSite: "subagentSpawn",
         ...(managed.state.config.overrideProfile
@@ -609,7 +612,7 @@ export class SubagentManager {
       return "terminal";
 
     // If the conversation is busy, queue the message; otherwise process immediately.
-    const result = managed.conversation.enqueueMessage(trimmed, []);
+    const result = managed.conversation.enqueueMessage({ content: trimmed });
     if (result.rejected) {
       return "sent"; // error event already delivered via sendToClient
     }
@@ -620,7 +623,9 @@ export class SubagentManager {
       // Capture conversation before the await — managed.conversation may be
       // nulled by an external dispose() while persistUserMessage is awaited.
       const conversation = managed.conversation;
-      const messageId = await conversation.persistUserMessage(trimmed, []);
+      const { id: messageId } = await conversation.persistUserMessage({
+        content: trimmed,
+      });
       conversation
         .runAgentLoop(trimmed, messageId, undefined, {
           callSite: "subagentSpawn",
@@ -984,19 +989,14 @@ export class SubagentManager {
       );
       return;
     }
-    const enqueueResult = parentConversation.enqueueMessage(
-      message,
-      [],
-      undefined,
-      undefined,
-      undefined,
-      undefined,
+    const enqueueResult = parentConversation.enqueueMessage({
+      content: message,
       metadata,
-    );
+    });
     if (!enqueueResult.queued && !enqueueResult.rejected) {
       parentConversation
-        .persistUserMessage(message, [], undefined, metadata)
-        .then((messageId) =>
+        .persistUserMessage({ content: message, metadata })
+        .then(({ id: messageId }) =>
           parentConversation.runAgentLoop(message, messageId),
         )
         .catch((err) => {

package/src/subagent/types.ts

@@ -69,6 +69,12 @@ export interface SubagentConfig {
    * profile, every spawned subagent inherits it automatically.
    */
   overrideProfile?: string;
+  /**
+   * Tool-use id of the `skill_execute` call that spawned this subagent.
+   * Forwarded into the `subagent_spawned` event so the client can anchor the
+   * inline subagent card to the exact spawn tool call.
+   */
+  parentToolUseId?: string;
 }
 
 // ── State (runtime) ─────────────────────────────────────────────────────

package/src/tasks/tool-sanitizer.ts

@@ -1,4 +1,4 @@
-import { getAllTools, getTool } from "../tools/registry.js";
+import { getAllTools, getTool, getToolOwner } from "../tools/registry.js";
 
 /**
  * Deduplicate and sort a list of tool names, validating against the live
@@ -24,7 +24,7 @@ export function sanitizeToolList(tools: string[]): string[] {
  */
 export function getRegisteredToolNames(): string[] {
   return getAllTools()
-    .filter((t) => t.executionMode !== "proxy" && t.origin !== "skill")
+    .filter((t) => getToolOwner(t.name)?.kind !== "skill")
     .map((t) => t.name)
     .sort();
 }

package/src/telemetry/types.ts

@@ -38,6 +38,18 @@ export interface LlmUsageTelemetryEvent extends TelemetryEventBase {
   output_tokens: number;
   cache_creation_input_tokens: number | null;
   cache_read_input_tokens: number | null;
+  /**
+   * The provider's untouched `usage` block. Anthropic surfaces a TTL
+   * breakdown under `cache_creation.ephemeral_{5m,1h}_input_tokens`;
+   * OpenAI surfaces cached-read counts under
+   * `prompt_tokens_details.cached_tokens` (and reasoning tokens under
+   * `completion_tokens_details`). Both shapes are forwarded verbatim so
+   * downstream consumers (admin charts, dbt models) can extract any
+   * provider-specific detail without requiring a schema change here.
+   * Null when the provider did not return a usage payload, and for
+   * daemons that predate `260-llm-usage-add-raw-usage`.
+   */
+  raw_usage: Record<string, unknown> | null;
   actor: string;
   llm_call_site: LLMCallSite | null;
   inference_profile: string | null;

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -159,6 +159,7 @@ function makeUsageEvent(
     outputTokens: 50,
     cacheCreationInputTokens: 10,
     cacheReadInputTokens: 5,
+    rawUsage: null,
     actor: "main_agent",
     callSite: null,
     inferenceProfile: null,
@@ -435,6 +436,53 @@ describe("UsageTelemetryReporter", () => {
     expect(e.inference_profile_source).toBe("conversation");
     expect(e.cost).toBe(0.001);
     expect(e.recorded_at).toBe(1700000099000);
+    // raw_usage defaults to null on this fixture (the makeUsageEvent default),
+    // confirming the wire shape carries the key as `null` rather than
+    // dropping it for legacy rows or providers that did not return a
+    // usage block.
+    expect(e.raw_usage).toBeNull();
+  });
+
+  test("payload forwards the provider's raw_usage block verbatim", async () => {
+    // The reporter must surface the literal usage object the provider
+    // returned (Anthropic nests TTL breakdown under `cache_creation`,
+    // OpenAI nests cached-read counts under `prompt_tokens_details`,
+    // etc.) so downstream consumers can extract any provider-specific
+    // detail without a wire-level schema change. Anything that
+    // transforms, summarises, or strips fields here destroys data the
+    // admin charts and dbt models depend on.
+    const rawUsage = {
+      input_tokens: 200,
+      output_tokens: 100,
+      cache_creation_input_tokens: 750,
+      cache_creation: {
+        ephemeral_5m_input_tokens: 250,
+        ephemeral_1h_input_tokens: 500,
+      },
+      cache_read_input_tokens: 15,
+      service_tier: "standard",
+    };
+    const event = makeUsageEvent({
+      id: "evt-raw-usage",
+      provider: "anthropic",
+      model: "claude-sonnet-4-20250514",
+      cacheCreationInputTokens: 750,
+      rawUsage,
+    });
+    mockQueryUnreportedUsageEvents.mockReturnValue([event]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    const e = body.events[0];
+    expect(e.cache_creation_input_tokens).toBe(750);
+    expect(e.raw_usage).toEqual(rawUsage);
   });
 
   test("payload preserves null attribution for historical usage rows", async () => {

package/src/telemetry/usage-telemetry-reporter.ts

@@ -234,6 +234,7 @@ export class UsageTelemetryReporter {
             output_tokens: e.outputTokens,
             cache_creation_input_tokens: e.cacheCreationInputTokens ?? null,
             cache_read_input_tokens: e.cacheReadInputTokens ?? null,
+            raw_usage: e.rawUsage,
             actor: e.actor,
             llm_call_site: e.callSite,
             inference_profile: e.inferenceProfile,

package/src/tools/acp/spawn.test.ts

@@ -82,6 +82,25 @@ mock.module("../../util/logger.js", () => ({
     }),
 }));
 
+// Stub secure-keys so the `prepareAgentEnv` preflight finds a token without
+// the test having to populate the real OS keyring. Driven via `secureKeyStore`
+// per test in beforeEach; the default seeds a vault token so existing tests
+// (which assume claude spawns succeed) keep passing.
+//
+// The real module's other exports are spread in so transitive importers
+// (e.g. session-manager → pending-interactions → credential-routes, which
+// imports `getSecureKeyResultAsync`) still resolve at parse time. Bun's
+// `mock.module` is process-global and returns *exactly* the keys the factory
+// returns — without the spread, any consumer pulling a non-`getSecureKeyAsync`
+// export errors with "Export named '<X>' not found".
+const secureKeyStore = new Map<string, string>();
+const realSecureKeys = await import("../../security/secure-keys.js");
+
+mock.module("../../security/secure-keys.js", () => ({
+  ...realSecureKeys,
+  getSecureKeyAsync: async (key: string) => secureKeyStore.get(key),
+}));
+
 // Stub session manager so we don't actually spawn child processes.
 const spawnMock = mock(
   async (
@@ -131,6 +150,14 @@ beforeEach(() => {
   _resetAdapterVersionCacheForTests();
   config.setConfig({ agents: DEFAULT_TEST_AGENTS });
   which.setWhich((cmd) => `/usr/local/bin/${cmd}`);
+  // Default: vault has a claude token so the preflight in `prepareAgentEnv`
+  // succeeds for tests that don't care about env injection. Env-injection
+  // tests below clear/override this explicitly.
+  secureKeyStore.clear();
+  secureKeyStore.set(
+    "credential/acp/claude_oauth_token",
+    "default-test-token",
+  );
 });
 
 // ---------------------------------------------------------------------------
@@ -376,3 +403,95 @@ describe("executeAcpSpawn — per-agent resume hint", () => {
     expect(payload.message).not.toContain("To resume this session later");
   });
 });
+
+// ---------------------------------------------------------------------------
+// executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN env injection + preflight
+//
+// Mirrors the HTTP-route test block in
+// `runtime/routes/acp-routes.test.ts` — the skill tool calls into the same
+// `prepareAgentEnv` helper, and the contract must be identical so a
+// missing token fails the spawn at the tool boundary (`isError: true`)
+// instead of letting a token-less subprocess zombie out. PR-history
+// context: the inline env-injection used to live in the route only; this
+// tool path was bypassing it entirely, causing every skill-driven ACP
+// spawn to die on first prompt with "Authentication required". Pin both
+// the happy paths and the throw path here so future drift on either
+// caller fails the suite loudly.
+// ---------------------------------------------------------------------------
+
+describe("executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN injection", () => {
+  test("injects CLAUDE_CODE_OAUTH_TOKEN from the secure store for the claude agent", async () => {
+    secureKeyStore.clear();
+    secureKeyStore.set(
+      "credential/acp/claude_oauth_token",
+      "tool-vault-token-abc",
+    );
+    execScripts.set("npm ls", { error: new Error("npm not installed") });
+    execScripts.set("npm view", { error: new Error("npm not installed") });
+
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(spawnMock).toHaveBeenCalledTimes(1);
+    const agentConfigArg = spawnMock.mock.calls[0][1] as {
+      env?: Record<string, string>;
+    };
+    expect(agentConfigArg.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe(
+      "tool-vault-token-abc",
+    );
+  });
+
+  test("accepts CLAUDE_CODE_OAUTH_TOKEN from config.json agent.env without a vault entry", async () => {
+    // Mirrors the route-level precedence test: a config.json env override
+    // is the first-priority provisioning route. The resolver surfaces it
+    // on `resolved.agent.env`, which the helper preserves.
+    secureKeyStore.clear();
+    config.setConfig({
+      agents: {
+        claude: {
+          command: "claude-agent-acp",
+          args: [],
+          env: { CLAUDE_CODE_OAUTH_TOKEN: "tool-config-token-xyz" },
+        },
+        codex: { command: "codex-acp", args: [] },
+        "unknown-agent": { command: "some-other-binary", args: [] },
+      },
+    });
+    execScripts.set("npm ls", { error: new Error("npm not installed") });
+    execScripts.set("npm view", { error: new Error("npm not installed") });
+
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const agentConfigArg = spawnMock.mock.calls[0][1] as {
+      env?: Record<string, string>;
+    };
+    expect(agentConfigArg.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe(
+      "tool-config-token-xyz",
+    );
+  });
+
+  test("returns isError when no token is available from either route (preflight throw mapped to tool result)", async () => {
+    // Both routes empty. The helper throws `FailedDependencyError`; the
+    // tool catches it and returns `{ isError: true, content: <msg> }`
+    // rather than letting it propagate (the tool boundary is a sync
+    // ToolExecutionResult, not an HTTP response).
+    secureKeyStore.clear();
+
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("CLAUDE_CODE_OAUTH_TOKEN");
+    // Spawn was NEVER called — preflight fired before the subprocess started.
+    expect(spawnMock).not.toHaveBeenCalled();
+  });
+});

package/src/tools/acp/spawn.ts

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 
 import { getAcpSessionManager } from "../../acp/index.js";
+import { prepareAgentEnv } from "../../acp/prepare-agent-env.js";
 import { resolveAcpAgent } from "../../acp/resolve-agent.js";
 import { DEFAULT_AGENT_NPM_PACKAGES } from "../../config/acp-defaults.js";
 import { getLogger } from "../../util/logger.js";
@@ -159,8 +160,6 @@ export async function executeAcpSpawn(
       }
     }
   }
-  const agentConfig = resolved.agent;
-
   const sendToClient = context.sendToClient as
     | ((msg: { type: string; [key: string]: unknown }) => void)
     | undefined;
@@ -171,6 +170,20 @@ export async function executeAcpSpawn(
     };
   }
 
+  // Inject required env vars and preflight via the shared helper. Mirrors
+  // the HTTP route at `runtime/routes/acp-routes.ts:spawnSession` — both
+  // call sites MUST go through `prepareAgentEnv` before `manager.spawn`,
+  // otherwise the spawned subprocess starts with no auth and dies as a
+  // zombie after the first prompt. See `acp/prepare-agent-env.ts` for
+  // the full rationale.
+  let agentConfig;
+  try {
+    agentConfig = await prepareAgentEnv(resolved.agent);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: msg, isError: true };
+  }
+
   // Best-effort version check — never blocks the spawn. If outdated, we
   // append a non-blocking warning to the success payload.
   const versionInfo = await checkAdapterVersion(agentConfig.command);

package/src/tools/apps/definitions.ts

@@ -9,17 +9,31 @@
  */
 
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
-import type { Tool, ToolExecutionResult } from "../types.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function proxyExecute(): Promise<ToolExecutionResult> {
-  throw new Error(
-    "Proxy tool: execution must be forwarded to the connected client",
-  );
+/**
+ * Forward execution to the connected macOS client via the request-bound
+ * `proxyToolResolver`. Returns a structured error when no resolver is
+ * configured (e.g. no client connected) so callers see a normal tool
+ * failure rather than an unhandled throw.
+ */
+function proxyExecute(toolName: string) {
+  return async (
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolExecutionResult> => {
+    if (!context.proxyToolResolver) {
+      return {
+        content: `No proxy resolver configured for proxy tool "${toolName}". This tool requires an external resolver (e.g. a connected macOS client).`,
+        isError: true,
+      };
+    }
+    return context.proxyToolResolver(toolName, input);
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -32,32 +46,26 @@ const appOpenTool: Tool = {
     "Open a persistent app in a dynamic_page surface on the connected client.",
   category: "apps",
   defaultRiskLevel: RiskLevel.Low,
-  executionMode: "proxy",
+  executionTarget: "host",
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: "object",
-        properties: {
-          app_id: {
-            type: "string",
-            description: "The ID of the app to open",
-          },
-          open_mode: {
-            type: "string",
-            enum: ["preview", "workspace"],
-            description:
-              "Display mode. 'preview' shows an inline preview card in chat. 'workspace' opens the full app in a workspace panel. Defaults to 'workspace'.",
-          },
-        },
-        required: ["app_id"],
+  input_schema: {
+    type: "object",
+    properties: {
+      app_id: {
+        type: "string",
+        description: "The ID of the app to open",
+      },
+      open_mode: {
+        type: "string",
+        enum: ["preview", "workspace"],
+        description:
+          "Display mode. 'preview' shows an inline preview card in chat. 'workspace' opens the full app in a workspace panel. Defaults to 'workspace'.",
       },
-    };
+    },
+    required: ["app_id"],
   },
 
-  execute: proxyExecute,
+  execute: proxyExecute("app_open"),
 };
 
 // ---------------------------------------------------------------------------

package/src/tools/ask-question/ask-question-tool.test.ts

@@ -51,7 +51,7 @@ const singleQ = {
 
 describe("AskQuestionTool definition", () => {
   test("exposes the expected schema shape and description language", () => {
-    const def = new AskQuestionTool().getDefinition();
+    const def = new AskQuestionTool();
     expect(def.name).toBe("ask_question");
     expect(def.description).toContain("free-text fallback is always added");
     expect(def.description).toContain("do not");
@@ -463,8 +463,8 @@ describe("AskQuestionTool batched input", () => {
 
 describe("AskQuestionTool definition (batched schema)", () => {
   test("exposes `questions[]` shape, keeps legacy fields, omits per-question id", () => {
-    const def = new AskQuestionTool().getDefinition();
-    const schema = def.input_schema as {
+    const def = new AskQuestionTool();
+    const schema = def.input_schema as unknown as {
       properties: Record<
         string,
         {