veryfront 0.1.64 → 0.1.65

package/esm/src/channels/invoke.js

@@ -1,12 +1,10 @@
-import * as dntShim from "../../_dnt.shims.js";
 import { fromError } from "../errors/veryfront-error.js";
 import { serverLogger } from "../utils/index.js";
-import { base64urlEncodeBytes } from "../utils/base64url.js";
 import { z } from "zod";
 import { getAgent as getRegisteredAgent, getAllAgentIds as getRegisteredAgentIds, } from "../agent/composition/composition.js";
+import { listRuntimeAgents } from "./control-plane.js";
 import { ensureProjectDiscovery as ensureProjectDiscoveryForProject } from "../server/handlers/request/api/project-discovery.js";
 const logger = serverLogger.component("channels-invoke");
-const SIGNATURE_SKEW_SECONDS = 5;
 const rawHistoryPartSchema = z.object({
     type: z.string(),
 }).passthrough();
@@ -103,117 +101,22 @@ export const ChannelInvokeResponseSchema = z.object({
         retryable: z.boolean(),
     }).optional(),
 });
-const dispatchHeaderSchema = z.object({
-    alg: z.literal("EdDSA"),
-    typ: z.string().optional(),
-    kid: z.string().optional(),
-});
-const dispatchClaimsSchema = z.object({
-    iss: z.string(),
-    aud: z.string(),
-    sub: z.string(),
-    project_id: z.string(),
-    platform: z.string(),
-    body_sha256: z.string(),
-    iat: z.number().int(),
-    exp: z.number().int(),
-});
 export const defaultChannelInvokeDeps = {
     ensureProjectDiscovery: ensureProjectDiscoveryForProject,
     getAgent: getRegisteredAgent,
     getAllAgentIds: getRegisteredAgentIds,
 };
-function getAssistantMetadata(agent) {
-    const rawConfig = agent.config;
-    return ChannelAssistantSchema.parse({
-        id: agent.id,
-        name: typeof rawConfig.name === "string" && rawConfig.name.trim().length > 0
-            ? rawConfig.name
-            : agent.id,
-        description: typeof rawConfig.description === "string" ? rawConfig.description : null,
-        model: agent.config.model ?? null,
-    });
-}
 export async function listChannelAssistants(ctx, deps) {
-    await deps.ensureProjectDiscovery(ctx);
-    const assistants = deps.getAllAgentIds()
-        .map((id) => deps.getAgent(id))
-        .filter((agent) => Boolean(agent))
-        .map(getAssistantMetadata)
-        .sort((left, right) => left.name.localeCompare(right.name));
+    const response = await listRuntimeAgents(ctx, deps);
+    const assistants = response.agents.map((agent) => ChannelAssistantSchema.parse({
+        id: agent.id,
+        name: agent.name,
+        description: agent.description ?? null,
+        model: agent.model ?? null,
+    }));
     return ChannelAssistantsResponseSchema.parse({ assistants });
 }
