@vellumai/assistant 0.8.8 → 0.8.9-staging.2

package/src/daemon/wake-target-adapter.ts

@@ -1,253 +0,0 @@
-/**
- * Adapter that wraps a live {@link Conversation} as a {@link WakeTarget}
- * for `wakeAgentForOpportunity()`.
- *
- * Extracted from `server.ts` so that `runtime/agent-wake.ts` can import
- * the resolver directly instead of going through a DI callback registered
- * at daemon startup.
- */
-
-import type { AgentEvent } from "../agent/loop.js";
-import {
-  addMessage,
-  getConversation,
-  provenanceFromTrustContext,
-} from "../memory/conversation-crud.js";
-import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
-import { backfillMessageIdOnLogs } from "../memory/llm-request-log-store.js";
-import type { WakeTarget } from "../runtime/agent-wake.js";
-import { broadcastMessage } from "../runtime/assistant-event-hub.js";
-import { getLogger } from "../util/logger.js";
-import type { Conversation } from "./conversation.js";
-import type { ServerMessage } from "./message-protocol.js";
-
-const log = getLogger("wake-target-adapter");
-
-/**
- * Translate a raw {@link AgentEvent} from the agent loop into the
- * corresponding {@link ServerMessage} wire frame. The normal user-turn
- * path does this via the full state-aware handler in
- * `conversation-agent-loop-handlers.ts`; the wake path has no tool
- * accounting, title generation, or activity-state tracking to worry
- * about, so we only need the subset that produces client-visible
- * frames. Events that have no client-visible wire shape (usage, error,
- * preview/input-json deltas, etc.) are dropped — they produce no UI.
- *
- * Keeping this translator co-located with the wake adapter preserves
- * the runtime/daemon layering: `runtime/agent-wake.ts` never imports
- * `message-protocol.ts` or wire shapes, and the daemon owns all
- * translation from agent-loop semantics to client frames.
- */
-function translateAgentEventToServerMessage(
-  event: AgentEvent,
-  conversationId: string,
-): ServerMessage | null {
-  switch (event.type) {
-    case "text_delta":
-      return {
-        type: "assistant_text_delta",
-        text: event.text,
-        conversationId,
-      };
-    case "thinking_delta":
-      return {
-        type: "assistant_thinking_delta",
-        thinking: event.thinking,
-        conversationId,
-      };
-    case "tool_use":
-      return {
-        type: "tool_use_start",
-        toolName: event.name,
-        input: event.input,
-        conversationId,
-        toolUseId: event.id,
-      };
-    case "tool_use_preview_start":
-      return {
-        type: "tool_use_preview_start",
-        toolUseId: event.toolUseId,
-        toolName: event.toolName,
-        conversationId,
-      };
-    case "tool_output_chunk":
-      return {
-        type: "tool_output_chunk",
-        chunk: event.chunk,
-        conversationId,
-        toolUseId: event.toolUseId,
-      };
-    case "tool_result": {
-      const imageBlocks = event.contentBlocks?.filter(
-        (b): b is Extract<typeof b, { type: "image" }> => b.type === "image",
-      );
-      const imageDataList = imageBlocks?.length
-        ? imageBlocks.map((b) => b.source.data)
-        : undefined;
-      return {
-        type: "tool_result",
-        toolName: "",
-        result: event.content,
-        isError: event.isError,
-        diff: event.diff,
-        status: event.status,
-        conversationId,
-        imageData: imageDataList?.[0],
-        imageDataList,
-        toolUseId: event.toolUseId,
-      };
-    }
-    case "server_tool_start":
-      return {
-        type: "tool_use_start",
-        toolName: event.name,
-        input: event.input,
-        conversationId,
-        toolUseId: event.toolUseId,
-      };
-    case "server_tool_complete": {
-      let resultText = "";
-      if (Array.isArray(event.content) && event.content.length > 0) {
-        resultText = (event.content as unknown[])
-          .filter(
-            (r): r is { type: string; title: string; url: string } =>
-              typeof r === "object" &&
-              r != null &&
-              (r as { type?: string }).type === "web_search_result",
-          )
-          .map((r) => `${r.title}\n${r.url}`)
-          .join("\n\n");
-      }
-      return {
-        type: "tool_result",
-        toolName: "web_search",
-        result: resultText,
-        isError: event.isError,
-        conversationId,
-        toolUseId: event.toolUseId,
-      };
-    }
-    case "message_complete":
-      return {
-        type: "message_complete",
-        conversationId,
-      };
-    case "input_json_delta":
-    case "usage":
-    case "error":
-    case "provider_error":
-    case "max_tokens_reached":
-    case "context_compacting":
-    case "compaction_circuit_open":
-    case "compaction_circuit_closed":
-    case "compaction_completed":
-    case "history_stripped":
-    case "agent_loop_exit":
-      return null;
-    case "llm_call_started":
-      // The wake path persists its assistant tail via `persistTailMessage`
-      // (an `addMessage`-shaped call below) rather than via the main
-      // event-handler's `reserve` → `updateContent` pipeline, so there is
-      // no row to reserve here. Translation returns null and the wake
-      // path's existing end-of-turn persist continues to mint the row.
-      // Following up with full wake-path pre-allocation parity is tracked
-      // as a B3 follow-up.
-      return null;
-  }
-}
-
-/**
- * Adapt a live {@link Conversation} to the narrow {@link WakeTarget}
- * surface expected by `wakeAgentForOpportunity()`.
- */
-export function conversationToWakeTarget(
-  conversation: Conversation,
-): WakeTarget {
-  return {
-    conversationId: conversation.conversationId,
-    agentLoop: conversation.agentLoop,
-    getMessages: () => conversation.getMessages(),
-    pushMessage: (msg) => {
-      conversation.messages.push(msg);
-    },
-    onWakeProducedOutput: (source, hint, surfaceId) => {
-      broadcastMessage({
-        type: "ui_surface_show",
-        conversationId: conversation.conversationId,
-        surfaceId,
-        surfaceType: "card",
-        data: {
-          title: "Conversation Woke",
-          body: hint,
-          metadata: [{ label: "Source", value: source }],
-        },
-        display: "inline",
-      });
-    },
-    emitAgentEvent: (event) => {
-      const frame = translateAgentEventToServerMessage(
-        event,
-        conversation.conversationId,
-      );
-      if (!frame) return;
-      broadcastMessage(frame);
-    },
-    isProcessing: () => conversation.isProcessing(),
-    markProcessing: (on) => {
-      conversation.setProcessing(on);
-    },
-    setTrustContext: (ctx) => conversation.setTrustContext(ctx),
-    setWakeAllowedTools: (tools) => {
-      const previous = conversation.subagentAllowedTools;
-      conversation.setSubagentAllowedTools(new Set(tools));
-      return () => {
-        conversation.setSubagentAllowedTools(previous);
-      };
-    },
-    persistTailMessage: async (message) => {
-      const turnChannelCtx = conversation.getTurnChannelContext();
-      const turnInterfaceCtx = conversation.getTurnInterfaceContext();
-      const metadata: Record<string, unknown> = {
-        ...provenanceFromTrustContext(conversation.trustContext),
-        userMessageChannel: turnChannelCtx?.userMessageChannel ?? "vellum",
-        assistantMessageChannel:
-          turnChannelCtx?.assistantMessageChannel ?? "vellum",
-        userMessageInterface: turnInterfaceCtx?.userMessageInterface ?? "web",
-        assistantMessageInterface:
-          turnInterfaceCtx?.assistantMessageInterface ?? "web",
-      };
-      const persisted = await addMessage(
-        conversation.conversationId,
-        message.role,
-        JSON.stringify(message.content),
-        { metadata },
-      );
-      if (message.role === "assistant") {
-        try {
-          backfillMessageIdOnLogs(conversation.conversationId, persisted.id);
-        } catch (err) {
-          log.warn(
-            { err, conversationId: conversation.conversationId },
-            "wake adapter: backfill messageId on LLM logs failed (non-fatal)",
-          );
-        }
-      }
-      try {
-        const convRow = getConversation(conversation.conversationId);
-        if (convRow) {
-          syncMessageToDisk(
-            conversation.conversationId,
-            persisted.id,
-            convRow.createdAt,
-          );
-        }
-      } catch (err) {
-        log.warn(
-          { err, conversationId: conversation.conversationId },
-          "wake adapter: syncMessageToDisk failed (non-fatal)",
-        );
-      }
-    },
-    drainQueue: () => conversation.drainQueue(),
-  };
-}

