veryfront 0.1.151 → 0.1.154

package/esm/src/internal-agents/schema.d.ts

@@ -1,7 +1,18 @@
 import { z } from "zod";
+import { type AgUiRuntimeRequest } from "../agent/runtime-ag-ui-contract.js";
 export declare const RunIdSchema: z.ZodString;
 export declare const AgentIdSchema: z.ZodString;
-export declare const ClientToolNameSchema: z.ZodString;
+export declare const RuntimeAgentSourceContextSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"branch">;
+    branch: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"environment">;
+    environmentName: z.ZodString;
+    releaseId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"release">;
+    releaseId: z.ZodString;
+}, z.core.$strip>], "type">;
 export declare const RuntimeInjectedToolSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -22,71 +33,6 @@ export declare const RuntimeContextItemSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     mimeType: z.ZodOptional<z.ZodString>;
     text: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "type">;
-export declare const RuntimeAgentSourceContextSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"branch">;
-    branch: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"environment">;
-    environmentName: z.ZodString;
-    releaseId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"release">;
-    releaseId: z.ZodString;
-}, z.core.$strip>], "type">;
-export declare const RuntimeToolFunctionCallSchema: z.ZodObject<{
-    name: z.ZodString;
-    arguments: z.ZodString;
-}, z.core.$strict>;
-export declare const RuntimeToolCallSchema: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"function">;
-    function: z.ZodObject<{
-        name: z.ZodString;
-        arguments: z.ZodString;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const RuntimeSystemMessageSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    createdAt: z.ZodOptional<z.ZodString>;
-    id: z.ZodString;
-    role: z.ZodLiteral<"system">;
-    content: z.ZodString;
-}, z.core.$strict>;
-export declare const RuntimeUserMessageSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    createdAt: z.ZodOptional<z.ZodString>;
-    id: z.ZodString;
-    role: z.ZodLiteral<"user">;
-    content: z.ZodString;
-}, z.core.$strict>;
-export declare const RuntimeAssistantMessageSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    createdAt: z.ZodOptional<z.ZodString>;
-    id: z.ZodString;
-    role: z.ZodLiteral<"assistant">;
-    content: z.ZodOptional<z.ZodString>;
-    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"function">;
-        function: z.ZodObject<{
-            name: z.ZodString;
-            arguments: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export declare const RuntimeToolMessageSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    createdAt: z.ZodOptional<z.ZodString>;
-    id: z.ZodString;
-    role: z.ZodLiteral<"tool">;
-    toolCallId: z.ZodString;
-    content: z.ZodString;
-    error: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
 export declare const RuntimeMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -321,7 +267,7 @@ export declare const InternalAgentStreamRequestSchema: z.ZodObject<{
     }, z.core.$strip>], "type">>;
     forwardedProps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-export declare function toRuntimeRunAgentInput(input: z.infer<typeof InternalAgentStreamRequestSchema>): z.infer<typeof RuntimeRunAgentInputSchema>;
+export declare function toRuntimeRunAgentInput(input: z.infer<typeof InternalAgentStreamRequestSchema>): AgUiRuntimeRequest;
 export declare const ResumeSignalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"tool_result">;
     toolCallId: z.ZodString;
@@ -331,7 +277,7 @@ export declare const ResumeSignalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 export type RuntimeInjectedTool = z.infer<typeof RuntimeInjectedToolSchema>;
 export type RuntimeContextItem = z.infer<typeof RuntimeContextItemSchema>;
 export type RuntimeAgentSourceContext = z.infer<typeof RuntimeAgentSourceContextSchema>;
-export type RuntimeRunAgentInput = z.infer<typeof RuntimeRunAgentInputSchema>;
+export type RuntimeRunAgentInput = AgUiRuntimeRequest;
 export type InternalAgentStreamRequest = z.infer<typeof InternalAgentStreamRequestSchema>;
 export type ResumeSignal = z.infer<typeof ResumeSignalSchema>;
 //# sourceMappingURL=schema.d.ts.map

