@vellumai/assistant 0.8.2 → 0.8.4

package/src/runtime/routes/content-source-routes.ts

@@ -0,0 +1,78 @@
+/**
+ * Route definitions for content-source configuration.
+ *
+ * POST /v1/content-source — validate and persist a content source URL as sidecar
+ *
+ * Uses policyKey: "secrets" — writes workspace data, same policy tier as
+ * the existing secrets routes.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { z } from "zod";
+
+import { getWorkspaceDir } from "../../util/platform.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function writeSidecar(relPath: string, data: Record<string, unknown>): void {
+  const workspaceDir = getWorkspaceDir();
+  const absPath = join(workspaceDir, relPath);
+  mkdirSync(dirname(absPath), { recursive: true });
+  writeFileSync(absPath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+function validateUrl(
+  raw: string,
+): { ok: true; normalized: string } | { ok: false; error: "invalid_url" } {
+  const trimmed = raw.trim();
+  let parsed: URL;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    return { ok: false, error: "invalid_url" };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return { ok: false, error: "invalid_url" };
+  }
+  parsed.username = "";
+  parsed.password = "";
+  return { ok: true, normalized: parsed.href };
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/content-source
+// ---------------------------------------------------------------------------
+
+function handleContentSource(args: RouteHandlerArgs): Record<string, unknown> {
+  const rawUrl = typeof args.body?.url === "string" ? args.body.url : "";
+
+  const result = validateUrl(rawUrl);
+  if (!result.ok) {
+    return { ok: false, error: result.error };
+  }
+
+  writeSidecar("data/content-source.json", { url: result.normalized });
+
+  return { ok: true };
+}
+
+// ---------------------------------------------------------------------------
+// Route definition
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "content_source_set",
+    endpoint: "content-source",
+    method: "POST",
+    policyKey: "secrets",
+    summary: "Validate and persist a content source URL",
+    requestBody: z.object({ url: z.string() }),
+    handler: handleContentSource,
+  },
+];

package/src/runtime/routes/conversation-cli-routes.ts

@@ -11,6 +11,7 @@ import { z } from "zod";
 
 import { clearAllConversations as clearAllActive } from "../../daemon/handlers/conversations.js";
 import { formatJson, formatMarkdown } from "../../export/formatter.js";
+import { ipcCall as ipcCallGateway } from "../../ipc/gateway-client.js";
 import {
   addMessage,
   createConversation,
@@ -19,8 +20,10 @@ import {
 } from "../../memory/conversation-crud.js";
 import { setConversationKey } from "../../memory/conversation-key-store.js";
 import { listConversations } from "../../memory/conversation-queries.js";
+import { getBindingByConversation } from "../../memory/external-conversation-store.js";
+import { sendSlackReply } from "../../messaging/providers/slack/send.js";
 import { getLogger } from "../../util/logger.js";
-import { BadRequestError, NotFoundError } from "./errors.js";
+import { BadGatewayError, BadRequestError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("conversation-cli-routes");
@@ -150,6 +153,136 @@ async function handleClearCli(_args: RouteHandlerArgs) {
   return { cleared };
 }
 
+// ---------------------------------------------------------------------------
+// slack detach (CLI)
+// ---------------------------------------------------------------------------
+
+const slackDetachRequestSchema = z.object({
+  conversationId: z.string().trim().min(1).optional(),
+  channelId: z.string().trim().min(1).optional(),
+  threadTs: z.string().trim().min(1).optional(),
+});
+
+const slackDetachResponseSchema = z.object({
+  detached: z.boolean(),
+  channelId: z.string(),
+  threadTs: z.string(),
+  source: z.enum(["explicit", "conversation_binding"]),
+  conversationId: z.string().optional(),
+});
+
+type SlackDetachGatewayResponse = {
+  detached: boolean;
+  channelId: string;
+  threadTs: string;
+};
+
+const SLACK_DETACH_CONFIRMATION_TEXT =
+  "Muted this Slack thread. I won't respond to further replies here unless you mention me again.";
+
+function isSlackDetachGatewayResponse(
+  value: unknown,
+): value is SlackDetachGatewayResponse {
+  return (
+    value != null &&
+    typeof value === "object" &&
+    typeof (value as SlackDetachGatewayResponse).detached === "boolean" &&
+    typeof (value as SlackDetachGatewayResponse).channelId === "string" &&
+    typeof (value as SlackDetachGatewayResponse).threadTs === "string"
+  );
+}
+
+async function handleSlackDetachCli({ body = {} }: RouteHandlerArgs) {
+  const parsed = slackDetachRequestSchema.parse(body);
+  const explicitChannelId = parsed.channelId;
+  const explicitThreadTs = parsed.threadTs;
+
+  let channelId: string;
+  let threadTs: string;
+  let source: "explicit" | "conversation_binding";
+  let conversationId: string | undefined;
+
+  if (explicitChannelId || explicitThreadTs) {
+    if (!explicitChannelId || !explicitThreadTs) {
+      throw new BadRequestError(
+        "Both channelId and threadTs are required when detaching by explicit Slack identifiers",
+      );
+    }
+    channelId = explicitChannelId;
+    threadTs = explicitThreadTs;
+    source = "explicit";
+  } else {
+    if (!parsed.conversationId) {
+      throw new BadRequestError(
+        "conversationId is required unless channelId and threadTs are provided",
+      );
+    }
+
+    const binding = getBindingByConversation(parsed.conversationId);
+    if (!binding) {
+      throw new NotFoundError(
+        `No channel binding found for conversation ${parsed.conversationId}`,
+      );
+    }
+    if (binding.sourceChannel !== "slack") {
+      throw new BadRequestError(
+        `Conversation ${parsed.conversationId} is bound to ${binding.sourceChannel}, not Slack`,
+      );
+    }
+    if (!binding.externalThreadId) {
+      throw new BadRequestError(
+        `Conversation ${parsed.conversationId} is not bound to a Slack thread`,
+      );
+    }
+
+    channelId = binding.externalChatId;
+    threadTs = binding.externalThreadId;
+    source = "conversation_binding";
+    conversationId = parsed.conversationId;
+  }
+
+  const gatewayResult = await ipcCallGateway(
+    "detach_slack_active_thread",
+    { channelId, threadTs },
+    5_000,
+  );
+  if (!isSlackDetachGatewayResponse(gatewayResult)) {
+    throw new BadGatewayError(
+      "Could not detach Slack thread from assistant listening",
+    );
+  }
+
+  if (gatewayResult.detached) {
+    try {
+      await sendSlackReply(
+        gatewayResult.channelId,
+        SLACK_DETACH_CONFIRMATION_TEXT,
+        { threadTs: gatewayResult.threadTs },
+      );
+    } catch (err) {
+      log.warn(
+        {
+          err,
+          channelId: gatewayResult.channelId,
+          threadTs: gatewayResult.threadTs,
+        },
+        "Slack thread detached, but confirmation message failed",
+      );
+      throw new BadGatewayError(
+        "Detached Slack thread but could not send confirmation",
+      );
+    }
+  }
+
+  return {
+    detached: gatewayResult.detached,
+    channelId: gatewayResult.channelId,
+    threadTs: gatewayResult.threadTs,
+    source,
+    ...(conversationId ? { conversationId } : {}),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -230,4 +363,16 @@ export const ROUTES: RouteDefinition[] = [
     }),
     handler: handleClearCli,
   },
+  {
+    operationId: "conversation_slack_detach_cli",
+    endpoint: "conversations/cli/slack/detach",
+    method: "POST",
+    summary: "Detach the assistant from a Slack thread (CLI)",
+    description:
+      "Stops Slack active-thread listening for a Slack thread. The CLI resolves current conversation defaults.",
+    tags: ["conversations"],
+    requestBody: slackDetachRequestSchema,
+    responseBody: slackDetachResponseSchema,
+    handler: handleSlackDetachCli,
+  },
 ];

package/src/runtime/routes/conversation-query-routes.ts

@@ -15,6 +15,7 @@
  * GET    /v1/messages/:id/llm-context   — LLM request logs for a message
  * GET    /v1/llm-request-logs/:id/payload — raw payload for a single log
  * DELETE /v1/messages/queued/:id        — delete queued message
+ * POST   /v1/messages/queued/:id/steer — steer to a queued message
  */
 
 import { z } from "zod";