package/src/plugins/defaults/circuit-breaker/middlewares/circuitBreaker.ts

@@ -1,93 +0,0 @@
-import type {
-  CircuitBreakerArgs,
-  CircuitBreakerResult,
-  Middleware,
-} from "../../../types.js";
-
-/**
- * Consecutive failures required to trip the breaker. Matches the legacy
- * `COMPACTION_CIRCUIT_FAILURE_THRESHOLD` in `conversation-agent-loop.ts`.
- */
-export const COMPACTION_CIRCUIT_FAILURE_THRESHOLD = 3;
-
-/**
- * Cooldown window after the breaker trips, during which auto-compaction is
- * suspended. Matches the legacy `COMPACTION_CIRCUIT_COOLDOWN_MS`.
- */
-export const COMPACTION_CIRCUIT_COOLDOWN_MS = 60 * 60 * 1000;
-
-/**
- * Default middleware for the `circuitBreaker` pipeline. A thin wrapper over the
- * state container passed in `CircuitBreakerArgs.state`:
- *
- * - `{ key }` — query. Defers to `next` for the current
- *   `{ open, cooldownRemainingMs? }`.
- * - `{ key, outcome }` — update state based on outcome, then defer to `next`
- *   for the post-update decision. A run of three failures trips the breaker;
- *   any non-failure outcome resets both the counter and the cooldown timestamp.
- *
- * Event emission preserves the existing `trackCompactionOutcome` behavior:
- * `compaction_circuit_open` fires once when the counter first reaches the
- * threshold while the circuit is dormant; `compaction_circuit_closed` fires
- * only on the open→closed transition.
- */
-const circuitBreaker: Middleware<CircuitBreakerArgs, CircuitBreakerResult> =
-  async function circuitBreaker(args, next) {
-    const { outcome, state, onEvent } = args;
-
-    // Update branch — mutate state first, then defer to the downstream
-    // chain (or terminal) for the decision so outer observers still see
-    // the fully-processed outcome. Separating state mutation from
-    // decision computation also keeps this middleware composable: an
-    // outer plugin may wrap the invocation to observe both the pre-update
-    // args and the post-update result.
-    if (outcome !== undefined) {
-      if (outcome === "failure") {
-        state.consecutiveCompactionFailures += 1;
-        // Treat a stale/expired open-until timestamp the same as null so
-        // a new 3-strike window can re-open the circuit after the prior
-        // cooldown elapses. Without this, subsequent trips would no-op
-        // because `compactionCircuitOpenUntil` remains set to a past
-        // timestamp even though the breaker is effectively closed.
-        const circuitDormant =
-          state.compactionCircuitOpenUntil === null ||
-          Date.now() >= state.compactionCircuitOpenUntil;
-        if (
-          state.consecutiveCompactionFailures >=
-            COMPACTION_CIRCUIT_FAILURE_THRESHOLD &&
-          circuitDormant
-        ) {
-          const openUntil = Date.now() + COMPACTION_CIRCUIT_COOLDOWN_MS;
-          state.compactionCircuitOpenUntil = openUntil;
-          if (onEvent) {
-            onEvent({
-              type: "compaction_circuit_open",
-              conversationId: state.conversationId,
-              reason: "3_consecutive_failures",
-              openUntil,
-            });
-          }
-        }
-      } else {
-        // Emit only on the open→closed transition; firing on the common
-        // closed→closed case would be noise.
-        const wasOpen = state.compactionCircuitOpenUntil !== null;
-        state.consecutiveCompactionFailures = 0;
-        state.compactionCircuitOpenUntil = null;
-        if (wasOpen && onEvent) {
-          onEvent({
-            type: "compaction_circuit_closed",
-            conversationId: state.conversationId,
-          });
-        }
-      }
-    }
-
-    // Defer to downstream (the terminal, in the default registration, but
-    // potentially another plugin in a customized chain) for the final
-    // decision. The terminal's implementation is the canonical read of
-    // the (now-updated) state container.
-    return next(args);
-  };
-
-export default circuitBreaker;