-function base64urlDecodeToBytes(input) {
-    const normalized = input
-        .replaceAll("-", "+")
-        .replaceAll("_", "/")
-        .padEnd(Math.ceil(input.length / 4) * 4, "=");
-    return toArrayBuffer(Uint8Array.from(atob(normalized), (char) => char.charCodeAt(0)));
-}
-function toArrayBuffer(bytes) {
-    const buffer = new ArrayBuffer(bytes.byteLength);
-    new Uint8Array(buffer).set(bytes);
-    return buffer;
-}
-function pemToDer(pem, label) {
-    const body = pem
-        .replace(`-----BEGIN ${label}-----`, "")
-        .replace(`-----END ${label}-----`, "")
-        .replace(/\s/g, "");
-    return toArrayBuffer(Uint8Array.from(atob(body), (char) => char.charCodeAt(0)));
-}
-async function importEd25519PublicKey(pem) {
-    return dntShim.crypto.subtle.importKey("spki", pemToDer(pem, "PUBLIC KEY"), "Ed25519", false, ["verify"]);
-}
-async function sha256Base64url(body) {
-    const hash = await dntShim.crypto.subtle.digest("SHA-256", new TextEncoder().encode(body));
-    return base64urlEncodeBytes(new Uint8Array(hash));
-}
-export async function verifyDispatchJws(jws, body, options) {
-    const parts = jws.split(".");
-    if (parts.length !== 3) {
-        throw new Error("Channel dispatch signature must be a compact JWS");
-    }
-    const encodedHeader = parts[0];
-    const encodedPayload = parts[1];
-    const encodedSignature = parts[2];
-    if (!encodedHeader || !encodedPayload || !encodedSignature) {
-        throw new Error("Channel dispatch signature must include header, payload, and signature");
-    }
-    const header = dispatchHeaderSchema.parse(JSON.parse(new TextDecoder().decode(base64urlDecodeToBytes(encodedHeader))));
-    const claims = dispatchClaimsSchema.parse(JSON.parse(new TextDecoder().decode(base64urlDecodeToBytes(encodedPayload))));
-    if (header.alg !== "EdDSA") {
-        throw new Error("Unsupported channel dispatch JWS algorithm");
-    }
-    const signingInput = new TextEncoder().encode(`${encodedHeader}.${encodedPayload}`);
-    const signature = base64urlDecodeToBytes(encodedSignature);
-    const publicKey = await importEd25519PublicKey(options.publicKeyPem);
-    const verified = await dntShim.crypto.subtle.verify("Ed25519", publicKey, signature, signingInput);
-    if (!verified) {
-        throw new Error("Channel dispatch signature verification failed");
-    }
-    if (claims.aud !== options.audience) {
-        throw new Error("Channel dispatch audience mismatch");
-    }
-    if (options.expectedProjectId && claims.project_id !== options.expectedProjectId) {
-        throw new Error("Channel dispatch project mismatch");
-    }
-    const now = Math.floor(Date.now() / 1000);
-    if (claims.exp <= now) {
-        throw new Error("Channel dispatch signature expired");
-    }
-    if (claims.iat > now + SIGNATURE_SKEW_SECONDS) {
-        throw new Error("Channel dispatch signature issued in the future");
-    }
-    if (now - claims.iat > options.maxAgeSeconds) {
-        throw new Error("Channel dispatch signature is too old");
-    }
-    const bodySha256 = await sha256Base64url(body);
-    if (claims.body_sha256 !== bodySha256) {
-        throw new Error("Channel dispatch body hash mismatch");
-    }
-    return claims;
-}
+export { verifyDispatchJws } from "./control-plane.js";
 function normalizeConversationPart(part) {
     if (part.type === "text" && typeof part.text === "string") {
         return { type: "text", text: part.text };

package/esm/src/internal-agents/ag-ui-sse.d.ts

@@ -0,0 +1,35 @@
+import type { AgentResponse } from "../agent/index.js";
+type RuntimeDataEvent = Record<string, unknown> & {
+    type: string;
+};
+export interface RunFinishedMetadata {
+    provider?: string;
+    model?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    finishReason?: string;
+}
+export interface StreamTransformState {
+    messageId: string | null;
+    textOpen: boolean;
+    stepIndex: number;
+    sawTerminalError: boolean;
+    metadata: RunFinishedMetadata;
+}
+export declare function createStreamTransformState(): StreamTransformState;
+export declare function formatAgUiEvent(event: string, payload: Record<string, unknown>): Uint8Array;
+export declare function parseSseJsonEvents(chunk: string): {
+    events: RuntimeDataEvent[];
+    remainder: string;
+};
+export declare function mapRuntimeEventToAgUi(state: StreamTransformState, event: RuntimeDataEvent): Array<{
+    event: string;
+    payload: Record<string, unknown>;
+}>;
+export declare function finalizeRunEvents(state: StreamTransformState, response: AgentResponse | null): Array<{
+    event: string;
+    payload: Record<string, unknown>;
+}>;
+export {};
+//# sourceMappingURL=ag-ui-sse.d.ts.map

package/esm/src/internal-agents/ag-ui-sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ag-ui-sse.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/ag-ui-sse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAOvD,KAAK,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,QAAQ,EAAE,mBAAmB,CAAC;CAC/B;AAED,wBAAgB,0BAA0B,IAAI,oBAAoB,CAQjE;AA2DD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,CAI3F;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG;IACjD,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;CACnB,CAyBA;AAkDD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,oBAAoB,EAC3B,KAAK,EAAE,gBAAgB,GACtB,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,CAoH5D;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,oBAAoB,EAC3B,QAAQ,EAAE,aAAa,GAAG,IAAI,GAC7B,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,CAwB5D"}

package/esm/src/internal-agents/ag-ui-sse.js

@@ -0,0 +1,263 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { serverLogger } from "../utils/index.js";
+import { z } from "zod";
+const encoder = new TextEncoder();
+const logger = serverLogger.component("internal-agents-ag-ui-sse");
+export function createStreamTransformState() {
+    return {
+        messageId: null,
+        textOpen: false,
+        stepIndex: 0,
+        sawTerminalError: false,
+        metadata: {},
+    };
+}
+const agUiEventPayloadSchemas = {
+    RunStarted: z.object({
+        runId: z.string().min(1),
+        threadId: z.string().min(1),
+        agentId: z.string().min(1),
+    }),
+    TextMessageStart: z.object({
+        messageId: z.string().min(1),
+        role: z.literal("assistant"),
+    }),
+    TextMessageContent: z.object({
+        messageId: z.string().min(1),
+        delta: z.string(),
+    }),
+    TextMessageEnd: z.object({
+        messageId: z.string().min(1),
+    }),
+    ToolCallStart: z.object({
+        toolCallId: z.string().min(1),
+        toolCallName: z.string().min(1),
+    }),
+    ToolCallArgs: z.object({
+        toolCallId: z.string().min(1),
+        delta: z.string(),
+    }),
+    ToolCallEnd: z.object({
+        toolCallId: z.string().min(1),
+    }),
+    ToolCallResult: z.object({
+        toolCallId: z.string().min(1),
+        result: z.unknown(),
+        isError: z.boolean().optional(),
+    }),
+    StepStarted: z.object({
+        stepIndex: z.number().int().positive(),
+    }),
+    StepFinished: z.object({
+        stepIndex: z.number().int().positive(),
+    }),
+    RunError: z.object({
+        code: z.string().min(1).optional(),
+        message: z.string().min(1),
+    }),
+    RunFinished: z.object({
+        metadata: z.object({
+            provider: z.string().optional(),
+            model: z.string().optional(),
+            inputTokens: z.number().int().nonnegative().optional(),
+            outputTokens: z.number().int().nonnegative().optional(),
+            totalTokens: z.number().int().nonnegative().optional(),
+            finishReason: z.string().optional(),
+        }),
+    }),
+};
+export function formatAgUiEvent(event, payload) {
+    const schema = agUiEventPayloadSchemas[event];
+    const validatedPayload = schema ? schema.parse(payload) : payload;
+    return encoder.encode(`event: ${event}\ndata: ${JSON.stringify(validatedPayload)}\n\n`);
+}
+export function parseSseJsonEvents(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 [];
+        }
+        try {
+            const payload = JSON.parse(dataLines.join("\n"));
+            return [payload];
+        }
+        catch (error) {
+            logger.warn("Skipping malformed runtime SSE event payload", {
+                error,
+                dataLength: dataLines.join("\n").length,
+            });
+            return [];
+        }
+    });
+    return { events, remainder };
+}
+function getMessageId(state, event) {
+    if (typeof event.messageId === "string") {
+        state.messageId = event.messageId;
+        return event.messageId;
+    }
+    if (!state.messageId && typeof event.id === "string") {
+        state.messageId = event.id;
+    }
+    if (!state.messageId) {
+        state.messageId = dntShim.crypto.randomUUID();
+    }
+    return state.messageId;
+}
+function applyDataMetadata(state, event) {
+    const data = event.data && typeof event.data === "object" && !Array.isArray(event.data)
+        ? event.data
+        : event;
+    if (typeof data.model === "string") {
+        state.metadata.model = data.model;
+        const provider = data.model.split("/")[0];
+        if (provider) {
+            state.metadata.provider = provider;
+        }
+    }
+}
+function applyResponseMetadata(state, response) {
+    if (!response)
+        return;
+    if (response.usage) {
+        state.metadata.inputTokens = response.usage.promptTokens;
+        state.metadata.outputTokens = response.usage.completionTokens;
+        state.metadata.totalTokens = response.usage.totalTokens;
+    }
+    const finishReason = response.metadata && typeof response.metadata === "object"
+        ? response.metadata.finishReason
+        : undefined;
+    if (typeof finishReason === "string") {
+        state.metadata.finishReason = finishReason;
+    }
+}
+export function mapRuntimeEventToAgUi(state, event) {
+    switch (event.type) {
+        case "message-start":
+            getMessageId(state, event);
+            return [];
+        case "text-start": {
+            if (state.textOpen)
+                return [];
+            const messageId = getMessageId(state, event);
+            state.textOpen = true;
+            return [{
+                    event: "TextMessageStart",
+                    payload: { messageId, role: "assistant" },
+                }];
+        }
+        case "text-delta": {
+            const messageId = getMessageId(state, event);
+            if (!state.textOpen) {
+                state.textOpen = true;
+                return [
+                    { event: "TextMessageStart", payload: { messageId, role: "assistant" } },
+                    {
+                        event: "TextMessageContent",
+                        payload: { messageId, delta: typeof event.delta === "string" ? event.delta : "" },
+                    },
+                ];
+            }
+            return [{
+                    event: "TextMessageContent",
+                    payload: { messageId, delta: typeof event.delta === "string" ? event.delta : "" },
+                }];
+        }
+        case "text-end": {
+            if (!state.textOpen)
+                return [];
+            state.textOpen = false;
+            return [{
+                    event: "TextMessageEnd",
+                    payload: { messageId: getMessageId(state, event) },
+                }];
+        }
+        case "tool-input-start":
+            return [{
+                    event: "ToolCallStart",
+                    payload: {
+                        toolCallId: event.toolCallId,
+                        toolCallName: event.toolName,
+                    },
+                }];
+        case "tool-input-delta":
+            return [{
+                    event: "ToolCallArgs",
+                    payload: {
+                        toolCallId: event.toolCallId,
+                        delta: typeof event.inputTextDelta === "string" ? event.inputTextDelta : "",
+                    },
+                }];
+        case "tool-input-available":
+            return [{
+                    event: "ToolCallEnd",
+                    payload: { toolCallId: event.toolCallId },
+                }];
+        case "tool-output-available":
+            return [{
+                    event: "ToolCallResult",
+                    payload: {
+                        toolCallId: event.toolCallId,
+                        result: event.output,
+                    },
+                }];
+        case "tool-output-error":
+            return [{
+                    event: "ToolCallResult",
+                    payload: {
+                        toolCallId: event.toolCallId,
+                        result: { error: event.errorText },
+                        isError: true,
+                    },
+                }];
+        case "step-start":
+            state.stepIndex += 1;
+            return [{
+                    event: "StepStarted",
+                    payload: { stepIndex: state.stepIndex },
+                }];
+        case "step-end":
+            return [{
+                    event: "StepFinished",
+                    payload: { stepIndex: state.stepIndex },
+                }];
+        case "data":
+            applyDataMetadata(state, event);
+            return [];
+        case "error":
+            state.sawTerminalError = true;
+            return [{
+                    event: "RunError",
+                    payload: {
+                        message: typeof event.error === "string" ? event.error : "Agent run failed",
+                    },
+                }];
+        default:
+            return [];
+    }
+}
+export function finalizeRunEvents(state, response) {
+    applyResponseMetadata(state, response);
+    if (state.sawTerminalError) {
+        return [];
+    }
+    const events = [];
+    if (state.textOpen) {
+        state.textOpen = false;
+        events.push({
+            event: "TextMessageEnd",
+            payload: { messageId: getMessageId(state, { type: "text-end" }) },
+        });
+    }
+    events.push({
+        event: "RunFinished",
+        payload: {
+            metadata: state.metadata,
+        },
+    });
+    return events;
+}

