veryfront 0.1.48 → 0.1.49

package/src/src/platform/compat/process.ts

@@ -162,16 +162,6 @@ export function getEnvBoolean(
   return fallback;
 }
 
-/**
- * Get an environment variable or throw if not set
- * @throws Error if the environment variable is not set
- */
-export function requireEnv(key: string): string {
-  const value = getEnv(key);
-  if (value === undefined) throw new Error(`Required environment variable "${key}" is not set`);
-  return value;
-}
-
 export function setEnv(key: string, value: string): void {
   if (IS_DENO) {
     dntShim.Deno.env.set(key, value);
@@ -223,12 +213,6 @@ export function pid(): number {
   return 0;
 }
 
-export function ppid(): number {
-  if (IS_DENO && "ppid" in dntShim.Deno) return dntShim.Deno.ppid || 0;
-  if (hasNodeProcess) return nodeProcess!.ppid || 0;
-  return 0;
-}
-
 export function memoryUsage(): {
   rss: number;
   heapTotal: number;
@@ -289,44 +273,6 @@ export function getTerminalSize(): { columns: number; rows: number } {
   return defaultSize;
 }
 
-/**
- * Get network interfaces
- */
-export async function getNetworkInterfaces(): Promise<
-  Array<{ name: string; address: string; family: "IPv4" | "IPv6" }>
-> {
-  if (IS_DENO) {
-    return dntShim.Deno.networkInterfaces().map((iface) => ({
-      name: iface.name,
-      address: iface.address,
-      family: iface.family as "IPv4" | "IPv6",
-    }));
-  }
-
-  // Bun and Node.js both support node:os
-  if (!hasNodeProcess && !IS_BUN) {
-    throw new Error("networkInterfaces() is not supported in this runtime");
-  }
-
-  // Use dynamicImport to avoid static analysis by bundlers
-  const os = await dynamicImport<typeof import("node:os")>("node:os");
-  const interfaces = os.networkInterfaces();
-  const result: Array<{ name: string; address: string; family: "IPv4" | "IPv6" }> = [];
-
-  for (const [name, addrs] of Object.entries(interfaces)) {
-    if (!addrs) continue;
-    for (const addr of addrs) {
-      result.push({
-        name,
-        address: addr.address,
-        family: addr.family as "IPv4" | "IPv6",
-      });
-    }
-  }
-
-  return result;
-}
-
 /**
  * Get runtime version string
  */
@@ -535,10 +481,14 @@ export function readStdinByteSync(): number | null {
 
   if (IS_BUN) {
     // Bun: read one byte from the file descriptor directly
-    // deno-lint-ignore no-explicit-any
-    const Bun = (dntShim.dntGlobalThis as any).Bun;
-    const chunk = Bun?.stdin?.read?.(1);
-    if (chunk && chunk.length > 0) return chunk[0];
+    const BunGlobal =
+      (dntShim.dntGlobalThis as { Bun?: { stdin?: { read?: (n: number) => Uint8Array | null } } })
+        .Bun;
+    const chunk = BunGlobal?.stdin?.read?.(1);
+    if (chunk && chunk.length > 0) {
+      const first = chunk.at(0);
+      return first ?? null;
+    }
     return null;
   }
 
@@ -566,6 +516,61 @@ export interface CommandOptions {
   inherit?: boolean;
   /** Use shell to run the command (needed for .cmd files on Windows) */
   shell?: boolean;
+  /** Kill the command if it exceeds this duration (milliseconds) */
+  timeoutMs?: number;
+}
+
+const COMMAND_TIMEOUT_EXIT_CODE = 124;
+const FORCE_KILL_GRACE_MS = 250;
+
+function createTimeoutResult(
+  timeoutMs: number,
+  stdout?: string,
+  stderr?: string,
+): CommandResult {
+  return {
+    success: false,
+    code: COMMAND_TIMEOUT_EXIT_CODE,
+    stdout,
+    stderr: `${stderr ?? ""}\nCommand timed out after ${timeoutMs}ms`.trim(),
+  };
+}
+
+function createProcessTimeout(
+  timeoutMs: number | undefined,
+  terminate: () => void,
+  forceTerminate: () => void,
+): { hasTimedOut: () => boolean; clear: () => void } {
+  let timedOut = false;
+  let timeoutId: ReturnType<typeof dntShim.setTimeout> | undefined;
+  let forceKillId: ReturnType<typeof dntShim.setTimeout> | undefined;
+
+  if (timeoutMs && timeoutMs > 0) {
+    timeoutId = dntShim.setTimeout(() => {
+      timedOut = true;
+      try {
+        terminate();
+      } catch {
+        // Best-effort terminate.
+      }
+
+      forceKillId = dntShim.setTimeout(() => {
+        try {
+          forceTerminate();
+        } catch {
+          // Best-effort force terminate.
+        }
+      }, FORCE_KILL_GRACE_MS);
+    }, timeoutMs);
+  }
+
+  return {
+    hasTimedOut: () => timedOut,
+    clear: () => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (forceKillId) clearTimeout(forceKillId);
+    },
+  };
 }
 
 async function readStreamToString(stream: ReadableStream<Uint8Array>): Promise<string> {
@@ -604,8 +609,16 @@ export async function runCommand(
   cmd: string,
   options: CommandOptions = {},
 ): Promise<CommandResult> {
-  const { args = [], cwd: cmdCwd, env: cmdEnv, capture = false, inherit = false, shell = false } =
-    options;
+  const {
+    args = [],
+    cwd: cmdCwd,
+    env: cmdEnv,
+    capture = false,
+    inherit = false,
+    shell = false,
+    timeoutMs,
+  } = options;
+  const effectiveTimeoutMs = timeoutMs && timeoutMs > 0 ? Math.floor(timeoutMs) : undefined;
 
   // Determine stdio mode: inherit > capture > null
   const stdioMode = inherit ? "inherit" : capture ? "piped" : "null";
@@ -620,15 +633,31 @@ export async function runCommand(
       stderr: stdioMode,
     });
 
-    const output = await command.output();
-    const decoder = new TextDecoder();
+    const child = command.spawn();
+    const timeout = createProcessTimeout(
+      effectiveTimeoutMs,
+      () => child.kill("SIGTERM"),
+      () => child.kill("SIGKILL"),
+    );
 
-    return {
-      success: output.success,
-      code: output.code,
-      stdout: capture ? decoder.decode(output.stdout) : undefined,
-      stderr: capture ? decoder.decode(output.stderr) : undefined,
-    };
+    try {
+      const [status, stdout, stderr] = await Promise.all([
+        child.status,
+        capture && child.stdout ? readStreamToString(child.stdout) : Promise.resolve(undefined),
+        capture && child.stderr ? readStreamToString(child.stderr) : Promise.resolve(undefined),
+      ]);
+
+      if (timeout.hasTimedOut()) return createTimeoutResult(effectiveTimeoutMs!, stdout, stderr);
+
+      return {
+        success: status.success,
+        code: status.code,
+        stdout,
+        stderr,
+      };
+    } finally {
+      timeout.clear();
+    }
   }
 
   if (IS_BUN) {
@@ -644,6 +673,7 @@ export async function runCommand(
           exited: Promise<number>;
           stdout: ReadableStream<Uint8Array> | null;
           stderr: ReadableStream<Uint8Array> | null;
+          kill?: (signal?: string | number) => void;
         };
       };
     };
@@ -667,17 +697,25 @@ export async function runCommand(
       stderr: bunStdio,
     });
 
-    const code = await proc.exited;
+    const timeout = createProcessTimeout(
+      effectiveTimeoutMs,
+      () => proc.kill?.("SIGTERM"),
+      () => proc.kill?.("SIGKILL"),
+    );
 
-    let stdout: string | undefined;
-    let stderr: string | undefined;
+    try {
+      const [code, stdout, stderr] = await Promise.all([
+        proc.exited,
+        capture && proc.stdout ? readStreamToString(proc.stdout) : Promise.resolve(undefined),
+        capture && proc.stderr ? readStreamToString(proc.stderr) : Promise.resolve(undefined),
+      ]);
 
-    if (capture) {
-      stdout = proc.stdout ? await readStreamToString(proc.stdout) : undefined;
-      stderr = proc.stderr ? await readStreamToString(proc.stderr) : undefined;
-    }
+      if (timeout.hasTimedOut()) return createTimeoutResult(effectiveTimeoutMs!, stdout, stderr);
 
-    return { success: code === 0, code, stdout, stderr };
+      return { success: code === 0, code, stdout, stderr };
+    } finally {
+      timeout.clear();
+    }
   }
 
   if (!hasNodeProcess) return { success: false, code: 1 };