package/src/plugins/defaults/circuit-breaker/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "default-circuit-breaker",
-  "version": "1.0.0",
-  "description": "First-party default plugin wrapping the assistant's built-in circuit-breaker pipeline with a passthrough implementation.",
-  "private": true,
-  "license": "MIT",
-  "type": "module",
-  "main": "./register.ts",
-  "engines": {
-    "node": ">=20.12.0"
-  },
-  "peerDependencies": {
-    "@vellumai/plugin-api": "^0.8.0"
-  }
-}

package/src/plugins/defaults/circuit-breaker/register.ts

@@ -1,39 +0,0 @@
-/**
- * Default `circuitBreaker` plugin.
- *
- * Replicates the inline compaction circuit-breaker logic that previously
- * lived in `daemon/conversation-agent-loop.ts`: three consecutive summary-LLM
- * failures open the circuit for a one-hour cooldown, and any successful
- * compaction resets the counter.
- *
- * The plugin is a thin wrapper over the state container passed in
- * `CircuitBreakerArgs.state`. The {@link Conversation} owns the underlying
- * fields (`consecutiveCompactionFailures`, `compactionCircuitOpenUntil`)
- * because dev-only playground routes (`POST /playground/reset-compaction-circuit`,
- * `POST /playground/inject-compaction-failures`) read and mutate them
- * directly. Keeping ownership on the conversation lets this plugin stay a
- * pure wrapper while preserving those hatches.
- *
- * The `key` parameter is carried through for multi-circuit futures but the
- * default plugin currently bundles all circuit state into the `state`
- * container; the key is attached to the log record via the pipeline runner.
- */
-
-import { type Plugin } from "../../types.js";
-import circuitBreaker from "./middlewares/circuitBreaker.js";
-import pkg from "./package.json" with { type: "json" };
-
-/**
- * Default plugin registered at daemon startup. Consumers negotiate against
- * `circuitBreakerApi@v1` via the registry's capability table.
- */
-export const defaultCircuitBreakerPlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-
-  middleware: {
-    circuitBreaker,
-  },
-};

