veryfront 0.1.501 → 0.1.503

package/src/src/agent/schemas/tool.schema.ts

@@ -1,8 +1,11 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
 /** Input schema when an agent is used as a tool */
-export const AgentToolInputSchema = z.object({
-  input: z.string().describe("Input for the agent"),
-});
+export const getAgentToolInputSchema = defineSchema((v) =>
+  v.object({
+    input: v.string().describe("Input for the agent"),
+  })
+);
 
-export type AgentToolInput = z.infer<typeof AgentToolInputSchema>;
+export type AgentToolInput = InferSchema<ReturnType<typeof getAgentToolInputSchema>>;

package/src/src/cache/schemas/cache-backend.schema.ts

@@ -1,13 +1,22 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
-export const CacheBackendTypeSchema = z.enum(["memory", "redis", "api", "disk"]);
+export const getCacheBackendTypeSchema = defineSchema((v) =>
+  v.enum(["memory", "redis", "api", "disk"])
+);
 
-export const CacheSetBatchEntrySchema = z.object({
-  key: z.string(),
-  value: z.string(),
-  ttl: z.number().int().positive().optional(),
-});
+export const getCacheSetBatchEntrySchema = defineSchema((v) =>
+  v.object({
+    key: v.string(),
+    value: v.string(),
+    ttl: v.number().int().positive().optional(),
+  })
+);
 
 // Inferred types
-export type CacheBackendType = z.infer<typeof CacheBackendTypeSchema>;
-export type CacheSetBatchEntry = z.infer<typeof CacheSetBatchEntrySchema>;
+export type CacheBackendType = InferSchema<ReturnType<typeof getCacheBackendTypeSchema>>;
+export type CacheSetBatchEntry = InferSchema<ReturnType<typeof getCacheSetBatchEntrySchema>>;
+
+// Backward compat aliases
+export const CacheBackendTypeSchema = getCacheBackendTypeSchema();
+export const CacheSetBatchEntrySchema = getCacheSetBatchEntrySchema();

package/src/src/cache/schemas/cache-key.schema.ts

@@ -1,11 +1,17 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
 /** Context used for generating cache keys in multi-project environments */
-export const CacheKeyContextSchema = z.object({
-  projectId: z.string().min(1, "projectId cannot be empty"),
-  mode: z.enum(["production", "preview"]),
-  versionId: z.string().min(1, "versionId cannot be empty"),
-});
+export const getCacheKeyContextSchema = defineSchema((v) =>
+  v.object({
+    projectId: v.string().min(1, "projectId cannot be empty"),
+    mode: v.enum(["production", "preview"]),
+    versionId: v.string().min(1, "versionId cannot be empty"),
+  })
+);
 
 // Inferred type
-export type CacheKeyContext = z.infer<typeof CacheKeyContextSchema>;
+export type CacheKeyContext = InferSchema<ReturnType<typeof getCacheKeyContextSchema>>;
+
+// Backward compat alias
+export const CacheKeyContextSchema = getCacheKeyContextSchema();

package/src/src/channels/control-plane.ts

@@ -4,107 +4,143 @@ import type { Agent } from "../agent/index.js";
 import type { HandlerContext } from "../types/index.js";
 import { skillRegistry } from "../skill/registry.js";
 import { base64urlEncodeBytes } from "../utils/base64url.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema, Schema } from "../extensions/schema/index.js";
 
 const SIGNATURE_SKEW_SECONDS = 5;
 
 export const CONTROL_PLANE_AGENTS_LIST_PATH = "/api/control-plane/agents/list";
 export const CONTROL_PLANE_AGENT_STREAM_PATH = "/api/control-plane/agents/stream";
 export const CONTROL_PLANE_AGENT_RUNS_PATH_PREFIX = "/api/control-plane/agents/runs/";
