@vellumai/assistant 0.4.49 → 0.4.50

package/src/config/bundled-skills/knowledge-graph/tools/graph-query.ts

@@ -1,211 +0,0 @@
-import { inArray } from "drizzle-orm";
-
-import { getDb, initializeDb } from "../../../../memory/db.js";
-import type {
-  EntityRelationType,
-  EntityType,
-} from "../../../../memory/entity-extractor.js";
-import { memoryEntities } from "../../../../memory/schema.js";
-import {
-  collectTypedNeighbors,
-  findMatchedEntities,
-  findNeighborEntities,
-  getEntityLinkedItemCandidates,
-} from "../../../../memory/search/entity.js";
-import type { TraversalStep } from "../../../../memory/search/types.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-
-interface GraphQueryInput {
-  query_type: "neighbors" | "typed_traversal" | "intersection";
-  seeds: string[];
-  steps?: Array<{
-    relation_types?: string[];
-    entity_types?: string[];
-  }>;
-  max_results?: number;
-  include_items?: boolean;
-}
-
-interface EntityResult {
-  id: string;
-  name: string;
-  type: string;
-  aliases: string[];
-  items?: Array<{ subject: string; statement: string }>;
-}
-
-export async function run(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const params = input as unknown as GraphQueryInput;
-
-  initializeDb();
-
-  const maxResults = params.max_results ?? 20;
-  const includeItems = params.include_items ?? true;
-
-  // Resolve seed entity names to IDs
-  const seedEntityIds: string[] = [];
-  const resolvedSeeds: Array<{ name: string; id: string }> = [];
-  for (const seedName of params.seeds) {
-    const matched = findMatchedEntities(seedName, 5);
-    if (matched.length > 0) {
-      seedEntityIds.push(matched[0].id);
-      resolvedSeeds.push({ name: seedName, id: matched[0].id });
-    }
-  }
-
-  if (seedEntityIds.length === 0) {
-    return {
-      content: JSON.stringify({
-        error: "No matching entities found for the provided seed names",
-        seeds: params.seeds,
-      }),
-      isError: true,
-    };
-  }
-
-  // For intersection queries, all seeds must resolve — dropping any seed silently
-  // changes semantics from "reachable from ALL seeds" to "reachable from resolved seeds"
-  if (
-    params.query_type === "intersection" &&
-    seedEntityIds.length < params.seeds.length
-  ) {
-    const unresolvedSeeds = params.seeds.filter(
-      (name) => !resolvedSeeds.some((s) => s.name === name),
-    );
-    return {
-      content: JSON.stringify({
-        error:
-          "Some seed entities could not be resolved. Intersection requires all seeds to match.",
-        unresolved_seeds: unresolvedSeeds,
-        resolved_seeds: resolvedSeeds,
-      }),
-      isError: true,
-    };
-  }
-
-  let resultEntityIds: string[];
-
-  switch (params.query_type) {
-    case "neighbors": {
-      const steps = params.steps?.[0];
-      const result = findNeighborEntities(seedEntityIds, {
-        maxEdges: 40,
-        maxNeighborEntities: maxResults,
-        maxDepth: 1,
-        relationTypes: steps?.relation_types as
-          | EntityRelationType[]
-          | undefined,
-        entityTypes: steps?.entity_types as EntityType[] | undefined,
-      });
-      resultEntityIds = result.neighborEntityIds;
-      break;
-    }
-
-    case "typed_traversal": {
-      const traversalSteps: TraversalStep[] = (params.steps ?? []).map((s) => ({
-        relationTypes: s.relation_types as EntityRelationType[] | undefined,
-        entityTypes: s.entity_types as EntityType[] | undefined,
-      }));
-      resultEntityIds = collectTypedNeighbors(seedEntityIds, traversalSteps, {
-        maxResultsPerStep: maxResults,
-        maxEdgesPerStep: 40,
-      });
-      break;
-    }
-
-    case "intersection": {
-      // Run typed traversal from each seed independently, then intersect
-      const traversalSteps: TraversalStep[] = (params.steps ?? []).map((s) => ({
-        relationTypes: s.relation_types as EntityRelationType[] | undefined,
-        entityTypes: s.entity_types as EntityType[] | undefined,
-      }));
-
-      const resultSets: Set<string>[] = [];
-      for (const seedId of seedEntityIds) {
-        const result = collectTypedNeighbors([seedId], traversalSteps, {
-          maxResultsPerStep: maxResults,
-          maxEdgesPerStep: 40,
-        });
-        resultSets.push(new Set(result));
-      }
-
-      if (resultSets.length === 0) {
-        resultEntityIds = [];
-      } else {
-        // Intersect all sets
-        const intersection = [...resultSets[0]].filter((id) =>
-          resultSets.every((set) => set.has(id)),
-        );
-        resultEntityIds = intersection;
-      }
-      break;
-    }
-
-    default:
-      return {
-        content: JSON.stringify({
-          error: `Unknown query_type: ${params.query_type}`,
-        }),
-        isError: true,
-      };
-  }
-
-  // Look up entity details
-  const db = getDb();
-  const entities: EntityResult[] = [];
-
-  if (resultEntityIds.length > 0) {
-    const entityRows = db
-      .select()
-      .from(memoryEntities)
-      .where(inArray(memoryEntities.id, resultEntityIds.slice(0, maxResults)))
-      .all();
-
-    for (const row of entityRows) {
-      const entity: EntityResult = {
-        id: row.id,
-        name: row.name,
-        type: row.type,
-        aliases: row.aliases ? (JSON.parse(row.aliases) as string[]) : [],
-      };
-
-      if (includeItems) {
-        const candidates = getEntityLinkedItemCandidates([row.id], {
-          source: "entity_direct",
-          scopeIds: _context.memoryScopeId
-            ? [_context.memoryScopeId]
-            : undefined,
-        });
-        entity.items = candidates.slice(0, 5).map((c) => {
-          const parts = c.text.split(": ");
-          return {
-            subject: parts[0] ?? "",
-            statement: parts.slice(1).join(": ") || c.text,
-          };
-        });
-      }
-
-      entities.push(entity);
-    }
-  }
-
-  return {
-    content: JSON.stringify(
-      {
-        query_type: params.query_type,
-        resolved_seeds: resolvedSeeds,
-        result_count: entities.length,
-        entities,
-      },
-      null,
-      2,
-    ),
-    isError: false,
-  };
-}