package/src/plugins/defaults/compaction/middlewares/compaction.ts

@@ -1,25 +0,0 @@
-import type {
-  CompactionArgs,
-  CompactionResult,
-  Middleware,
-} from "../../../types.js";
-
-/**
- * Passthrough middleware for the `compaction` pipeline. Forwards to
- * `next(args)` so any custom plugins layered outside still run; when this is
- * the only middleware, `next` is the terminal handler (`../terminal.ts`) and
- * returns the real compaction output.
- *
- * Defaults register at the OUTERMOST onion position, so deciding here without
- * calling `next` would shadow every later-registered plugin. Routing through
- * `next(args)` lets user middleware participate normally.
- */
-const defaultCompactionMiddleware: Middleware<
-  CompactionArgs,
-  CompactionResult
-> = async function defaultCompaction(args, next, ctx) {
-  void ctx;
-  return next(args);
-};
-
-export default defaultCompactionMiddleware;

package/src/plugins/defaults/compaction/register.ts

@@ -1,35 +0,0 @@
-/**
- * Default `compaction` plugin.
- *
- * The plugin's middleware is a passthrough — it calls `next(args)` and returns
- * the result unchanged. The actual compaction lives in the terminal handler in
- * `./terminal.ts`, which is wired in as the pipeline's `terminal` argument by
- * the `runPipeline` call site in `daemon/conversation-agent-loop.ts`. This
- * separation matters: the default plugin is registered before any user plugin
- * (defaults load first in `bootstrapPlugins()`), which puts it at the
- * OUTERMOST position of the onion chain. If the default middleware were to
- * invoke the terminal directly without calling `next`, it would shadow every
- * later-registered plugin. Routing through `next(args)` lets user middleware
- * participate normally.
- *
- * Design doc: `.private/plans/agent-plugin-system.md` (PR 25).
- */
-
-import { type Plugin } from "../../types.js";
-import defaultCompactionMiddleware from "./middlewares/compaction.js";
-import pkg from "./package.json" with { type: "json" };
-
-/**
- * Manifest + middleware wiring for the default compaction plugin. The
- * registration happens in `daemon/external-plugins-bootstrap.ts` before
- * {@link bootstrapPlugins} fires plugin `init()` hooks.
- */
-export const defaultCompactionPlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  middleware: {
-    compaction: defaultCompactionMiddleware,
-  },
-};