@@ -705,6 +743,11 @@ export async function runCommand(
     let stdout = "";
     let stderr = "";
     const decoder = new TextDecoder();
+    const timeout = createProcessTimeout(
+      effectiveTimeoutMs,
+      () => child.kill("SIGTERM"),
+      () => child.kill("SIGKILL"),
+    );
 
     if (capture) {
       child.stdout?.on("data", (data: Uint8Array) => {
@@ -716,6 +759,19 @@ export async function runCommand(
     }
 
     child.on("close", (code) => {
+      timeout.clear();
+
+      if (timeout.hasTimedOut()) {
+        resolve(
+          createTimeoutResult(
+            effectiveTimeoutMs!,
+            capture ? stdout : undefined,
+            capture ? stderr : undefined,
+          ),
+        );
+        return;
+      }
+
       resolve({
         success: code === 0,
         code: code ?? 1,
@@ -725,6 +781,7 @@ export async function runCommand(
     });
 
     child.on("error", () => {
+      timeout.clear();
       resolve({ success: false, code: 1 });
     });
   });

package/src/src/provider/index.ts

@@ -21,6 +21,7 @@ import "../../_dnt.polyfills.js";
 export {
   clearModelProviders,
   ensureModelReady,
+  findAvailableCloudModel,
   getRegisteredModelProviders,
   hasModelProvider,
   registerModelProvider,

package/src/src/provider/local/ai-sdk-adapter.ts

@@ -18,22 +18,30 @@ import { isLocalAIDisabled } from "./env.js";
 
 const logger = serverLogger.component("local-llm");
 
+/** Shape of a single message in the AI SDK LanguageModelV2 prompt array. */
+interface PromptMessage {
+  role: string;
+  content: string | ReadonlyArray<{ type: string; text?: string }>;
+}
+
 /**
  * Convert AI SDK LanguageModelV2 prompt format to simple ChatMessage array.
  *
  * The AI SDK prompt is an array of message objects with role and content arrays.
  * We extract text content for the local model.
  */
-// deno-lint-ignore no-explicit-any
-function convertPrompt(prompt: any[]): ChatMessage[] {
+function convertPrompt(prompt: ReadonlyArray<PromptMessage>): ChatMessage[] {
   const messages: ChatMessage[] = [];
 
   for (const msg of prompt) {
-    const role = msg.role as "system" | "user" | "assistant" | "tool";
     // Skip tool messages — local models don't support tool calling
-    if (role === "tool") continue;
+    if (msg.role === "tool") continue;
 
-    const mappedRole = role === "system" ? "system" : role === "user" ? "user" : "assistant";
+    const mappedRole = msg.role === "system"
+      ? "system"
+      : msg.role === "user"
+      ? "user"
+      : "assistant";
 
     // Extract text content from content array
     let text = "";
@@ -55,6 +63,27 @@ function convertPrompt(prompt: any[]): ChatMessage[] {
   return messages;
 }
 
+/** AI SDK LanguageModelV2 generation options that both doGenerate and doStream receive. */
+interface LocalModelOptions {
+  prompt: unknown[];
+  maxOutputTokens?: number;
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  stopSequences?: string[];
+}
+
+/** Map AI SDK generation options to local engine GenerateOptions. */
+function toGenerateOptions(options: LocalModelOptions): GenerateOptions {
+  return {
+    maxNewTokens: options.maxOutputTokens ?? 512,
+    temperature: options.temperature ?? 0.7,
+    topP: options.topP,
+    topK: options.topK,
+    stopSequences: options.stopSequences,
+  };
+}
+
 /**
  * Create a local AI SDK LanguageModel for the given model ID.
  *
@@ -75,22 +104,9 @@ export function createLocalModel(modelId?: string): LanguageModel {
 
     supportedUrls: {},
 
-    async doGenerate(options: {
-      prompt: unknown[];
-      maxOutputTokens?: number;
-      temperature?: number;
-      topP?: number;
-      topK?: number;
-      stopSequences?: string[];
-    }) {
-      const messages = convertPrompt(options.prompt as unknown[]);
-      const genOptions: GenerateOptions = {
-        maxNewTokens: options.maxOutputTokens ?? 512,
-        temperature: options.temperature ?? 0.7,
-        topP: options.topP,
-        topK: options.topK,
-        stopSequences: options.stopSequences,
-      };
+    async doGenerate(options: LocalModelOptions) {
+      const messages = convertPrompt(options.prompt as ReadonlyArray<PromptMessage>);
+      const genOptions = toGenerateOptions(options);
 
       logger.debug(`[local] doGenerate: ${messages.length} messages → ${resolvedId}`);
 
@@ -108,14 +124,7 @@ export function createLocalModel(modelId?: string): LanguageModel {
       };
     },
 
-    async doStream(options: {
-      prompt: unknown[];
-      maxOutputTokens?: number;
-      temperature?: number;
-      topP?: number;
-      topK?: number;
-      stopSequences?: string[];
-    }) {
+    async doStream(options: LocalModelOptions) {
       // Eagerly check if local AI is disabled — must throw before creating the
       // ReadableStream, otherwise the 200 response headers are already committed.
       // Note: getTransformers() in local-engine.ts also checks this, but we need
@@ -130,14 +139,8 @@ export function createLocalModel(modelId?: string): LanguageModel {
         );
       }
 
-      const messages = convertPrompt(options.prompt as unknown[]);
-      const genOptions: GenerateOptions = {
-        maxNewTokens: options.maxOutputTokens ?? 512,
-        temperature: options.temperature ?? 0.7,
-        topP: options.topP,
-        topK: options.topK,
-        stopSequences: options.stopSequences,
-      };
+      const messages = convertPrompt(options.prompt as ReadonlyArray<PromptMessage>);
+      const genOptions = toGenerateOptions(options);
 
       logger.debug(`[local] doStream: ${messages.length} messages → ${resolvedId}`);
 

package/src/src/provider/local/env.ts

@@ -18,7 +18,10 @@ export function isLocalAIDisabled(): boolean {
   const denoVal = (dntShim.dntGlobalThis as any).Deno?.env?.get?.("VERYFRONT_DISABLE_LOCAL_AI");
   if (denoVal === "1") return true;
 
-  if (typeof process !== "undefined" && process.env?.VERYFRONT_DISABLE_LOCAL_AI === "1") {
+  if (
+    typeof process !== "undefined" &&
+    process.env?.VERYFRONT_DISABLE_LOCAL_AI === "1"
+  ) {
     return true;
   }
 

package/src/src/provider/model-registry.ts

@@ -137,6 +137,53 @@ function autoInitializeFromEnv(): void {
   }
 }
 
+/**
+ * Default cloud models to try when auto-upgrading from a local model.
+ * Ordered by preference: Anthropic → OpenAI → Google.
+ *
+ * NOTE: model IDs are hardcoded — update when default models change.
+ */
+const CLOUD_UPGRADE_CANDIDATES: Array<{
+  provider: string;
+  model: string;
+  hasKey: () => boolean;
+}> = [
+  {
+    provider: "anthropic",
+    model: "claude-sonnet-4-20250514",
+    hasKey: () => !!getAnthropicEnvConfig().apiKey,
+  },
+  {
+    provider: "openai",
+    model: "gpt-4o-mini",
+    hasKey: () => !!getOpenAIEnvConfig().apiKey,
+  },
+  {
+    provider: "google",
+    model: "gemini-2.0-flash",
+    hasKey: () => !!getGoogleGenAIEnvConfig().apiKey,
+  },
+];
+
+/**
+ * Find the first cloud provider with a valid API key.
+ *
+ * Returns a "provider/model" string that can be passed to `resolveModel`,
+ * or `null` if no cloud provider is available.
+ *
+ * This is intentionally a **query** — it does NOT resolve the model.
+ * The caller (agent runtime) decides whether to use it.
+ */
+export function findAvailableCloudModel(): string | null {
+  autoInitializeFromEnv();
+  for (const { provider, model, hasKey } of CLOUD_UPGRADE_CANDIDATES) {
+    if (!hasKey()) continue;
+    if (!manager.has(provider)) continue;
+    return `${provider}/${model}`;
+  }
+  return null;
+}
+
 /**
  * Resolve a "provider/model" string to an AI SDK LanguageModel instance.
  *

package/src/src/proxy/retry.ts

@@ -6,8 +6,6 @@
  * Check if a fetch error is a transient connection error worth retrying.
  * These occur when renderer pods are being recycled or temporarily unavailable.
  */
-import * as dntShim from "../../_dnt.shims.js";
-
 export function isRetryableConnectionError(error: unknown): boolean {
   if (!(error instanceof Error)) return false;
   const msg = error.message.toLowerCase();
@@ -19,10 +17,3 @@ export function isRetryableConnectionError(error: unknown): boolean {
     msg.includes("os error 111") // ECONNREFUSED
   );
 }
-
-/**
- * Sleep for the specified number of milliseconds.
- */
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => dntShim.setTimeout(resolve, ms));
-}

package/src/src/proxy/tracing.ts

@@ -69,7 +69,7 @@ async function loadApis(): Promise<void> {
   propagationApi = await import("@opentelemetry/core");
 }
 
-export async function initializeOTLP(): Promise<void> {
+export async function initializeOTLPWithApis(): Promise<void> {
   if (initialized) return;
 
   const config = getConfig();
@@ -139,10 +139,6 @@ export async function shutdownOTLP(): Promise<void> {
   }
 }
 
-export function isOTLPEnabled(): boolean {
-  return initialized && tracerProvider !== null;
-}
-
 function getPropagator(): import("@opentelemetry/core").W3CTraceContextPropagator | null {
   if (!propagationApi) return null;
   return new propagationApi.W3CTraceContextPropagator();
@@ -239,8 +235,6 @@ export function getTraceContext(): { traceId?: string; spanId?: string } {
  * Span names for proxy tracing.
  */
 export const ProxySpanNames = {
-  PROXY_REQUEST: "proxy.request",
-  PROXY_PROCESS: "proxy.process",
   PROXY_TOKEN_FETCH: "proxy.token_fetch",
   PROXY_DOMAIN_LOOKUP: "proxy.domain_lookup",
   OAUTH_TOKEN_REQUEST: "oauth.token_request",
@@ -282,5 +276,3 @@ export async function withSpan<T>(
     span.end();
   }
 }
-
-export { initializeOTLP as initializeOTLPWithApis };

package/src/src/react/components/ai/chat/components/code-block.tsx

@@ -72,7 +72,7 @@ export const RichCodeBlock = React.forwardRef<HTMLDivElement, CodeBlockProps>(
               )}
           </button>
         </div>
-        <pre className="p-4 text-[var(--foreground)] overflow-auto text-sm">
+        <pre className="p-4 text-[var(--foreground)] bg-[var(--accent)] overflow-auto text-sm [&_.hljs]:bg-transparent [&_.hljs]:p-0">
         <code className={language ? `language-${language}` : undefined}>{code}</code>
         </pre>
       </div>

package/src/src/react/components/ai/chat/components/skill-badge.tsx

@@ -0,0 +1,51 @@
+/**
+ * Skill Badge — compact indicator for skill tool calls (load-skill, load-skill-reference, execute-skill-script).
+ * @module ai/react/components/chat/components/skill-badge
+ */
+
+import * as React from "react";
+import { cn } from "../../theme.js";
+import { CheckCircleIcon, SparklesIcon, XCircleIcon } from "../../icons/index.js";
+import type { DynamicToolUIPart, ToolUIPart } from "../../../../../agent/react/index.js";
+
+export interface SkillBadgeProps {
+  tool: ToolUIPart | DynamicToolUIPart;
+  className?: string;
+}
+
+export function SkillBadge({ tool, className }: SkillBadgeProps): React.JSX.Element {
+  const input = tool.input as Record<string, unknown> | undefined;
+  const skillId = input?.skillId as string | undefined;
+  const isComplete = tool.state === "output-available";
+  const isError = tool.state === "output-error";
+
+  let label: string;
+  if (tool.toolName === "load-skill") {
+    label = isComplete
+      ? `Skill: ${skillId ?? "unknown"}`
+      : `Loading skill${skillId ? `: ${skillId}` : ""}...`;
+  } else if (tool.toolName === "load-skill-reference") {
+    const ref = input?.reference as string | undefined;
+    label = isComplete ? `Reference: ${ref ?? "unknown"}` : `Reading${ref ? `: ${ref}` : ""}...`;
+  } else {
+    const script = input?.script as string | undefined;
+    label = isComplete
+      ? `Script: ${script ?? "complete"}`
+      : `Running${script ? `: ${script}` : ""}...`;
+  }
+
+  return (
+    <span
+      className={cn(
+        "inline-flex items-center gap-1.5 rounded-full px-2.5 py-1 text-xs font-medium",
+        "bg-[var(--accent)] text-[var(--muted-foreground)] border border-[var(--border)]",
+        className,
+      )}
+    >
+      <SparklesIcon className={cn("size-3", !isComplete && !isError && "animate-pulse")} />
+      <span>{label}</span>
+      {isComplete && <CheckCircleIcon className="size-3 text-[var(--success)]" />}
+      {isError && <XCircleIcon className="size-3 text-[var(--destructive)]" />}
+    </span>
+  );
+}

package/src/src/react/components/ai/chat/components/step-indicator.tsx

@@ -16,15 +16,15 @@ export function StepIndicator({
   return (
     <div
       className={cn(
-        "flex items-center gap-3 py-3 text-xs text-[var(--input-placeholder)]",
+        "flex items-center gap-3 py-3 text-xs text-[var(--muted-foreground)]",
         className,
       )}
     >
       <div className="flex-1 h-px bg-[var(--border)]" />
-      <div className="flex items-center gap-1.5 px-2 py-0.5 rounded-full bg-[var(--accent)]">
+      <div className="flex items-center gap-1.5 px-2 py-0.5 rounded-full border border-[var(--border)] bg-[var(--accent)]">
         {isComplete
-          ? <CheckCircleIcon className="size-3.5 text-emerald-500" />
-          : <span className="size-2 rounded-full bg-violet-500 animate-pulse" />}
+          ? <CheckCircleIcon className="size-3.5 text-[var(--success)]" />
+          : <span className="size-2 rounded-full bg-[var(--muted-foreground)] animate-pulse" />}
         <span className="font-medium">Step {stepIndex + 1}</span>
       </div>
       <div className="flex-1 h-px bg-[var(--border)]" />

package/src/src/react/components/ai/chat/composition/chat-message-list.tsx

@@ -24,10 +24,12 @@ import {
   extractSourcesFromParts,
   getTextContent,
   groupPartsInOrder,
+  isSkillToolPart,
 } from "../utils/message-parts.js";
 import { ConversationScrollButton } from "../components/empty-state.js";
 import { MessageActions } from "../components/message-actions.js";
 import { ReasoningCard } from "../components/reasoning.js";
+import { SkillBadge } from "../components/skill-badge.js";
 import { ToolCallCard } from "../components/tool-ui.js";
 
 import { Sources } from "../components/sources.js";
@@ -320,9 +322,14 @@ function AssistantMessage({
               )
               : null;
           }
+          const isSkill = isSkillToolPart(group.tool);
           return (
-            <div key={group.tool.toolCallId} className="my-3">
-              {renderTool ? renderTool(group.tool) : <ToolCallCard tool={group.tool} />}
+            <div key={group.tool.toolCallId} className={isSkill ? "my-2" : "my-3"}>
+              {renderTool
+                ? renderTool(group.tool)
+                : isSkill
+                ? <SkillBadge tool={group.tool} />
+                : <ToolCallCard tool={group.tool} />}
             </div>
           );
         })}