package/esm/src/internal-agents/control-plane-auth.d.ts

@@ -0,0 +1,20 @@
+import * as dntShim from "../../_dnt.shims.js";
+import type { HandlerContext } from "../types/index.js";
+export declare class ControlPlaneRequestError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare function verifyControlPlaneRequest(req: dntShim.Request, ctx: HandlerContext, rawBody: string, options?: {
+    expectedSubject?: string;
+    expectedSurface?: "studio" | "channels" | "a2a" | "mcp";
+}): Promise<{
+    project_id: string;
+    sub: string;
+    surface: "mcp" | "studio" | "channels" | "a2a";
+    iss: string;
+    aud: string;
+    iat: number;
+    exp: number;
+    request_hash: string;
+}>;
+//# sourceMappingURL=control-plane-auth.d.ts.map

package/esm/src/internal-agents/control-plane-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-plane-auth.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/control-plane-auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAE/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAQxD,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAK5C;AAED,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IACP,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,CAAC;CACpD;;;;;;;;;GAsDP"}

package/esm/src/internal-agents/control-plane-auth.js

@@ -0,0 +1,56 @@
+import { verifyControlPlaneJws } from "../channels/control-plane.js";
+import { serverLogger } from "../utils/index.js";
+import { HTTP_INTERNAL_SERVER_ERROR } from "../utils/constants/index.js";
+const CONTROL_PLANE_JWS_HEADER = "x-veryfront-control-plane-jws";
+const MAX_CONTROL_PLANE_SIGNATURE_AGE_SECONDS = 60;
+const logger = serverLogger.component("internal-agents-auth");
+export class ControlPlaneRequestError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "ControlPlaneRequestError";
+    }
+}
+export async function verifyControlPlaneRequest(req, ctx, rawBody, options = {}) {
+    const publicKeyPem = ctx.adapter.env.get("CHANNEL_DISPATCH_SIGNING_PUBLIC_KEY");
+    if (!publicKeyPem) {
+        throw new ControlPlaneRequestError(HTTP_INTERNAL_SERVER_ERROR, "Control-plane verification is not configured");
+    }
+    const projectSlug = ctx.projectSlug;
+    if (!projectSlug) {
+        throw new ControlPlaneRequestError(400, "Project context is unavailable");
+    }
+    const controlPlaneJws = req.headers.get(CONTROL_PLANE_JWS_HEADER);
+    if (!controlPlaneJws) {
+        throw new ControlPlaneRequestError(401, "Missing control-plane signature");
+    }
+    try {
+        return await verifyControlPlaneJws(controlPlaneJws, rawBody, {
+            audience: projectSlug,
+            expectedProjectId: ctx.projectId,
+            expectedSubject: options.expectedSubject,
+            expectedSurface: options.expectedSurface,
+            publicKeyPem,
+            maxAgeSeconds: MAX_CONTROL_PLANE_SIGNATURE_AGE_SECONDS,
+        });
+    }
+    catch (error) {
+        const isAuthError = error instanceof Error && (error.message.includes("Control-plane") ||
+            error.message.includes("Unsupported"));
+        if (isAuthError) {
+            logger.warn("Invalid control-plane signature", {
+                error,
+                projectSlug,
+                expectedSubject: options.expectedSubject,
+                expectedSurface: options.expectedSurface,
+            });
+            throw new ControlPlaneRequestError(401, "Invalid control-plane signature");
+        }
+        logger.error("Unexpected error during control-plane verification", {
+            error,
+            projectSlug,
+        });
+        throw new ControlPlaneRequestError(HTTP_INTERNAL_SERVER_ERROR, "Internal error during request verification");
+    }
+}