package/src/daemon/session-conflict-gate.ts

@@ -1,167 +0,0 @@
-/**
- * Conflict-gate logic extracted from Session.
- *
- * Handles pending memory conflicts internally: dismisses non-user-evidenced
- * and non-actionable conflicts, and attempts resolution when the user's reply
- * looks like an explicit clarification with topical relevance. Never produces
- * user-facing clarification text.
- */
-
-import { resolveConflictClarification } from "../memory/clarification-resolver.js";
-import {
-  areStatementsCoherent,
-  computeConflictRelevance,
-  looksLikeClarificationReply,
-  shouldAttemptConflictResolution,
-} from "../memory/conflict-intent.js";
-import {
-  isConflictKindPairEligible,
-  isConflictUserEvidenced,
-  isStatementConflictEligible,
-} from "../memory/conflict-policy.js";
-import type { PendingConflictDetail } from "../memory/conflict-store.js";
-import {
-  applyConflictResolution,
-  listPendingConflictDetails,
-  resolveConflict,
-} from "../memory/conflict-store.js";
-
-export class ConflictGate {
-  async evaluate(
-    userMessage: string,
-    conflictConfig: {
-      enabled: boolean;
-      gateMode: string;
-      relevanceThreshold: number;
-      resolverLlmTimeoutMs: number;
-      conflictableKinds: readonly string[];
-    },
-    scopeId = "default",
-  ): Promise<void> {
-    if (!conflictConfig.enabled || conflictConfig.gateMode !== "soft") return;
-
-    const pendingBeforeResolve = listPendingConflictDetails(scopeId, 50);
-
-    // Dismiss non-actionable conflicts (kind/statement policy, incoherent pair,
-    // or assistant-inferred-only provenance with no user evidence)
-    const dismissedIds = new Set<string>();
-    for (const conflict of pendingBeforeResolve) {
-      const dismissReason = this.getDismissReason(
-        conflict,
-        conflictConfig.conflictableKinds,
-      );
-      if (dismissReason) {
-        resolveConflict(conflict.id, {
-          status: "dismissed",
-          resolutionNote: dismissReason,
-        });
-        dismissedIds.add(conflict.id);
-      }
-    }
-
-    const actionablePending = pendingBeforeResolve.filter(
-      (c) => !dismissedIds.has(c.id),
-    );
-
-    // Attempt resolution only for explicit clarification-like replies with
-    // topical relevance to the conflict statements
-    const clarificationReply = looksLikeClarificationReply(userMessage);
-    const candidatesBeforeResolve = actionablePending.filter((conflict) => {
-      const relevance = computeConflictRelevance(userMessage, conflict);
-      return shouldAttemptConflictResolution({
-        clarificationReply,
-        relevance,
-      });
-    });
-    await this.resolvePendingConflicts(
-      userMessage,
-      conflictConfig.resolverLlmTimeoutMs,
-      candidatesBeforeResolve,
-    );
-  }
-
-  private async resolvePendingConflicts(
-    userMessage: string,
-    resolverTimeoutMs: number,
-    pendingConflicts: PendingConflictDetail[],
-  ): Promise<void> {
-    for (const conflict of pendingConflicts) {
-      const resolution = await resolveConflictClarification(
-        {
-          existingStatement: conflict.existingStatement,
-          candidateStatement: conflict.candidateStatement,
-          userMessage,
-        },
-        { timeoutMs: resolverTimeoutMs },
-      );
-      if (resolution.resolution === "still_unclear") continue;
-
-      applyConflictResolution({
-        conflictId: conflict.id,
-        resolution: resolution.resolution,
-        mergedStatement:
-          resolution.resolution === "merge"
-            ? resolution.resolvedStatement
-            : null,
-        resolutionNote: resolution.explanation,
-      });
-    }
-  }
-
-  /**
-   * Returns a dismissal reason if the conflict should be dismissed, or null if actionable.
-   */
-  private getDismissReason(
-    conflict: PendingConflictDetail,
-    conflictableKinds: readonly string[],
-  ): string | null {
-    if (
-      !isConflictKindPairEligible(
-        conflict.existingKind,
-        conflict.candidateKind,
-        { conflictableKinds },
-      )
-    ) {
-      return "Dismissed by conflict policy (kind not eligible).";
-    }
-    if (
-      !isStatementConflictEligible(
-        conflict.existingKind,
-        conflict.existingStatement,
-        { conflictableKinds },
-      )
-    ) {
-      return "Dismissed by conflict policy (transient/non-durable).";
-    }
-    if (
-      !isStatementConflictEligible(
-        conflict.candidateKind,
-        conflict.candidateStatement,
-        { conflictableKinds },
-      )
-    ) {
-      return "Dismissed by conflict policy (transient/non-durable).";
-    }
-    // Dismiss incoherent conflicts where the two statements have zero topical overlap
-    if (
-      !areStatementsCoherent(
-        conflict.existingStatement,
-        conflict.candidateStatement,
-      )
-    ) {
-      return "Dismissed by conflict policy (incoherent — zero statement overlap).";
-    }
-    // Dismiss conflicts where neither side has user-evidenced provenance
-    if (
-      !isConflictUserEvidenced(
-        conflict.existingVerificationState,
-        conflict.candidateVerificationState,
-      )
-    ) {
-      return "Dismissed by conflict policy (no user-evidenced provenance).";
-    }
-    return null;
-  }
-}
-
-export { computeConflictRelevance, looksLikeClarificationReply };

