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

package/src/gallery/gallery-manifest.ts

@@ -1,28 +0,0 @@
-export interface GalleryManifest {
-  version: number;
-  updatedAt: string;
-  categories: GalleryCategory[];
-  apps: GalleryApp[];
-}
-
-export interface GalleryCategory {
-  id: string; // e.g. "productivity", "health", "fun"
-  name: string; // Display name
-  icon: string; // Emoji
-}
-
-export interface GalleryApp {
-  id: string; // Unique identifier
-  name: string;
-  description: string;
-  icon: string; // Emoji
-  category: string; // Category ID
-  version: string; // e.g. "1.0.0"
-  featured?: boolean;
-  schemaJson: string; // JSON schema for app records
-  htmlDefinition: string; // Complete HTML app (also serves as compiled fallback)
-  /** 2 = multi-file TSX format with sourceFiles */
-  formatVersion?: number;
-  /** Maps relative path to file content, e.g. { "src/main.tsx": "...", "src/index.html": "..." } */
-  sourceFiles?: Record<string, string>;
-}

package/src/home/feature-gate.ts

@@ -1,22 +0,0 @@
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../config/schema.js";
-
-const HOME_PAGE_FLAG_KEY = "home-page" as const;
-
-/**
- * Whether the home page / home feed surface is enabled for this install.
- *
- * `home-page` is a `"both"`-scope flag: the client renders the home feed as the
- * landing view, and the notification pipeline uses it to decide whether passive
- * notifications have a home-feed surface to land on (when off, they fall back to
- * materializing a conversation instead of being suppressed).
- *
- * `config` is accepted for parity with the other gate modules but is unused —
- * the value resolves from the gateway override cache / registry default.
- */
-export function isHomePageEnabled(config?: AssistantConfig): boolean {
-  return isAssistantFeatureFlagEnabled(
-    HOME_PAGE_FLAG_KEY,
-    (config ?? {}) as AssistantConfig,
-  );
-}

package/src/memory/v3/provider-blocks.ts

@@ -1,16 +0,0 @@
-import type { ContentBlock } from "../../providers/types.js";
-
-/**
- * Text content block carrying an ephemeral `cache_control` breakpoint. Our
- * internal `TextContent` type omits the field (only the Anthropic provider
- * transforms it onto the wire), so we reach through a `Record` cast — this
- * keeps the core types provider-agnostic. Shared by the v3 router and selector,
- * whose STATIC numbered blocks are stable across turns and so cache well.
- */
-export function cachedTextBlock(text: string): ContentBlock {
-  const block: ContentBlock = { type: "text", text };
-  (block as unknown as Record<string, unknown>).cache_control = {
-    type: "ephemeral",
-  };
-  return block;
-}

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/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/middlewares/emptyResponse.ts