-export const LEGACY_INTERNAL_AGENTS_LIST_PATH = "/internal/agents/list";
-export const LEGACY_INTERNAL_AGENT_STREAM_PATH = "/internal/agents/stream";
-export const LEGACY_INTERNAL_AGENT_RUNS_PATH_PREFIX = "/internal/agents/runs/";
-
-const compactJwsHeaderSchema = z.object({
-  alg: z.literal("EdDSA"),
-  typ: z.string().optional(),
-  kid: z.string().optional(),
-});
-
-export const ControlPlaneSurfaceSchema = z.enum(["studio", "channels", "a2a", "mcp"]);
-
-export const ControlPlaneAgentsListRequestSchema = z.object({
-  requestId: z.string().min(1),
-  projectId: z.string().min(1),
-  surface: ControlPlaneSurfaceSchema,
-});
-
-export const RuntimeAgentSkillSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  examples: z.array(z.string()).optional(),
-});
-
-export const RuntimeAgentSuggestionSchema = z.discriminatedUnion("type", [
-  z.object({
-    id: z.string().min(1),
-    type: z.literal("prompt"),
-    title: z.string().min(1),
-    description: z.string().optional(),
-    prompt: z.string().min(1),
-  }),
-  z.object({
-    id: z.string().min(1),
-    type: z.literal("task"),
-    title: z.string().min(1),
-    description: z.string().optional(),
-    task: z.string().min(1),
-    prompt: z.string().min(1).optional(),
-  }),
-]);
-
-export const RuntimeAgentSuggestionsSchema = z.object({
-  welcomeMessage: z.string().min(1).optional(),
-  suggestions: z.array(RuntimeAgentSuggestionSchema),
-});
-
-export const RuntimeAgentSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().nullable().optional(),
-  model: z.string().nullable().optional(),
-  version: z.string().nullable().optional(),
-  skills: z.array(RuntimeAgentSkillSchema).optional(),
-  suggestions: RuntimeAgentSuggestionsSchema.optional(),
-});
-
-export const RuntimeAgentListResponseSchema = z.object({
-  agents: z.array(RuntimeAgentSchema),
-});
-
-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(),
-});
-
-const controlPlaneClaimsSchema = z.object({
-  iss: z.string(),
-  aud: z.string(),
-  sub: z.string(),
-  surface: ControlPlaneSurfaceSchema,
-  project_id: z.string(),
-  request_hash: z.string(),
-  iat: z.number().int(),
-  exp: z.number().int(),
-});
-
-export type ControlPlaneSurface = z.infer<typeof ControlPlaneSurfaceSchema>;
-export type ControlPlaneAgentsListRequest = z.infer<typeof ControlPlaneAgentsListRequestSchema>;
-export type RuntimeAgentSkill = z.infer<typeof RuntimeAgentSkillSchema>;
-export type RuntimeAgentSuggestion = z.infer<typeof RuntimeAgentSuggestionSchema>;
-export type RuntimeAgentSuggestions = z.infer<typeof RuntimeAgentSuggestionsSchema>;
-export type RuntimeAgent = z.infer<typeof RuntimeAgentSchema>;
-export type RuntimeAgentListResponse = z.infer<typeof RuntimeAgentListResponseSchema>;
-export type DispatchClaims = z.infer<typeof dispatchClaimsSchema>;
-export type ControlPlaneClaims = z.infer<typeof controlPlaneClaimsSchema>;
+
+const getCompactJwsHeaderSchema = defineSchema((v) =>
+  v.object({
+    alg: v.literal("EdDSA"),
+    typ: v.string().optional(),
+    kid: v.string().optional(),
+  })
+);
+const compactJwsHeaderSchema = getCompactJwsHeaderSchema();
+
+export const getControlPlaneSurfaceSchema = defineSchema((v) =>
+  v.enum(["studio", "channels", "a2a", "mcp"])
+);
+export const ControlPlaneSurfaceSchema = getControlPlaneSurfaceSchema();
+
+export const getControlPlaneAgentsListRequestSchema = defineSchema((v) =>
+  v.object({
+    requestId: v.string().min(1),
+    projectId: v.string().min(1),
+    surface: getControlPlaneSurfaceSchema(),
+  })
+);
+export const ControlPlaneAgentsListRequestSchema = getControlPlaneAgentsListRequestSchema();
+
+export const getRuntimeAgentSkillSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().min(1),
+    name: v.string().min(1),
+    description: v.string().optional(),
+    tags: v.array(v.string()).optional(),
+    examples: v.array(v.string()).optional(),
+  })
+);
+export const RuntimeAgentSkillSchema = getRuntimeAgentSkillSchema();
+
+export const getRuntimeAgentSuggestionSchema = defineSchema((v) =>
+  v.discriminatedUnion("type", [
+    v.object({
+      id: v.string().min(1),
+      type: v.literal("prompt"),
+      title: v.string().min(1),
+      description: v.string().optional(),
+      prompt: v.string().min(1),
+    }),
+    v.object({
+      id: v.string().min(1),
+      type: v.literal("task"),
+      title: v.string().min(1),
+      description: v.string().optional(),
+      task: v.string().min(1),
+      prompt: v.string().min(1).optional(),
+    }),
+  ])
+);
+export const RuntimeAgentSuggestionSchema = getRuntimeAgentSuggestionSchema();
+
+export const getRuntimeAgentSuggestionsSchema = defineSchema((v) =>
+  v.object({
+    welcomeMessage: v.string().min(1).optional(),
+    suggestions: v.array(getRuntimeAgentSuggestionSchema()),
+  })
+);
+export const RuntimeAgentSuggestionsSchema = getRuntimeAgentSuggestionsSchema();
+
+export const getRuntimeAgentSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().min(1),
+    name: v.string().min(1),
+    description: v.string().nullable().optional(),
+    model: v.string().nullable().optional(),
+    version: v.string().nullable().optional(),
+    skills: v.array(getRuntimeAgentSkillSchema()).optional(),
+    suggestions: getRuntimeAgentSuggestionsSchema().optional(),
+  })
+);
+export const RuntimeAgentSchema = getRuntimeAgentSchema();
+
+export const getRuntimeAgentListResponseSchema = defineSchema((v) =>
+  v.object({
+    agents: v.array(getRuntimeAgentSchema()),
+  })
+);
+export const RuntimeAgentListResponseSchema = getRuntimeAgentListResponseSchema();
+
+const getDispatchClaimsSchema = defineSchema((v) =>
+  v.object({
+    iss: v.string(),
+    aud: v.string(),
+    sub: v.string(),
+    project_id: v.string(),
+    platform: v.string(),
+    body_sha256: v.string(),
+    iat: v.number().int(),
+    exp: v.number().int(),
+  })
+);
+const dispatchClaimsSchema = getDispatchClaimsSchema();
+
+const getControlPlaneClaimsSchema = defineSchema((v) =>
+  v.object({
+    iss: v.string(),
+    aud: v.string(),
+    sub: v.string(),
+    surface: getControlPlaneSurfaceSchema(),
+    project_id: v.string(),
+    request_hash: v.string(),
+    iat: v.number().int(),
+    exp: v.number().int(),
+  })
+);
+const controlPlaneClaimsSchema = getControlPlaneClaimsSchema();
+
+export type ControlPlaneSurface = InferSchema<ReturnType<typeof getControlPlaneSurfaceSchema>>;
+export type ControlPlaneAgentsListRequest = InferSchema<
+  ReturnType<typeof getControlPlaneAgentsListRequestSchema>
+>;
+export type RuntimeAgentSkill = InferSchema<ReturnType<typeof getRuntimeAgentSkillSchema>>;
+export type RuntimeAgentSuggestion = InferSchema<
+  ReturnType<typeof getRuntimeAgentSuggestionSchema>
+>;
+export type RuntimeAgentSuggestions = InferSchema<
+  ReturnType<typeof getRuntimeAgentSuggestionsSchema>
+>;
+export type RuntimeAgent = InferSchema<ReturnType<typeof getRuntimeAgentSchema>>;
+export type RuntimeAgentListResponse = InferSchema<
+  ReturnType<typeof getRuntimeAgentListResponseSchema>
+>;
+export type DispatchClaims = InferSchema<ReturnType<typeof getDispatchClaimsSchema>>;
+export type ControlPlaneClaims = InferSchema<ReturnType<typeof getControlPlaneClaimsSchema>>;
 
 export interface RuntimeAgentDiscoveryDeps {
   ensureProjectDiscovery: (ctx: HandlerContext) => Promise<void>;
@@ -168,7 +204,7 @@ async function verifySignedRequestJws<TClaims extends SignedRequestClaims>(
   body: string,
   options: {
     audience: string;
-    claimsSchema: z.ZodType<TClaims>;
+    claimsSchema: Schema<TClaims>;
     expectedProjectId?: string;
     expectedSubject?: string;
     hashClaimKey: keyof TClaims & string;

package/src/src/channels/invoke.ts

@@ -3,7 +3,8 @@ import type { Agent, AgentMessage as Message, AgentResponse } from "../agent/ind
 import { fromError } from "../errors/veryfront-error.js";
 import type { HandlerContext } from "../types/index.js";
 import { serverLogger } from "../utils/index.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import {
   getAgent as getRegisteredAgent,
   getAllAgentIds as getRegisteredAgentIds,
@@ -13,123 +14,167 @@ import { ensureProjectDiscovery as ensureProjectDiscoveryForProject } from "../s
 
 const logger = serverLogger.component("channels-invoke");
 
-const rawHistoryPartSchema = z.object({
-  type: z.string(),
-}).passthrough();
-
-const channelAttachmentSchema = z.object({
-  id: z.string(),
-  kind: z.enum(["image", "file"]),
-  filename: z.string().optional(),
-  mediaType: z.string().optional(),
-  privateUrl: z.string().optional(),
-});
-
-const channelInvokeHistoryMessageSchema = z.object({
-  id: z.string(),
-  role: z.enum(["user", "assistant", "system", "tool"]),
-  parts: z.array(rawHistoryPartSchema),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string().optional(),
-});
-
-const channelInvokeRequestWireSchema = z.object({
-  dispatchId: z.string().min(1),
-  conversationId: z.string().min(1),
-  projectId: z.string().min(1),
-  assistantId: z.string().min(1),
-  platform: z.literal("slack"),
-  inboundMessage: z.object({
-    text: z.string(),
-    userId: z.string(),
-    userName: z.string(),
-    isDirectMessage: z.boolean(),
-    attachments: z.array(channelAttachmentSchema).optional(),
-  }),
-  conversationHistory: z.array(channelInvokeHistoryMessageSchema),
-  generation: z.object({
-    maxResponseTokens: z.number().int().positive().max(16384).optional(),
-  }).optional(),
-});
-
-export const ChannelInvokeRequestSchema = channelInvokeRequestWireSchema;
-
-export const ChannelAssistantsRequestSchema = z.object({
-  requestId: z.string().min(1),
-  projectId: z.string().min(1),
-  platform: z.literal("slack"),
-});
-
-export const ChannelAssistantSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().nullable().optional(),
-  model: z.string().nullable().optional(),
-});
-
-export const ChannelAssistantsResponseSchema = z.object({
-  assistants: z.array(ChannelAssistantSchema),
-});
-
-const channelTextPartSchema = z.object({
-  type: z.literal("text"),
-  text: z.string(),
-});
-
-const channelToolCallPartSchema = z.object({
-  type: z.literal("tool_call"),
-  id: z.string(),
-  name: z.string(),
-  input: z.record(z.string(), z.unknown()),
-  state: z.enum(["streaming", "pending", "completed", "error"]),
-});
-
-const channelToolResultPartSchema = z.object({
-  type: z.literal("tool_result"),
-  tool_call_id: z.string(),
-  output: z.unknown(),
-  is_error: z.boolean().optional(),
-});
-
-const channelReasoningPartSchema = z.object({
-  type: z.literal("reasoning"),
-  text: z.string(),
-});
-
-const channelErrorPartSchema = z.object({
-  type: z.literal("error"),
-  code: z.string(),
-  message: z.string(),
-});
-
-export const ChannelResponsePartSchema = z.discriminatedUnion("type", [
-  channelTextPartSchema,
-  channelToolCallPartSchema,
-  channelToolResultPartSchema,
-  channelReasoningPartSchema,
-  channelErrorPartSchema,
-]);
-
-export const ChannelInvokeResponseSchema = z.object({
-  ignored: z.boolean(),
-  responseParts: z.array(ChannelResponsePartSchema).optional(),
-  tokenUsage: z.object({
-    inputTokens: z.number().int().nonnegative().optional(),
-    outputTokens: z.number().int().nonnegative().optional(),
-    totalTokens: z.number().int().nonnegative().optional(),
-  }).optional(),
-  error: z.object({
-    code: z.enum(["provider_error", "internal_error"]),
-    retryable: z.boolean(),
-  }).optional(),
-});
-
-export type ChannelInvokeRequest = z.infer<typeof ChannelInvokeRequestSchema>;
-export type ChannelInvokeResponse = z.infer<typeof ChannelInvokeResponseSchema>;
-export type ChannelAssistantsRequest = z.infer<typeof ChannelAssistantsRequestSchema>;
-export type ChannelAssistantsResponse = z.infer<typeof ChannelAssistantsResponseSchema>;
-
-type ChannelResponsePart = z.infer<typeof ChannelResponsePartSchema>;
+const getRawHistoryPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.string(),
+  }).passthrough()
+);
+const _rawHistoryPartSchema = getRawHistoryPartSchema();
+
+const getChannelAttachmentSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    kind: v.enum(["image", "file"]),
+    filename: v.string().optional(),
+    mediaType: v.string().optional(),
+    privateUrl: v.string().optional(),
+  })
+);
+
+const getChannelInvokeHistoryMessageSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    role: v.enum(["user", "assistant", "system", "tool"]),
+    parts: v.array(getRawHistoryPartSchema()),
+    metadata: v.record(v.string(), v.unknown()).optional(),
+    createdAt: v.string().optional(),
+  })
+);
+
+const getChannelInvokeRequestWireSchema = defineSchema((v) =>
+  v.object({
+    dispatchId: v.string().min(1),
+    conversationId: v.string().min(1),
+    projectId: v.string().min(1),
+    assistantId: v.string().min(1),
+    platform: v.literal("slack"),
+    inboundMessage: v.object({
+      text: v.string(),
+      userId: v.string(),
+      userName: v.string(),
+      isDirectMessage: v.boolean(),
+      attachments: v.array(getChannelAttachmentSchema()).optional(),
+    }),
+    conversationHistory: v.array(getChannelInvokeHistoryMessageSchema()),
+    generation: v.object({
+      maxResponseTokens: v.number().int().positive().max(16384).optional(),
+    }).optional(),
+  })
+);
+
+export const getChannelInvokeRequestSchema = getChannelInvokeRequestWireSchema;
+export const ChannelInvokeRequestSchema = getChannelInvokeRequestSchema();
+
+export const getChannelAssistantsRequestSchema = defineSchema((v) =>
+  v.object({
+    requestId: v.string().min(1),
+    projectId: v.string().min(1),
+    platform: v.literal("slack"),
+  })
+);
+export const ChannelAssistantsRequestSchema = getChannelAssistantsRequestSchema();
+
+export const getChannelAssistantSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().min(1),
+    name: v.string().min(1),
+    description: v.string().nullable().optional(),
+    model: v.string().nullable().optional(),
+  })
+);
+export const ChannelAssistantSchema = getChannelAssistantSchema();
+
+export const getChannelAssistantsResponseSchema = defineSchema((v) =>
+  v.object({
+    assistants: v.array(getChannelAssistantSchema()),
+  })
+);
+export const ChannelAssistantsResponseSchema = getChannelAssistantsResponseSchema();
+
+const getChannelTextPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("text"),
+    text: v.string(),
+  })
+);
+const channelTextPartSchema = getChannelTextPartSchema();
+
+const getChannelToolCallPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("tool_call"),
+    id: v.string(),
+    name: v.string(),
+    input: v.record(v.string(), v.unknown()),
+    state: v.enum(["streaming", "pending", "completed", "error"]),
+  })
+);
+const channelToolCallPartSchema = getChannelToolCallPartSchema();
+
+const getChannelToolResultPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("tool_result"),
+    tool_call_id: v.string(),
+    output: v.unknown(),
+    is_error: v.boolean().optional(),
+  })
+);
+const channelToolResultPartSchema = getChannelToolResultPartSchema();
+
+const getChannelReasoningPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("reasoning"),
+    text: v.string(),
+  })
+);
+const channelReasoningPartSchema = getChannelReasoningPartSchema();
+
+const getChannelErrorPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("error"),
+    code: v.string(),
+    message: v.string(),
+  })
+);
+const _channelErrorPartSchema = getChannelErrorPartSchema();
+
+export const getChannelResponsePartSchema = defineSchema((v) =>
+  v.discriminatedUnion("type", [
+    getChannelTextPartSchema(),
+    getChannelToolCallPartSchema(),
+    getChannelToolResultPartSchema(),
+    getChannelReasoningPartSchema(),
+    getChannelErrorPartSchema(),
+  ])
+);
+export const ChannelResponsePartSchema = getChannelResponsePartSchema();
+
+export const getChannelInvokeResponseSchema = defineSchema((v) =>
+  v.object({
+    ignored: v.boolean(),
+    responseParts: v.array(getChannelResponsePartSchema()).optional(),
+    tokenUsage: v.object({
+      inputTokens: v.number().int().nonnegative().optional(),
+      outputTokens: v.number().int().nonnegative().optional(),
+      totalTokens: v.number().int().nonnegative().optional(),
+    }).optional(),
+    error: v.object({
+      code: v.enum(["provider_error", "internal_error"]),
+      retryable: v.boolean(),
+    }).optional(),
+  })
+);
+export const ChannelInvokeResponseSchema = getChannelInvokeResponseSchema();
+
+export type ChannelInvokeRequest = InferSchema<ReturnType<typeof getChannelInvokeRequestSchema>>;
+export type ChannelInvokeResponse = InferSchema<ReturnType<typeof getChannelInvokeResponseSchema>>;
+export type ChannelAssistantsRequest = InferSchema<
+  ReturnType<typeof getChannelAssistantsRequestSchema>
+>;
+export type ChannelAssistantsResponse = InferSchema<
+  ReturnType<typeof getChannelAssistantsResponseSchema>
+>;
+
+type ChannelResponsePart = InferSchema<ReturnType<typeof getChannelResponsePartSchema>>;
 export interface ChannelInvokeDeps extends RuntimeAgentDiscoveryDeps {}
 
 export const defaultChannelInvokeDeps: ChannelInvokeDeps = {
@@ -157,7 +202,7 @@ export async function listChannelAssistants(
 export { verifyDispatchJws, verifyDispatchJwsSignature } from "./control-plane.js";
 
 function normalizeConversationPart(
-  part: z.infer<typeof rawHistoryPartSchema>,
+  part: InferSchema<ReturnType<typeof getRawHistoryPartSchema>>,
 ): Message["parts"][number] | null {
   if (part.type === "text" && typeof part.text === "string") {
     return { type: "text", text: part.text };
@@ -202,7 +247,7 @@ export function normalizeConversationHistoryForRuntime(
       .filter((part): part is NonNullable<typeof part> => part !== null),
     ...(message.createdAt ? { timestamp: Date.parse(message.createdAt) || undefined } : {}),
     ...(message.metadata ? { metadata: message.metadata } : {}),
-  }));
+  })) as any;
 }
 
 export function resolveChannelInvokeAgent(