package/esm/src/internal-agents/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB,eAAO,MAAM,WAAW,aAAqD,CAAC;AAE9E,eAAO,MAAM,aAAa,aAAqD,CAAC;AAEhF,eAAO,MAAM,oBAAoB,aAO9B,CAAC;AAEJ,eAAO,MAAM,yBAAyB;;;;iBAOpC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;2BAqBnC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;2BAc1C,CAAC;AAQH,eAAO,MAAM,6BAA6B;;;kBAG/B,CAAC;AAEZ,eAAO,MAAM,qBAAqB;;;;;;;kBAIvB,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;;;;;kBAK5B,CAAC;AAEZ,eAAO,MAAM,wBAAwB;;;;;;;kBAK1B,CAAC;AAEZ,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;kBAM/B,CAAC;AAEZ,eAAO,MAAM,wBAAwB;;;;;;;;;kBAO1B,CAAC;AAEZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAK/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;6BAM/B,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAerC,CAAC;AAEH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;iBAMlD,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB3C,CAAC;AAyKH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,GACtD,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAW5C;AAED,eAAO,MAAM,kBAAkB;;;;;2BAU7B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAC1F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAML,KAAK,kBAAkB,EAIxB,MAAM,oCAAoC,CAAC;AAiB5C,eAAO,MAAM,WAAW,aAAyB,CAAC;AAElD,eAAO,MAAM,aAAa,aAAqD,CAAC;AAEhF,eAAO,MAAM,+BAA+B;;;;;;;;;;2BAc1C,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;iBAAgC,CAAC;AACvE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;2BAA+B,CAAC;AACrE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAA2B,CAAC;AAC7D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;6BAA2B,CAAC;AAC7D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2B,CAAC;AAEnE,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;iBAMlD,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB3C,CAAC;AAyKH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,GACtD,kBAAkB,CAWpB;AAED,eAAO,MAAM,kBAAkB;;;;;2BAU7B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,oBAAoB,GAAG,kBAAkB,CAAC;AACtD,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAC1F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/esm/src/internal-agents/schema.js

@@ -1,8 +1,6 @@
 import { z } from "zod";
+import { AgUiRuntimeContextItemSchema, AgUiRuntimeContextSchema, AgUiRuntimeInjectedToolSchema, AgUiRuntimeMessageSchema, AgUiRuntimeRequestSchema, AgUiRuntimeRunIdSchema, } from "../agent/runtime-ag-ui-contract.js";
 const AGENT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
-const MAX_TOOL_PARAMETERS_BYTES = 16_384;
-const MAX_CONTEXT_ITEM_BYTES = 16_384;
-const MAX_CONTEXT_TOTAL_BYTES = 65_536;
 const MAX_FORWARDED_PROPS_BYTES = 65_536;
 const MAX_TOOL_RESULT_BYTES = 65_536;
 const MAX_RUNTIME_MESSAGES = 100;
@@ -15,37 +13,8 @@ function isWithinJsonSizeLimit(value, maxBytes) {
         return false;
     }
 }
-export const RunIdSchema = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
+export const RunIdSchema = AgUiRuntimeRunIdSchema;
 export const AgentIdSchema = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
