@vellumai/assistant 0.4.41 → 0.4.43

package/src/tools/memory/handlers.ts

@@ -1,13 +1,18 @@
-import { and, eq } from "drizzle-orm";
+import { and, eq, ne } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import type { AssistantConfig } from "../../config/types.js";
 import { getDb } from "../../memory/db.js";
+import {
+  getMemoryBackendStatus,
+  logMemoryEmbeddingWarning,
+} from "../../memory/embedding-backend.js";
 import { computeMemoryFingerprint } from "../../memory/fingerprint.js";
+import { formatRecallText } from "../../memory/format-recall.js";
 import { enqueueMemoryJob } from "../../memory/jobs-store.js";
 import {
-  formatRelativeTime,
-  searchMemoryItems,
+  collectAndMergeCandidates,
+  embedWithRetry,
 } from "../../memory/retriever.js";
 import { memoryItems } from "../../memory/schema.js";
 import type { ScopePolicyOverride } from "../../memory/search/types.js";
@@ -17,66 +22,6 @@ import type { ToolExecutionResult } from "../types.js";
 
 const log = getLogger("memory-tools");
 
-// ── memory_search ────────────────────────────────────────────────────
-
-export async function handleMemorySearch(
-  args: Record<string, unknown>,
-  config: AssistantConfig,
-  scopeId?: string,
-): Promise<ToolExecutionResult> {
-  const query = args.query;
-  if (typeof query !== "string" || query.trim().length === 0) {
-    return {
-      content: "Error: query is required and must be a non-empty string",
-      isError: true,
-    };
-  }
-
-  const limit =
-    typeof args.limit === "number" && args.limit > 0
-      ? Math.min(args.limit, 20)
-      : 5;
-
-  // Private threads should always fall back to default scope for search
-  const scopePolicyOverride: ScopePolicyOverride | undefined =
-    scopeId && scopeId.startsWith("private:")
-      ? { scopeId, fallbackToDefault: true }
-      : undefined;
-
-  try {
-    const results = await searchMemoryItems(
-      query,
-      limit,
-      config,
-      scopeId,
-      scopePolicyOverride,
-    );
-
-    if (results.length === 0) {
-      return { content: "No matching memories found.", isError: false };
-    }
-
-    const lines: string[] = [`Found ${results.length} memory item(s):\n`];
-    for (const result of results) {
-      const timeAgo = formatRelativeTime(result.createdAt);
-      lines.push(`- **[${result.kind}]** ${result.text}`);
-      lines.push(
-        `  _ID: ${result.id} | source: ${
-          result.type
-        } | ${timeAgo} | confidence: ${result.confidence.toFixed(
-          2,
-        )} | importance: ${result.importance.toFixed(2)}_`,
-      );
-    }
-
-    return { content: lines.join("\n"), isError: false };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    log.error({ err, query }, "memory_search failed");
-    return { content: `Error: Memory search failed: ${msg}`, isError: true };
-  }
-}
-
 // ── memory_save ──────────────────────────────────────────────────────
 
 export async function handleMemorySave(
@@ -263,12 +208,13 @@ export async function handleMemoryUpdate(
         and(
           eq(memoryItems.fingerprint, fingerprint),
           eq(memoryItems.scopeId, scopeId),
+          ne(memoryItems.status, "deleted"),
         ),
       )
       .get();
     if (collision && collision.id !== existing.id) {
       return {
-        content: `Error: Another memory item (ID: ${collision.id}) already contains this statement. Use memory_search to find it.`,
+        content: `Error: Another memory item (ID: ${collision.id}) already contains this statement. Use memory_recall to find it.`,
         isError: true,
       };
     }
@@ -301,6 +247,217 @@ export async function handleMemoryUpdate(
   }
 }
 