@@ -49,7 +50,10 @@ import {
   getMessageContent,
   performConversationSearch,
 } from "../../daemon/handlers/conversation-history.js";
-import { deleteQueuedMessage } from "../../daemon/handlers/conversations.js";
+import {
+  deleteQueuedMessage,
+  steerToMessage,
+} from "../../daemon/handlers/conversations.js";
 import {
   CONFIG_RELOAD_DEBOUNCE_MS,
   log,
@@ -59,12 +63,20 @@ import {
   getConversation,
   getMessageById,
 } from "../../memory/conversation-crud.js";
+import { getDb } from "../../memory/db-connection.js";
 import { clearEmbeddingBackendCache } from "../../memory/embedding-backend.js";
 import { getLlmRequestLogSource } from "../../memory/llm-request-log-source.js";
 import { getMemoryRecallLogByMessageIds } from "../../memory/memory-recall-log-store.js";
 import { getMemoryV2ActivationLogByMessageIds } from "../../memory/memory-v2-activation-log-store.js";
 import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../memory/v2/constants.js";
+import {
+  createConnection,
+  listConnections,
+  PROVIDERS_REQUIRING_BASE_URL_AND_MODELS,
+} from "../../providers/inference/connections.js";
+import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
 import { initializeProviders } from "../../providers/registry.js";
+import { credentialKey } from "../../security/credential-key.js";
 import { validateAllowlistFile } from "../../security/secret-allowlist.js";
 import { resolvePricingForUsage } from "../../util/pricing.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
@@ -379,13 +391,42 @@ function readPlainObject(value: unknown): Record<string, unknown> | undefined {
 
 function handleGetConfig() {
   try {
-    return applyContextDefaultsToRawConfig(loadRawConfig());
+    const config = applyContextDefaultsToRawConfig(loadRawConfig());
+    enrichProfilesWithVisionFlag(config);
+    return config;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new InternalError(`Failed to read config: ${message}`);
   }
 }
 
+/**
+ * Annotate each profile in `config.llm.profiles` with `supportsVision`
+ * resolved from the model catalog. The flag is wire-only — it is never
+ * persisted to disk. Unknown (provider, model) pairs default to `true`
+ * (fail-open) so image upload remains available for custom / unlisted models.
+ */
+function enrichProfilesWithVisionFlag(config: unknown): void {
+  const root = readPlainObject(config);
+  if (!root) return;
+  const llm = readPlainObject(root.llm);
+  if (!llm) return;
+  const profiles = readPlainObject(llm.profiles);
+  if (!profiles) return;
+
+  for (const profile of Object.values(profiles)) {
+    const entry = readPlainObject(profile);
+    if (!entry) continue;
+    const provider = entry.provider;
+    const model = entry.model;
+    if (typeof provider !== "string" || typeof model !== "string") continue;
+
+    const catalogProvider = PROVIDER_CATALOG.find((p) => p.id === provider);
+    const catalogModel = catalogProvider?.models.find((m) => m.id === model);
+    entry.supportsVision = catalogModel?.supportsVision ?? true;
+  }
+}
+
 /**
  * Return the JSON Schema for the assistant config (full or scoped).
  *
@@ -617,6 +658,36 @@ async function handleReplaceInferenceProfile({
       );
     }
   }
+  // When the UI sends provider but no provider_connection ("Any active X
+  // connection"), derive the connection now so the config deep-merge doesn't
+  // inherit a stale connection from the default layer.
+  const fragment = parsed.data as Record<string, unknown>;
+  if (!isManaged && fragment.provider && !fragment.provider_connection) {
+    const provider = fragment.provider as string;
+    const db = getDb();
+    const candidates = listConnections(db, { provider });
+    const active = candidates.find((c) => c.status === "active");
+    if (active) {
+      fragment.provider_connection = active.name;
+    } else if (!PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(provider)) {
+      const connectionName = `${provider}-personal`;
+      const isKeyless = provider === "ollama";
+      const result = createConnection(db, {
+        name: connectionName,
+        provider,
+        auth: isKeyless
+          ? { type: "none" }
+          : {
+              type: "api_key",
+              credential: credentialKey(provider, "api_key"),
+            },
+      });
+      if (result.ok) {
+        fragment.provider_connection = connectionName;
+      }
+    }
+  }
+
   const raw = loadRawConfig();
   if (isManaged) {
     // Partial overlay: keep every existing key intact, only update label
@@ -624,17 +695,9 @@ async function handleReplaceInferenceProfile({
     // here would wipe the UI-owned seed fields (provider, model, advanced
     // params) because that function assumes the body carries the full UI
     // surface.
-    patchManagedProfileFields(
-      raw,
-      name,
-      parsed.data as Record<string, unknown>,
-    );
+    patchManagedProfileFields(raw, name, fragment);
   } else {
-    replaceInferenceProfileConfig(
-      raw,
-      name,
-      parsed.data as Record<string, unknown>,
-    );
+    replaceInferenceProfileConfig(raw, name, fragment);
   }
   // Route through `commitConfigWrite` so profile edits flow through the
   // post-write side effects shared with `handlePatchConfig` /
@@ -795,6 +858,12 @@ async function handleGetLlmContext({ pathParams = {} }: RouteHandlerArgs) {
         requestPayload: null,
         responsePayload: null,
         createdAt: log.createdAt,
+        // Agent-loop exit reason for the iteration that produced this
+        // call, stamped onto the most-recent unstamped log by
+        // `conversation-agent-loop-handlers.ts` after the loop yields.
+        // Only the terminal call in each loop iteration carries a value;
+        // non-terminal calls land here as `null`.
+        agentLoopExitReason: log.agentLoopExitReason ?? null,
         ...result,
       };
     }),
@@ -850,6 +919,36 @@ function handleDeleteQueuedMessage({
   throw new NotFoundError("Queued message not found");
 }
 
+function handleSteerToMessage({
+  queryParams = {},
+  pathParams = {},
+  body,
+}: RouteHandlerArgs) {
+  const conversationId =
+    queryParams.conversationId ??
+    (body && typeof body === "object" && "conversationId" in body
+      ? (body as Record<string, unknown>).conversationId
+      : undefined);
+  if (!conversationId || typeof conversationId !== "string") {
+    throw new BadRequestError(
+      "Missing required parameter: conversationId",
+    );
+  }
+  const result = steerToMessage(conversationId, pathParams.id ?? "");
+  if (result.steered) {
+    return { ok: true, conversationId, requestId: pathParams.id };
+  }
+  if (result.reason === "conversation_not_found") {
+    throw new NotFoundError("Conversation not found");
+  }
+  if (result.reason === "not_processing") {
+    throw new BadRequestError(
+      "Cannot steer: conversation is not currently processing",
+    );
+  }
+  throw new NotFoundError("Queued message not found");
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions (shared HTTP + IPC)
 // ---------------------------------------------------------------------------
@@ -1081,4 +1180,23 @@ export const ROUTES: RouteDefinition[] = [
     ],
     handler: handleDeleteQueuedMessage,
   },
+  {
+    operationId: "messages_queued_steer",
+    endpoint: "messages/queued/:id/steer",
+    method: "POST",
+    policyKey: "messages/queued",
+    summary: "Steer to a queued message",
+    description:
+      "Promote a queued message to the head of the queue and abort the current generation so it is processed next.",
+    tags: ["messages"],
+    queryParams: [
+      {
+        name: "conversationId",
+        schema: { type: "string" },
+        required: true,
+        description: "Conversation ID (required)",
+      },
+    ],
+    handler: handleSteerToMessage,
+  },
 ];