veryfront 0.1.47 → 0.1.49

package/src/src/agent/chat-handler.ts

@@ -39,11 +39,24 @@ const dynamicToolPartSchema = z
   })
   .passthrough();
 
+const stepPartSchema = z.object({
+  type: z.enum(["step-start", "step-end"]),
+  stepIndex: z.number().optional(),
+}).passthrough();
+
+const reasoningPartSchema = z.object({
+  type: z.literal("reasoning"),
+  text: z.string(),
+  state: z.string().optional(),
+}).passthrough();
+
 const partSchema = z.union([
   textPartSchema,
   toolCallPartSchema,
   toolResultPartSchema,
   dynamicToolPartSchema,
+  stepPartSchema,
+  reasoningPartSchema,
 ]);
 
 const messageSchema = z.object({
@@ -54,9 +67,11 @@ const messageSchema = z.object({
 
 const chatRequestSchema = z.object({
   messages: z.array(messageSchema).min(1).max(100),
+  model: z.string().optional(),
 });
 
 type ParsedMessage = z.infer<typeof messageSchema>;
+type ParsedTextPart = z.infer<typeof textPartSchema>;
 
 // ---------------------------------------------------------------------------
 // Message transformation
@@ -118,10 +133,96 @@ function transformUIMessages(messages: ParsedMessage[]): Message[] {
   return result as unknown as Message[];
 }
 
+function isTextPart(part: unknown): part is ParsedTextPart {
+  return typeof part === "object" && part !== null && (part as { type?: string }).type === "text";
+}
+
+function extractLastUserText(messages: ParsedMessage[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message || message.role !== "user") continue;
+
+    const text = message.parts
+      .filter(isTextPart)
+      .map((part) => part.text)
+      .join("\n")
+      .trim();
+
+    if (text.length > 0) return text;
+  }
+
+  return "";
+}
+
+function isResponseLike(value: unknown): value is dntShim.Response {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as dntShim.Response).status === "number" &&
+    typeof (value as dntShim.Response).headers === "object" &&
+    typeof (value as dntShim.Response).bodyUsed === "boolean"
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 
+export type ChatHandlerMessageInput = Omit<Message, "id"> & { id?: string };
+
+export interface ChatHandlerBeforeStreamContext {
+  request: dntShim.Request;
+  messages: Message[];
+  context: Record<string, unknown>;
+  lastUserText: string;
+}
+
+export interface ChatHandlerBeforeStreamResult {
+  prepend?: ChatHandlerMessageInput[];
+  append?: ChatHandlerMessageInput[];
+  replaceMessages?: ChatHandlerMessageInput[];
+  context?: Record<string, unknown>;
+}
+
+export type ChatHandlerBeforeStream = (
+  input: ChatHandlerBeforeStreamContext,
+) =>
+  | void
+  | dntShim.Response
+  | ChatHandlerBeforeStreamResult
+  | Promise<void | dntShim.Response | ChatHandlerBeforeStreamResult>;
+
+function normalizeHookMessages(
+  messages: ChatHandlerMessageInput[] | undefined,
+  prefix: string,
+  idCounter: { value: number },
+): Message[] {
+  if (!messages || messages.length === 0) return [];
+
+  return messages.map((message) => ({
+    ...message,
+    id: message.id ?? `${prefix}_${idCounter.value++}`,
+  })) as Message[];
+}
+
+function applyBeforeStreamResult(
+  baseMessages: Message[],
+  result: ChatHandlerBeforeStreamResult | undefined,
+): Message[] {
+  if (!result) return baseMessages;
+
+  const idCounter = { value: 0 };
+  const coreMessages = result.replaceMessages
+    ? normalizeHookMessages(result.replaceMessages, "replace", idCounter)
+    : baseMessages;
+
+  return [
+    ...normalizeHookMessages(result.prepend, "prepend", idCounter),
+    ...coreMessages,
+    ...normalizeHookMessages(result.append, "append", idCounter),
+  ];
+}
+
 /** Options for `createChatHandler` — customize the context passed to the agent. */
 export interface ChatHandlerOptions {
   /** Override context passed to agent.stream(). Default: `{ userId: "current-user" }` */
@@ -130,6 +231,11 @@ export interface ChatHandlerOptions {
     | ((
       request: dntShim.Request,
     ) => Record<string, unknown> | Promise<Record<string, unknown>>);
+  /**
+   * Hook to customize validated messages/context right before `agent.stream()`.
+   * Return `Response` to short-circuit (e.g. auth/rate limit).
+   */
+  beforeStream?: ChatHandlerBeforeStream;
 }
 
 /**
@@ -177,67 +283,71 @@ export function createChatHandler(
   // deno-lint-ignore no-explicit-any
   return async function POST(requestOrCtx: any): Promise<dntShim.Response> {
     const request = extractRequest(requestOrCtx);
-    // Resolve agent outside try so it's available in the catch block for
-    // extracting the system prompt in the 503 fallback response.
     let agent: ReturnType<typeof getAgent> | undefined;
     try {
       agent = getAgent(agentId);
     } catch {
       return dntShim.Response.json({ error: "Agent not found" }, { status: 404 });
     }
+    if (!agent) {
+      return dntShim.Response.json({ error: "Agent not found" }, { status: 404 });
+    }
 
     try {
       const body = await request.json();
-      const { messages: rawMessages } = chatRequestSchema.parse(body);
+      const { messages: rawMessages, model: requestModel } = chatRequestSchema.parse(body);
 
-      if (!agent) {
-        return dntShim.Response.json({ error: "Agent not found" }, { status: 404 });
-      }
+      const context = typeof options?.context === "function"
+        ? await options.context(request)
+        : options?.context ?? { userId: "current-user" };
+
+      const baseMessages = transformUIMessages(rawMessages);
+      const beforeStreamResult = await options?.beforeStream?.({
+        request,
+        messages: baseMessages,
+        context,
+        lastUserText: extractLastUserText(rawMessages),
+      });
+
+      if (isResponseLike(beforeStreamResult)) return beforeStreamResult;
+
+      const hookResult = beforeStreamResult ?? undefined;
+      const messages = applyBeforeStreamResult(baseMessages, hookResult);
+      const streamContext = hookResult?.context ?? context;
 
       // Clear server-side memory before each request —
       // the client (useChat) manages full conversation history
       await agent.clearMemory();
 
-      const context = typeof options?.context === "function"
-        ? await options.context(request)
-        : options?.context ?? { userId: "current-user" };
-
       const result = await agent.stream({
-        messages: transformUIMessages(rawMessages),
-        context,
+        messages,
+        context: streamContext,
+        ...(requestModel ? { model: requestModel } : {}),
       });
 
       return result.toDataStreamResponse();
     } catch (error) {
       if (error instanceof z.ZodError) {
         return dntShim.Response.json(
-          { error: "Invalid request", details: error.errors },
+          {
+            error: "Invalid request",
+            details: error.errors.map((e) => ({ path: e.path, message: e.message })),
+          },
           { status: 400 },
         );
       }
 
-      // Detect structured "no_ai_available" errors from local engine
+      // Detect structured "no_ai_available" errors from local engine.
+      // Never send the server-side system prompt to the client — it may
+      // contain business logic, personas, or internal instructions.
+      // The client (useChat) has its own systemPrompt option for browser fallback.
       const vfError = fromError(error);
       if (vfError?.type === "no_ai_available") {
-        // Resolve the agent's system prompt so the browser can use it for inference
-        const systemConfig = agent?.config?.system;
-        let systemPrompt = "You are a helpful AI assistant.";
-        if (typeof systemConfig === "string") {
-          systemPrompt = systemConfig;
-        } else if (typeof systemConfig === "function") {
-          try {
-            systemPrompt = await systemConfig();
-          } catch {
-            // Fall back to default
-          }
-        }
-
         return dntShim.Response.json(
           {
             code: "NO_AI_AVAILABLE",
             fallback: "browser",
             model: DEFAULT_LOCAL_MODEL,
-            systemPrompt,
           },
           { status: 503 },
         );

package/src/src/agent/factory.ts

@@ -1,11 +1,19 @@
 import * as dntShim from "../../_dnt.shims.js";
-import type { Agent, AgentConfig, AgentResponse, Message } from "./types.js";
+import type { Agent, AgentConfig, AgentResponse, AgentStreamResult, Message } from "./types.js";
 import { AgentRuntime } from "./runtime/index.js";
 import {
   detectPlatform,
   validatePlatformCompatibility,
 } from "../platform/core-platform.js";
 import { registerTool } from "../mcp/index.js";
+import { toolRegistry } from "../tool/index.js";
+import { skillRegistry } from "../skill/registry.js";
+import { buildSkillManifestPrompt } from "../skill/prompt-augmentation.js";
+import {
+  createExecuteSkillScriptTool,
+  createLoadSkillReferenceTool,
+  createLoadSkillTool,
+} from "../skill/tools.js";
 import { agentRegistry } from "./composition/index.js";
 import { agentLogger } from "../utils/logger/logger.js";
 import { createError, toError } from "../errors/veryfront-error.js";
@@ -18,13 +26,11 @@ const STREAMING_HEADERS: Record<string, string> = {
   "x-vercel-ai-ui-message-stream": "v1",
 };
 
-export interface AgentStreamResult {
-  toDataStreamResponse(options?: {
-    headers?: Record<string, string>;
-    status?: number;
-    statusText?: string;
-  }): dntShim.Response;
-}
+const SKILL_TOOL_REGISTRATIONS = [
+  { id: "load-skill", create: createLoadSkillTool },
+  { id: "load-skill-reference", create: createLoadSkillReferenceTool },
+  { id: "execute-skill-script", create: createExecuteSkillScriptTool },
+] as const;
 
 function createAgentStreamResult(stream: ReadableStream<Uint8Array>): AgentStreamResult {
   return {
@@ -60,6 +66,45 @@ export function agent(config: AgentConfig): Agent {
     }
   }
 
+  // Skill tool registration (immutable config merge)
+  let mergedToolsConfig = config.tools;
+
+  if (config.skills) {
+    // Skill tools (load-skill, load-skill-reference, execute-skill-script) are
+    // framework infrastructure — shared across all projects. Project tools and
+    // skills themselves remain project-scoped. Using registerShared avoids
+    // scope mismatch between module-load time and request-handling time.
+    for (const registration of SKILL_TOOL_REGISTRATIONS) {
+      if (!toolRegistry.has(registration.id)) {
+        toolRegistry.registerShared(registration.id, registration.create());
+      }
+    }
+
+    // Ensure skill tools are enabled for this agent even when config.tools is undefined
+    if (config.tools !== true) {
+      mergedToolsConfig = {
+        ...(config.tools ?? {}),
+        "load-skill": true,
+        "load-skill-reference": true,
+        "execute-skill-script": true,
+      };
+    }
+  }
+
+  // System prompt augmentation with skill manifest.
+  // Re-resolve skills at invocation time so HMR changes are picked up.
+  const originalSystem = config.system;
+  const augmentedSystem = config.skills
+    ? async () => {
+      const currentSkills = skillRegistry.resolveForAgent(config.skills!);
+      const basePrompt = typeof originalSystem === "function"
+        ? await originalSystem()
+        : originalSystem;
+      if (!currentSkills.size) return basePrompt ?? "You are a helpful AI assistant.";
+      return `${basePrompt}\n\n${buildSkillManifestPrompt(currentSkills)}`;
+    }
+    : originalSystem;
+
   const platform = detectPlatform();
   const compatibility = validatePlatformCompatibility(
     {
@@ -86,7 +131,11 @@ export function agent(config: AgentConfig): Agent {
     agentLogger.warn(`Agent "${id}" warnings:\n${compatibility.warnings.join("\n")}`);
   }
 
-  const runtime = new AgentRuntime(id, config);
+  const runtime = new AgentRuntime(id, {
+    ...config,
+    tools: mergedToolsConfig,
+    system: augmentedSystem,
+  });
 
   const agentInstance: Agent = {
     id,

package/src/src/agent/index.ts

@@ -29,11 +29,26 @@
  * const assistant = agent({
  *   model: "openai/gpt-4o",
  *   system: "You are a helpful assistant.",
- *   tools: [searchTool],
+ *   tools: { search: searchTool },
  *   memory: { type: "conversation", maxMessages: 50 },
  * });
  * ```
  *
+ * @example Agent with skills
+ * ```ts
+ * import { agent } from "veryfront/agent";
+ *
+ * const assistant = agent({
+ *   model: "openai/gpt-4o",
+ *   system: "You are a support engineer. Use skills when relevant.",
+ *   skills: ["incident-response", "repo-maintainer"], // or `true` for all discovered skills
+ *   tools: {
+ *     Read: true,
+ *     "github:list-issues": true,
+ *   },
+ * });
+ * ```
+ *
  * @example Streaming API route
  * ```ts
  * // app/api/chat/route.ts
@@ -124,5 +139,12 @@ export {
 } from "./composition/index.js";
 
 export { agent } from "./factory.js";
-export { type ChatHandlerOptions, createChatHandler } from "./chat-handler.js";
+export {
+  type ChatHandlerBeforeStream,
+  type ChatHandlerBeforeStreamContext,
+  type ChatHandlerBeforeStreamResult,
+  type ChatHandlerMessageInput,
+  type ChatHandlerOptions,
+  createChatHandler,
+} from "./chat-handler.js";
 export { AgentRuntime } from "./runtime/index.js";

package/src/src/agent/memory/memory.ts

@@ -3,20 +3,11 @@ import {
   getTextFromMemoryParts,
   type Memory,
   type MemoryConfigBase,
-  type MemoryPersistence,
   type MemoryStats,
   type MinimalMessage,
 } from "./memory-interface.js";
 import { withSpan, withSpanSync } from "../../observability/tracing/otlp-setup.js";
 
-export {
-  estimateTokens,
-  type Memory,
-  type MemoryPersistence,
-  type MemoryStats,
-  type MinimalMessage,
-};
-
 type BasicMemoryType = "conversation" | "buffer";
 
 function getMessagesWithTrace<M extends MinimalMessage>(

package/src/src/agent/react/index.ts

@@ -6,11 +6,13 @@
 
 export { useChat } from "./use-chat/index.js";
 export type {
+  BranchInfo,
   BrowserInferenceStatus,
   DynamicToolUIPart,
   InferenceMode,
   OnToolCallArg,
   ReasoningUIPart,
+  StepUIPart,
   TextUIPart,
   ToolOutput,
   ToolResultUIPart,

package/src/src/agent/react/use-chat/index.ts

@@ -7,11 +7,13 @@
 
 export { useChat } from "./use-chat.js";
 export type {
+  BranchInfo,
   BrowserInferenceStatus,
   DynamicToolUIPart,
   InferenceMode,
   OnToolCallArg,
   ReasoningUIPart,
+  StepUIPart,
   TextUIPart,
   ToolOutput,
   ToolResultUIPart,

package/src/src/agent/react/use-chat/streaming/handler.ts

@@ -1,16 +1,24 @@
 import type { ToolUIPart, UIMessagePart } from "../types.js";
 import { createAssistantMessage, generateClientId } from "../utils.js";
 import { buildCurrentParts } from "./parts-builder.js";
-import type { OrderedReasoning, OrderedToolCall, StreamingCallbacks, TextBlock } from "./types.js";
+import type {
+  OrderedReasoning,
+  OrderedStep,
+  OrderedToolCall,
+  StreamingCallbacks,
+  TextBlock,
+} from "./types.js";
 
 interface StreamingState {
   textBlocks: Map<string, TextBlock>;
   toolCalls: Map<string, OrderedToolCall>;
   reasoningBlocks: Map<string, OrderedReasoning>;
+  steps: Map<number, OrderedStep>;
   messageParts: UIMessagePart[];
   currentTextId: string;
   messageId: string;
   partOrderCounter: number;
+  currentStep: number;
 }
 
 function createStreamingState(): StreamingState {
@@ -18,10 +26,12 @@ function createStreamingState(): StreamingState {
     textBlocks: new Map(),
     toolCalls: new Map(),
     reasoningBlocks: new Map(),
+    steps: new Map(),
     messageParts: [],
     currentTextId: "",
     messageId: "",
     partOrderCounter: 0,
+    currentStep: 0,
   };
 }
 
@@ -34,14 +44,19 @@ export async function handleStreamingResponse(
   const state = createStreamingState();
 
   const getBuildParts = (): UIMessagePart[] =>
-    buildCurrentParts(state.textBlocks, state.reasoningBlocks, state.toolCalls);
+    buildCurrentParts(state.textBlocks, state.reasoningBlocks, state.toolCalls, state.steps);
+
+  let buffer = "";
 
   while (true) {
     const { done, value } = await reader.read();
-    if (done) return;
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? ""; // last element may be incomplete
 
-    const chunk = decoder.decode(value, { stream: true });
-    for (const line of chunk.split("\n")) {
+    for (const line of lines) {
       if (!line.startsWith("data: ") || !line.trim()) continue;
 
       const data = line.slice(6);
@@ -53,6 +68,16 @@ export async function handleStreamingResponse(
       }
     }
   }
+
+  // Process any remaining buffered data
+  if (buffer.startsWith("data: ") && buffer.trim()) {
+    try {
+      const parsed = JSON.parse(buffer.slice(6)) as Record<string, unknown>;
+      processEvent(parsed, state, callbacks, getBuildParts);
+    } catch {
+      // Skip invalid JSON
+    }
+  }
 }
 
 function processEvent(
@@ -69,7 +94,11 @@ function processEvent(
       return;
 
     case "step-start":
+      handleStepStart(parsed, state, callbacks.onUpdate, getBuildParts);
+      return;
+
     case "step-end":
+      handleStepEnd(parsed, state, callbacks.onUpdate, getBuildParts);
       return;
 
     case "text-start":
@@ -351,6 +380,38 @@ function handleReasoningEnd(
   onUpdate?.(getBuildParts(), state.messageId);
 }
 
+function handleStepStart(
+  _parsed: Record<string, unknown>,
+  state: StreamingState,
+  onUpdate: StreamingCallbacks["onUpdate"],
+  getBuildParts: () => UIMessagePart[],
+): void {
+  const stepIndex = state.currentStep;
+  const step: OrderedStep = {
+    index: stepIndex,
+    isComplete: false,
+    order: state.partOrderCounter++,
+  };
+  state.steps.set(stepIndex, step);
+  onUpdate?.(getBuildParts(), state.messageId);
+}
+
+function handleStepEnd(
+  _parsed: Record<string, unknown>,
+  state: StreamingState,
+  onUpdate: StreamingCallbacks["onUpdate"],
+  getBuildParts: () => UIMessagePart[],
+): void {
+  const step = state.steps.get(state.currentStep);
+  if (step) {
+    step.isComplete = true;
+    // Add a step-end order entry so the UI can render a completion marker
+    step.order = state.partOrderCounter++;
+  }
+  state.currentStep++;
+  onUpdate?.(getBuildParts(), state.messageId);
+}
+
 function handleFinish(
   state: StreamingState,
   onMessage: StreamingCallbacks["onMessage"],

package/src/src/agent/react/use-chat/streaming/parts-builder.ts

@@ -1,5 +1,5 @@
 import type { ToolUIPart, UIMessagePart } from "../types.js";
-import type { OrderedReasoning, OrderedToolCall, TextBlock } from "./types.js";
+import type { OrderedReasoning, OrderedStep, OrderedToolCall, TextBlock } from "./types.js";
 
 interface OrderedPart {
   order: number;
@@ -10,12 +10,14 @@ export function buildCurrentParts(
   textBlocks: Map<string, TextBlock>,
   reasoningBlocks: Map<string, OrderedReasoning>,
   toolCalls: Map<string, OrderedToolCall>,
+  steps?: Map<number, OrderedStep>,
 ): UIMessagePart[] {
   const orderedParts: OrderedPart[] = [];
 
   addTextParts(orderedParts, textBlocks);
   addReasoningParts(orderedParts, reasoningBlocks);
   addToolParts(orderedParts, toolCalls);
+  if (steps) addStepParts(orderedParts, steps);
 
   orderedParts.sort((a, b) => a.order - b.order);
   return orderedParts.map(({ part }) => part);
@@ -72,3 +74,18 @@ function addToolParts(
     orderedParts.push({ order: tool.order, part });
   }
 }
+
+function addStepParts(
+  orderedParts: OrderedPart[],
+  steps: Map<number, OrderedStep>,
+): void {
+  for (const step of steps.values()) {
+    orderedParts.push({
+      order: step.order,
+      part: {
+        type: step.isComplete ? "step-end" : "step-start",
+        stepIndex: step.index,
+      },
+    });
+  }
+}

package/src/src/agent/react/use-chat/streaming/types.ts

@@ -31,5 +31,11 @@ export interface TextBlock {
   order: number | null;
 }
 
+export interface OrderedStep {
+  index: number;
+  isComplete: boolean;
+  order: number;
+}
+
 export type OrderedToolCall = StreamingToolCall & { order: number };
 export type OrderedReasoning = StreamingReasoning & { order: number };

package/src/src/agent/react/use-chat/types.ts

@@ -60,12 +60,18 @@ export interface DynamicToolUIPart {
   errorText?: string;
 }
 
+export interface StepUIPart {
+  type: "step-start" | "step-end";
+  stepIndex: number;
+}
+
 export type UIMessagePart =
   | TextUIPart
   | ReasoningUIPart
   | ToolUIPart
   | ToolResultUIPart
-  | DynamicToolUIPart;
+  | DynamicToolUIPart
+  | StepUIPart;
 
 export interface UIMessage {
   id: string;
@@ -112,6 +118,11 @@ export interface UseChatOptions {
   onToolCall?: (arg: OnToolCallArg) => void | Promise<void>;
 }
 
+export interface BranchInfo {
+  current: number;
+  total: number;
+}
+
 export interface UseChatResult {
   messages: UIMessage[];
   input: string;
@@ -119,6 +130,8 @@ export interface UseChatResult {
   error: Error | null;
   /** Current model override (undefined = use agent default) */
   model: string | undefined;
+  /** The actual model being used after auto-upgrade (e.g. "anthropic/claude-sonnet-4-20250514") */
+  activeModel: string | undefined;
   /** Where inference is currently happening */
   inferenceMode: InferenceMode;
   /** Browser-side model loading/inference status (null when not using browser fallback) */
@@ -127,6 +140,12 @@ export interface UseChatResult {
   /** Change the model for subsequent requests */
   setModel: (model: string | undefined) => void;
   sendMessage: (message: { text: string }) => Promise<void>;
+  /** Edit a user message and resubmit — truncates history to that point */
+  editMessage: (messageId: string, newText: string) => Promise<void>;
+  /** Get branch info for a message (returns { current, total }; total=1 if no branches) */
+  getBranches: (messageId: string) => BranchInfo;
+  /** Switch to a different branch at a given message */
+  switchBranch: (messageId: string, branchIndex: number) => void;
   reload: () => Promise<void>;
   stop: () => void;
   setMessages: (messages: UIMessage[]) => void;
@@ -134,4 +153,10 @@ export interface UseChatResult {
   data?: unknown;
   handleInputChange: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
   handleSubmit: (e: React.FormEvent) => Promise<void>;
+  /** Alias for `handleInputChange` — matches `ChatProps.onChange` for easy spreading */
+  onChange: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+  /** Alias for `handleSubmit` — matches `ChatProps.onSubmit` for easy spreading */
+  onSubmit: (e: React.FormEvent) => Promise<void>;
+  /** Alias for `setModel` — matches `ChatProps.onModelChange` for easy spreading */
+  onModelChange: (model: string | undefined) => void;
 }