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

package/src/plugins/defaults/tool-error/middlewares/toolError.ts

@@ -1,21 +0,0 @@
-import type {
-  Middleware,
-  ToolErrorArgs,
-  ToolErrorDecision,
-} from "../../../types.js";
-
-/**
- * Passthrough middleware for the `toolError` pipeline. Forwards to `next(args)`
- * so later-registered user plugins still participate in the onion chain; the
- * actual nudge-decision logic lives in the terminal handler (`../terminal.ts`),
- * wired in at the `runPipeline` call site in `agent/loop.ts`.
- *
- * Named explicitly so the pipeline's structured log record carries
- * `"defaultToolErrorMiddleware"` in `chain` instead of an anonymous entry.
- */
-const defaultToolErrorMiddleware: Middleware<ToolErrorArgs, ToolErrorDecision> =
-  async function defaultToolErrorMiddleware(args, next) {
-    return next(args);
-  };
-
-export default defaultToolErrorMiddleware;

package/src/plugins/defaults/tool-error/terminal.ts

@@ -1,47 +0,0 @@
-/**
- * Default `toolError` behavior: decides whether to nudge the LLM after a tool
- * call fails.
- *
- * This module is side-effect free: importing it does not register any plugin.
- *
- * The canonical nudge decision: when the current turn produced at least one
- * failed tool result, append a system-notice block to the tool results that
- * coaches the LLM to either retry with corrected parameters (for recoverable
- * errors) or report the failure to the user (for unrecoverable ones). Once
- * the consecutive-error-turn counter exceeds the caller-supplied cap, the
- * nudge is skipped — the error is likely not something the LLM can fix on
- * its own and continuing to nudge only burns tokens.
- */
-
-import type { ToolErrorArgs, ToolErrorDecision } from "../../types.js";
-
-/**
- * Canonical nudge text. Kept as a module-level constant so tests and future
- * plugins can match it without duplicating the string.
- */
-export const DEFAULT_TOOL_ERROR_NUDGE_TEXT =
-  "<system_notice>One or more tool calls returned an error. If the error looks recoverable (e.g. missing or invalid parameters), fix the parameters and retry. If the error is clearly unrecoverable (e.g. a service is down, a resource does not exist, or a permission is permanently denied), report it to the user.</system_notice>";
-
-/**
- * Nudge iff the current turn had an error AND the consecutive-error counter is
- * within the cap. Once the cap is breached the caller should stop appending
- * the nudge (the error is likely unrecoverable and the LLM already had
- * multiple attempts to correct it).
- *
- * Exported so the agent loop can call it directly and tests can verify the
- * decision logic.
- */
-export const defaultToolErrorTerminal = async (
-  args: ToolErrorArgs,
-): Promise<ToolErrorDecision> => {
-  if (
-    args.hasToolError &&
-    args.consecutiveErrorTurns <= args.maxConsecutiveErrorNudges
-  ) {
-    return {
-      action: "nudge",
-      nudgeText: DEFAULT_TOOL_ERROR_NUDGE_TEXT,
-    };
-  }
-  return { action: "skip" };
-};

package/src/plugins/defaults/tool-execute/middlewares/toolExecute.ts

@@ -1,23 +0,0 @@
-import type {
-  Middleware,
-  ToolExecuteArgs,
-  ToolExecuteResult,
-} from "../../../types.js";
-
-/**
- * Passthrough middleware for the `toolExecute` pipeline. Forwards to
- * `next(args)` and returns the downstream result unchanged. The original
- * `ToolExecutor.execute` behavior runs in the terminal bound at the call site,
- * so this default makes the pipeline shape explicit without introducing any
- * behavior of its own: the chain `[defaultMiddleware] → terminal` composes
- * identically to `[] → terminal`.
- *
- * Named so the pipeline runner's `chain` log entry reads `defaultToolExecute`
- * instead of `anonymous`.
- */
-const defaultToolExecute: Middleware<ToolExecuteArgs, ToolExecuteResult> =
-  async function defaultToolExecute(args, next) {
-    return next(args);
-  };
-
-export default defaultToolExecute;

package/src/plugins/defaults/tool-execute/package.json

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

