@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

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

@@ -11,6 +11,7 @@ import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { INTERNAL_GUARDIAN_TRUST_CONTEXT } from "../../daemon/trust-context.js";
 import { bootstrapConversation } from "../../memory/conversation-bootstrap.js";
 import { getConversation } from "../../memory/conversation-crud.js";
+import { getUsageCostForConversationWindow } from "../../memory/llm-usage-store.js";
 import { normalizeScheduleSyntax } from "../../schedule/recurrence-types.js";
 import {
   runScript,
@@ -27,10 +28,13 @@ import {
   getSchedule,
   getScheduleRuns,
   listSchedules,
+  setScheduleRunConversationId,
   updateSchedule,
 } from "../../schedule/schedule-store.js";
+import { getScheduleUsageSummaries } from "../../schedule/schedule-usage-store.js";
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import { parseEpochMillisRange } from "./epoch-millis-range.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -57,6 +61,9 @@ const scheduleSchema = z.object({
   maxRetries: z.number(),
   retryBackoffMs: z.number(),
   timeoutMs: z.number().nullable(),
+  createdFromConversationId: z.string().nullable(),
+  createdFromConversationExists: z.boolean(),
+  createdFromConversationArchivedAt: z.number().nullable(),
   description: z.string().nullable(),
   mode: z.enum(["notify", "execute", "script", "wake"]),
   status: z.enum(["active", "firing", "fired", "cancelled"]),
@@ -76,48 +83,96 @@ const scheduleRunSchema = z.object({
   output: z.string().nullable(),
   error: z.string().nullable(),
   conversationId: z.string().nullable(),
+  conversationExists: z.boolean(),
+  conversationArchivedAt: z.number().nullable(),
+  estimatedCostUsd: z.number(),
   createdAt: z.number(),
 });
 
+const scheduleUsageSummarySchema = z.object({
+  scheduleId: z.string(),
+  runCount: z.number(),
+  totalEstimatedCostUsd: z.number(),
+  eventCount: z.number(),
+});
+
 // ---------------------------------------------------------------------------
 // Handlers (transport-agnostic)
 // ---------------------------------------------------------------------------
 
+interface CreatedFromConversationState {
+  exists: boolean;
+  archivedAt: number | null;
+}
+
+function getCreatedFromConversationState(
+  conversationId: string | null,
+  cache: Map<string, CreatedFromConversationState>,
+): CreatedFromConversationState {
+  if (!conversationId) {
+    return { exists: false, archivedAt: null };
+  }
+
+  const cached = cache.get(conversationId);
+  if (cached) return cached;
+
+  const conversation = getConversation(conversationId);
+  const state = {
+    exists: conversation !== null,
+    archivedAt: conversation?.archivedAt ?? null,
+  };
+  cache.set(conversationId, state);
+  return state;
+}
+
 function handleListSchedules(queryParams: Record<string, string>) {
   const includeAll = queryParams.include_all === "true";
   const jobs = listSchedules();
   const filtered = includeAll
     ? jobs
     : jobs.filter((j) => j.createdBy !== "defer");
+  const sourceConversationCache = new Map<
+    string,
+    CreatedFromConversationState
+  >();
   return {
-    schedules: filtered.map((j) => ({
-      id: j.id,
-      name: j.name,
-      enabled: j.enabled,
-      syntax: j.syntax,
-      expression: j.expression,
-      cronExpression: j.cronExpression,
-      timezone: j.timezone,
-      message: j.message,
-      script: j.script,
-      nextRunAt: j.nextRunAt,
-      lastRunAt: j.lastRunAt,
-      lastStatus: j.lastStatus,
-      retryCount: j.retryCount,
-      maxRetries: j.maxRetries,
-      retryBackoffMs: j.retryBackoffMs,
-      timeoutMs: j.timeoutMs,
-      description:
-        j.syntax === "cron"
-          ? describeCronExpression(j.cronExpression)
-          : j.expression,
-      mode: j.mode,
-      status: j.status,
-      routingIntent: j.routingIntent,
-      reuseConversation: j.reuseConversation,
-      wakeConversationId: j.wakeConversationId,
-      isOneShot: j.cronExpression == null,
-    })),
+    schedules: filtered.map((j) => {
+      const sourceConversation = getCreatedFromConversationState(
+        j.createdFromConversationId,
+        sourceConversationCache,
+      );
+      return {
+        id: j.id,
+        name: j.name,
+        enabled: j.enabled,
+        syntax: j.syntax,
+        expression: j.expression,
+        cronExpression: j.cronExpression,
+        timezone: j.timezone,
+        message: j.message,
+        script: j.script,
+        nextRunAt: j.nextRunAt,
+        lastRunAt: j.lastRunAt,
+        lastStatus: j.lastStatus,
+        retryCount: j.retryCount,
+        maxRetries: j.maxRetries,
+        retryBackoffMs: j.retryBackoffMs,
+        timeoutMs: j.timeoutMs,
+        createdFromConversationId: j.createdFromConversationId,
+        createdFromConversationExists: sourceConversation.exists,
+        createdFromConversationArchivedAt: sourceConversation.archivedAt,
+        description:
+          j.syntax === "cron"
+            ? describeCronExpression(j.cronExpression)
+            : j.expression,
+        mode: j.mode,
+        status: j.status,
+        routingIntent: j.routingIntent,
+        reuseConversation: j.reuseConversation,
+        wakeConversationId: j.wakeConversationId,
+        isOneShot: j.cronExpression == null,
+      };
+    }),
   };
 }
 
@@ -291,22 +346,42 @@ function handleListScheduleRuns(
     ? Math.min(Math.max(Math.floor(rawLimit), 1), 100)
     : 10;
   const runs = getScheduleRuns(id, limit);
+  const now = Date.now();
   return {
-    runs: runs.map((r) => ({
-      id: r.id,
-      jobId: r.jobId,
-      status: r.status,
-      startedAt: r.startedAt,
-      finishedAt: r.finishedAt,
-      durationMs: r.durationMs,
-      output: r.output,
-      error: r.error,
-      conversationId: r.conversationId,
-      createdAt: r.createdAt,
-    })),
+    runs: runs.map((r) => {
+      const conversation = r.conversationId
+        ? getConversation(r.conversationId)
+        : null;
+      return {
+        id: r.id,
+        jobId: r.jobId,
+        status: r.status,
+        startedAt: r.startedAt,
+        finishedAt: r.finishedAt,
+        durationMs: r.durationMs,
+        output: r.output,
+        error: r.error,
+        conversationId: r.conversationId,
+        conversationExists: conversation != null,
+        conversationArchivedAt: conversation?.archivedAt ?? null,
+        estimatedCostUsd: r.conversationId
+          ? getUsageCostForConversationWindow({
+              conversationId: r.conversationId,
+              from: r.startedAt,
+              to: r.finishedAt ?? now,
+            })
+          : 0,
+        createdAt: r.createdAt,
+      };
+    }),
   };
 }
 
+function handleScheduleUsageSummary(queryParams: Record<string, string>) {
+  const range = parseEpochMillisRange(queryParams);
+  return { summaries: getScheduleUsageSummaries(range) };
+}
+
 // ---------------------------------------------------------------------------
 // Shared route definitions (HTTP + IPC)
 // ---------------------------------------------------------------------------
@@ -337,6 +412,40 @@ export const ROUTES: RouteDefinition[] = [
     handler: ({ queryParams }: RouteHandlerArgs) =>
       handleListSchedules(queryParams ?? {}),
   },
+  {
+    operationId: "getScheduleUsageSummary",
+    endpoint: "schedules/usage-summary",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "Get schedule usage summaries",
+    description:
+      "Return per-schedule run counts and usage totals for a time range.",
+    tags: ["schedules"],
+    queryParams: [
+      {
+        name: "from",
+        type: "integer",
+        required: true,
+        description: "Start epoch millis (required)",
+      },
+      {
+        name: "to",
+        type: "integer",
+        required: true,
+        description: "End epoch millis (required)",
+      },
+    ],
+    responseBody: z.object({
+      summaries: z
+        .array(scheduleUsageSummarySchema)
+        .describe("Schedule usage summary rows"),
+    }),
+    handler: ({ queryParams }: RouteHandlerArgs) =>
+      handleScheduleUsageSummary(queryParams ?? {}),
+  },
   {
     operationId: "createSchedule",
     endpoint: "schedules",
@@ -551,6 +660,7 @@ async function handleRunScheduleNow(id: string) {
   const taskMatch = schedule.message.match(/^run_task:(\S+)$/);
   if (taskMatch) {
     const taskId = taskMatch[1];
+    const runId = createScheduleRun(schedule.id, null);
     try {
       log.info(
         { jobId: schedule.id, name: schedule.name, taskId },
@@ -577,7 +687,7 @@ async function handleRunScheduleNow(id: string) {
         },
       );
 
-      const runId = createScheduleRun(schedule.id, result.conversationId);
+      setScheduleRunConversationId(runId, result.conversationId);
       if (result.status === "failed") {
         completeScheduleRun(runId, {
           status: "error",
@@ -598,7 +708,7 @@ async function handleRunScheduleNow(id: string) {
         origin: "schedule",
         systemHint: `Schedule (manual): ${schedule.name}`,
       });
-      const runId = createScheduleRun(schedule.id, fallbackConversation.id);
+      setScheduleRunConversationId(runId, fallbackConversation.id);
       completeScheduleRun(runId, { status: "error", error: message });
     }
     return handleListSchedules({});

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

@@ -684,9 +684,21 @@ export const ROUTES: RouteDefinition[] = [
     tags: ["secrets"],
     responseBody: z.object({
       secrets: z
-        .array(z.unknown())
+        .array(
+          z.object({
+            type: z.enum(["api_key", "credential"]),
+            name: z.string(),
+          }),
+        )
         .describe("List of secret metadata entries, each with type and name"),
-      accounts: z.array(z.unknown()).describe("Alias for secrets (same data)"),
+      accounts: z
+        .array(
+          z.object({
+            type: z.enum(["api_key", "credential"]),
+            name: z.string(),
+          }),
+        )
+        .describe("Alias for secrets (same data)"),
     }),
     handler: handleListSecrets,
   },

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

@@ -26,6 +26,7 @@ import {
   uninstallSkill,
   updateSkill,
 } from "../../daemon/handlers/skills.js";
+import { getCategories } from "../../skills/categories-cache.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -41,19 +42,11 @@ const slimSkillBase = {
   id: z.string(),
   name: z.string(),
   description: z.string(),
+  icon: z.string().optional(),
   emoji: z.string().optional(),
   kind: z.enum(["bundled", "installed", "catalog"]),
   status: z.enum(["enabled", "disabled", "available"]),
-  category: z.enum([
-    "communication",
-    "productivity",
-    "development",
-    "media",
-    "automation",
-    "webSocial",
-    "knowledge",
-    "integration",
-  ]),
+  category: z.string(),
 };
 
 const slimSkillSchema = z.discriminatedUnion("origin", [
@@ -220,6 +213,33 @@ export const ROUTES: RouteDefinition[] = [
       return { skills };
     },
   },
+  {
+    operationId: "listSkillCategories",
+    endpoint: "skills/categories",
+    method: "GET",
+    policy: {
+      requiredScopes: ["settings.read"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    summary: "List skill categories",
+    description:
+      "Return all skill category definitions with labels, icons, and descriptions.",
+    tags: ["skills"],
+    responseBody: z.object({
+      categories: z.array(
+        z.object({
+          slug: z.string(),
+          label: z.string(),
+          description: z.string(),
+          icon: z.string(),
+        }),
+      ),
+    }),
+    handler: async () => {
+      const categories = await getCategories();
+      return { categories };
+    },
+  },
   {
     operationId: "getSkillFileContent",
     endpoint: "skills/:id/files/content",
@@ -546,10 +566,19 @@ export const ROUTES: RouteDefinition[] = [
     description: "Install a skill by slug, URL, or spec.",
     tags: ["skills"],
     requestBody: z.object({
-      slug: z.string().describe("Skill slug"),
-      url: z.string().describe("Skill URL"),
-      spec: z.string().describe("Skill spec"),
-      version: z.string(),
+      slug: z
+        .string()
+        .optional()
+        .describe("Skill slug. One of slug, url, or spec is required."),
+      url: z
+        .string()
+        .optional()
+        .describe("Skill URL. One of slug, url, or spec is required."),
+      spec: z
+        .string()
+        .optional()
+        .describe("Skill spec. One of slug, url, or spec is required."),
+      version: z.string().optional().describe("Specific version to install"),
       origin: z
         .enum(["clawhub", "skillssh"])
         .optional()

package/src/runtime/routes/surface-conversation-resolver.ts

@@ -18,8 +18,8 @@ import type { Conversation } from "../../daemon/conversation.js";
 import {
   findConversation,
   findConversationBySurfaceId,
-  getOrCreateConversation,
-} from "../../daemon/conversation-store.js";
+} from "../../daemon/conversation-registry.js";
+import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { rawGet } from "../../memory/raw-query.js";
 
 /**
@@ -60,6 +60,7 @@ export async function resolveSurfaceConversation(
     `%"surfaceId":"${escaped}"%`,
   );
   if (!row) return undefined;
-  if (conversationId && conversationId !== row.conversation_id) return undefined;
+  if (conversationId && conversationId !== row.conversation_id)
+    return undefined;
   return await getOrCreateConversation(row.conversation_id);
 }

package/src/runtime/routes/tool-call-confirmation-enrichment.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Tests for render-time enrichment of history tool calls with confirmation
+ * context: derived scope ladders for scope-aware tools and outstanding prompts
+ * read from the pending-interactions registry.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+
+import type { ConversationMessageToolCall } from "../../api/responses/conversation-message.js";
+import { clear, register } from "../pending-interactions.js";
+import {
+  collectPendingConfirmations,
+  enrichToolCallsWithConfirmation,
+} from "./tool-call-confirmation-enrichment.js";
+
+const WORKSPACE = "/home/user/project";
+
+function toolCall(
+  overrides: Partial<ConversationMessageToolCall>,
+): ConversationMessageToolCall {
+  return {
+    name: "file_read",
+    input: {},
+    ...overrides,
+  };
+}
+
+afterEach(() => {
+  clear();
+});
+
+describe("collectPendingConfirmations", () => {
+  test("keys confirmation interactions by toolUseId", () => {
+    // GIVEN a confirmation interaction registered for a conversation with a
+    // tool-use id and confirmation details
+    register("req-1", {
+      conversationId: "conv-1",
+      kind: "confirmation",
+      toolUseId: "tool-abc",
+      confirmationDetails: {
+        toolName: "file_read",
+        input: { path: "/home/user/project/a.txt" },
+        riskLevel: "low",
+        allowlistOptions: [],
+        scopeOptions: [],
+      },
+    });
+
+    // WHEN we collect the conversation's pending confirmations
+    const byToolUseId = collectPendingConfirmations("conv-1");
+
+    // THEN the interaction is keyed by its tool-use id
+    expect(byToolUseId.size).toBe(1);
+    expect(byToolUseId.get("tool-abc")?.requestId).toBe("req-1");
+  });
+
+  test("ignores interactions lacking a toolUseId or confirmation details", () => {
+    // GIVEN a confirmation without a toolUseId AND a non-confirmation
+    // interaction in the same conversation
+    register("req-no-tool", {
+      conversationId: "conv-2",
+      kind: "confirmation",
+      confirmationDetails: {
+        toolName: "file_read",
+        input: {},
+        riskLevel: "low",
+        allowlistOptions: [],
+        scopeOptions: [],
+      },
+    });
+    register("req-secret", {
+      conversationId: "conv-2",
+      kind: "secret",
+      toolUseId: "tool-xyz",
+    });
+
+    // WHEN we collect the conversation's pending confirmations
+    const byToolUseId = collectPendingConfirmations("conv-2");
+
+    // THEN neither is included — one has no toolUseId, the other is not a
+    // confirmation
+    expect(byToolUseId.size).toBe(0);
+  });
+});
+
+describe("enrichToolCallsWithConfirmation", () => {
+  test("derives the scope ladder for scope-aware tools", () => {
+    // GIVEN a completed scope-aware tool call with no registry entry
+    const calls = [toolCall({ id: "tool-1", name: "file_read" })];
+
+    // WHEN we enrich it
+    const [enriched] = enrichToolCallsWithConfirmation(calls, {
+      workspaceDir: WORKSPACE,
+      pendingConfirmations: new Map(),
+    });
+
+    // THEN the scope ladder is derived from the workspace and tool name
+    expect(enriched?.scopeOptions?.[0]).toEqual({
+      label: WORKSPACE,
+      scope: WORKSPACE,
+    });
+    // AND no pending confirmation is stamped
+    expect(enriched?.pendingConfirmation).toBeUndefined();
+  });
+
+  test("leaves non-scope-aware tool calls untouched", () => {
+    // GIVEN a tool call for a tool that has no scope ladder
+    const original = toolCall({ id: "tool-2", name: "web_search" });
+
+    // WHEN we enrich it with no matching registry entry
+    const [enriched] = enrichToolCallsWithConfirmation([original], {
+      workspaceDir: WORKSPACE,
+      pendingConfirmations: new Map(),
+    });
+
+    // THEN the tool call is returned unchanged (same reference)
+    expect(enriched).toBe(original);
+  });
+
+  test("stamps the pending confirmation when the registry has a match", () => {
+    // GIVEN a registry entry matching the tool call by id
+    const pendingConfirmations = collectPendingConfirmationsFixture();
+    const calls = [toolCall({ id: "tool-abc", name: "file_read" })];
+
+    // WHEN we enrich it
+    const [enriched] = enrichToolCallsWithConfirmation(calls, {
+      workspaceDir: WORKSPACE,
+      pendingConfirmations,
+    });
+
+    // THEN the outstanding prompt is projected onto the tool call
+    expect(enriched?.pendingConfirmation?.requestId).toBe("req-1");
+    expect(enriched?.pendingConfirmation?.toolName).toBe("file_read");
+    expect(enriched?.pendingConfirmation?.riskLevel).toBe("high");
+    // AND the directory scope ladder carries through from the registry so a
+    // restored prompt offers the same scope the live event did
+    expect(enriched?.pendingConfirmation?.directoryScopeOptions).toEqual([
+      { label: "Anywhere in project/", scope: "/home/user/project" },
+    ]);
+    // AND the derived scope ladder is still present
+    expect(enriched?.scopeOptions?.length).toBeGreaterThan(0);
+  });
+});
+
+function collectPendingConfirmationsFixture() {
+  register("req-1", {
+    conversationId: "conv-fixture",
+    kind: "confirmation",
+    toolUseId: "tool-abc",
+    confirmationDetails: {
+      toolName: "file_read",
+      input: { path: "/home/user/project/a.txt" },
+      riskLevel: "high",
+      allowlistOptions: [],
+      scopeOptions: [],
+      directoryScopeOptions: [
+        { label: "Anywhere in project/", scope: "/home/user/project" },
+      ],
+    },
+  });
+  return collectPendingConfirmations("conv-fixture");
+}

package/src/runtime/routes/tool-call-confirmation-enrichment.ts

@@ -0,0 +1,107 @@
+/**
+ * Render-time enrichment of history tool calls with confirmation context.
+ *
+ * Two pieces of state the persisted content does not itself carry are layered
+ * onto each rendered tool call here so the web/API clients can render the same
+ * confirmation UI on a cold reconnect (or a history reopen after the live
+ * event buffer has aged out) that the live `confirmation_request` SSE stream
+ * would have produced:
+ *
+ * 1. `scopeOptions` — the confirmation scope ladder for scope-aware tools
+ *    (file/bash). It is a pure function of the workspace directory and the
+ *    tool name, so it is *derived* at render rather than persisted. Completed
+ *    tool calls regain the ladder the rule editor's trust-rule suggestion
+ *    fallback consumes.
+ *
+ * 2. `pendingConfirmation` — the in-flight prompt for a tool call still
+ *    awaiting a user decision. It is read from the in-memory
+ *    `pending-interactions` registry (the authoritative store of unresolved
+ *    prompts), so it appears only while the prompt is genuinely outstanding.
+ */
+
+import type { ConversationMessageToolCall } from "../../api/responses/conversation-message.js";
+import { generateScopeOptions } from "../../permissions/checker.js";
+import {
+  type ConfirmationDetails,
+  getByConversation,
+} from "../pending-interactions.js";
+
+/** A pending confirmation matched to the tool call it prompts for, keyed by `toolUseId`. */
+interface PendingConfirmationMatch {
+  requestId: string;
+  details: ConfirmationDetails;
+}
+
+/**
+ * Build the `toolUseId → pending confirmation` lookup for a conversation from
+ * the registry. Only confirmation interactions that carry both a `toolUseId`
+ * and `confirmationDetails` can be stamped onto a wire tool call.
+ */
+export function collectPendingConfirmations(
+  conversationId: string,
+): Map<string, PendingConfirmationMatch> {
+  const byToolUseId = new Map<string, PendingConfirmationMatch>();
+  for (const interaction of getByConversation(conversationId)) {
+    if (
+      interaction.kind === "confirmation" &&
+      interaction.confirmationDetails &&
+      interaction.toolUseId
+    ) {
+      byToolUseId.set(interaction.toolUseId, {
+        requestId: interaction.requestId,
+        details: interaction.confirmationDetails,
+      });
+    }
+  }
+  return byToolUseId;
+}
+
+/** Project a registry `ConfirmationDetails` into the wire `pendingConfirmation` shape. */
+function toPendingConfirmation(
+  requestId: string,
+  details: ConfirmationDetails,
+): NonNullable<ConversationMessageToolCall["pendingConfirmation"]> {
+  return {
+    requestId,
+    toolName: details.toolName,
+    riskLevel: details.riskLevel,
+    input: details.input,
+    allowlistOptions: details.allowlistOptions,
+    scopeOptions: details.scopeOptions,
+    directoryScopeOptions: details.directoryScopeOptions,
+    persistentDecisionsAllowed: details.persistentDecisionsAllowed,
+  };
+}
+
+/**
+ * Layer derived `scopeOptions` and any outstanding `pendingConfirmation` onto a
+ * message's rendered tool calls. Returns a new array; tool calls without
+ * enrichment are returned unchanged.
+ */
+export function enrichToolCallsWithConfirmation(
+  toolCalls: ConversationMessageToolCall[],
+  opts: {
+    workspaceDir: string;
+    pendingConfirmations: ReadonlyMap<string, PendingConfirmationMatch>;
+  },
+): ConversationMessageToolCall[] {
+  return toolCalls.map((tc) => {
+    const scopeOptions = generateScopeOptions(opts.workspaceDir, tc.name);
+    const match = tc.id ? opts.pendingConfirmations.get(tc.id) : undefined;
+    if (scopeOptions.length === 0 && !match) {
+      return tc;
+    }
+    return {
+      ...tc,
+      ...(scopeOptions.length > 0 ? { scopeOptions } : {}),
+      ...(match
+        ? {
+            pendingConfirmation: toPendingConfirmation(
+              match.requestId,
+              match.details,
+            ),
+          }
+        : {}),
+    };
+  });
+}