+// ── memory_recall ────────────────────────────────────────────────────
+
+export interface MemoryRecallToolResult {
+  text: string;
+  resultCount: number;
+  degraded: boolean;
+  items: Array<{ id: string; type: string; kind: string }>;
+  sources: {
+    lexical: number;
+    semantic: number;
+    recency: number;
+    entity: number;
+  };
+}
+
+export async function handleMemoryRecall(
+  args: Record<string, unknown>,
+  config: AssistantConfig,
+  scopeId?: string,
+  conversationId?: string,
+): Promise<ToolExecutionResult> {
+  const query = args.query;
+  if (typeof query !== "string" || query.trim().length === 0) {
+    return {
+      content: "Error: query is required and must be a non-empty string",
+      isError: true,
+    };
+  }
+
+  const maxResults =
+    typeof args.max_results === "number" && args.max_results > 0
+      ? Math.min(args.max_results, 50)
+      : 10;
+
+  const scope =
+    typeof args.scope === "string" && args.scope.trim().length > 0
+      ? args.scope.trim()
+      : "default";
+
+  // Scope policy: "conversation" means strict (only that scope),
+  // anything else allows fallback to the default scope.
+  const scopePolicyOverride: ScopePolicyOverride | undefined = scopeId
+    ? {
+        scopeId,
+        fallbackToDefault: scope !== "conversation",
+      }
+    : undefined;
+
+  try {
+    const trimmedQuery = query.trim();
+
+    // Generate embedding vector (graceful degradation if unavailable)
+    let queryVector: number[] | null = null;
+    let provider: string | undefined;
+    let model: string | undefined;
+    let degraded = false;
+
+    const backendStatus = getMemoryBackendStatus(config);
+    if (backendStatus.provider) {
+      try {
+        const embedded = await embedWithRetry(config, [trimmedQuery]);
+        queryVector = embedded.vectors[0] ?? null;
+        provider = embedded.provider;
+        model = embedded.model;
+      } catch (err) {
+        logMemoryEmbeddingWarning(err, "query");
+        degraded = !!config.memory.embeddings.required;
+      }
+    } else {
+      degraded = backendStatus.degraded;
+    }
+
+    // Run the full retrieval pipeline with all sources enabled
+    const collected = await collectAndMergeCandidates(trimmedQuery, config, {
+      queryVector,
+      provider,
+      model,
+      conversationId,
+      scopeId,
+      scopePolicyOverride,
+    });
+
+    if (collected.semanticSearchFailed || collected.semanticUnavailable) {
+      degraded = true;
+    }
+
+    const candidates = collected.merged.slice(0, maxResults);
+
+    if (candidates.length === 0) {
+      const result: MemoryRecallToolResult = {
+        text: "No matching memories found.",
+        resultCount: 0,
+        degraded,
+        items: [],
+        sources: {
+          lexical: 0,
+          semantic: 0,
+          recency: 0,
+          entity: 0,
+        },
+      };
+      return {
+        content: JSON.stringify(result),
+        isError: false,
+      };
+    }
+
+    // Format candidates into readable text using the shared formatter
+    const formatted = formatRecallText(candidates, {
+      format: config.memory.retrieval.injectionFormat,
+      maxTokens: config.memory.retrieval.maxInjectTokens,
+    });
+
+    const items = formatted.selected.map((c) => ({
+      id: c.id,
+      type: c.type,
+      kind: c.kind,
+    }));
+
+    const result: MemoryRecallToolResult = {
+      text: formatted.text,
+      resultCount: formatted.selected.length,
+      degraded,
+      items,
+      sources: {
+        lexical: collected.lexical.length,
+        semantic: collected.semantic.length,
+        recency: collected.recency.length,
+        entity: collected.entity.length,
+      },
+    };
+
+    return {
+      content: JSON.stringify(result),
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.error({ err, query }, "memory_recall failed");
+    return {
+      content: `Error: Memory recall failed: ${msg}`,
+      isError: true,
+    };
+  }
+}
+
+// ── memory_delete ────────────────────────────────────────────────────
+
+export async function handleMemoryDelete(
+  args: Record<string, unknown>,
+  _config: AssistantConfig,
+  scopeId: string = "default",
+): Promise<ToolExecutionResult> {
+  const rawMemoryId = args.memory_id;
+  if (typeof rawMemoryId !== "string" || rawMemoryId.trim().length === 0) {
+    return {
+      content: "Error: memory_id is required and must be a non-empty string",
+      isError: true,
+    };
+  }
+
+  const memoryId = stripTypedIdPrefix(rawMemoryId.trim());
+
+  try {
+    const db = getDb();
+
+    const existing = db
+      .select()
+      .from(memoryItems)
+      .where(
+        and(eq(memoryItems.id, memoryId), eq(memoryItems.scopeId, scopeId)),
+      )
+      .get();
+
+    if (!existing) {
+      return {
+        content: `Error: Memory item with ID "${memoryId}" not found`,
+        isError: true,
+      };
+    }
+
+    if (existing.status === "deleted") {
+      return {
+        content: `Memory item (ID: ${memoryId}) was already deleted.`,
+        isError: false,
+      };
+    }
+
+    db.update(memoryItems)
+      .set({
+        status: "deleted",
+        lastSeenAt: Date.now(),
+      })
+      .where(eq(memoryItems.id, existing.id))
+      .run();
+
+    log.debug(
+      { id: existing.id, kind: existing.kind },
+      "Memory item deleted via tool",
+    );
+    return {
+      content: `Deleted memory (ID: ${existing.id}).\nKind: ${existing.kind}\nSubject: ${existing.subject}\nStatement: ${existing.statement}`,
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.error({ err, memoryId }, "memory_delete failed");
+    return { content: `Error: Failed to delete memory: ${msg}`, isError: true };
+  }
+}
+
 // ── Helpers ──────────────────────────────────────────────────────────
 
 function inferSubjectFromStatement(statement: string): string {
@@ -311,7 +468,7 @@ function inferSubjectFromStatement(statement: string): string {
 
 /**
  * Strip a typed ID prefix (e.g. "item:abc-123" -> "abc-123") so that IDs
- * copied from memory_search output work in memory_update.
+ * copied from memory_recall output work in memory_update.
  */
 function stripTypedIdPrefix(id: string): string {
   const match = id.match(/^(?:item|segment|summary):(.+)$/);

package/src/tools/memory/register.ts

@@ -3,37 +3,18 @@ import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 import {
+  memoryDeleteDefinition,
+  memoryRecallDefinition,
   memorySaveDefinition,
-  memorySearchDefinition,
   memoryUpdateDefinition,
 } from "./definitions.js";
 import {
+  handleMemoryDelete,
+  handleMemoryRecall,
   handleMemorySave,
-  handleMemorySearch,
   handleMemoryUpdate,
 } from "./handlers.js";
 
-// ── memory_search ────────────────────────────────────────────────────
-
-class MemorySearchTool implements Tool {
-  name = "memory_search";
-  description = memorySearchDefinition.description;
-  category = "memory";
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return memorySearchDefinition;
-  }
-
-  async execute(
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolExecutionResult> {
-    const config = getConfig();
-    return handleMemorySearch(input, config, context.memoryScopeId);
-  }
-}
-
 // ── memory_save ──────────────────────────────────────────────────────
 
 class MemorySaveTool implements Tool {
@@ -82,8 +63,56 @@ class MemoryUpdateTool implements Tool {
   }
 }
 
+// ── memory_delete ────────────────────────────────────────────────────
+
+class MemoryDeleteTool implements Tool {
+  name = "memory_delete";
+  description = memoryDeleteDefinition.description;
+  category = "memory";
+  defaultRiskLevel = RiskLevel.Low;
+
+  getDefinition(): ToolDefinition {
+    return memoryDeleteDefinition;
+  }
+
+  async execute(
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolExecutionResult> {
+    const config = getConfig();
+    return handleMemoryDelete(input, config, context.memoryScopeId);
+  }
+}
+
+// ── memory_recall ────────────────────────────────────────────────────
+
+class MemoryRecallTool implements Tool {
+  name = "memory_recall";
+  description = memoryRecallDefinition.description;
+  category = "memory";
+  defaultRiskLevel = RiskLevel.Low;
+
+  getDefinition(): ToolDefinition {
+    return memoryRecallDefinition;
+  }
+
+  async execute(
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolExecutionResult> {
+    const config = getConfig();
+    return handleMemoryRecall(
+      input,
+      config,
+      context.memoryScopeId,
+      context.conversationId,
+    );
+  }
+}
+
 // ── Exported tool instances ──────────────────────────────────────────
 
-export const memorySearchTool = new MemorySearchTool();
 export const memorySaveTool = new MemorySaveTool();
 export const memoryUpdateTool = new MemoryUpdateTool();
+export const memoryDeleteTool = new MemoryDeleteTool();
+export const memoryRecallTool = new MemoryRecallTool();

package/src/tools/network/script-proxy/session-manager.ts

@@ -2,7 +2,6 @@ import { randomUUID } from "node:crypto";
 import type { Server } from "node:http";
 import { join } from "node:path";
 
-import { getProviderProfile } from "../../../oauth/provider-profiles.js";
 import {
   buildDecisionTrace,
   createProxyServer,
@@ -124,22 +123,12 @@ function buildInjectedValue(
 
 /**
  * Resolve injection templates for a credential.
- *
- * Preferred source is credential metadata. For legacy OAuth credentials that
- * predate provider-level template registration, fall back to well-known
- * profile templates when this is an access_token credential.
  */
 function resolveInjectionTemplates(
   resolved: ResolvedCredential | undefined,
 ): CredentialInjectionTemplate[] {
   if (!resolved) return [];
-  if (resolved.injectionTemplates.length > 0)
-    return resolved.injectionTemplates;
-  if (resolved.field !== "access_token") return [];
-
-  const profile = getProviderProfile(resolved.service);
-  if (!profile?.injectionTemplates?.length) return [];
-  return profile.injectionTemplates;
+  return resolved.injectionTemplates;
 }
 
 /** Return a defensive copy so callers cannot mutate internal state. */

package/src/tools/schedule/update.ts

@@ -20,14 +20,6 @@ export async function executeScheduleUpdate(
     return { content: "Error: job_id is required", isError: true };
   }
 
-  if (input.cron_expression !== undefined) {
-    return {
-      content:
-        'Error: "cron_expression" is deprecated. Use "expression" instead.',
-      isError: true,
-    };
-  }
-
   const updates: Record<string, unknown> = {};
   if (input.name !== undefined) updates.name = input.name;
   if (input.timezone !== undefined) updates.timezone = input.timezone;

package/src/tools/skills/load.ts

@@ -126,14 +126,14 @@ export class SkillLoadTool implements Tool {
           continue;
 
         childLines.push(
-          `  - ${child.id}: ${child.name} — ${child.description} (${child.skillFilePath})`,
+          `  - ${child.id}: ${child.displayName} — ${child.description} (${child.skillFilePath})`,
         );
 
         // Load the included skill's body content
         const childLoaded = loadSkillBySelector(childId);
         if (childLoaded.skill && childLoaded.skill.body.length > 0) {
           includedBodies.push(
-            `--- Included Skill: ${childLoaded.skill.name} (${childId}) ---\n${childLoaded.skill.body}`,
+            `--- Included Skill: ${childLoaded.skill.displayName} (${childId}) ---\n${childLoaded.skill.body}`,
           );
         }
       }
@@ -182,7 +182,7 @@ export class SkillLoadTool implements Tool {
 
     return {
       content: [
-        `Skill: ${skill.name}`,
+        `Skill: ${skill.displayName}`,
         `ID: ${skill.id}`,
         `Description: ${skill.description}`,
         `Path: ${skill.skillFilePath}`,

package/src/tools/subagent/read.ts

@@ -1,4 +1,4 @@
-import { getMessages } from "../../memory/conversation-store.js";
+import { getMessages } from "../../memory/conversation-crud.js";
 import { getSubagentManager, TERMINAL_STATUSES } from "../../subagent/index.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 

package/src/tools/system/voice-config.ts

@@ -153,12 +153,6 @@ export class VoiceConfigUpdateTool implements Tool {
             description:
               "The new value for the setting (type depends on setting)",
           },
-          // Backward compat: legacy schema used activation_key directly
-          activation_key: {
-            type: "string",
-            description:
-              'Deprecated — use setting: "activation_key" with value instead',
-          },
           reason: {
             type: "string",
             description:
@@ -173,14 +167,8 @@ export class VoiceConfigUpdateTool implements Tool {
     input: Record<string, unknown>,
     context: ToolContext,
   ): Promise<ToolExecutionResult> {
-    // Backward compat: if activation_key is provided without setting/value, treat as setting: "activation_key"
-    let setting = input.setting as string | undefined;
-    let value = input.value;
-
-    if (!setting && typeof input.activation_key === "string") {
-      setting = "activation_key";
-      value = input.activation_key;
-    }
+    const setting = input.setting as string | undefined;
+    const value = input.value;
 
     if (!setting) {
       return {

package/src/tools/terminal/safe-env.ts

@@ -5,14 +5,8 @@
  *
  * Shared by the sandbox bash tool and skill sandbox runner.
  */
-import {
-  getGatewayInternalBaseUrl,
-  getIngressPublicBaseUrl,
-} from "../../config/env.js";
-import {
-  isSigningKeyInitialized,
-  mintEdgeRelayToken,
-} from "../../runtime/auth/token-service.js";
+import { getGatewayInternalBaseUrl } from "../../config/env.js";
+import { getDataDir } from "../../util/platform.js";
 
 const SAFE_ENV_VARS = [
   "PATH",
@@ -45,15 +39,8 @@ export function buildSanitizedEnv(): Record<string, string> {
   // Always inject an internal gateway base for local control-plane/API calls.
   const internalGatewayBase = getGatewayInternalBaseUrl();
   env.INTERNAL_GATEWAY_BASE_URL = internalGatewayBase;
-  // Inject a public gateway base when ingress is configured; otherwise fall
-  // back to the internal base so commands remain functional in local-only mode.
-  const publicGatewayBase = getIngressPublicBaseUrl()?.replace(/\/+$/, "");
-  env.GATEWAY_BASE_URL = publicGatewayBase || internalGatewayBase;
-  // Mint a short-lived JWT for gateway authentication when the signing key
-  // is available (daemon context). CLI-only contexts without daemon startup
-  // will not have the key initialized — gracefully skip.
-  if (isSigningKeyInitialized()) {
-    env.GATEWAY_AUTH_TOKEN = mintEdgeRelayToken();
-  }
+  // Expose the runtime data directory so child processes can locate databases,
+  // logs, and other instance-scoped state without re-deriving the path.
+  env.VELLUM_DATA_DIR = getDataDir();
   return env;
 }

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

@@ -1,5 +1,5 @@
 import { consumeGrantForInvocation } from "../approvals/approval-primitive.js";
-import { isToolAllowedInChannel } from "../config/channel-permission-profiles.js";
+import { isToolAllowedInChannel } from "../channels/permission-profiles.js";
 import {
   getCanonicalGuardianRequest,
   updateCanonicalGuardianRequest,
@@ -9,7 +9,6 @@ import { createOrReuseToolGrantRequest } from "../runtime/tool-grant-request-hel
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { getTaskRunRules } from "../tasks/ephemeral-permissions.js";
 import { getLogger } from "../util/logger.js";
-import { enforceGuardianOnlyPolicy } from "./guardian-control-plane-policy.js";
 import { getAllTools, getTool } from "./registry.js";
 import { isSideEffectTool } from "./side-effects.js";
 import type {
@@ -19,6 +18,7 @@ import type {
   ToolExecutionResult,
   ToolLifecycleEvent,
 } from "./types.js";
+import { enforceVerificationControlPlanePolicy } from "./verification-control-plane-policy.js";
 
 const log = getLogger("tool-approval-handler");
 
@@ -215,7 +215,7 @@ export class ToolApprovalHandler {
     }
 
     // Reject tool invocations targeting guardian control-plane endpoints from non-guardian actors.
-    const guardianCheck = enforceGuardianOnlyPolicy(
+    const guardianCheck = enforceVerificationControlPlanePolicy(
       name,
       input,
       context.trustClass,
@@ -417,7 +417,7 @@ export class ToolApprovalHandler {
     // minting (2-5s). Non-voice channels get an instant sync lookup so
     // normal denials are not delayed.
     if (needsGrantConsumption && deferredConsumeParams) {
-      const isVoice = context.executionChannel === "voice";
+      const isVoice = context.executionChannel === "phone";
       const grantResult = await consumeGrantForInvocation(
         deferredConsumeParams,
         isVoice ? { signal: context.signal } : { maxWaitMs: 0 },

package/src/tools/tool-manifest.ts

@@ -9,8 +9,9 @@
 import { accountManageTool } from "./credentials/account-registry.js";
 import { credentialStoreTool } from "./credentials/vault.js";
 import {
+  memoryDeleteTool,
+  memoryRecallTool,
   memorySaveTool,
-  memorySearchTool,
   memoryUpdateTool,
 } from "./memory/register.js";
 import type { LazyToolDescriptor } from "./registry.js";
@@ -79,9 +80,10 @@ export const eagerModuleToolNames: string[] = [
 // relying on import side effects.
 
 export const explicitTools: Tool[] = [
-  memorySearchTool,
   memorySaveTool,
   memoryUpdateTool,
+  memoryDeleteTool,
+  memoryRecallTool,
   credentialStoreTool,
   accountManageTool,
   screenWatchTool,

package/src/tools/types.ts

@@ -155,7 +155,7 @@ export interface ToolContext {
    * See {@link TrustClass} in actor-trust-resolver.ts for value semantics.
    */
   trustClass: TrustClass;
-  /** Channel through which the tool invocation originates (e.g. 'telegram', 'voice'). Used for scoped grant consumption. */
+  /** Channel through which the tool invocation originates (e.g. 'telegram', 'phone'). Used for scoped grant consumption. */
   executionChannel?: string;
   /** Voice/call session ID, if the invocation originates from a call. Used for scoped grant consumption. */
   callSessionId?: string;