@vellumai/assistant 0.8.12-staging.1 → 0.8.12

package/src/providers/model-catalog.ts

@@ -691,6 +691,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           outputPer1mTokens: 2.5,
         },
       },
+      {
+        id: "accounts/fireworks/models/minimax-m3",
+        displayName: "MiniMax M3",
+        // The model supports 1M context, but Fireworks serves it with a
+        // 512K (524,288-token) window; advertise the served limit.
+        contextWindowTokens: 524288,
+        maxOutputTokens: 512000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        maxEffort: "high",
+        pricing: {
+          inputPer1mTokens: 0.3,
+          outputPer1mTokens: 1.2,
+          cacheReadPer1mTokens: 0.06,
+        },
+      },
       {
         id: "accounts/fireworks/models/minimax-m2p7",
         displayName: "MiniMax M2.7",
@@ -1241,6 +1259,16 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open MiniMax Dashboard",
     },
     models: [
+      {
+        id: "MiniMax-M3",
+        displayName: "MiniMax M3",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 512000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+      },
       {
         id: "MiniMax-M2.7",
         displayName: "MiniMax M2.7",

package/src/providers/model-intents.ts

@@ -35,7 +35,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
     "vision-optimized": "llama3.2",
   },
   fireworks: {
-    balanced: "accounts/fireworks/models/kimi-k2p6",
+    balanced: "accounts/fireworks/models/minimax-m3",
     "latency-optimized": "accounts/fireworks/models/kimi-k2p5",
     "quality-optimized": "accounts/fireworks/models/kimi-k2p6",
     "vision-optimized": "accounts/fireworks/models/kimi-k2p6",

package/src/providers/openai/chat-completions-provider.ts

@@ -18,6 +18,7 @@ import {
   ContextOverflowError,
   extractOverflowTokensFromMessage,
 } from "../types.js";
+import { wrapUnparseableToolArgs } from "../unparseable-tool-args.js";
 
 /**
  * Detect OpenAI-compatible context-overflow signals on an `OpenAI.APIError`.
@@ -635,7 +636,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
         try {
           input = JSON.parse(tc.args);
         } catch {
-          input = { _raw: tc.args };
+          input = wrapUnparseableToolArgs(tc.args);
         }
         content.push({
           type: "tool_use",

package/src/providers/openai/responses-provider.ts

@@ -15,6 +15,7 @@ import type {
   SendMessageOptions,
 } from "../types.js";
 import { ContextOverflowError } from "../types.js";
+import { wrapUnparseableToolArgs } from "../unparseable-tool-args.js";
 import { detectOpenAICompatibleContextOverflow } from "./chat-completions-provider.js";
 
 const log = getLogger("openai-responses");
@@ -465,7 +466,7 @@ export class OpenAIResponsesProvider implements Provider {
         try {
           input = JSON.parse(tc.args);
         } catch {
-          input = { _raw: tc.args };
+          input = wrapUnparseableToolArgs(tc.args);
         }
         content.push({
           type: "tool_use",

package/src/providers/unparseable-tool-args.ts

@@ -0,0 +1,56 @@
+/**
+ * Marker shape for tool-call arguments that failed JSON parsing.
+ *
+ * Streaming providers accumulate tool-call argument deltas as a string and
+ * parse the result once the stream completes. Some models/gateways emit
+ * truncated or malformed argument JSON (e.g. MiniMax M3 via OpenRouter cutting
+ * the stream mid-object). The provider cannot drop the tool_use block — the
+ * protocol requires a paired tool_result for every tool_use id — so it wraps
+ * the raw string under this marker key instead.
+ *
+ * The tool execution layer detects the marker and rejects the invocation with
+ * an error tool result, so the model sees the failure and can retry, instead
+ * of a tool executing with garbage input.
+ */
+const UNPARSEABLE_TOOL_ARGS_KEY = "_raw";
+
+/** Wrap raw, unparseable tool-call argument text in the marker shape. */
+export function wrapUnparseableToolArgs(raw: string): Record<string, unknown> {
+  return { [UNPARSEABLE_TOOL_ARGS_KEY]: raw };
+}
+
+/**
+ * Detect input produced by {@link wrapUnparseableToolArgs}: exactly one key,
+ * the marker key, holding the raw argument string. The exact-shape check
+ * avoids false positives on hypothetical legitimate inputs that merely
+ * contain a `_raw` field among others.
+ */
+export function isUnparseableToolArgs(
+  input: Record<string, unknown>,
+): input is { _raw: string } {
+  const keys = Object.keys(input);
+  return (
+    keys.length === 1 &&
+    keys[0] === UNPARSEABLE_TOOL_ARGS_KEY &&
+    typeof input[UNPARSEABLE_TOOL_ARGS_KEY] === "string"
+  );
+}
+
+/**
+ * Build the error message returned to the model when it sends unparseable
+ * tool arguments. Includes a bounded prefix of what was received so the model
+ * can see where its output was cut off or malformed.
+ */
+export function unparseableToolArgsMessage(
+  toolName: string,
+  raw: string,
+): string {
+  const PREVIEW_LIMIT = 200;
+  const preview =
+    raw.length > PREVIEW_LIMIT ? `${raw.slice(0, PREVIEW_LIMIT)}…` : raw;
+  return (
+    `Error: the arguments for "${toolName}" were not valid JSON — the argument stream was malformed or truncated, so the tool was NOT executed. ` +
+    `Received: ${preview || "(empty)"}\n` +
+    `Retry the call with complete, valid JSON arguments.`
+  );
+}

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

@@ -175,6 +175,26 @@ function seedRequestLog(
     .run();
 }
 
+function seedRequestLogWithSections(messageId: string, id: string): void {
+  getDb()
+    .insert(llmRequestLogs)
+    .values({
+      id,
+      conversationId: "conv-1",
+      messageId,
+      provider: "openai",
+      requestPayload: JSON.stringify({
+        model: "gpt-4.1",
+        messages: [{ role: "user", content: "hello" }],
+      }),
+      responsePayload: JSON.stringify({
+        choices: [{ message: { content: "hi" } }],
+      }),
+      createdAt: 1_700_000_000_000,
+    })
+    .run();
+}
+
 function seedConversationKey(
   conversationKey: string,
   conversationId: string,
@@ -274,6 +294,118 @@ describe("GET /v1/conversations/llm-context", () => {
   });
 });
 
+describe("llm-context view=summary", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  function seedConversationWithLog(): void {
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId: "msg-1",
+      source: "user",
+      conversationType: "standard",
+    });
+    seedConversationKey("conv-key", "conv-1");
+    seedRequestLogWithSections("msg-1", "log-a");
+  }
+
+  test("conversation endpoint omits sections in summary view but keeps summary fields", async () => {
+    seedConversationWithLog();
+
+    const body = (await dispatchConversationLlmContext({
+      conversationKey: "conv-key",
+      view: "summary",
+    })) as {
+      logs: Array<Record<string, unknown>>;
+    };
+
+    expect(body.logs).toHaveLength(1);
+    const log = body.logs[0]!;
+    expect(log.requestSections).toBeUndefined();
+    expect(log.responseSections).toBeUndefined();
+    expect(log.id).toBe("log-a");
+    expect(log.summary).toBeDefined();
+  });
+
+  test("conversation endpoint includes sections by default", async () => {
+    seedConversationWithLog();
+
+    const body = (await dispatchConversationLlmContext({
+      conversationKey: "conv-key",
+    })) as {
+      logs: Array<Record<string, unknown>>;
+    };
+
+    expect(Array.isArray(body.logs[0]!.requestSections)).toBe(true);
+    expect(Array.isArray(body.logs[0]!.responseSections)).toBe(true);
+  });
+
+  test("message endpoint omits sections in summary view", async () => {
+    seedConversationWithLog();
+
+    const body = (await llmContextRoute.handler({
+      pathParams: { id: "msg-1" },
+      queryParams: { view: "summary" },
+    })) as {
+      logs: Array<Record<string, unknown>>;
+    };
+
+    expect(body.logs).toHaveLength(1);
+    expect(body.logs[0]!.requestSections).toBeUndefined();
+    expect(body.logs[0]!.responseSections).toBeUndefined();
+    expect(body.logs[0]!.summary).toBeDefined();
+  });
+
+  test("rejects unknown view values", async () => {
+    seedConversationWithLog();
+
+    expect(
+      dispatchConversationLlmContext({
+        conversationKey: "conv-key",
+        view: "compact",
+      }),
+    ).rejects.toThrow("Invalid view parameter");
+  });
+});
+
+describe("GET /v1/llm-request-logs/:id/context", () => {
+  const logContextRoute = ROUTES.find(
+    (r) => r.operationId === "llm_request_logs_context_get",
+  )!;
+
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("returns the normalized entry with sections for a single log", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId: "msg-1",
+      source: "user",
+      conversationType: "standard",
+    });
+    seedRequestLogWithSections("msg-1", "log-detail");
+
+    const body = (await logContextRoute.handler({
+      pathParams: { id: "log-detail" },
+    })) as Record<string, unknown>;
+
+    expect(body.id).toBe("log-detail");
+    expect(body.requestPayload).toBeNull();
+    expect(body.responsePayload).toBeNull();
+    expect(body.summary).toBeDefined();
+    expect(Array.isArray(body.requestSections)).toBe(true);
+    expect(Array.isArray(body.responseSections)).toBe(true);
+  });
+
+  test("throws NotFound for a missing log id", async () => {
+    expect(
+      logContextRoute.handler({ pathParams: { id: "log-missing" } }),
+    ).rejects.toThrow("log not found");
+  });
+});
+
 describe("GET /v1/messages/:id/llm-context — memoryV2Activation", () => {
   beforeEach(() => {
     clearTables();

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -34,6 +34,12 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import {
+  type InspectPluginDeps,
+  type InspectPluginOptions,
+  type PluginInspection,
+  PluginInspectNotFoundError,
+} from "../../../cli/lib/inspect-plugin.js";
 import {
   type InstallPluginOptions,
   type InstallPluginResult,
@@ -59,6 +65,12 @@ import {
   type UninstallPluginOptions,
   type UninstallPluginResult,
 } from "../../../cli/lib/uninstall-plugin.js";
+import {
+  PluginNotUpgradableError,
+  type PluginUpgradeResult,
+  type UpgradePluginDeps,
+  type UpgradePluginOptions,
+} from "../../../cli/lib/upgrade-plugin.js";
 
 // Mutable list returned by the mocked library function. Tests reassign
 // `installedFixture` before invoking the handler.
@@ -133,6 +145,38 @@ mock.module("../../../cli/lib/plugin-details.js", () => ({
   getPluginDetails: detailsSpy,
 }));
 
+// Mock inspectPlugin: the lib computes the local-vs-remote drift (covered by
+// inspect-plugin.test.ts); the route only forwards the name and maps errors.
+const inspectSpy = mock(
+  async (
+    _opts: InspectPluginOptions,
+    _deps: InspectPluginDeps,
+  ): Promise<PluginInspection> => {
+    throw new Error("inspectSpy default impl not configured");
+  },
+);
+
+mock.module("../../../cli/lib/inspect-plugin.js", () => ({
+  PluginInspectNotFoundError,
+  inspectPlugin: inspectSpy,
+}));
+
+// Mock upgradePlugin: the lib performs the re-pin (covered by
+// upgrade-plugin.test.ts); the route projects its result and maps errors.
+const upgradeSpy = mock(
+  async (
+    _opts: UpgradePluginOptions,
+    _deps: UpgradePluginDeps,
+  ): Promise<PluginUpgradeResult> => {
+    throw new Error("upgradeSpy default impl not configured");
+  },
+);
+
+mock.module("../../../cli/lib/upgrade-plugin.js", () => ({
+  PluginNotUpgradableError,
+  upgradePlugin: upgradeSpy,
+}));
+
 import {
   BadRequestError,
   ConflictError,
@@ -154,6 +198,8 @@ const searchHandler = findHandler("plugins_search");
 const uninstallHandler = findHandler("plugins_uninstall");
 const getHandler = findHandler("plugins_get");
 const installHandler = findHandler("plugins_install");
+const inspectHandler = findHandler("plugins_inspect");
+const upgradeHandler = findHandler("plugins_upgrade");
 
 function invoke(args: RouteHandlerArgs = {}): {
   plugins: Array<Record<string, unknown>>;
@@ -881,3 +927,304 @@ describe("POST /v1/plugins/install", () => {
     expect((caught as Error).message).toContain("ECONNRESET");
   });
 });
+
+function inspection(
+  overrides: Partial<PluginInspection> = {},
+): PluginInspection {
+  return {
+    name: overrides.name ?? "level-up",
+    installed: overrides.installed ?? true,
+    status: overrides.status ?? "update-available",
+    local:
+      overrides.local === undefined
+        ? {
+            target: "/workspace/.vellum/plugins/level-up",
+            commit: "60a392b0000000000000000000000000000000aa",
+            version: "0.1.0",
+            description: "Surfaces a Level Up diff card.",
+            installedAt: "2026-06-08T00:00:00.000Z",
+            source: {
+              kind: "github",
+              owner: "vellum-ai",
+              repo: "level-up",
+              ref: "60a392b0000000000000000000000000000000aa",
+            },
+            localChanges: {
+              modified: [],
+              added: [],
+              removed: [],
+              clean: true,
+            },
+            issues: [],
+          }
+        : overrides.local,
+    remote:
+      overrides.remote === undefined
+        ? {
+            repo: "vellum-ai/level-up",
+            path: "",
+            commit: "3eae1820000000000000000000000000000000bb",
+            description: "Surfaces a Level Up diff card.",
+            homepage: "https://github.com/vellum-ai/level-up",
+            license: "MIT",
+            category: null,
+            marketplaceRef: "main",
+          }
+        : overrides.remote,
+    remoteError: overrides.remoteError ?? null,
+  };
+}
+
+async function invokeInspect(
+  args: RouteHandlerArgs = {},
+): Promise<PluginInspection> {
+  return (await inspectHandler(args)) as PluginInspection;
+}
+
+describe("GET /v1/plugins/:name/inspect", () => {
+  beforeEach(() => {
+    inspectSpy.mockReset();
+  });
+
+  test("forwards the name to inspectPlugin and returns the drift verbatim", async () => {
+    // GIVEN inspectPlugin reports an available update for an installed plugin
+    const view = inspection({ status: "update-available" });
+    inspectSpy.mockImplementation(async () => view);
+
+    // WHEN the route handler is invoked with the path name
+    const result = await invokeInspect({ pathParams: { name: "level-up" } });
+
+    // THEN the inspection is returned unchanged
+    expect(result).toEqual(view);
+    // AND the name is forwarded to the lib (ref is never caller-supplied)
+    expect(inspectSpy.mock.calls[0]?.[0]).toEqual({ name: "level-up" });
+  });
+
+  test("a captured marketplace error is returned as 200 with remote-unavailable, not thrown", async () => {
+    // GIVEN the catalog was unreachable but a local copy exists, so the lib
+    // returns a status rather than throwing
+    const view = inspection({
+      status: "remote-unavailable",
+      remote: null,
+      remoteError: "ENOTFOUND raw.githubusercontent.com",
+    });
+    inspectSpy.mockImplementation(async () => view);
+
+    // WHEN the handler runs
+    const result = await invokeInspect({ pathParams: { name: "level-up" } });
+
+    // THEN it resolves (does not throw) and surfaces the captured error
+    expect(result.status).toBe("remote-unavailable");
+    expect(result.remoteError).toContain("ENOTFOUND");
+  });
+
+  test("InvalidPluginNameError → BadRequestError (400)", async () => {
+    inspectSpy.mockImplementation(async () => {
+      throw new InvalidPluginNameError("../escape");
+    });
+
+    await expect(
+      invokeInspect({ pathParams: { name: "../escape" } }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
+  test("PluginInspectNotFoundError → NotFoundError (404)", async () => {
+    inspectSpy.mockImplementation(async () => {
+      throw new PluginInspectNotFoundError("ghost");
+    });
+
+    await expect(
+      invokeInspect({ pathParams: { name: "ghost" } }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("unknown errors → InternalError with original message preserved", async () => {
+    inspectSpy.mockImplementation(async () => {
+      throw new Error("EUNEXPECTED");
+    });
+
+    let caught: unknown;
+    try {
+      await invokeInspect({ pathParams: { name: "level-up" } });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(InternalError);
+    expect((caught as Error).message).toContain("EUNEXPECTED");
+  });
+});
+
+function upgradeResult(
+  overrides: Partial<PluginUpgradeResult> = {},
+): PluginUpgradeResult {
+  return {
+    name: overrides.name ?? "level-up",
+    outcome: overrides.outcome ?? "upgraded",
+    fromCommit:
+      overrides.fromCommit === undefined
+        ? "60a392b0000000000000000000000000000000aa"
+        : overrides.fromCommit,
+    toCommit: overrides.toCommit ?? "3eae1820000000000000000000000000000000bb",
+    target: overrides.target ?? "/workspace/.vellum/plugins/level-up",
+    fileCount: overrides.fileCount === undefined ? 12 : overrides.fileCount,
+    dryRun: overrides.dryRun ?? false,
+    provenanceWasUnknown: overrides.provenanceWasUnknown ?? false,
+  };
+}
+
+async function invokeUpgrade(args: RouteHandlerArgs = {}): Promise<{
+  name: string;
+  outcome: string;
+  fromCommit: string | null;
+  toCommit: string;
+  target: string;
+  fileCount: number | null;
+  dryRun: boolean;
+  provenanceWasUnknown: boolean;
+}> {
+  return (await upgradeHandler(args)) as {
+    name: string;
+    outcome: string;
+    fromCommit: string | null;
+    toCommit: string;
+    target: string;
+    fileCount: number | null;
+    dryRun: boolean;
+    provenanceWasUnknown: boolean;
+  };
+}
+
+describe("POST /v1/plugins/:name/upgrade", () => {
+  beforeEach(() => {
+    upgradeSpy.mockReset();
+  });
+
+  test("forwards name + dryRun and projects the upgrade result", async () => {
+    // GIVEN upgradePlugin reports a successful re-pin
+    upgradeSpy.mockImplementation(async () => upgradeResult());
+
+    // WHEN the handler runs with an explicit dryRun flag
+    const result = await invokeUpgrade({
+      pathParams: { name: "level-up" },
+      body: { dryRun: false },
+    });
+
+    // THEN the result is projected onto the wire shape
+    expect(result).toEqual({
+      name: "level-up",
+      outcome: "upgraded",
+      fromCommit: "60a392b0000000000000000000000000000000aa",
+      toCommit: "3eae1820000000000000000000000000000000bb",
+      target: "/workspace/.vellum/plugins/level-up",
+      fileCount: 12,
+      dryRun: false,
+      provenanceWasUnknown: false,
+    });
+    // AND the name + dryRun are forwarded to the lib
+    expect(upgradeSpy.mock.calls[0]?.[0]).toEqual({
+      name: "level-up",
+      dryRun: false,
+    });
+  });
+
+  test("omits dryRun (passes undefined) when the body flag is absent", async () => {
+    // GIVEN a no-op upgrade where the install already matches the pin
+    upgradeSpy.mockImplementation(async () =>
+      upgradeResult({
+        outcome: "already-up-to-date",
+        toCommit: "60a392b0000000000000000000000000000000aa",
+        fileCount: null,
+      }),
+    );
+
+    // WHEN invoked without a body
+    const result = await invokeUpgrade({ pathParams: { name: "level-up" } });
+
+    // THEN the no-op outcome is surfaced
+    expect(result.outcome).toBe("already-up-to-date");
+    expect(result.fileCount).toBeNull();
+    // AND dryRun is passed through as undefined (not coerced to false)
+    expect(upgradeSpy.mock.calls[0]?.[0]).toEqual({
+      name: "level-up",
+      dryRun: undefined,
+    });
+  });
+
+  test("InvalidPluginNameError → BadRequestError (400)", async () => {
+    upgradeSpy.mockImplementation(async () => {
+      throw new InvalidPluginNameError("../escape");
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "../escape" } }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
+  test("PluginNotInstalledError → NotFoundError (404)", async () => {
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginNotInstalledError(
+        "ghost",
+        "/workspace/.vellum/plugins/ghost",
+      );
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "ghost" } }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("PluginNotUpgradableError → ConflictError (409)", async () => {
+    // The install exists but has no marketplace entry to advance to: a
+    // well-formed request that isn't actionable in the current state.
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginNotUpgradableError(
+        "level-up",
+        "it has no marketplace entry to upgrade from",
+      );
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "level-up" } }),
+    ).rejects.toBeInstanceOf(ConflictError);
+  });
+
+  test("PluginNotFoundError → NotFoundError (404)", async () => {
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginNotFoundError("level-up", "main", "vellum-ai/level-up");
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "level-up" } }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  test("PluginSourceUnavailableError → ServiceUnavailableError (503)", async () => {
+    // The re-install fetch can hit a rate-limited GitHub; that is retryable,
+    // so surface 503 rather than a misleading 500.
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginSourceUnavailableError(
+        "GitHub tree listing for vellum-ai/level-up: HTTP 403",
+        403,
+      );
+    });
+
+    await expect(
+      invokeUpgrade({ pathParams: { name: "level-up" } }),
+    ).rejects.toBeInstanceOf(ServiceUnavailableError);
+  });
+
+  test("unknown errors → InternalError with original message preserved", async () => {
+    upgradeSpy.mockImplementation(async () => {
+      throw new Error("ECONNRESET");
+    });
+
+    let caught: unknown;
+    try {
+      await invokeUpgrade({ pathParams: { name: "level-up" } });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(InternalError);
+    expect((caught as Error).message).toContain("ECONNRESET");
+  });
+});