package/esm/src/internal-agents/request-body.d.ts

@@ -0,0 +1,9 @@
+import * as dntShim from "../../_dnt.shims.js";
+export declare const INTERNAL_AGENT_STREAM_MAX_BODY_BYTES: number;
+export declare const INTERNAL_AGENT_CONTROL_PLANE_MAX_BODY_BYTES: number;
+export declare class InternalAgentRequestBodyTooLargeError extends Error {
+    readonly status = 413;
+    constructor(message?: string);
+}
+export declare function readInternalAgentRequestBody(request: dntShim.Request, maxBodyBytes?: number): Promise<string>;
+//# sourceMappingURL=request-body.d.ts.map

package/esm/src/internal-agents/request-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-body.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/request-body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAQ/C,eAAO,MAAM,oCAAoC,QAA8B,CAAC;AAChF,eAAO,MAAM,2CAA2C,QAAa,CAAC;AAEtE,qBAAa,qCAAsC,SAAQ,KAAK;IAC9D,QAAQ,CAAC,MAAM,OAA0B;gBAE7B,OAAO,SAAsB;CAI1C;AAED,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,YAAY,SAAuC,GAClD,OAAO,CAAC,MAAM,CAAC,CAkBjB"}

package/esm/src/internal-agents/request-body.js