@@ -1,49 +0,0 @@
-/**
- * Default `toolExecute` plugin — a no-argument passthrough that preserves
- * the behavior `ToolExecutor.execute` had before the pipeline wrapper was
- * introduced.
- *
- * Design
- * ------
- * The public {@link ToolExecutor.execute} method invokes
- * {@link runPipeline} with the terminal bound to an internal
- * `executeInternal` method (the original execute body, refactored to avoid
- * recursion). Because the terminal IS the original behavior, the default
- * plugin's `middleware.toolExecute` is a thin passthrough: it forwards to
- * `next(args)` and returns the downstream result unchanged.
- *
- * This matches the convention set by PR 15 (`default-llm-call.ts`) for
- * `llmCall` — the default plugin makes the pipeline shape explicit without
- * introducing any behavior of its own. When no third-party plugins are
- * registered the chain is `[defaultMiddleware] → terminal`, which composes
- * identically to `[] → terminal`, so the shell-integration tests (which
- * never register the default) stay unchanged-green.
- *
- * Why a dedicated plugin at all?
- * ------------------------------
- * - It signals publicly that `toolExecute` is a supported pipeline slot with
- *   a concrete contract.
- * - Registration order determines onion order. If a third-party plugin
- *   wraps `toolExecute`, the runtime should boot with the default present
- *   (as the innermost passthrough) so the chain visibly contains a
- *   canonical terminator regardless of which third parties load.
- */
-
-import { type Plugin } from "../../types.js";
-import defaultToolExecute from "./middlewares/toolExecute.js";
-import pkg from "./package.json" with { type: "json" };
-
-/**
- * The default `toolExecute` plugin. Exported as a module constant that the
- * defaults aggregator registers centrally; tests may register it explicitly to
- * cover the on-by-default execution path.
- */
-export const defaultToolExecutePlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  middleware: {
-    toolExecute: defaultToolExecute,
-  },
-};

package/src/plugins/defaults/tool-result-truncate/middlewares/toolResultTruncate.ts

@@ -1,23 +0,0 @@
-import type { Middleware } from "../../../types.js";
-import type {
-  ToolResultTruncateArgs,
-  ToolResultTruncateResult,
-} from "../types.js";
-
-/**
- * Passthrough middleware for the `toolResultTruncate` pipeline. Forwards to
- * `next(args)` unchanged; the actual truncation 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 (including
- * hot-reloaded ones). Routing through `next(args)` lets user middleware
- * participate normally.
- */
-const passthrough: Middleware<
-  ToolResultTruncateArgs,
-  ToolResultTruncateResult
-> = async (args, next) => next(args);
-
-export default passthrough;

package/src/plugins/defaults/tool-result-truncate/types.ts

@@ -1,22 +0,0 @@
-/**
- * Argument and result shapes for the default `toolResultTruncate` behavior.
- */
-
-/**
- * Input to tool-result truncation: the raw tool-result text and the character
- * budget the caller computed from the context-window share.
- */
-export type ToolResultTruncateArgs = {
-  readonly content: string;
-  readonly maxChars: number;
-};
-
-/**
- * Output of tool-result truncation: the (possibly truncated) content and a
- * boolean indicating whether the input was actually shortened. Callers use
- * `truncated` for telemetry / warnings.
- */
-export type ToolResultTruncateResult = {
-  readonly content: string;
-  readonly truncated: boolean;
-};

package/src/skills/category-inference.ts

@@ -1,111 +0,0 @@
-/**
- * Skill category inference — ports the Swift `inferCategory` logic from
- * `ConstellationView.swift` to TypeScript for server-side use.
- *
- * Pure function with no side effects or external dependencies.
- */
-
-export type SkillCategory =
-  | "communication"
-  | "productivity"
-  | "development"
-  | "media"
-  | "automation"
-  | "webSocial"
-  | "knowledge"
-  | "integration";
-
-const CATEGORY_KEYWORDS: [SkillCategory, string[]][] = [
-  [
-    "communication",
-    [
-      "email",
-      "message",
-      "messaging",
-      "chat",
-      "phone",
-      "phone call",
-      "voice call",
-      "video call",
-      "contact",
-      "notification",
-      "followup",
-      "slack",
-      "telegram",
-    ],
-  ],
-  [
-    "productivity",
-    [
-      "task",
-      "calendar",
-      "reminder",
-      "schedule",
-      "document",
-      "playbook",
-      "notion",
-    ],
-  ],
-  [
-    "development",
-    [
-      "code",
-      "app builder",
-      "github",
-      "developer",
-      "programming",
-      "debug",
-      "typescript",
-      "frontend",
-      "subagent",
-      "api mapping",
-      "cli discovery",
-    ],
-  ],
-  ["automation", ["browser", "computer use", "macos", "watcher", "automat"]],
-  [
-    "media",
-    ["image", "screen", "media", "transcri", "video", "audio", "recording"],
-  ],
-  [
-    "webSocial",
-    [
-      "x.com",
-      "twitter",
-      "public ingress",
-      "influencer",
-      "doordash",
-      "amazon",
-      "restaurant",
-    ],
-  ],
-  [
-    "knowledge",
-    [
-      "knowledge",
-      "weather",
-      "start the day",
-      "skills catalog",
-      "self upgrade",
-      "briefing",
-    ],
-  ],
-  ["integration", ["oauth", "setup", "configure", "connect", "webhook"]],
-];
-
-export function inferCategory(
-  name: string,
-  description: string,
-): SkillCategory {
-  const combined = `${name} ${description}`.toLowerCase();
-
-  for (const [category, keywords] of CATEGORY_KEYWORDS) {
-    for (const keyword of keywords) {
-      if (combined.includes(keyword)) {
-        return category;
-      }
-    }
-  }
-
-  return "knowledge";
-}