package/src/daemon/session-dynamic-profile.ts

@@ -1,77 +0,0 @@
-/**
- * Dynamic-profile injection and stripping helpers extracted from Session.
- *
- * These are pure functions with no state — they wrap profile text into user
- * messages at runtime and strip it back out before persistence.
- */
-
-import type { Message } from "../providers/types.js";
-
-export function injectDynamicProfileIntoUserMessage(
-  message: Message,
-  profileText: string,
-): Message {
-  const trimmedProfile = profileText.trim();
-  if (trimmedProfile.length === 0) return message;
-  const block = [
-    "<dynamic-profile-context>",
-    trimmedProfile,
-    "</dynamic-profile-context>",
-  ].join("\n");
-  return {
-    ...message,
-    content: [...message.content, { type: "text", text: `\n\n${block}` }],
-  };
-}
-
-export function stripDynamicProfileMessages(
-  messages: Message[],
-  profileText: string,
-): Message[] {
-  const trimmedProfile = profileText.trim();
-  if (trimmedProfile.length === 0) return messages;
-  const injectedBlock = `\n\n<dynamic-profile-context>\n${trimmedProfile}\n</dynamic-profile-context>`;
-  // Find the last user message that actually contains the injected profile block.
-  // We can't just target the last user message by role — tool_result messages also
-  // have role 'user', so after tool use the last user message won't be the one
-  // we injected the profile into.
-  let lastUserIdx = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (
-      messages[i].role === "user" &&
-      messages[i].content.some(
-        (b) => b.type === "text" && b.text.includes(injectedBlock),
-      )
-    ) {
-      lastUserIdx = i;
-      break;
-    }
-  }
-  if (lastUserIdx === -1) return messages;
-  const message = messages[lastUserIdx];
-  let changed = false;
-  const nextContent = message.content
-    .map((block) => {
-      if (block.type !== "text") return block;
-      const nextText = block.text.split(injectedBlock).join("");
-      if (nextText === block.text) return block;
-      changed = true;
-      const stripped = nextText.replace(/\n{3,}/g, "\n\n").trimEnd();
-      return stripped.length > 0 ? { ...block, text: stripped } : null;
-    })
-    .filter((block): block is NonNullable<typeof block> => block != null);
-  if (!changed) return messages;
-  // If stripping removed all content blocks, drop the message entirely
-  // to avoid sending an empty content array to the provider.
-  if (nextContent.length === 0) {
-    return [
-      ...messages.slice(0, lastUserIdx),
-      ...messages.slice(lastUserIdx + 1),
-    ];
-  }
-  return [
-    ...messages.slice(0, lastUserIdx),
-    { ...message, content: nextContent },
-    ...messages.slice(lastUserIdx + 1),
-  ];
-}