@@ -0,0 +1,28 @@
+import { VeryfrontError } from "../errors/types.js";
+import { readBodyWithLimit } from "../security/index.js";
+import { DEFAULT_MAX_BODY_SIZE_BYTES, HTTP_PAYLOAD_TOO_LARGE, } from "../utils/constants/index.js";
+export const INTERNAL_AGENT_STREAM_MAX_BODY_BYTES = DEFAULT_MAX_BODY_SIZE_BYTES;
+export const INTERNAL_AGENT_CONTROL_PLANE_MAX_BODY_BYTES = 128 * 1024;
+export class InternalAgentRequestBodyTooLargeError extends Error {
+    status = HTTP_PAYLOAD_TOO_LARGE;
+    constructor(message = "Payload too large") {
+        super(message);
+        this.name = "InternalAgentRequestBodyTooLargeError";
+    }
+}
+export async function readInternalAgentRequestBody(request, maxBodyBytes = INTERNAL_AGENT_STREAM_MAX_BODY_BYTES) {
+    if (!request.body) {
+        return "";
+    }
+    try {
+        return await readBodyWithLimit(request, maxBodyBytes);
+    }
+    catch (error) {
+        if (error instanceof VeryfrontError &&
+            error.slug === "input-validation-failed" &&
+            error.detail === "Request body exceeds size limit") {
+            throw new InternalAgentRequestBodyTooLargeError();
+        }
+        throw error;
+    }
+}