-export const ClientToolNameSchema = z
-    .string()
-    .min(1)
-    .max(128)
-    .regex(/^[a-zA-Z][a-zA-Z0-9._:-]*$/, "Tool names must start with a letter and use a valid client-tool format");
-export const RuntimeInjectedToolSchema = z.object({
-    name: ClientToolNameSchema,
-    description: z.string().max(1024).optional(),
-    parameters: z.record(z.string(), z.unknown()).optional().refine((value) => value === undefined || isWithinJsonSizeLimit(value, MAX_TOOL_PARAMETERS_BYTES), { message: "Tool parameters must be less than 16 KB" }),
-});
-export const RuntimeContextItemSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("text"),
-        title: z.string().max(256).optional(),
-        text: z.string().max(MAX_CONTEXT_ITEM_BYTES),
-    }),
-    z.object({
-        type: z.literal("json"),
-        title: z.string().max(256).optional(),
-        data: z.record(z.string(), z.unknown()).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_ITEM_BYTES), { message: "JSON context item must be less than 16 KB" }),
-    }),
-    z.object({
-        type: z.literal("resource"),
-        title: z.string().max(256).optional(),
-        uri: z.string().max(2048),
-        mimeType: z.string().max(256).optional(),
-        text: z.string().max(MAX_CONTEXT_ITEM_BYTES).optional(),
-    }),
-]);
 export const RuntimeAgentSourceContextSchema = z.discriminatedUnion("type", [
     z.object({
         type: z.literal("branch"),
@@ -61,70 +30,11 @@ export const RuntimeAgentSourceContextSchema = z.discriminatedUnion("type", [
         releaseId: z.string().min(1).max(255),
     }),
 ]);
-const RuntimeMessageExtensionFieldsSchema = {
-    name: z.string().max(256).optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    createdAt: z.string().optional(),
-};
-export const RuntimeToolFunctionCallSchema = z.object({
-    name: ClientToolNameSchema,
-    arguments: z.string().max(MAX_TOOL_PARAMETERS_BYTES),
-}).strict();
-export const RuntimeToolCallSchema = z.object({
-    id: z.string().min(1).max(128),
-    type: z.literal("function"),
-    function: RuntimeToolFunctionCallSchema,
-}).strict();
-export const RuntimeSystemMessageSchema = z.object({
-    id: z.string().min(1),
-    role: z.literal("system"),
-    content: z.string(),
-    ...RuntimeMessageExtensionFieldsSchema,
-}).strict();
-export const RuntimeUserMessageSchema = z.object({
-    id: z.string().min(1),
-    role: z.literal("user"),
-    content: z.string(),
-    ...RuntimeMessageExtensionFieldsSchema,
-}).strict();
-export const RuntimeAssistantMessageSchema = z.object({
-    id: z.string().min(1),
-    role: z.literal("assistant"),
-    content: z.string().optional(),
-    toolCalls: z.array(RuntimeToolCallSchema).optional(),
-    ...RuntimeMessageExtensionFieldsSchema,
-}).strict();
-export const RuntimeToolMessageSchema = z.object({
-    id: z.string().min(1),
-    role: z.literal("tool"),
-    toolCallId: z.string().min(1).max(128),
-    content: z.string(),
-    error: z.string().optional(),
-    ...RuntimeMessageExtensionFieldsSchema,
-}).strict();
-export const RuntimeMessageSchema = z.discriminatedUnion("role", [
-    RuntimeSystemMessageSchema,
-    RuntimeUserMessageSchema,
-    RuntimeAssistantMessageSchema,
-    RuntimeToolMessageSchema,
-]);
-export const RuntimeContextSchema = z.union([
-    z.object({
-        description: z.string().max(1024),
-        value: z.string().max(MAX_CONTEXT_ITEM_BYTES),
-    }),
-    RuntimeContextItemSchema,
-]);
-export const RuntimeRunAgentInputSchema = z.object({
-    threadId: z.string().uuid(),
-    runId: RunIdSchema,
-    parentRunId: RunIdSchema.optional(),
-    state: z.unknown().optional(),
-    messages: z.array(RuntimeMessageSchema).max(MAX_RUNTIME_MESSAGES),
-    tools: z.array(RuntimeInjectedToolSchema).max(50).default([]),
-    context: z.array(RuntimeContextSchema).max(10).default([]).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES), { message: "context must be less than 64 KB total" }),
-    forwardedProps: z.record(z.string(), z.unknown()).optional().refine((value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES), { message: "forwardedProps must be less than 64 KB" }),
-});
+export const RuntimeInjectedToolSchema = AgUiRuntimeInjectedToolSchema;
+export const RuntimeContextItemSchema = AgUiRuntimeContextItemSchema;
+export const RuntimeMessageSchema = AgUiRuntimeMessageSchema;
+export const RuntimeContextSchema = AgUiRuntimeContextSchema;
+export const RuntimeRunAgentInputSchema = AgUiRuntimeRequestSchema;
 export const InternalAgentCompatibilityMessageSchema = z.object({
     id: z.string().min(1),
     role: z.enum(["user", "assistant", "system", "tool"]),
@@ -140,7 +50,7 @@ export const InternalAgentStreamRequestSchema = z.object({
     state: z.unknown().optional(),
     messages: z.array(z.union([RuntimeMessageSchema, InternalAgentCompatibilityMessageSchema])).max(MAX_RUNTIME_MESSAGES),
     tools: z.array(RuntimeInjectedToolSchema).max(50).default([]),
-    context: z.array(RuntimeContextSchema).max(10).default([]).refine((value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES), { message: "context must be less than 64 KB total" }),
+    context: z.array(RuntimeContextSchema).max(10).default([]).refine((value) => isWithinJsonSizeLimit(value, 65_536), { message: "context must be less than 64 KB total" }),
     agentSource: RuntimeAgentSourceContextSchema.optional(),
     forwardedProps: z.record(z.string(), z.unknown()).optional().refine((value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES), { message: "forwardedProps must be less than 64 KB" }),
 });

package/esm/src/provider/runtime-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-loader.d.ts","sourceRoot":"","sources":["../../../src/src/provider/runtime-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,KAAK,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,KAAK,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,KAAK,CAAC;CAC9B;AAqhDD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAkDd;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,MAAM,GACd,YAAY,CA4Dd;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAkDd;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CA0ClB;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CAgDlB"}
+{"version":3,"file":"runtime-loader.d.ts","sourceRoot":"","sources":["../../../src/src/provider/runtime-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,KAAK,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,KAAK,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,KAAK,CAAC;CAC9B;AAu/CD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAkDd;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,MAAM,GACd,YAAY,CA4Dd;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAkDd;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CA0ClB;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CAgDlB"}

package/esm/src/provider/runtime-loader.js

@@ -404,11 +404,11 @@ function buildAnthropicGenerateResult(payload) {
         usage: extractAnthropicUsage(payload),
     };
 }
-function parseAnthropicSseChunk(chunk) {
-    const blocks = chunk.split("\n\n");
+function parseSseChunk(chunk) {
+    const blocks = chunk.split(/\r?\n\r?\n/);
     const remainder = blocks.pop() ?? "";
     const events = blocks.flatMap((block) => {
-        const dataLines = block.split("\n")
+        const dataLines = block.split(/\r?\n/)
             .filter((line) => line.startsWith("data:"))
             .map((line) => line.slice(5).trimStart());
         if (!dataLines.length) {
@@ -435,7 +435,7 @@ async function* streamAnthropicCompatibleParts(stream) {
     let usage;
     for await (const chunk of stream) {
         buffer += decoder.decode(chunk, { stream: true });
-        const parsed = parseAnthropicSseChunk(buffer);
+        const parsed = parseSseChunk(buffer);
         buffer = parsed.remainder;
         for (const event of parsed.events) {
             if (event === "[DONE]") {
@@ -547,7 +547,7 @@ async function* streamAnthropicCompatibleParts(stream) {
         }
     }
     if (buffer.trim().length > 0) {
-        const parsed = parseAnthropicSseChunk(`${buffer}\n\n`);
+        const parsed = parseSseChunk(`${buffer}\n\n`);
         for (const event of parsed.events) {
             if (event === "[DONE]") {
                 continue;
@@ -855,7 +855,7 @@ async function* streamGoogleCompatibleParts(stream) {
     let usage;
     for await (const chunk of stream) {
         buffer += decoder.decode(chunk, { stream: true });
-        const parsed = parseOpenAISseChunk(buffer);
+        const parsed = parseSseChunk(buffer);
         buffer = parsed.remainder;
         for (const event of parsed.events) {
             if (event === "[DONE]") {
@@ -902,7 +902,7 @@ async function* streamGoogleCompatibleParts(stream) {
         }
     }
     if (buffer.trim().length > 0) {
-        const parsed = parseOpenAISseChunk(`${buffer}\n\n`);
+        const parsed = parseSseChunk(`${buffer}\n\n`);
         for (const event of parsed.events) {
             if (event === "[DONE]") {
                 continue;
@@ -947,29 +947,6 @@ function buildOpenAIGenerateResult(payload) {
         usage: extractOpenAIUsage(payload),
     };
 }
-function parseOpenAISseChunk(chunk) {
-    const blocks = chunk.split("\n\n");
-    const remainder = blocks.pop() ?? "";
-    const events = blocks.flatMap((block) => {
-        const dataLines = block.split("\n")
-            .filter((line) => line.startsWith("data:"))
-            .map((line) => line.slice(5).trimStart());
-        if (!dataLines.length) {
-            return [];
-        }
-        const payload = dataLines.join("\n").trim();
-        if (payload === "[DONE]") {
-            return ["[DONE]"];
-        }
-        try {
-            return [JSON.parse(payload)];
-        }
-        catch {
-            return [];
-        }
-    });
-    return { events, remainder };
-}
 async function* streamOpenAICompatibleParts(stream) {
     const decoder = new TextDecoder();
     let buffer = "";
@@ -978,7 +955,7 @@ async function* streamOpenAICompatibleParts(stream) {
     let usage;
     for await (const chunk of stream) {
         buffer += decoder.decode(chunk, { stream: true });
-        const parsed = parseOpenAISseChunk(buffer);
+        const parsed = parseSseChunk(buffer);
         buffer = parsed.remainder;
         for (const event of parsed.events) {
             if (event === "[DONE]") {
@@ -1040,7 +1017,7 @@ async function* streamOpenAICompatibleParts(stream) {
         }
     }
     if (buffer.trim().length > 0) {
-        const parsed = parseOpenAISseChunk(`${buffer}\n\n`);
+        const parsed = parseSseChunk(`${buffer}\n\n`);
         for (const event of parsed.events) {
             if (event === "[DONE]") {
                 continue;

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.151";
+export declare const VERSION = "0.1.154";
 //# 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.151";
+export const VERSION = "0.1.154";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.151",
+  "version": "0.1.154",
   "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.151",
+  "version": "0.1.154",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [

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

@@ -135,6 +135,24 @@ export {
 } from "./composition/index.js";
 
 export { agent } from "./factory.js";
+export {
+  type AgUiRuntimeContextItem,
+  AgUiRuntimeContextItemSchema,
+  type AgUiRuntimeInjectedTool,
+  AgUiRuntimeInjectedToolSchema,
+  type AgUiRuntimeMessage,
+  AgUiRuntimeMessageSchema,
+  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,