@@ -1,22 +0,0 @@
-import type {
-  EmptyResponseArgs,
-  EmptyResponseResult,
-  Middleware,
-} from "../../../types.js";
-
-/**
- * Passthrough middleware for the `emptyResponse` pipeline. Forwards to
- * `next(args)` unchanged; the actual empty-response decision lives in the
- * terminal handler (`../terminal.ts`), wired in at the `runPipeline` call site
- * in `agent/loop.ts`.
- *
- * 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 passthrough: Middleware<EmptyResponseArgs, EmptyResponseResult> = async (
-  args,
-  next,
-) => next(args);
-
-export default passthrough;

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

@@ -1,106 +0,0 @@
-/**
- * Default `emptyResponse` behavior: decides whether an empty assistant turn
- * should be nudged (re-queried) or accepted.
- *
- * This module is side-effect free: importing it does not register any plugin.
- *
- * The handler inspects the turn snapshot and returns one of:
- *
- * 1. `"nudge"`  — fired in two distinct shapes:
- *                 (a) **Post-tool empty.** The turn produced no visible text,
- *                     no tool calls, follows at least one prior tool-use turn,
- *                     no earlier turn in this run() has already delivered
- *                     visible text, AND the retry counter is below
- *                     `maxEmptyResponseRetries`. Uses `NUDGE_TEXT`.
- *                 (b) **Refusal stop.** The provider returned
- *                     `stopReason === "refusal"` with no visible text and no
- *                     tool calls (Anthropic's safety classifier). Nudges even
- *                     on turn 0 / before any tool use, because a refusal on
- *                     the first model call of the run is a hard guarantee
- *                     that no organic text exists yet — without intervening
- *                     we'd persist an empty assistant bubble to the user.
- *                     Uses the refusal-specific `REFUSAL_NUDGE_TEXT`. The
- *                     retry cap still applies; after `maxEmptyResponseRetries`
- *                     refusals in a row the terminal falls through to accept.
- *                 The loop appends the chosen `nudgeText` as a `user` turn
- *                 and re-queries the model.
- * 2. `"accept"` — every other case. The turn either legitimately ended
- *                 (model said its piece earlier), is still in progress
- *                 (tool calls pending), or exhausted its retry budget. The
- *                 loop pushes the assistant message and continues normally.
- *
- * The default never returns `"error"` — that action is an escape hatch for
- * downstream plugins (e.g. a circuit breaker) that want to surface an
- * explicit error instead of silently absorbing an empty turn.
- *
- * `MAX_EMPTY_RESPONSE_RETRIES` lives in `agent/loop.ts` and is passed in via
- * `EmptyResponseArgs.maxEmptyResponseRetries` so the cap is declared in one
- * place only.
- */
-
-import type { EmptyResponseArgs, EmptyResponseResult } from "../../types.js";
-
-/**
- * Canonical nudge text. Must stay verbatim so a plugin that wraps the
- * default cannot accidentally see a different string.
- *
- * Wire-compat note: this is shown to the LLM, not the user. Edits here
- * affect model behavior but not end-user UX directly.
- */
-const NUDGE_TEXT =
-  "<system_notice>Your previous response was empty. You must respond to the user with a summary of what you found or did. Do not use any tools — just respond with text.</system_notice>";
-
-/**
- * Refusal-specific nudge. Used when the provider stops with `"refusal"`
- * before any tool use — i.e. the safety classifier zeroed the response.
- * Kept distinct from `NUDGE_TEXT` so the model gets context-appropriate
- * guidance (no "summary of what you found or did" — there is no tool
- * trail to summarize on a turn-0 refusal).
- *
- * Wire-compat note: this is shown to the LLM, not the user. Edits here
- * affect retry behavior but not end-user UX directly.
- */
-export const REFUSAL_NUDGE_TEXT =
-  '<system_notice>Your previous response was empty because the upstream provider returned stop_reason="refusal". Please answer the user\'s last message directly with a plain-text response. Do not use any tools — just respond with text.</system_notice>';
-
-/**
- * Decide whether an empty turn should be nudged or accepted. Exported so the
- * agent loop can call it directly and tests can verify the decision logic.
- */
-export function defaultEmptyResponseTerminal(
-  args: EmptyResponseArgs,
-): EmptyResponseResult {
-  const hasVisibleText = args.responseContent.some(
-    (block) =>
-      block.type === "text" &&
-      typeof (block as { text?: unknown }).text === "string" &&
-      (block as { text: string }).text.trim().length > 0,
-  );
-
-  // Refusal stop with zero usable content — the provider's safety
-  // classifier zeroed the response. Nudge regardless of toolUseTurns or
-  // priorAssistantHadVisibleText: a `"refusal"` stop with no visible
-  // text and no tool calls IS the failure mode this branch exists to
-  // catch (otherwise we persist an empty assistant bubble to the user).
-  // Still respect the retry cap so a persistent classifier doesn't
-  // burn turns indefinitely.
-  const isRefusal =
-    args.stopReason === "refusal" &&
-    !hasVisibleText &&
-    args.toolUseBlocksLength === 0;
-
-  if (isRefusal && args.emptyResponseRetries < args.maxEmptyResponseRetries) {
-    return { action: "nudge", nudgeText: REFUSAL_NUDGE_TEXT };
-  }
-
-  const isEmptyTurn =
-    !hasVisibleText &&
-    args.toolUseBlocksLength === 0 &&
-    args.toolUseTurns > 0 &&
-    !args.priorAssistantHadVisibleText;
-
-  if (isEmptyTurn && args.emptyResponseRetries < args.maxEmptyResponseRetries) {
-    return { action: "nudge", nudgeText: NUDGE_TEXT };
-  }
-  return { action: "accept" };
-}

