veryfront 0.1.210 → 0.1.212

package/esm/src/agent/runtime/index.js

@@ -34,7 +34,7 @@ export { executeConfiguredTool, getAvailableTools, isDynamicTool, parseToolArgs,
 export { accumulateUsage, getMaxSteps, normalizeInput } from "./input-utils.js";
 export { createStreamState, processStream } from "./chat-stream-handler.js";
 export { DEFAULT_MAX_STEPS, DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE, MAX_STREAM_BUFFER_SIZE, } from "./constants.js";
-import { DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE } from "./constants.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE, getModelMaxOutputTokens } from "./constants.js";
 import { closeSSEStream, generateMessageId, sendSSE } from "./sse-utils.js";
 import { executeConfiguredTool, getAvailableTools, isDynamicTool, parseToolArgs, } from "./tool-helpers.js";
 import { accumulateUsage, getMaxSteps, normalizeInput } from "./input-utils.js";
@@ -99,6 +99,59 @@ export function captureStreamedToolCallInput(toolCall) {
         ...(error ? { parseError: error } : {}),
     };
 }
+/**
+ * A streamed tool call is "incomplete" when the provider stream terminated
+ * (abort, stall, timeout, transport error) before the SDK emitted the
+ * finalizing `tool-call` event that sets `inputAvailable: true`. In that state
+ * `arguments` only holds partial JSON fragments from `tool-input-delta` events,
+ * so the tool call is NOT a committed model choice and must not be parsed or
+ * executed. This is semantically distinct from a parse failure on a finalized
+ * tool call (`inputAvailable: true` but malformed JSON — which only happens on
+ * genuine provider bugs) and needs to be reported as a stream-termination
+ * error rather than a tool-argument error.
+ */
+export function isStreamedToolCallIncomplete(toolCall) {
+    return toolCall.inputAvailable !== true;
+}
+/**
+ * Classify and build the persisted `MessagePart` for a single streamed tool
+ * call. Pure function — no logging, no SSE, no memory. Callers decide what to
+ * do with the result so this stays unit-testable.
+ *
+ * The resulting `part` is always pushed into the assistant message so the
+ * conversation history is transparent: even incomplete tool calls leave a
+ * visible trace with their partial `inputText`. What differs is the caller's
+ * error-surfacing behavior (log warning, SSE event, tool-result error).
+ */
+export function materializeStreamedToolCall(tc) {
+    const basePart = {
+        type: `tool-${tc.name}`,
+        toolCallId: tc.id,
+        toolName: tc.name,
+        args: {},
+        ...(tc.arguments.length > 0 ? { inputText: tc.arguments } : {}),
+    };
+    if (isStreamedToolCallIncomplete(tc)) {
+        return {
+            kind: "incomplete",
+            part: basePart,
+            partialArgumentsLength: tc.arguments.length,
+            partialArgumentsPreview: tc.arguments.slice(0, 200),
+        };
+    }
+    const capturedInput = captureStreamedToolCallInput(tc);
+    const part = {
+        type: `tool-${tc.name}`,
+        toolCallId: tc.id,
+        toolName: tc.name,
+        args: capturedInput.args,
+        ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
+    };
+    if (capturedInput.parseError) {
+        return { kind: "parse-error", part, parseError: capturedInput.parseError };
+    }
+    return { kind: "complete", part };
+}
 function isToolResultPart(part) {
     return part.type === "tool-result" && "result" in part;
 }
@@ -393,7 +446,7 @@ export class AgentRuntime {
                             allowedToolNames: allowedRemoteToolNames,
                         }),
                         experimental_repairToolCall: repairToolCall,
-                        maxOutputTokens: this.resolveMaxOutputTokens(maxOutputTokensOverride),
+                        maxOutputTokens: this.resolveMaxOutputTokens(effectiveModel, maxOutputTokensOverride),
                         temperature: DEFAULT_TEMPERATURE,
                         ...(headers ? { headers } : {}),
                         ...(providerOptions ? { providerOptions } : {}),