package/src/plugins/defaults/compaction/terminal.ts

@@ -1,73 +0,0 @@
-/**
- * Default `compaction` behavior: summarizes conversation history when the
- * context window fills up.
- *
- * This module is side-effect free: importing it does not register any plugin.
- *
- * Delegates to the orchestrator's existing {@link ContextWindowManager}
- * instance, read from `ctx.contextWindowManager` on the {@link TurnContext} as
- * a typed optional field. The orchestrator is responsible for attaching that
- * handle to the per-turn context. If the handle is missing, this throws a
- * {@link PluginExecutionError} so the bug surfaces with clear attribution
- * instead of a late `undefined.maybeCompact is not a function`.
- */
-
-import type {
-  ContextWindowCompactOptions,
-  ContextWindowManager,
-  ContextWindowResult,
-} from "../../../context/window-manager.js";
-import type { Message } from "../../../providers/types.js";
-import {
-  type CompactionArgs,
-  type CompactionResult,
-  PluginExecutionError,
-  type TurnContext,
-} from "../../types.js";
-
-/**
- * Name under which the default plugin registers. Exposed so tests and later
- * plugins can assert registration order or override the default via
- * composition.
- */
-export const DEFAULT_COMPACTION_PLUGIN_NAME = "default-compaction";
-
-/**
- * Read `contextWindowManager` off the turn context. Throws
- * {@link PluginExecutionError} when absent so the failure attributes cleanly
- * to the default plugin instead of manifesting as a later NPE.
- */
-function extractManager(ctx: TurnContext): ContextWindowManager {
-  const manager = ctx.contextWindowManager;
-  if (
-    manager == null ||
-    typeof manager !== "object" ||
-    typeof (manager as { maybeCompact?: unknown }).maybeCompact !== "function"
-  ) {
-    throw new PluginExecutionError(
-      "default-compaction: ctx.contextWindowManager is missing — orchestrator must attach it before invoking compaction",
-      DEFAULT_COMPACTION_PLUGIN_NAME,
-    );
-  }
-  return manager;
-}
-
-/**
- * Run compaction for the turn: reads the context window manager off the turn
- * context and returns the (possibly summarized) message history from
- * `maybeCompact`.
- */
-export async function defaultCompactionTerminal(
-  args: CompactionArgs,
-  ctx: TurnContext,
-): Promise<CompactionResult> {
-  const manager = extractManager(ctx);
-  const messages = args.messages as Message[];
-  const options = args.options as ContextWindowCompactOptions | undefined;
-  const result: ContextWindowResult = await manager.maybeCompact(
-    messages,
-    args.signal,
-    options,
-  );
-  return result;
-}

package/src/plugins/defaults/empty-response/register.ts

@@ -1,23 +0,0 @@
-/**
- * Default `empty-response` plugin.
- *
- * Contributes a `stop` hook that re-queries the model when a turn yields with
- * no tool calls but came back empty (or as a provider refusal). The decision
- * logic lives in `./hooks/stop.ts`. Defaults register before user plugins, so
- * this runs at the front of the `stop` hook chain.
- */
-
-import { type Plugin } from "../../types.js";
-import stop from "./hooks/stop.js";
-import pkg from "./package.json" with { type: "json" };
-
-/** Singleton plugin — the registry rejects duplicate registrations by name. */
-export const defaultEmptyResponsePlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  hooks: {
-    stop,
-  },
-};

package/src/plugins/defaults/history-repair/register.ts

@@ -1,24 +0,0 @@
-/**
- * Default `history-repair` plugin.
- *
- * Contributes a `user-prompt-submit` hook that normalizes the working message
- * history (tool-use/tool-result pairing, role alternation) before the agent
- * loop hands it to the provider. The repair implementation lives in
- * `./terminal.ts`; the hook in `./hooks/user-prompt-submit.ts` wires it into
- * the lifecycle. Defaults register before user plugins, so this normalization
- * runs at the front of the hook chain.
- */
-
-import { type Plugin } from "../../types.js";
-import userPromptSubmit from "./hooks/user-prompt-submit.js";
-import pkg from "./package.json" with { type: "json" };
-
-export const defaultHistoryRepairPlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  hooks: {
-    "user-prompt-submit": userPromptSubmit,
-  },
-};