package/src/plugins/defaults/injectors/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "default-injectors",
-  "version": "1.0.0",
-  "description": "First-party default plugin wrapping the assistant's built-in injectors 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/llm-call/middlewares/llmCall.ts

@@ -1,17 +0,0 @@
-import type { LLMCallArgs, LLMCallResult, Middleware } from "../../../types.js";
-
-/**
- * Passthrough middleware for the `llmCall` pipeline. Forwards to `next(args)`
- * unchanged so any user-registered middleware (registered later, inner in the
- * onion) still runs and the terminal at the call site (`agent/loop.ts`)
- * performs the actual `provider.sendMessage(...)` call.
- *
- * Defaults register at the OUTERMOST onion position; forwarding
- * unconditionally keeps user-registered middleware reachable.
- */
-const defaultLlmCall: Middleware<LLMCallArgs, LLMCallResult> =
-  async function defaultLlmCall(args, next, _ctx) {
-    return next(args);
-  };
-
-export default defaultLlmCall;

package/src/plugins/defaults/llm-call/register.ts

@@ -1,45 +0,0 @@
-/**
- * Default `llmCall` plugin — a passthrough that declares the pipeline
- * surface and yields to downstream middleware.
- *
- * The plugin system wraps every LLM request in the `llmCall` pipeline. The
- * actual call to {@link Provider.sendMessage} lives in the `runPipeline`
- * terminal at the call site (`agent/loop.ts`); this default's only job is to
- * contribute the manifest (`provides.llmCall: "v1"`) so other plugins can
- * negotiate against the pipeline surface.
- *
- * This plugin registers at module load — before user plugins are loaded by
- * `bootstrapPlugins()` — so it sits at the outermost layer in
- * `composeMiddleware`'s onion ordering. To keep user-registered middleware
- * reachable, the middleware forwards unconditionally via `next(args)`.
- *
- * Registered from `daemon/external-plugins-bootstrap.ts` via a side-effect
- * import so the plugin is present in the registry before
- * {@link bootstrapPlugins} walks it.
- *
- * Design doc: `.private/plans/agent-plugin-system.md` (PR 15).
- */
-
-import { type Plugin } from "../../types.js";
-import llmCall from "./middlewares/llmCall.js";
-import pkg from "./package.json" with { type: "json" };
-
-/**
- * The default LLM-call plugin. Its `llmCall` middleware is a passthrough that
- * forwards to `next(args)` unchanged so any user-registered middleware
- * (registered later, inner in the onion) still runs and the terminal at the
- * call site performs the actual `provider.sendMessage(...)` call.
- *
- * Manifest declares `provides.llmCall: "v1"` so other plugins can negotiate
- * against the pipeline surface and `requires.pluginRuntime: "v1"` to satisfy
- * the registry's mandatory capability check.
- */
-export const defaultLlmCallPlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  middleware: {
-    llmCall,
-  },
-};

package/src/plugins/defaults/memory-retrieval/middlewares/memoryRetrieval.ts

@@ -1,17 +0,0 @@
-import type { MemoryArgs, MemoryResult, Middleware } from "../../../types.js";
-
-/**
- * Passthrough middleware for the `memoryRetrieval` pipeline.
- *
- * Keeping a real middleware registered (rather than an empty list) makes the
- * pipeline observable in `plugin.pipeline` logs with a non-empty `chain` field
- * and lets third-party plugins rely on the default slot being present even
- * when nothing is overriding it. The work happens in the terminal supplied by
- * the agent loop, which calls `runDefaultMemoryRetrieval`.
- */
-const defaultMemoryRetrievalMiddleware: Middleware<MemoryArgs, MemoryResult> =
-  async function defaultMemoryRetrieval(args, next) {
-    return next(args);
-  };
-
-export default defaultMemoryRetrievalMiddleware;

package/src/plugins/defaults/memory-retrieval/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "default-memory-retrieval",
-  "version": "0.0.1",
-  "description": "First-party default plugin wrapping the assistant's built-in memory-retrieval 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"
-  }
-}