@@ -632,7 +685,7 @@ export class AgentRuntime {
                     allowedToolNames: allowedRemoteToolNames,
                 }),
                 experimental_repairToolCall: repairToolCall,
-                maxOutputTokens: this.resolveMaxOutputTokens(maxOutputTokensOverride),
+                maxOutputTokens: this.resolveMaxOutputTokens(effectiveModel, maxOutputTokensOverride),
                 temperature: DEFAULT_TEMPERATURE,
                 ...(headers ? { headers } : {}),
                 ...(providerOptions ? { providerOptions } : {}),
@@ -649,20 +702,35 @@ export class AgentRuntime {
             if (state.accumulatedText)
                 streamParts.push({ type: "text", text: state.accumulatedText });
             for (const tc of state.toolCalls.values()) {
-                const capturedInput = captureStreamedToolCallInput(tc);
-                if (capturedInput.parseError) {
+                const materialized = materializeStreamedToolCall(tc);
+                streamParts.push(materialized.part);
+                if (materialized.kind === "incomplete") {
+                    // Stream terminated before the provider emitted the finalizing
+                    // `tool-call` event for this block. The model never committed this
+                    // tool use. Surface the failure via SSE so the live client can
+                    // react, and leave the partial fragment under `inputText` in the
+                    // persisted part above so the history is replayable and transparent.
+                    logger.warn("Streamed tool call terminated before tool-call event", {
+                        toolCallId: tc.id,
+                        toolName: tc.name,
+                        partialArgumentsLength: materialized.partialArgumentsLength,
+                        partialArgumentsPreview: materialized.partialArgumentsPreview,
+                    });
+                    const dynamicIncomplete = isDynamicTool(tc.name);
+                    sendSSE(controller, encoder, {
+                        type: "tool-input-error",
+                        toolCallId: tc.id,
+                        errorText: `Stream terminated before tool-call event fired for "${tc.name}". ` +
+                            `Received ${materialized.partialArgumentsLength} chars of partial tool-input deltas.`,
+                        ...(dynamicIncomplete ? { dynamic: true } : {}),
+                    });
+                }
+                else if (materialized.kind === "parse-error") {
                     logger.warn("Failed to parse streamed tool arguments", {
                         toolCallId: tc.id,
-                        error: capturedInput.parseError,
+                        error: materialized.parseError,
                     });
                 }
-                streamParts.push({
-                    type: `tool-${tc.name}`,
-                    toolCallId: tc.id,
-                    toolName: tc.name,
-                    args: capturedInput.args,
-                    ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
-                });
             }
             const assistantMessage = {
                 id: `msg_${Date.now()}_${step}`,
@@ -711,6 +779,23 @@ export class AgentRuntime {
                 streamedToolCalls.some((tc) => tc.name === LOAD_SKILL_TOOL_ID);
             for (const tc of streamedToolCalls) {
                 throwIfAborted(abortSignal);
+                if (isStreamedToolCallIncomplete(tc)) {
+                    // Stream ended before the provider finalized this tool call. We
+                    // cannot execute it — record a distinct stream-termination error
+                    // (not a tool-argument parse error) so the parent step and any
+                    // upstream orchestrator (e.g. the child-fork watchdog) see a
+                    // completed step with a clearly-labelled failure and can recover.
+                    const incompleteToolCall = {
+                        id: tc.id,
+                        name: tc.name,
+                        args: {},
+                        ...(tc.arguments.length > 0 ? { inputText: tc.arguments } : {}),
+                        status: "pending",
+                    };
+                    await this.recordToolError(incompleteToolCall, `Stream terminated before tool-call event fired for "${tc.name}". ` +
+                        `Received ${tc.arguments.length} chars of partial tool-input deltas.`, controller, encoder, currentMessages, toolCalls);
+                    continue;
+                }
                 const capturedInput = captureStreamedToolCallInput(tc);
                 const toolCall = {
                     id: tc.id,
@@ -872,13 +957,15 @@ export class AgentRuntime {
         const edgeMaxSteps = this.config.edge?.enabled ? this.config.edge.maxSteps : undefined;
         return getMaxSteps(this.config.maxSteps, edgeMaxSteps, platformLimit);
     }
-    resolveMaxOutputTokens(maxOutputTokensOverride) {
+    resolveMaxOutputTokens(modelString, maxOutputTokensOverride) {
         if (typeof maxOutputTokensOverride === "number" &&
             Number.isFinite(maxOutputTokensOverride) &&
             maxOutputTokensOverride > 0) {
             return Math.floor(maxOutputTokensOverride);
         }
-        return this.config.memory?.maxTokens ?? DEFAULT_MAX_TOKENS;
+        return this.config.memory?.maxTokens ??
+            (modelString ? getModelMaxOutputTokens(modelString) : undefined) ??
+            DEFAULT_MAX_TOKENS;
     }
     /**
      * Get memory instance (for advanced use cases)

package/esm/src/utils/version-constant.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.210";
+export declare const VERSION = "0.1.212";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.210";
+export const VERSION = "0.1.212";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.210",
+  "version": "0.1.212",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",

package/src/cli/mcp/advanced-tools.ts

@@ -21,15 +21,19 @@ import {
   vfListLocalProjects,
   vfListRoutes,
 } from "./tools/project-tools.js";
+import { vfBuild } from "./tools/build-tool.js";
+import { vfRunLint } from "./tools/run-lint-tool.js";
 import { vfRunTests } from "./tools/run-tests-tool.js";
 import { vfGetConventions, vfScaffold } from "./tools/scaffold-tools.js";
 import { vfGetSkillReference, vfGetSkills } from "./tools/skill-tools.js";
+import { vfBootstrap } from "./tools/bootstrap-tool.js";
 import { cicdTools } from "./tools/cicd-tools.js";
 import { introspectionTools } from "./tools/introspection-tools.js";
 
 export const advancedTools: MCPTool[] = [
   ...cicdTools,
   ...introspectionTools,
+  vfBootstrap,
   vfGetSkills,
   vfGetSkillReference,
   vfListLocalProjects,
@@ -45,9 +49,11 @@ export const advancedTools: MCPTool[] = [
   vfPreviewRoute,
   vfGetDebugContext,
   vfGetComponentTree,
+  vfBuild,
   vfHotReload,
   vfTriggerHmr,
   vfWaitForReady,
+  vfRunLint,
   vfGetFlywheelStatus,
   vfRunTests,
 ];

package/src/cli/mcp/standalone.ts

@@ -444,6 +444,71 @@ export class StandaloneMCPServer {
           });
         },
       },
+      {
+        name: "vf_run_lint",
+        description:
+          "Run the linter. Returns structured diagnostics with file, line, column, rule code, and message. " +
+          "Do not use for test results — use vf_run_tests instead. " +
+          "Do not use for compile/runtime errors — use vf_get_errors instead.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            timeout: {
+              type: "number",
+              description:
+                "Maximum time to wait for lint completion in milliseconds (default: 120000)",
+            },
+          },
+        },
+        async execute(args) {
+          const { executeLint } = await import("./tools/run-lint-tool.js");
+          return executeLint({
+            timeout: args.timeout as number | undefined,
+          });
+        },
+      },
+      {
+        name: "vf_bootstrap",
+        description:
+          "Get full project context in one call: structure, conventions, errors, and server status. " +
+          "Use at session start instead of calling vf_get_project_context + vf_get_conventions + " +
+          "vf_get_errors + vf_get_status separately.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectPath: {
+              type: "string",
+              description: "Project directory (defaults to cwd)",
+            },
+          },
+        },
+        async execute(args) {
+          const { vfGetProjectContext } = await import("./tools/project-tools.js");
+          const { vfGetConventions } = await import("./tools/scaffold-tools.js");
+
+          const [project, conventions] = await Promise.all([
+            vfGetProjectContext.execute({ projectPath: args.projectPath as string }),
+            vfGetConventions.execute({ topic: "all" }),
+          ]);
+
+          let errors: unknown[] = [];
+          let running = false;
+          try {
+            const result = await client.getLiveErrors();
+            errors = Array.isArray(result) ? result : [];
+            running = true;
+          } catch {
+            // Dev server not running — no errors available
+          }
+
+          return {
+            project,
+            conventions,
+            errors: { total: errors.length, items: errors.slice(-20) },
+            status: { running },
+          };
+        },
+      },
       ...this.createContext7Tools(),
     ];
   }

package/src/cli/mcp/tools/bootstrap-tool.ts

@@ -0,0 +1,67 @@
+/**
+ * MCP tool: vf_bootstrap
+ *
+ * Returns everything an agent needs at session start in a single call:
+ * project context, coding conventions, current errors, and server status.
+ */
+
+import { z } from "zod";
+import type { MCPTool } from "../../../src/mcp/index.js";
+import { type DevError, getErrorCollector } from "../../../src/observability/index.js";
+import { vfGetProjectContext } from "./project-tools.js";
+import { vfGetConventions } from "./scaffold-tools.js";
+
+const bootstrapInput = z.object({
+  projectPath: z.string().optional().describe(
+    "Project directory (defaults to current working directory)",
+  ),
+});
+
+type BootstrapInput = z.infer<typeof bootstrapInput>;
+
+interface BootstrapResult {
+  project: Awaited<ReturnType<typeof vfGetProjectContext.execute>>;
+  conventions: Awaited<ReturnType<typeof vfGetConventions.execute>>;
+  errors: { total: number; items: DevError[] };
+  status: { running: boolean };
+}
+
+export const vfBootstrap: MCPTool<BootstrapInput, BootstrapResult> = {
+  name: "vf_bootstrap",
+  title: "Bootstrap",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description: "Use this at the start of a new session to get full project context in one call. " +
+    "Returns project structure, coding conventions, current errors, and server status. " +
+    "Equivalent to calling vf_get_project_context + vf_get_conventions + vf_get_errors + " +
+    "vf_get_status separately, but in a single round-trip. " +
+    "Do not use repeatedly — call once at session bootstrap.",
+  inputSchema: bootstrapInput,
+  execute: async (input) => {
+    const [project, conventions] = await Promise.all([
+      vfGetProjectContext.execute({ projectPath: input.projectPath }),
+      vfGetConventions.execute({ topic: "all" }),
+    ]);
+
+    let errors: DevError[] = [];
+    let running = false;
+    try {
+      const collector = getErrorCollector();
+      errors = collector.getAll();
+      running = true;
+    } catch {
+      running = false;
+    }
+
+    return {
+      project,
+      conventions,
+      errors: { total: errors.length, items: errors.slice(-20) },
+      status: { running },
+    };
+  },
+};

package/src/cli/mcp/tools/build-tool.ts

@@ -0,0 +1,115 @@
+/**
+ * MCP tool for production builds.
+ */
+
+import { z } from "zod";
+import { cwd } from "../../../src/platform/index.js";
+import { join } from "../../../src/platform/compat/path/index.js";
+import { buildProduction } from "../../../src/build/index.js";
+import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
+import type { MCPTool } from "../tools.js";
+
+// ============================================================================
+// Tool: vf_build
+// ============================================================================
+
+const buildInput = z.object({
+  outputDir: z
+    .string()
+    .optional()
+    .describe("Output directory for the build. Defaults to '<projectDir>/dist'."),
+  splitting: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe("Enable code splitting. Defaults to true."),
+  compress: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe("Enable compression (gzip/brotli). Defaults to true."),
+  ssg: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe("Enable static site generation. Defaults to true."),
+  dryRun: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("Preview the build without writing files to disk. Defaults to false."),
+});
+
+type BuildInput = z.infer<typeof buildInput>;
+
+interface BuildResult {
+  success: boolean;
+  pages?: number;
+  chunks?: number;
+  assets?: number;
+  totalSize?: number;
+  duration_ms?: number;
+  outputDir?: string;
+  dryRun?: boolean;
+  ssgPaths?: string[];
+  error?: string;
+}
+
+export const vfBuild: MCPTool<BuildInput, BuildResult> = {
+  name: "vf_build",
+  title: "Production Build",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description: "Use this when you need to run a production build for the current project. " +
+    "Bundles, optimises, and writes output to the dist directory. " +
+    "Use dryRun=true to preview the build without writing files. " +
+    "Do not use for development — use the dev server tools instead. " +
+    "Do not use for lint checks — use vf_run_lint instead.",
+  inputSchema: buildInput,
+  execute: (input) =>
+    withSpan(
+      "cli.mcp.tool.vf_build",
+      async () => {
+        const projectDir = cwd();
+        const outputDir = input.outputDir ?? join(projectDir, "dist");
+        const startTime = Date.now();
+
+        try {
+          const stats = await buildProduction({
+            projectDir,
+            outputDir,
+            enableSplitting: input.splitting,
+            enableCompression: input.compress,
+            ssg: input.ssg,
+            dryRun: input.dryRun,
+          });
+
+          const duration_ms = Date.now() - startTime;
+
+          return {
+            success: true,
+            pages: stats.pages,
+            chunks: stats.chunks,
+            assets: stats.assets,
+            totalSize: stats.totalSize,
+            duration_ms,
+            outputDir,
+            dryRun: input.dryRun,
+            ssgPaths: stats.ssgPaths,
+          };
+        } catch (error) {
+          const duration_ms = Date.now() - startTime;
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            duration_ms,
+          };
+        }
+      },
+      { "tool.dryRun": input.dryRun },
+    ),
+};

package/src/cli/mcp/tools/run-lint-tool.ts

@@ -0,0 +1,69 @@
+/**
+ * MCP tool: vf_run_lint
+ *
+ * Runs the linter via subprocess and returns structured diagnostics.
+ * Reuses parseLintJsonOutput from the CLI lint command.
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import { z } from "zod";
+import type { MCPTool } from "../tools.js";
+import { type LintResult, parseLintJsonOutput } from "../../commands/lint/command.js";
+
+const runLintInput = z.object({
+  timeout: z.number().optional().default(120000).describe(
+    "Maximum time to wait for lint completion in milliseconds. Defaults to 120000 (2 minutes).",
+  ),
+});
+
+type RunLintInput = z.infer<typeof runLintInput>;
+
+/** Spawn deno lint and return structured results. Exported for standalone reuse. */
+export async function executeLint(
+  input: { timeout?: number } = {},
+): Promise<LintResult> {
+  const cmd = new dntShim.Deno.Command("deno", {
+    args: ["lint", "--json"],
+    stdout: "piped",
+    stderr: "piped",
+  });
+
+  const child = cmd.spawn();
+  const timeoutMs = input.timeout ?? 120000;
+
+  const result = await Promise.race([
+    child.output(),
+    new Promise<never>((_, reject) => {
+      const timer = dntShim.setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+          // Process may have already exited
+        }
+        reject(new Error(`Lint execution timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      dntShim.Deno.unrefTimer(timer);
+    }),
+  ]);
+
+  const stdout = new TextDecoder().decode(result.stdout);
+  return parseLintJsonOutput(stdout, result.code);
+}
+
+export const vfRunLint: MCPTool<RunLintInput, LintResult> = {
+  name: "vf_run_lint",
+  title: "Run Lint",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description: "Use this when you need to check for lint issues in the project. " +
+    "Returns structured diagnostics with file path, line, column, rule code, and message for each issue. " +
+    "Do not use for test results — use vf_run_tests instead. " +
+    "Do not use for compile/runtime errors — use vf_get_errors instead.",
+  inputSchema: runLintInput,
+  execute: (input) => executeLint(input),
+};

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.210",
+  "version": "0.1.212",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [

package/src/src/agent/data-stream.ts

@@ -26,14 +26,16 @@ export function stripLeadingEmptyObjectPlaceholder(rawArgs: string): string {
 }
 
 export function mergeToolInputDelta(currentArguments: string, nextDelta: string): string {
-  if (currentArguments === "{}") {
-    const normalizedDelta = nextDelta.trimStart();
-    if (normalizedDelta.startsWith("{")) {
-      return normalizedDelta;
-    }
-
-    if (normalizedDelta.startsWith('"')) {
-      return `{${normalizedDelta}`;
+  const normalizedDelta = nextDelta.trimStart();
+  const candidateDeltas = normalizedDelta.startsWith('"')
+    ? [normalizedDelta, `{${normalizedDelta}`]
+    : [normalizedDelta];
+
+  if (currentArguments === "{}" || currentArguments.length === 0) {
+    for (const candidate of candidateDeltas) {
+      if (candidate.startsWith("{")) {
+        return candidate;
+      }
     }
   }
 
@@ -45,18 +47,20 @@ export function mergeToolInputDelta(currentArguments: string, nextDelta: string)
     return nextDelta;
   }
 
-  if (nextDelta === currentArguments || currentArguments.includes(nextDelta)) {
-    return currentArguments;
-  }
+  for (const candidate of candidateDeltas) {
+    if (candidate === currentArguments || currentArguments.includes(candidate)) {
+      return currentArguments;
+    }
 
-  if (nextDelta.startsWith(currentArguments)) {
-    return nextDelta;
-  }
+    if (candidate.startsWith(currentArguments)) {
+      return candidate;
+    }
 
-  const maxOverlap = Math.min(currentArguments.length, nextDelta.length);
-  for (let overlap = maxOverlap; overlap > 0; overlap--) {
-    if (currentArguments.endsWith(nextDelta.slice(0, overlap))) {
-      return currentArguments + nextDelta.slice(overlap);
+    const maxOverlap = Math.min(currentArguments.length, candidate.length);
+    for (let overlap = maxOverlap; overlap > 0; overlap--) {
+      if (currentArguments.endsWith(candidate.slice(0, overlap))) {
+        return currentArguments + candidate.slice(overlap);
+      }
     }
   }
 
@@ -68,10 +72,16 @@ export function mergeToolCallInput(currentArguments: string, nextInput: string):
     return nextInput;
   }
 
+  const normalizedCurrent = stripLeadingEmptyObjectPlaceholder(currentArguments);
+
   if (nextInput.trim() === "{}" && currentArguments.trim().startsWith("{")) {
     return currentArguments;
   }
 
+  if (nextInput.trim() === "{}" && normalizedCurrent.trim().startsWith("{")) {
+    return normalizedCurrent;
+  }
+
   if (currentArguments.trim() === "{}" && nextInput.trim().startsWith("{")) {
     return nextInput;
   }

package/src/src/agent/runtime/constants.ts

@@ -4,3 +4,21 @@ export const DEFAULT_MAX_TOKENS = AGENT_DEFAULTS.maxTokens;
 export const DEFAULT_TEMPERATURE = AGENT_DEFAULTS.temperature;
 export const MAX_STREAM_BUFFER_SIZE = STREAMING_DEFAULTS.maxBufferSize;
 export const DEFAULT_MAX_STEPS = 20;
+
+/** Max output token limits per model (normalized IDs without `veryfront-cloud/` prefix). */
+const MODEL_MAX_OUTPUT_TOKENS: Record<string, number> = {
+  "anthropic/claude-opus-4-6": 32_768,
+  "anthropic/claude-sonnet-4-6": 16_384,
+  "anthropic/claude-haiku-4-5-20251001": 8_192,
+  "openai/gpt-5.2": 16_384,
+  "google-ai-studio/gemini-2.5-pro": 65_536,
+  "google-ai-studio/gemini-2.5-flash": 8_192,
+};
+
+/** Look up max output tokens for a model, stripping the `veryfront-cloud/` prefix. */
+export function getModelMaxOutputTokens(modelString: string): number | undefined {
+  const normalized = modelString.startsWith("veryfront-cloud/")
+    ? modelString.slice("veryfront-cloud/".length)
+    : modelString;
+  return MODEL_MAX_OUTPUT_TOKENS[normalized];
+}