@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/plugin-api/index.ts

@@ -33,9 +33,11 @@
  * - {@link assistantEventHub} — the assistant's pub/sub hub for runtime events
  * - {@link getModelProfiles} — list the workspace inference profiles a plugin
  *   can route to (e.g. a model router building its category → profile map)
- * - {@link getConfiguredProvider} — resolve a {@link Provider} for a call site
+ * - {@link getConfiguredProvider}: resolve a {@link Provider} for a call site
  *   (optionally overriding the profile) and run inference through the
- *   workspace's configured profiles and credentials — no plugin-supplied API key
+ *   workspace's configured profiles and credentials, with no plugin-supplied API key
+ * - {@link getEffectiveContextWindow}: resolve that call site's provider,
+ *   model, and effective maximum input size
  *
  * - {@link InitContext} — passed to `init` hook at bootstrap
  * - {@link ShutdownContext} — passed to `shutdown` hook at teardown
@@ -169,10 +171,12 @@ export { publishEvent } from "./publish-event.js";
 // `inputModalities.image` override winning when set (mix profiles are
 // vision-capable if any arm is). Returns false when nothing resolves.
 export { doesSupportVision } from "./vision-support.js";
-// Resolve a stored credential to its plaintext value — the same value
-// `assistant credentials reveal` prints — from a UUID or a "service/field"
+// Resolve a stored credential to its plaintext value (the same value
+// `assistant credentials reveal` prints) from a UUID or a "service/field"
 // reference. When a plugin is in context, resolution is scoped to credentials