package/esm/src/internal-agents/run-stream.d.ts

@@ -0,0 +1,14 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { type Agent, type AgentMessage as Message, type AgentResponse } from "../agent/index.js";
+import { type AgentRunSessionManager } from "./session-manager.js";
+import type { RuntimeRunAgentInput } from "./schema.js";
+export interface RuntimeAgentStreamExecutionDeps {
+    sessionManager: AgentRunSessionManager;
+    createRuntime?: (agent: Agent, mergedTools: Agent["config"]["tools"]) => {
+        stream: (messages: Message[], context?: Record<string, unknown>, callbacks?: {
+            onFinish?: (response: AgentResponse) => void;
+        }) => Promise<ReadableStream<Uint8Array>>;
+    };
+}
+export declare function createRuntimeAgentStreamResponse(input: RuntimeRunAgentInput, agent: Agent, deps: RuntimeAgentStreamExecutionDeps): Promise<dntShim.Response>;
+//# sourceMappingURL=run-stream.d.ts.map

package/esm/src/internal-agents/run-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-stream.d.ts","sourceRoot":"","sources":["../../../src/src/internal-agents/run-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EACL,KAAK,KAAK,EACV,KAAK,YAAY,IAAI,OAAO,EAC5B,KAAK,aAAa,EAEnB,MAAM,mBAAmB,CAAC;AAW3B,OAAO,EAA0B,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAIxD,MAAM,WAAW,+BAA+B;IAC9C,cAAc,EAAE,sBAAsB,CAAC;IACvC,aAAa,CAAC,EAAE,CACd,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,KAClC;QACH,MAAM,EAAE,CACN,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,SAAS,CAAC,EAAE;YACV,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;SAC9C,KACE,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;KAC1C,CAAC;CACH;AAsKD,wBAAsB,gCAAgC,CACpD,KAAK,EAAE,oBAAoB,EAC3B,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,+BAA+B,GACpC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAmJ3B"}