veryfront 0.1.152 → 0.1.155

package/esm/src/routing/api/module-loader/loader.js

@@ -293,24 +293,32 @@ function createImportMapPlugin(projectDir, adapter, config) {
                 logger.debug(`Import map resolved: ${args.path} -> ${absolutePath}`);
                 return { path: absolutePath, namespace: "import-map" };
             });
-            build.onLoad({ filter: /.*/, namespace: "import-map" }, wrapWithCurrentContext(async (args) => {
-                try {
-                    const { filePath, contents } = await readFileWithExtensions(adapter, args.path, FILE_EXTENSIONS, projectDir);
-                    return {
-                        contents,
-                        loader: getLoaderForFile(filePath),
-                        resolveDir: pathHelper.dirname(filePath),
-                    };
-                }
-                catch (error) {
-                    const msg = error instanceof Error ? error.message : String(error);
-                    logger.error(`Failed to load file via import map: ${args.path}`, error);
-                    return { errors: [{ text: `Failed to load: ${msg}` }] };
-                }
+            build.onLoad({ filter: /.*/, namespace: "import-map" }, createNamespaceOnLoadHandler({
+                adapter,
+                projectDir,
+                errorLabel: "file via import map",
             }));
         },
     };
 }
+function createNamespaceOnLoadHandler(options) {
+    const { adapter, projectDir, errorLabel } = options;
+    return wrapWithCurrentContext(async (args) => {
+        try {
+            const { filePath, contents } = await readFileWithExtensions(adapter, args.path, FILE_EXTENSIONS, projectDir);
+            return {
+                contents,
+                loader: getLoaderForFile(filePath),
+                resolveDir: pathHelper.dirname(filePath),
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.error(`Failed to load ${errorLabel}: ${args.path}`, error);
+            return { errors: [{ text: `Failed to load: ${msg}` }] };
+        }
+    });
+}
 /** Resolves relative imports through the adapter's virtual FS for remote projects. */
 function createAdapterResolvePlugin(adapter, projectDir) {
     return {
@@ -337,20 +345,10 @@ function createAdapterResolvePlugin(adapter, projectDir) {
             // callbacks fire from the child process message handler, losing the
             // AsyncLocalStorage store. Without this, MultiProjectFSAdapter.getAdapter()
             // cannot resolve the per-project adapter and all file reads fail silently.
-            build.onLoad({ filter: /.*/, namespace: "vf-adapter" }, wrapWithCurrentContext(async (args) => {
-                try {
-                    const { filePath, contents } = await readFileWithExtensions(adapter, args.path, FILE_EXTENSIONS, projectDir);
-                    return {
-                        contents,
-                        loader: getLoaderForFile(filePath),
-                        resolveDir: pathHelper.dirname(filePath),
-                    };
-                }
-                catch (error) {
-                    const msg = error instanceof Error ? error.message : String(error);
-                    logger.error(`Failed to load via adapter: ${args.path}`, error);
-                    return { errors: [{ text: `Failed to load: ${msg}` }] };
-                }
+            build.onLoad({ filter: /.*/, namespace: "vf-adapter" }, createNamespaceOnLoadHandler({
+                adapter,
+                projectDir,
+                errorLabel: "via adapter",
             }));
         },
     };

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

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.152";
+export declare const VERSION = "0.1.155";
 //# 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.152";
+export const VERSION = "0.1.155";

package/package.json

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

package/src/deno.js

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

package/src/src/agent/ag-ui-handler.ts

@@ -2,7 +2,14 @@ import * as dntShim from "../../_dnt.shims.js";
 import { z } from "zod";
 import { getAgent } from "./composition/index.js";
 import type { Agent, Message } from "./types.js";
+import {
+  AgentRuntime,
+  RunAlreadyExistsError,
+  type RunResumeSessionManager,
+} from "./runtime/index.js";
 import { INVALID_ARGUMENT } from "../errors/index.js";
+import { SKILL_TOOL_IDS } from "../skill/types.js";
+import { type Tool, toolRegistry } from "../tool/index.js";
 import {
   createStreamTransformState,
   finalizeRunEvents,
@@ -101,6 +108,7 @@ export type AgUiContextItem = z.infer<typeof AgUiContextItemSchema>;
 export type AgUiRequest = z.infer<typeof AgUiRequestSchema>;
 
 type AgUiRuntimePart = Record<string, unknown> & { type: string };
+type AgUiResumeValue = { result: unknown; isError: boolean };
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -259,24 +267,29 @@ function enqueueEvent(
 }
 
 async function createAgUiStreamResponse(
-  agent: Agent,
-  request: AgUiRequest,
-  baseContext: Record<string, unknown>,
+  options: {
+    agentId: string;
+    request: AgUiRequest;
+    runId: string;
+    threadId: string;
+    upstreamBody: ReadableStream<Uint8Array> | null;
+    upstreamStatus: number;
+    upstreamStatusText?: string;
+    onFinish?: () => void;
+    onError?: (error: unknown) => void;
+  },
 ): Promise<dntShim.Response> {
-  const threadId = request.threadId ?? dntShim.crypto.randomUUID();
-  const runId = request.runId ?? generateRunId();
-
-  await agent.clearMemory();
-
-  const result = await agent.stream({
-    messages: normalizeMessages(request.messages),
-    context: buildStreamContext(request, baseContext, threadId, runId),
-    ...(request.model ? { model: request.model } : {}),
-    ...(request.maxOutputTokens ? { maxOutputTokens: request.maxOutputTokens } : {}),
-  });
-
-  const upstream = result.toDataStreamResponse();
-  const upstreamBody = upstream.body;
+  const {
+    agentId,
+    request,
+    runId,
+    threadId,
+    upstreamBody,
+    upstreamStatus,
+    upstreamStatusText,
+    onFinish,
+    onError,
+  } = options;
 
   const stream = new ReadableStream<Uint8Array>({
     start: async (controller) => {
@@ -285,7 +298,7 @@ async function createAgUiStreamResponse(
       let remainder = "";
       const decoder = new TextDecoder();
 
-      if (!enqueueEvent(controller, "RunStarted", { runId, threadId, agentId: agent.id })) {
+      if (!enqueueEvent(controller, "RunStarted", { runId, threadId, agentId })) {
         return;
       }
       if (!enqueueEvent(controller, "StateSnapshot", { snapshot: {} })) {
@@ -302,6 +315,7 @@ async function createAgUiStreamResponse(
               return;
             }
           }
+          onFinish?.();
           closeController(controller);
           return;
         }
@@ -340,7 +354,9 @@ async function createAgUiStreamResponse(
             return;
           }
         }
+        onFinish?.();
       } catch (error) {
+        onError?.(error);
         enqueueEvent(controller, "RunError", {
           message: error instanceof Error ? error.message : "Agent run failed",
         });
@@ -352,16 +368,147 @@ async function createAgUiStreamResponse(
   });
 
   return new dntShim.Response(stream, {
-    status: upstream.status,
-    statusText: upstream.statusText,
+    status: upstreamStatus,
+    statusText: upstreamStatusText,
     headers: { ...AG_UI_HEADERS },
   });
 }
 
+async function createAgUiDirectStreamResponse(
+  agent: Agent,
+  request: AgUiRequest,
+  baseContext: Record<string, unknown>,
+): Promise<dntShim.Response> {
+  const threadId = request.threadId ?? dntShim.crypto.randomUUID();
+  const runId = request.runId ?? generateRunId();
+
+  await agent.clearMemory();
+
+  const result = await agent.stream({
+    messages: normalizeMessages(request.messages),
+    context: buildStreamContext(request, baseContext, threadId, runId),
+    ...(request.model ? { model: request.model } : {}),
+    ...(request.maxOutputTokens ? { maxOutputTokens: request.maxOutputTokens } : {}),
+  });
+
+  const upstream = result.toDataStreamResponse();
+  return await createAgUiStreamResponse({
+    agentId: agent.id,
+    request,
+    runId,
+    threadId,
+    upstreamBody: upstream.body,
+    upstreamStatus: upstream.status,
+    upstreamStatusText: upstream.statusText,
+  });
+}
+
+function createInjectedAgUiTool(
+  runId: string,
+  tool: AgUiInjectedTool,
+  sessionManager: RunResumeSessionManager<AgUiResumeValue>,
+): Tool {
+  return {
+    id: tool.name,
+    type: "function",
+    description: tool.description ?? tool.name,
+    inputSchema: z.record(z.string(), z.unknown()),
+    inputSchemaJson: (tool.parameters ??
+      { type: "object", properties: {}, additionalProperties: true }) as Tool["inputSchemaJson"],
+    execute: async (_input, context) => {
+      const toolCallId = typeof context?.toolCallId === "string" ? context.toolCallId : null;
+      if (!toolCallId) {
+        throw new Error(`Missing toolCallId for injected tool "${tool.name}"`);
+      }
+
+      const submitted = await sessionManager.waitForSignal(runId, toolCallId);
+      if (submitted.isError) {
+        throw new Error(
+          typeof submitted.result === "string"
+            ? submitted.result
+            : JSON.stringify(submitted.result),
+        );
+      }
+      return submitted.result;
+    },
+  };
+}
+
+async function createAgUiInjectedToolsStreamResponse(
+  agent: Agent,
+  request: AgUiRequest,
+  baseContext: Record<string, unknown>,
+  sessionManager: RunResumeSessionManager<AgUiResumeValue>,
+): Promise<dntShim.Response> {
+  const threadId = request.threadId ?? dntShim.crypto.randomUUID();
+  const runId = request.runId ?? generateRunId();
+
+  try {
+    sessionManager.startRun({ runId, threadId });
+  } catch (error) {
+    if (error instanceof RunAlreadyExistsError) {
+      return dntShim.Response.json({ error: "Run already active" }, { status: 409 });
+    }
+    throw error;
+  }
+
+  const injectedTools = Object.fromEntries(
+    request.tools.map((tool) => [tool.name, createInjectedAgUiTool(runId, tool, sessionManager)]),
+  );
+
+  const mergedTools: Agent["config"]["tools"] = !agent.config.tools
+    ? injectedTools
+    : agent.config.tools === true
+    ? {
+      ...Object.fromEntries(
+        [...toolRegistry.getAll()]
+          .filter(([toolId]) => agent.config.skills || !SKILL_TOOL_IDS.has(toolId))
+          .map(([toolId]) => [toolId, true]),
+      ),
+      ...injectedTools,
+    }
+    : { ...agent.config.tools, ...injectedTools };
+
+  const runtime = new AgentRuntime(agent.id, {
+    ...agent.config,
+    tools: mergedTools,
+  });
+
+  let upstreamBody: ReadableStream<Uint8Array>;
+  try {
+    upstreamBody = await runtime.stream(
+      normalizeMessages(request.messages),
+      buildStreamContext(request, baseContext, threadId, runId),
+      undefined,
+      request.model,
+      request.maxOutputTokens,
+    );
+  } catch (error) {
+    sessionManager.failRun(runId);
+    throw error;
+  }
+
+  return await createAgUiStreamResponse({
+    agentId: agent.id,
+    request,
+    runId,
+    threadId,
+    upstreamBody,
+    upstreamStatus: 200,
+    onFinish: () => {
+      sessionManager.completeRun(runId);
+    },
+    onError: () => {
+      sessionManager.failRun(runId);
+    },
+  });
+}
+
 export interface AgUiHandlerOptions {
   context?:
     | Record<string, unknown>
     | ((request: dntShim.Request) => Record<string, unknown> | Promise<Record<string, unknown>>);
+  sessionManager?: RunResumeSessionManager<AgUiResumeValue>;
 }
 
 export interface AgUiHandlerConfigWithAgent extends AgUiHandlerOptions {
@@ -418,12 +565,25 @@ export function createAgUiHandler(
       const parsed = AgUiRequestSchema.parse(await request.json());
 
       if (parsed.tools.length > 0) {
-        return dntShim.Response.json(
-          {
-            error:
-              "Injected AG-UI tools are not supported by createAgUiHandler yet. Use package-level wait/resume runtime primitives instead.",
-          },
-          { status: 501 },
+        if (!options?.sessionManager) {
+          return dntShim.Response.json(
+            {
+              error:
+                "Injected AG-UI tools require a public RunResumeSessionManager on createAgUiHandler().",
+            },
+            { status: 501 },
+          );
+        }
+
+        const context = typeof options?.context === "function"
+          ? await options.context(request)
+          : options?.context ?? {};
+
+        return await createAgUiInjectedToolsStreamResponse(
+          agent,
+          parsed,
+          context,
+          options.sessionManager,
         );
       }
 
@@ -431,7 +591,7 @@ export function createAgUiHandler(
         ? await options.context(request)
         : options?.context ?? {};
 
-      return await createAgUiStreamResponse(agent, parsed, context);
+      return await createAgUiDirectStreamResponse(agent, parsed, context);
     } catch (error) {
       if (error instanceof z.ZodError) {
         return dntShim.Response.json(

package/src/src/agent/ag-ui-run-control.ts

@@ -0,0 +1,161 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { z } from "zod";
+import { INVALID_ARGUMENT } from "../errors/index.js";
+import {
+  RunNotActiveError,
+  RunResumeSessionManager,
+  WaitConflictError,
+  WaitNotPendingError,
+} from "./runtime/resume-session.js";
+
+const RESUME_PATH_REGEX = /^\/api\/ag-ui\/runs\/([^/]+)\/resume$/;
+const CANCEL_PATH_REGEX = /^\/api\/ag-ui\/runs\/([^/]+)$/;
+
+export const AgUiResumeSignalSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("tool_result"),
+    toolCallId: z.string().min(1).max(128),
+    result: z.unknown(),
+    isError: z.boolean().optional().default(false),
+  }),
+]);
+
+export type AgUiResumeSignal = z.infer<typeof AgUiResumeSignalSchema>;
+
+type ResumeValue = {
+  result: unknown;
+  isError: boolean;
+};
+
+function isRequest(value: unknown): value is dntShim.Request {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "json" in value &&
+    typeof value.json === "function" &&
+    "url" in value &&
+    typeof value.url === "string" &&
+    "method" in value &&
+    typeof value.method === "string"
+  );
+}
+
+function extractRequest(requestOrCtx: unknown): dntShim.Request {
+  if (isRequest(requestOrCtx)) return requestOrCtx;
+
+  if (typeof requestOrCtx === "object" && requestOrCtx !== null && "request" in requestOrCtx) {
+    const candidate = (requestOrCtx as Record<string, unknown>).request;
+    if (isRequest(candidate)) return candidate;
+  }
+
+  throw INVALID_ARGUMENT.create({
+    detail: "Invalid handler argument: expected Request or APIContext",
+  });
+}
+
+function getRunId(pathname: string, regex: RegExp): string | null {
+  return regex.exec(pathname)?.[1] ?? null;
+}
+
+export interface AgUiRunControlHandlerOptions {
+  resolveRunId?:
+    | ((input: { request: dntShim.Request; requestOrCtx: unknown }) => string | null)
+    | ((input: { request: dntShim.Request; requestOrCtx: unknown }) => Promise<string | null>);
+}
+
+export interface AgUiResumeHandlerOptions extends AgUiRunControlHandlerOptions {
+  sessionManager: RunResumeSessionManager<ResumeValue>;
+}
+
+export interface AgUiCancelHandlerOptions<T = unknown> extends AgUiRunControlHandlerOptions {
+  sessionManager: RunResumeSessionManager<T>;
+}
+
+async function resolveRunId(
+  requestOrCtx: unknown,
+  request: dntShim.Request,
+  options: AgUiRunControlHandlerOptions | undefined,
+  regex: RegExp,
+): Promise<string | null> {
+  const explicit = await options?.resolveRunId?.({ request, requestOrCtx });
+  if (explicit) return explicit;
+  return getRunId(new URL(request.url).pathname, regex);
+}
+
+export function createAgUiResumeHandler(
+  options: AgUiResumeHandlerOptions,
+): (requestOrCtx: unknown) => Promise<dntShim.Response> {
+  return async function POST(requestOrCtx: unknown): Promise<dntShim.Response> {
+    const request = extractRequest(requestOrCtx);
+    const runId = await resolveRunId(requestOrCtx, request, options, RESUME_PATH_REGEX);
+
+    if (!runId) {
+      return dntShim.Response.json({ error: "Run not found" }, { status: 404 });
+    }
+
+    try {
+      const parsed = AgUiResumeSignalSchema.parse(await request.json());
+      const outcome = options.sessionManager.submitSignal(runId, {
+        waitKey: parsed.toolCallId,
+        value: {
+          result: parsed.result,
+          isError: parsed.isError,
+        },
+      });
+
+      return dntShim.Response.json(outcome, { status: 200 });
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return dntShim.Response.json(
+          {
+            error: "Invalid AG-UI resume request",
+            details: error.issues.map((issue) => ({
+              path: issue.path,
+              message: issue.message,
+            })),
+          },
+          { status: 400 },
+        );
+      }
+
+      if (error instanceof WaitConflictError) {
+        return dntShim.Response.json({ error: "TOOL_RESULT_CONFLICT" }, { status: 409 });
+      }
+
+      if (error instanceof WaitNotPendingError) {
+        return dntShim.Response.json({ error: "TOOL_RESULT_NOT_WAITING" }, { status: 409 });
+      }
+
+      if (error instanceof RunNotActiveError) {
+        return dntShim.Response.json({ error: "RUN_NOT_ACTIVE" }, { status: 410 });
+      }
+
+      return dntShim.Response.json(
+        {
+          error: error instanceof Error ? error.message : "Internal resume failed",
+        },
+        { status: 500 },
+      );
+    }
+  };
+}
+
+export function createAgUiCancelHandler<T = unknown>(
+  options: AgUiCancelHandlerOptions<T>,
+): (requestOrCtx: unknown) => Promise<dntShim.Response> {
+  return async function DELETE(requestOrCtx: unknown): Promise<dntShim.Response> {
+    const request = extractRequest(requestOrCtx);
+    const runId = await resolveRunId(requestOrCtx, request, options, CANCEL_PATH_REGEX);
+
+    if (!runId) {
+      return dntShim.Response.json({ error: "Run not found" }, { status: 404 });
+    }
+
+    const accepted = options.sessionManager.cancelRun(runId);
+    if (accepted) {
+      return dntShim.Response.json({ accepted: true }, { status: 202 });
+    }
+
+    return new dntShim.Response(null, { status: 204 });
+  };
+}

package/src/src/agent/index.ts

@@ -145,6 +145,14 @@ export {
   type AgUiRuntimeRequest,
   AgUiRuntimeRequestSchema,
 } from "./runtime-ag-ui-contract.js";
+export {
+  type AgUiCancelHandlerOptions,
+  type AgUiResumeHandlerOptions,
+  type AgUiResumeSignal,
+  AgUiResumeSignalSchema,
+  createAgUiCancelHandler,
+  createAgUiResumeHandler,
+} from "./ag-ui-run-control.js";
 export {
   type AgUiContextItem,
   type AgUiHandlerConfigWithAgent,

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

@@ -15,6 +15,7 @@ import { serverLogger } from "../../utils/index.js";
 import { isAnyDebugEnabled } from "../../utils/constants/env.js";
 import { setActiveSpanAttributes, withSpan } from "../../observability/tracing/otlp-setup.js";
 import { getHostEnv } from "../../platform/compat/process.js";
+import { stringifyToolError, throwIfAborted } from "./error-utils.js";
 
 const logger = serverLogger.component("agent");
 
@@ -84,39 +85,6 @@ function normalizeToolInputObject(input: unknown): Record<string, unknown> {
   return {};
 }
 
-function createAbortError(reason?: unknown): Error {
-  if (reason instanceof Error) {
-    return reason;
-  }
-
-  return new DOMException(
-    typeof reason === "string" && reason.length > 0 ? reason : "The operation was aborted",
-    "AbortError",
-  );
-}
-
-function throwIfAborted(abortSignal?: AbortSignal): void {
-  if (abortSignal?.aborted) {
-    throw createAbortError(abortSignal.reason);
-  }
-}
-
-function stringifyToolError(output: unknown): string {
-  if (typeof output === "string" && output.length > 0) {
-    return output;
-  }
-
-  if (output instanceof Error && typeof output.message === "string" && output.message.length > 0) {
-    return output.message;
-  }
-
-  try {
-    return JSON.stringify(output);
-  } catch {
-    return String(output);
-  }
-}
-
 function summarizeDebugValue(value: unknown): unknown {
   if (value instanceof Error) {
     return {

package/src/src/agent/runtime/error-utils.ts

@@ -0,0 +1,32 @@
+export function createAbortError(reason?: unknown): Error {
+  if (reason instanceof Error) {
+    return reason;
+  }
+
+  return new DOMException(
+    typeof reason === "string" && reason.length > 0 ? reason : "The operation was aborted",
+    "AbortError",
+  );
+}
+
+export function throwIfAborted(abortSignal?: AbortSignal): void {
+  if (abortSignal?.aborted) {
+    throw createAbortError(abortSignal.reason);
+  }
+}
+
+export function stringifyToolError(error: unknown): string {
+  if (typeof error === "string" && error.length > 0) {
+    return error;
+  }
+
+  if (error instanceof Error && typeof error.message === "string" && error.message.length > 0) {
+    return error.message;
+  }
+
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}