-// whose service matches the plugin's manifest name; outside any plugin it is
+// whose service matches the plugin's runtime name. A plugin-resident skill
+// script or skill-tool child presents a daemon-issued invocation grant and is
+// scoped the same way. Outside any plugin context or grant the resolver is
 // unscoped. Throws CredentialResolutionError when the ref does not resolve, the
 // store is unreachable, or the credential is out of the plugin's scope.
 export {
@@ -218,6 +222,11 @@ export { resolveOauthCallbackUrl } from "../inbound/oauth-callback-url.js";
 // float the chosen profile above the call-site layers when the plugin must
 // run on a specific profile regardless of workspace tuning.
 export { getConfiguredProvider } from "../providers/provider-send-message.js";
+export type {
+  EffectiveContextWindowInfo,
+  EffectiveContextWindowOptions,
+} from "./effective-context-window.js";
+export { getEffectiveContextWindow } from "./effective-context-window.js";
 // Resolve an image/file block's media `source` to its bytes as inline base64,
 // whether the source is inline base64 or a persisted workspace reference
 // (attachment-store row or a file on disk). Returns null when a reference can no
@@ -286,6 +295,11 @@ export {
 // writes files under the workspace (e.g. its own `plugins/<name>/data/`
 // directory) resolves them against this instead of hardcoding a base path.
 export { getWorkspaceDir } from "../util/platform.js";
+// `String.prototype.slice` that never cuts a UTF-16 surrogate pair in half.
+// Any text a plugin truncates by character budget and hands to a model must
+// go through this: an orphaned half is invalid UTF-16 that strict provider
+// parsers reject.
+export { safeStringSlice } from "../util/unicode.js";
 // Declarative help for the top-level `assistant` CLI commands that have adopted
 // the static-help split. Plugins (e.g. the memory capability indexer) read this
 // to embed CLI command capabilities without importing the CLI action graph.
@@ -359,7 +373,8 @@ export {
   stringifyMessageContent,
 } from "../persistence/message-content.js";
 // Conversation history — reads and writes on the host conversation store
-// (rows, message history, processing state, disk-view paths) plus the lexical
+// (rows, message history, processing state, the recorded wire tool surface,
+// disk-view paths) plus the lexical
 // message-search surface. Every operation takes explicit parameters; nothing
 // is resolved from config. Async because the facade loads the DB store graph
 // lazily on first call.
@@ -371,7 +386,9 @@ export {
   getConversation,
   getConversationDirPath,
   getConversationProcessingStartedAt,
+  getConversationToolSurface,
   getMessages,
+  getRecordedConversationToolSurface,
   hasLexicalTokens,
   isConversationProcessing,
   listConversations,
@@ -380,6 +397,7 @@ export {
   syncMessageToDisk,
   updateMessageMetadata,
 } from "../persistence/conversation-plugin-facade.js";
+export type { ConversationToolSurface } from "../persistence/conversation-tool-surface.js";
 // System cards: a transcript notice authored by the daemon rather than the
 // assistant persona, for telling the user something a turn did to their input
 // that the model's reply cannot explain (e.g. an attachment that could not be
@@ -392,6 +410,16 @@ export { persistSystemCard } from "./system-card.js";
 // what makes that true. Host tools and plugin tools share this one guard.
 export type { CancellableToolContext } from "./tool-cancellation.js";
 export { throwIfCancelled } from "./tool-cancellation.js";
+// Tool input from a Zod schema: derive the advertised `input_schema` from the
+// schema the tool parses its input with, so what the model is told and what
+// the tool accepts share one source. The host validates built-in tools'
+// input centrally; a plugin tool parses its own, and answers a failed parse
+// with `invalidToolInputResult` so its message reads the same as the host's.
+export {
+  invalidToolInputResult,
+  nullAsOmitted,
+  toToolInputSchema,
+} from "../tools/shared/zod-tool-schema.js";
 // Synthesize text to speech through the assistant's globally configured TTS
 // provider (ElevenLabs, Fish Audio, etc.). Plugins that need voice output —
 // e.g. a meeting bot speaking into a live call — use this instead of managing
@@ -438,6 +466,7 @@ export type {
   RunConversationTurnResult,
 } from "./conversation-turn.js";
 export { runConversationTurn } from "./conversation-turn.js";
+export { PluginTurnNotAdmittedError } from "./plugin-channel-turn-trust.js";
 // Live voice — drive a single client's real-time voice session (STT → agent
 // turn → TTS, with server-VAD turn-taking, pauses, and barge-in) over a
 // transport the plugin owns. The plugin brings only a `send` callback (e.g.

package/src/plugin-api/plugin-channel-turn-trust.test.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+type InboundTrustReadResult =
+  | {
+      ok: true;
+      verdict: {
+        trustClass: string;
+        canonicalSenderId: string | null;
+        contactId?: string;
+        status?: string;
+        resolutionFailed?: boolean;
+      };
+      admissionPolicy: string | null;
+    }
+  | { ok: false };
+
+let nextRead: InboundTrustReadResult = { ok: false };
+
+mock.module("../calls/inbound-trust-reader.js", () => ({
+  readInboundTrust: async () => nextRead,
+}));
+
+import {
+  PluginTurnNotAdmittedError,
+  resolvePluginChannelTurnTrust,
+} from "./plugin-channel-turn-trust.js";
+
+const CHANNEL = {
+  sourceChannel: "plugin" as const,
+  externalChatId: "imessage:+12025550142",
+  externalUserId: "imessage:+12025550142",
+  displayName: "Ada",
+};
+
+beforeEach(() => {
+  nextRead = { ok: false };
+});
+
+describe("resolvePluginChannelTurnTrust", () => {
+  test("returns the gateway verdict as the turn trust context", async () => {
+    nextRead = {
+      ok: true,
+      verdict: {
+        trustClass: "trusted_contact",
+        canonicalSenderId: "imessage:+12025550142",
+        contactId: "c-ada",
+        status: "active",
+      },
+      admissionPolicy: "trusted_contacts",
+    };
+
+    const trust = await resolvePluginChannelTurnTrust(CHANNEL);
+    expect(trust.trustClass).toBe("trusted_contact");
+    expect(trust.sourceChannel).toBe("plugin");
+    expect(trust.requesterChatId).toBe(CHANNEL.externalChatId);
+  });
+
+  test("fails closed when the gateway could not vouch for the sender", async () => {
+    nextRead = {
+      ok: true,
+      verdict: {
+        trustClass: "unknown",
+        canonicalSenderId: null,
+        resolutionFailed: true,
+      },
+      admissionPolicy: "strangers",
+    };
+
+    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toMatchObject({
+      name: "PluginTurnNotAdmittedError",
+      reason: "trust_resolution_failed",
+    });
+  });
+
+  test("fails closed when the gateway trust read fails", async () => {
+    nextRead = { ok: false };
+    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toMatchObject({
+      name: "PluginTurnNotAdmittedError",
+      reason: "trust_resolution_failed",
+    });
+  });
+
+  test("rejects a sender below the channel admission floor", async () => {
+    nextRead = {
+      ok: true,
+      verdict: { trustClass: "unknown", canonicalSenderId: null },
+      admissionPolicy: "guardian_only",
+    };
+
+    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toEqual(
+      expect.objectContaining({
+        name: "PluginTurnNotAdmittedError",
+        reason: "admission_policy_guardian_only",
+      }),
+    );
+  });
+
+  test("rejects a blocked member regardless of floor", async () => {
+    nextRead = {
+      ok: true,
+      verdict: {
+        trustClass: "trusted_contact",
+        canonicalSenderId: "imessage:+12025550142",
+        contactId: "c-ada",
+        status: "blocked",
+      },
+      admissionPolicy: "strangers",
+    };
+
+    await expect(resolvePluginChannelTurnTrust(CHANNEL)).rejects.toMatchObject({
+      name: "PluginTurnNotAdmittedError",
+      reason: "member_blocked",
+    });
+  });
+
+  test("admits when the gateway reports no admission policy", async () => {
+    nextRead = {
+      ok: true,
+      verdict: { trustClass: "unknown", canonicalSenderId: null },
+      admissionPolicy: null,
+    };
+
+    const trust = await resolvePluginChannelTurnTrust(CHANNEL);
+    expect(trust.trustClass).toBe("unknown");
+  });
+
+  test("PluginTurnNotAdmittedError names the deny reason", () => {
+    const err = new PluginTurnNotAdmittedError("admission_policy_no_one");
+    expect(err).toBeInstanceOf(Error);
+    expect(err.reason).toBe("admission_policy_no_one");
+    expect(err.message).toContain("admission_policy_no_one");
+  });
+});

package/src/plugin-api/plugin-channel-turn-trust.ts

@@ -0,0 +1,71 @@
+/**
+ * Gateway admission and trust for plugin turns addressed by a channel chat.
+ *
+ * A channel address means an inbound sender, not an internal plugin job.
+ * Trust comes from the gateway verdict (`resolve_inbound_trust`); the turn
+ * runs only when that sender clears the channel admission floor.
+ */
+
+import { meetsAdmissionFloor } from "@vellumai/gateway-client";
+
+import { readInboundTrust } from "../calls/inbound-trust-reader.js";
+import type { ChannelId } from "../channels/types.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
+import { trustContextFromVerdict } from "../runtime/trust-verdict-consumer.js";
+
+interface PluginChannelTurnAddress {
+  sourceChannel: ChannelId;
+  externalChatId: string;
+  externalUserId?: string | null;
+  displayName?: string | null;
+  username?: string | null;
+}
+
+export class PluginTurnNotAdmittedError extends Error {
+  readonly reason: string;
+
+  constructor(reason: string) {
+    super(`This inbound plugin turn was not admitted (${reason}).`);
+    this.name = "PluginTurnNotAdmittedError";
+    this.reason = reason;
+  }
+}
+
+export async function resolvePluginChannelTurnTrust(
+  channel: PluginChannelTurnAddress,
+): Promise<TrustContext> {
+  const actorExternalId = channel.externalUserId?.trim() || undefined;
+  const read = await readInboundTrust({
+    channelType: channel.sourceChannel,
+    actorExternalId,
+  });
+  if (!read.ok) {
+    throw new PluginTurnNotAdmittedError("trust_resolution_failed");
+  }
+
+  if (read.verdict.resolutionFailed) {
+    throw new PluginTurnNotAdmittedError("trust_resolution_failed");
+  }
+
+  const memberStatus = read.verdict.status;
+  if (memberStatus === "blocked" || memberStatus === "revoked") {
+    throw new PluginTurnNotAdmittedError(`member_${memberStatus}`);
+  }
+
+  const trustClass = read.verdict.trustClass;
+  if (
+    read.admissionPolicy != null &&
+    !meetsAdmissionFloor(read.admissionPolicy, trustClass)
+  ) {
+    throw new PluginTurnNotAdmittedError(
+      `admission_policy_${read.admissionPolicy}`,
+    );
+  }
+
+  return trustContextFromVerdict(read.verdict, {
+    sourceChannel: channel.sourceChannel,
+    conversationExternalId: channel.externalChatId,
+    actorDisplayName: channel.displayName ?? undefined,
+    actorUsername: channel.username ?? undefined,
+  });
+}

package/src/plugin-api/plugin-name-env.ts

@@ -0,0 +1,125 @@
+/**
+ * How a child process learns which plugin it is running as.
+ *
+ * In-process plugin hooks, tools, and routes use AsyncLocalStorage
+ * ({@link getCurrentPluginName}). A bash or skill-sandbox child does not
+ * inherit that store. Those children recover the install-directory basename
+ * from `VELLUM_PLUGIN_NAME` (injected after env sanitization) or from the
+ * entry script path under `plugins/<service>/skills/<skill>/{scripts,tools}/`.
+ */
+
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { getCurrentPluginName } from "../plugins/plugin-execution-context.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+
+export const PLUGIN_NAME_ENV = "VELLUM_PLUGIN_NAME";
+
+const SKILL_SCRIPT_ROOTS = new Set(["scripts", "tools"]);
+
+/**
+ * Read a plugin install-directory name from the process environment.
+ * Empty or whitespace-only values are ignored.
+ */
+export function readPluginNameFromEnv(
+  env: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  const raw = env[PLUGIN_NAME_ENV];
+  if (typeof raw !== "string") {
+    return undefined;
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+/**
+ * If `filePath` is a skill script or tool under an installed plugin, return
+ * that plugin's install-directory basename (the runtime service name).
+ *
+ * Expected layout:
+ * `plugins/<service>/skills/<skill-id>/scripts|tools/<file>`.
+ */
+export function derivePluginNameFromSkillScriptPath(
+  filePath: string,
+  pluginsDir: string = getWorkspacePluginsDir(),
+): string | undefined {
+  if (filePath.length === 0) {
+    return undefined;
+  }
+  let resolved = filePath;
+  if (filePath.startsWith("file:")) {
+    try {
+      resolved = fileURLToPath(filePath);
+    } catch {
+      return undefined;
+    }
+  }
+  if (!isAbsolute(resolved)) {
+    resolved = resolve(process.cwd(), resolved);
+  }
+  const pluginsRoot = resolve(pluginsDir);
+  const rel = relative(pluginsRoot, resolved);
+  if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel)) {
+    return undefined;
+  }
+  const parts = rel.split(sep).filter((part) => part.length > 0);
+  if (parts.length < 5) {
+    return undefined;
+  }
+  const [service, skillsSeg, skillId, root] = parts;
+  if (
+    service === undefined ||
+    skillsSeg !== "skills" ||
+    skillId === undefined ||
+    root === undefined ||
+    !SKILL_SCRIPT_ROOTS.has(root)
+  ) {
+    return undefined;
+  }
+  return service;
+}
+
+/**
+ * Scan argv for a plugin-resident skill script path, resolving relative
+ * entries against `cwd`.
+ */
+export function derivePluginNameFromProcess(
+  argv: readonly string[] = process.argv,
+  cwd: string = process.cwd(),
+  pluginsDir: string = getWorkspacePluginsDir(),
+): string | undefined {
+  for (const candidate of argv.slice(1)) {
+    if (typeof candidate !== "string" || candidate.length === 0) {
+      continue;
+    }
+    if (candidate.startsWith("-")) {
+      continue;
+    }
+    const absolute = isAbsolute(candidate)
+      ? candidate
+      : resolve(cwd, candidate);
+    const name = derivePluginNameFromSkillScriptPath(absolute, pluginsDir);
+    if (name !== undefined) {
+      return name;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Plugin identity for credential scoping: in-process AsyncLocalStorage,
+ * then the injected env var, then the process entry script path.
+ */
+export function resolveCallingPluginName(
+  env: NodeJS.ProcessEnv = process.env,
+  argv: readonly string[] = process.argv,
+  cwd: string = process.cwd(),
+  pluginsDir: string = getWorkspacePluginsDir(),
+): string | undefined {
+  return (
+    getCurrentPluginName() ??
+    readPluginNameFromEnv(env) ??
+    derivePluginNameFromProcess(argv, cwd, pluginsDir)
+  );
+}

package/src/plugin-api/resolve-credential.ts

@@ -1,28 +1,42 @@
 /**
  * Plugin-facing credential resolution.
  *
- * {@link resolveCredential} returns a stored credential's plaintext value — the
- * same value `assistant credentials reveal` prints — resolving a reference that
- * is either a credential UUID or a `"service/field"` string, exactly as the
- * reveal path does (see {@link ../tools/credentials/resolve.resolveCredentialRef}
- * and the `credentials/reveal` route).
+ * {@link resolveCredential} returns a stored credential's plaintext value
+ * (the same value `assistant credentials reveal` prints), resolving a
+ * reference that is either a credential UUID or a `"service/field"` string,
+ * exactly as the reveal path does (see
+ * {@link ../tools/credentials/resolve.resolveCredentialRef} and the
+ * `credentials/reveal` route).
  *
  * ## Plugin scoping
  *
- * When a plugin is in context (its hook, tool, or one of its own
- * `/x/plugins/<name>/` routes is executing, tracked by
- * {@link ../plugins/plugin-execution-context.getCurrentPluginName}), resolution
- * is restricted: the plugin may only resolve credentials whose `service`
- * equals its manifest name (`imessage/api_key` for plugin `imessage`). It
- * cannot read another service (`openai/api_key`, `openai/imessage`). Outside
- * any plugin context (host-internal callers, CLI, tests) the resolver is
- * unscoped and behaves like a direct reveal.
+ * When a plugin is in context, resolution is restricted to credentials
+ * whose `service` equals the plugin's runtime install-directory name
+ * (`sms/account_sid` for plugin `sms`). Context is:
+ *
+ * 1. In-process AsyncLocalStorage from `runInPluginContext` (hooks, plugin
+ *    tools, plugin routes).
+ * 2. `VELLUM_PLUGIN_NAME` on a bash or skill-sandbox child.
+ * 3. The process entry path, when it sits under
+ *    `plugins/<service>/skills/<skill>/{scripts,tools}/`.
+ *
+ * Outside any plugin context the resolver is unscoped and behaves like a
+ * direct reveal. A standalone child has an empty in-process metadata
+ * cache; when plugin context is set, a cache miss consults the live
+ * credential catalog so an empty cache is not reported as "not found".
  */
 
-import { getCurrentPluginName } from "../plugins/plugin-execution-context.js";
+import { credentialKey } from "@vellumai/credential-storage";
+
 import { getSecureKeyResultAsync } from "../security/secure-keys.js";
+import {
+  type CredentialMetadata,
+  listCredentialRecordsLive,
+} from "../tools/credentials/metadata-store.js";
+import { parseServiceFieldRef } from "../tools/credentials/ref-parse.js";
 import { resolveCredentialRef } from "../tools/credentials/resolve.js";
 import { credentialInPluginScope } from "./credential-scope.js";
+import { resolveCallingPluginName } from "./plugin-name-env.js";
 
 /**
  * Raised when a credential cannot be resolved: the reference does not match a
@@ -36,6 +50,50 @@ export class CredentialResolutionError extends Error {
   }
 }
 
+interface ResolvedRef {
+  service: string;
+  field: string;
+  storageKey: string;
+}
+
+function findLiveRecord(
+  records: CredentialMetadata[],
+  ref: string,
+): CredentialMetadata | undefined {
+  const byId = records.find((record) => record.credentialId === ref);
+  if (byId) {
+    return byId;
+  }
+  const parsed = parseServiceFieldRef(ref);
+  if (!parsed) {
+    return undefined;
+  }
+  return records.find(
+    (record) =>
+      record.service === parsed.service && record.field === parsed.field,
+  );
+}
+
+async function resolveCredentialRefLive(
+  ref: string,
+): Promise<ResolvedRef | undefined> {
+  const live = await listCredentialRecordsLive();
+  if (live.unreachable) {
+    throw new CredentialResolutionError(
+      "Credential store is unreachable.",
+    );
+  }
+  const record = findLiveRecord(live.records, ref);
+  if (!record) {
+    return undefined;
+  }
+  return {
+    service: record.service,
+    field: record.field,
+    storageKey: credentialKey(record.service, record.field),
+  };
+}
+
 /**
  * Resolve a credential reference to its plaintext value.
  *
@@ -45,15 +103,16 @@ export class CredentialResolutionError extends Error {
  *   store is unreachable, or a plugin in context is not scoped to the credential.
  */
 export async function resolveCredential(ref: string): Promise<string> {
-  const resolved = resolveCredentialRef(ref);
+  const pluginName = resolveCallingPluginName();
+
+  let resolved: ResolvedRef | undefined = resolveCredentialRef(ref);
+  if (!resolved && pluginName !== undefined) {
+    resolved = await resolveCredentialRefLive(ref);
+  }
   if (!resolved) {
     throw new CredentialResolutionError(`Credential not found: ${ref}`);
   }
 
-  // Scope the resolution to the plugin in context, if any. The ownership gate
-  // is enforced before the plaintext is read so an out-of-scope plugin never
-  // touches the secure backend.
-  const pluginName = getCurrentPluginName();
   if (
     pluginName !== undefined &&
     !credentialInPluginScope(pluginName, resolved.service)
@@ -70,7 +129,7 @@ export async function resolveCredential(ref: string): Promise<string> {
   if (value == null || value.length === 0) {
     if (unreachable) {
       throw new CredentialResolutionError(
-        "Credential store is unreachable — ensure the assistant is running",
+        "Credential store is unreachable.",
       );
     }
     throw new CredentialResolutionError(`Credential not found: ${ref}`);

package/src/plugin-api/vision-support.test.ts

@@ -397,3 +397,25 @@ describe("doesSupportVision with a bare string", () => {
     expect(doesSupportVision("qwen2.5-vl")).toBe(true);
   });
 });
+
+describe("doesSupportVision with a resolved target", () => {
+  test("profile policy can enable images for a catalog text model", () => {
+    expect(
+      doesSupportVision({
+        provider: "fireworks",
+        model: "accounts/fireworks/models/glm-5p2",
+        inputModalities: { image: { enabled: true, supported: true } },
+      }),
+    ).toBe(true);
+  });
+
+  test("profile policy can disable images for a catalog vision model", () => {
+    expect(
+      doesSupportVision({
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+        inputModalities: { image: { enabled: false } },
+      }),
+    ).toBe(false);
+  });
+});

package/src/plugin-api/vision-support.ts

@@ -37,15 +37,24 @@ import {
 } from "../providers/model-catalog.js";
 import type { ModelProfileInfo } from "./types.js";
 
+/** A fully resolved provider target plus the winning profile's policy. */
+export interface ResolvedVisionTarget {
+  readonly provider?: string;
+  readonly model: string;
+  readonly inputModalities?: InputModalities | null;
+}
+
 /**
  * Whether the given model or profile can process image input.
  *
- * `modelOrProfile` may be a concrete model id, a profile key, or a
- * {@link ModelProfileInfo}. A bare string is resolved as a model id first and,
- * failing that, as a profile key. Returns `false` when nothing resolves.
+ * `modelOrProfile` may be a concrete model id, a profile key, a
+ * {@link ModelProfileInfo}, or a fully resolved target. A resolved target
+ * combines the final provider/model with the winning profile's modality
+ * policy. A bare string is resolved as a model id first and, failing that, as
+ * a profile key. Returns `false` when nothing resolves.
  */
 export function doesSupportVision(
-  modelOrProfile: ModelProfileInfo | string,
+  modelOrProfile: ModelProfileInfo | ResolvedVisionTarget | string,
 ): boolean {
   if (typeof modelOrProfile === "string") {
     // Concrete catalog model id first, then a profile key, then any profile
@@ -58,7 +67,10 @@ export function doesSupportVision(
       false
     );
   }
-  return profileVision(modelOrProfile.key) ?? false;
+  if ("key" in modelOrProfile) {
+    return profileVision(modelOrProfile.key) ?? false;
+  }
+  return resolveEntryVision(modelOrProfile) ?? false;
 }
 
 /**