veryfront 0.1.501 → 0.1.503

package/src/src/agent/runtime-project-files-client.ts

@@ -1,34 +1,48 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 
 const DEFAULT_PROJECT_FILES_TIMEOUT_MS = 15_000;
 const DEFAULT_PROJECT_FILES_PAGE_LIMIT = 100;
 
-export const runtimeProjectFileSchema = z.object({
-  path: z.string(),
-  content: z.string(),
-});
-
-export const runtimeProjectFileListItemSchema = z.object({
-  path: z.string(),
-});
-
-const runtimeProjectFileListRestResponseSchema = z.object({
-  data: z.array(runtimeProjectFileListItemSchema),
-  page_info: z.object({
-    next: z.string().nullable(),
-  }),
-});
-
-const apiErrorBodySchema = z
-  .object({
-    detail: z.string().optional(),
-    message: z.string().optional(),
-    error: z.string().optional(),
+export const getRuntimeProjectFileSchema = defineSchema((v) =>
+  v.object({
+    path: v.string(),
+    content: v.string(),
   })
-  .passthrough();
+);
 
-export type RuntimeProjectFile = z.infer<typeof runtimeProjectFileSchema>;
-export type RuntimeProjectFileListItem = z.infer<typeof runtimeProjectFileListItemSchema>;
+export const getRuntimeProjectFileListItemSchema = defineSchema((v) =>
+  v.object({
+    path: v.string(),
+  })
+);
+
+const getRuntimeProjectFileListRestResponseSchema = defineSchema((v) =>
+  v.object({
+    data: v.array(getRuntimeProjectFileListItemSchema()),
+    page_info: v.object({
+      next: v.string().nullable(),
+    }),
+  })
+);
+
+const getApiErrorBodySchema = defineSchema((v) =>
+  v.object({
+    detail: v.string().optional(),
+    message: v.string().optional(),
+    error: v.string().optional(),
+  }).passthrough()
+);
+
+/** @deprecated Use getRuntimeProjectFileSchema() */
+export const runtimeProjectFileSchema = getRuntimeProjectFileSchema();
+/** @deprecated Use getRuntimeProjectFileListItemSchema() */
+export const runtimeProjectFileListItemSchema = getRuntimeProjectFileListItemSchema();
+
+export type RuntimeProjectFile = InferSchema<ReturnType<typeof getRuntimeProjectFileSchema>>;
+export type RuntimeProjectFileListItem = InferSchema<
+  ReturnType<typeof getRuntimeProjectFileListItemSchema>
+>;
 
 export type RuntimeProjectFilesApiOptions = {
   projectId: string;
@@ -103,7 +117,7 @@ export async function getRuntimeProjectFile(
       );
     }
 
-    const parsed = runtimeProjectFileSchema.safeParse(await response.json());
+    const parsed = getRuntimeProjectFileSchema().safeParse(await response.json());
     if (!parsed.success) {
       throw new Error(
         `Failed to fetch file ${options.path} for project ${options.projectId}: invalid API response`,
@@ -137,7 +151,7 @@ export async function getRuntimeProjectFiles(
         );
       }
 
-      const parsed = runtimeProjectFileListRestResponseSchema.safeParse(await response.json());
+      const parsed = getRuntimeProjectFileListRestResponseSchema().safeParse(await response.json());
       if (!parsed.success) {
         throw new Error(
           `Failed to fetch files for project ${options.projectId}: invalid API response`,
@@ -215,18 +229,16 @@ async function readApiErrorMessage(response: Response): Promise<string> {
     return response.statusText || `HTTP ${response.status}`;
   }
 
-  const parsedJson = z
-    .string()
-    .transform((value, ctx) => {
-      try {
-        return JSON.parse(value);
-      } catch {
-        ctx.addIssue({ code: "custom", message: "Invalid JSON" });
-        return z.NEVER;
-      }
-    })
-    .pipe(apiErrorBodySchema)
-    .safeParse(body);
+  let parsedJson: { success: true; data: { detail?: string; message?: string; error?: string } } | {
+    success: false;
+  };
+  try {
+    const jsonValue = JSON.parse(body);
+    const result = getApiErrorBodySchema().safeParse(jsonValue);
+    parsedJson = result.success ? { success: true, data: result.data } : { success: false };
+  } catch {
+    parsedJson = { success: false };
+  }
 
   if (parsedJson.success) {
     return parsedJson.data.detail ?? parsedJson.data.message ?? parsedJson.data.error ?? body;

package/src/src/agent/runtime-skill-metadata.ts

@@ -1,5 +1,5 @@
 import { extract } from "../platform/compat/std/front-matter-yaml.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
 
 function normalizeAllowedTools(value: string | string[] | undefined): string[] {
   if (value === undefined) {
@@ -15,27 +15,44 @@ function normalizeAllowedTools(value: string | string[] | undefined): string[] {
   return values.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
 }
 
-const rawRuntimeSkillFrontmatterSchema = z
-  .object({
-    name: z.string().optional(),
-    description: z.string().optional(),
-    "allowed-tools": z.union([z.string(), z.array(z.string())]).optional(),
-    model: z.string().optional(),
-    thinking: z.union([z.literal(false), z.coerce.number().int().positive()]).optional(),
-    "max-steps": z.coerce.number().int().positive().optional(),
-  })
-  .passthrough();
-
-export const RuntimeSkillFrontmatterSchema = rawRuntimeSkillFrontmatterSchema.transform((data) => ({
-  name: data.name?.trim() || undefined,
-  description: data.description?.trim() || undefined,
-  allowedTools: normalizeAllowedTools(data["allowed-tools"]),
-  model: data.model?.trim() || undefined,
-  thinking: data.thinking,
-  maxSteps: data["max-steps"],
-}));
-
-export type RuntimeSkillFrontmatter = z.infer<typeof RuntimeSkillFrontmatterSchema>;
+// Hand-written transform output type. The contract DSL erases the parameter
+// type through `.transform()`, so we annotate explicitly.
+export interface RuntimeSkillFrontmatter {
+  name: string | undefined;
+  description: string | undefined;
+  allowedTools: string[];
+  model: string | undefined;
+  thinking: false | number | undefined;
+  maxSteps: number | undefined;
+}
+
+export const getRuntimeSkillFrontmatterSchema = defineSchema((v) =>
+  v
+    .object({
+      name: v.string().optional(),
+      description: v.string().optional(),
+      "allowed-tools": v.union([v.string(), v.array(v.string())]).optional(),
+      model: v.string().optional(),
+      thinking: v.union([v.literal(false), v.coerce.number().int().positive()]).optional(),
+      "max-steps": v.coerce.number().int().positive().optional(),
+    })
+    .passthrough()
+    .transform((data): RuntimeSkillFrontmatter => {
+      const d = data as Record<string, unknown>;
+      return {
+        name: (typeof d.name === "string" ? d.name.trim() : undefined) || undefined,
+        description: (typeof d.description === "string" ? d.description.trim() : undefined) ||
+          undefined,
+        allowedTools: normalizeAllowedTools(d["allowed-tools"] as string | string[] | undefined),
+        model: (typeof d.model === "string" ? d.model.trim() : undefined) || undefined,
+        thinking: d.thinking as false | number | undefined,
+        maxSteps: d["max-steps"] as number | undefined,
+      };
+    })
+);
+
+/** @deprecated Use getRuntimeSkillFrontmatterSchema() */
+export const RuntimeSkillFrontmatterSchema = getRuntimeSkillFrontmatterSchema();
 
 export type RuntimeSkillDefinition = {
   id: string;
@@ -111,11 +128,11 @@ export function parseRuntimeSkillDocument(
 ): ParsedRuntimeSkillDocument | null {
   try {
     const parsed = extract<Record<string, unknown>>(content);
-    const result = RuntimeSkillFrontmatterSchema.safeParse(parsed.attrs);
+    const result = getRuntimeSkillFrontmatterSchema().safeParse(parsed.attrs);
 
     if (!result.success) {
       options.logger?.error?.("Invalid skill frontmatter; skipping skill", {
-        error: result.error.message,
+        error: result.issues?.map((i) => i.message).join("; ") ?? "validation failed",
       });
       return null;
     }

package/src/src/agent/runtime-upload-url-client.ts

@@ -1,18 +1,20 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
 
 const DEFAULT_RUNTIME_UPLOAD_URL_TIMEOUT_MS = 15_000;
 
-const runtimeUploadUrlResponseSchema = z.object({
-  signed_url: z.string(),
-});
-
-const apiErrorBodySchema = z
-  .object({
-    detail: z.string().optional(),
-    message: z.string().optional(),
-    error: z.string().optional(),
+const getRuntimeUploadUrlResponseSchema = defineSchema((v) =>
+  v.object({
+    signed_url: v.string(),
   })
-  .passthrough();
+);
+
+const getApiErrorBodySchema = defineSchema((v) =>
+  v.object({
+    detail: v.string().optional(),
+    message: v.string().optional(),
+    error: v.string().optional(),
+  }).passthrough()
+);
 
 export type RuntimeUploadUrlFetch = (url: string, init: RequestInit) => Promise<Response>;
 
@@ -45,7 +47,7 @@ export async function getRuntimeUploadUrl(options: RuntimeUploadUrlOptions): Pro
     );
   }
 
-  const parsed = runtimeUploadUrlResponseSchema.safeParse(await response.json());
+  const parsed = getRuntimeUploadUrlResponseSchema().safeParse(await response.json());
   if (!parsed.success) {
     throw new Error(
       `Failed to fetch signed upload URL for ${options.uploadId}: invalid API response`,
@@ -74,18 +76,16 @@ async function readApiErrorMessage(response: Response): Promise<string> {
     return response.statusText || `HTTP ${response.status}`;
   }
 
-  const parsedJson = z
-    .string()
-    .transform((value, ctx) => {
-      try {
-        return JSON.parse(value);
-      } catch {
-        ctx.addIssue({ code: "custom", message: "Invalid JSON" });
-        return z.NEVER;
-      }
-    })
-    .pipe(apiErrorBodySchema)
-    .safeParse(body);
+  let parsedJson: { success: true; data: { detail?: string; message?: string; error?: string } } | {
+    success: false;
+  };
+  try {
+    const jsonValue = JSON.parse(body);
+    const result = getApiErrorBodySchema().safeParse(jsonValue);
+    parsedJson = result.success ? { success: true, data: result.data } : { success: false };
+  } catch {
+    parsedJson = { success: false };
+  }
 
   if (parsedJson.success) {
     return parsedJson.data.detail ?? parsedJson.data.message ?? parsedJson.data.error ?? body;

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

@@ -1,144 +1,181 @@
-import { z } from "zod";
-
-export const modelProviderSchema = z.enum(["openai", "anthropic", "google", "local"]);
-
-export const agentStatusSchema = z.enum([
-  "idle",
-  "thinking",
-  "tool_execution",
-  "streaming",
-  "completed",
-  "error",
-]);
-
-export const MemoryConfigSchema = z.object({
-  type: z.enum(["conversation", "buffer", "summary", "redis"]),
-  maxTokens: z.number().int().positive().optional(),
-  maxMessages: z.number().int().positive().optional(),
-});
-
-export const EdgeConfigSchema = z.object({
-  enabled: z.boolean(),
-  maxSteps: z.number().int().positive().optional(),
-  timeoutMs: z.number().int().positive().optional(),
-  streaming: z.boolean().optional(),
-});
-
-export const ToolCallPartWithArgsSchema = z.object({
-  type: z.string().regex(/^tool-.+$/),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  args: z.record(z.string(), z.unknown()),
-  inputText: z.string().optional(),
-});
-
-export const ToolCallPartWithInputSchema = z.object({
-  type: z.string().regex(/^tool-.+$/),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  input: z.record(z.string(), z.unknown()),
-  inputText: z.string().optional(),
-});
-
-export const ToolCallPartSchema = z.union([
-  ToolCallPartWithArgsSchema,
-  ToolCallPartWithInputSchema,
-]);
-
-export const ToolResultPartSchema = z.object({
-  type: z.literal("tool-result"),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  result: z.unknown(),
-});
-
-export const MessagePartSchema = z.union([
-  z.object({
-    type: z.literal("text"),
-    text: z.string(),
-  }),
-  ToolCallPartSchema,
-  z.object({
-    type: z.literal("tool-call"),
-    toolCallId: z.string(),
-    toolName: z.string(),
-    args: z.record(z.string(), z.unknown()),
-  }),
-  ToolResultPartSchema,
-  z.object({
-    type: z.literal("image"),
-    url: z.string(),
-    mediaType: z.string(),
-  }),
-  z.object({
-    type: z.literal("file"),
-    url: z.string(),
-    mediaType: z.string(),
-  }),
-]);
-
-export const MessageSchema = z.object({
-  id: z.string(),
-  role: z.enum(["user", "assistant", "system", "tool"]),
-  parts: z.array(MessagePartSchema),
-  timestamp: z.number().int().nonnegative().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-});
-
-export const StreamToolCallSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  arguments: z.record(z.string(), z.unknown()),
-});
-
-export const ToolCallSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  args: z.record(z.string(), z.unknown()),
-  inputText: z.string().optional(),
-  status: z.enum(["pending", "executing", "completed", "error"]),
-  result: z.unknown().optional(),
-  error: z.string().optional(),
-  executionTime: z.number().nonnegative().optional(),
-});
-
-export const AgentResponseSchema = z.object({
-  text: z.string(),
-  messages: z.array(MessageSchema),
-  toolCalls: z.array(ToolCallSchema),
-  status: agentStatusSchema,
-  thinking: z.string().optional(),
-  usage: z
-    .object({
-      promptTokens: z.number().int().nonnegative(),
-      completionTokens: z.number().int().nonnegative(),
-      totalTokens: z.number().int().nonnegative(),
-    })
-    .optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-});
-
-export const AgentContextSchema = z.object({
-  agentId: z.string(),
-  model: z.string().optional(),
-  input: z.union([z.string(), z.array(MessageSchema)]),
-  data: z.record(z.string(), z.unknown()).optional(),
-  platform: z.any(), // Platform type is complex
-  metadata: z.record(z.string(), z.unknown()).optional(),
-});
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema, SchemaValidator } from "../../extensions/schema/index.js";
+
+export const getModelProviderSchema = defineSchema((v) =>
+  v.enum(["openai", "anthropic", "google", "local"] as const)
+);
+
+export const getAgentStatusSchema = defineSchema((v) =>
+  v.enum(
+    [
+      "idle",
+      "thinking",
+      "tool_execution",
+      "streaming",
+      "completed",
+      "error",
+    ] as const,
+  )
+);
+
+export const getMemoryConfigSchema = defineSchema((v) =>
+  v.object({
+    type: v.enum(["conversation", "buffer", "summary", "redis"] as const),
+    maxTokens: v.number().int().positive().optional(),
+    maxMessages: v.number().int().positive().optional(),
+  })
+);
+
+export const getEdgeConfigSchema = defineSchema((v) =>
+  v.object({
+    enabled: v.boolean(),
+    maxSteps: v.number().int().positive().optional(),
+    timeoutMs: v.number().int().positive().optional(),
+    streaming: v.boolean().optional(),
+  })
+);
+
+export const getToolCallPartWithArgsSchema = defineSchema((v) =>
+  v.object({
+    type: v.string().regex(/^tool-.+$/),
+    toolCallId: v.string(),
+    toolName: v.string(),
+    args: v.record(v.string(), v.unknown()),
+    inputText: v.string().optional(),
+  })
+);
+
+export const getToolCallPartWithInputSchema = defineSchema((v) =>
+  v.object({
+    type: v.string().regex(/^tool-.+$/),
+    toolCallId: v.string(),
+    toolName: v.string(),
+    input: v.record(v.string(), v.unknown()),
+    inputText: v.string().optional(),
+  })
+);
+
+export const getToolCallPartSchema = defineSchema((v) =>
+  v.union([
+    getToolCallPartWithArgsSchema(),
+    getToolCallPartWithInputSchema(),
+  ])
+);
+
+export const getToolResultPartSchema = defineSchema((v) =>
+  v.object({
+    type: v.literal("tool-result"),
+    toolCallId: v.string(),
+    toolName: v.string(),
+    result: v.unknown(),
+  })
+);
+
+// Helper for the inline tool-call alternative within MessagePartSchema —
+// matches the legacy `{ type: "tool-call", ... }` shape distinct from the
+// top-level ToolCallPart variants above.
+const inlineToolCallPartShape = (v: SchemaValidator) =>
+  v.object({
+    type: v.literal("tool-call"),
+    toolCallId: v.string(),
+    toolName: v.string(),
+    args: v.record(v.string(), v.unknown()),
+  });
+
+export const getMessagePartSchema = defineSchema((v) =>
+  v.union([
+    v.object({
+      type: v.literal("text"),
+      text: v.string(),
+    }),
+    getToolCallPartSchema(),
+    inlineToolCallPartShape(v),
+    getToolResultPartSchema(),
+    v.object({
+      type: v.literal("image"),
+      url: v.string(),
+      mediaType: v.string(),
+    }),
+    v.object({
+      type: v.literal("file"),
+      url: v.string(),
+      mediaType: v.string(),
+    }),
+  ])
+);
+
+export const getMessageSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    role: v.enum(["user", "assistant", "system", "tool"] as const),
+    parts: v.array(getMessagePartSchema()),
+    timestamp: v.number().int().nonnegative().optional(),
+    metadata: v.record(v.string(), v.unknown()).optional(),
+  })
+);
+
+export const getStreamToolCallSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    name: v.string(),
+    arguments: v.record(v.string(), v.unknown()),
+  })
+);
+
+export const getToolCallSchema = defineSchema((v) =>
+  v.object({
+    id: v.string(),
+    name: v.string(),
+    args: v.record(v.string(), v.unknown()),
+    inputText: v.string().optional(),
+    status: v.enum(["pending", "executing", "completed", "error"] as const),
+    result: v.unknown().optional(),
+    error: v.string().optional(),
+    executionTime: v.number().nonnegative().optional(),
+  })
+);
+
+export const getAgentResponseSchema = defineSchema((v) =>
+  v.object({
+    text: v.string(),
+    messages: v.array(getMessageSchema()),
+    toolCalls: v.array(getToolCallSchema()),
+    status: getAgentStatusSchema(),
+    thinking: v.string().optional(),
+    usage: v
+      .object({
+        promptTokens: v.number().int().nonnegative(),
+        completionTokens: v.number().int().nonnegative(),
+        totalTokens: v.number().int().nonnegative(),
+      })
+      .optional(),
+    metadata: v.record(v.string(), v.unknown()).optional(),
+  })
+);
+
+export const getAgentContextSchema = defineSchema((v) =>
+  v.object({
+    agentId: v.string(),
+    model: v.string().optional(),
+    input: v.union([v.string(), v.array(getMessageSchema())]),
+    data: v.record(v.string(), v.unknown()).optional(),
+    platform: v.any(), // Platform type is complex
+    metadata: v.record(v.string(), v.unknown()).optional(),
+  })
+);
 
 // Inferred types
-export type ModelProvider = z.infer<typeof modelProviderSchema>;
-export type AgentStatus = z.infer<typeof agentStatusSchema>;
-export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
-export type EdgeConfig = z.infer<typeof EdgeConfigSchema>;
-export type ToolCallPartWithArgs = z.infer<typeof ToolCallPartWithArgsSchema>;
-export type ToolCallPartWithInput = z.infer<typeof ToolCallPartWithInputSchema>;
-export type ToolCallPart = z.infer<typeof ToolCallPartSchema>;
-export type ToolResultPart = z.infer<typeof ToolResultPartSchema>;
-export type MessagePart = z.infer<typeof MessagePartSchema>;
-export type Message = z.infer<typeof MessageSchema>;
-export type StreamToolCall = z.infer<typeof StreamToolCallSchema>;
-export type ToolCall = z.infer<typeof ToolCallSchema>;
-export type AgentResponse = z.infer<typeof AgentResponseSchema>;
-export type AgentContext = z.infer<typeof AgentContextSchema>;
+export type ModelProvider = InferSchema<ReturnType<typeof getModelProviderSchema>>;
+export type AgentStatus = InferSchema<ReturnType<typeof getAgentStatusSchema>>;
+export type MemoryConfig = InferSchema<ReturnType<typeof getMemoryConfigSchema>>;
+export type EdgeConfig = InferSchema<ReturnType<typeof getEdgeConfigSchema>>;
+export type ToolCallPartWithArgs = InferSchema<ReturnType<typeof getToolCallPartWithArgsSchema>>;
+export type ToolCallPartWithInput = InferSchema<ReturnType<typeof getToolCallPartWithInputSchema>>;
+export type ToolCallPart = InferSchema<ReturnType<typeof getToolCallPartSchema>>;
+export type ToolResultPart = InferSchema<ReturnType<typeof getToolResultPartSchema>>;
+export type MessagePart = InferSchema<ReturnType<typeof getMessagePartSchema>>;
+export type Message = InferSchema<ReturnType<typeof getMessageSchema>>;
+export type StreamToolCall = InferSchema<ReturnType<typeof getStreamToolCallSchema>>;
+export type ToolCall = InferSchema<ReturnType<typeof getToolCallSchema>>;
+export type AgentResponse = InferSchema<ReturnType<typeof getAgentResponseSchema>>;
+export type AgentContext = InferSchema<ReturnType<typeof getAgentContextSchema>>;

package/src/src/agent/schemas/index.ts

@@ -6,33 +6,33 @@
 
 export {
   type AgentContext,
-  AgentContextSchema,
   type AgentResponse,
-  AgentResponseSchema,
   type AgentStatus,
-  agentStatusSchema,
   type EdgeConfig,
-  EdgeConfigSchema,
+  getAgentContextSchema,
+  getAgentResponseSchema,
+  getAgentStatusSchema,
+  getEdgeConfigSchema,
+  getMemoryConfigSchema,
+  getMessagePartSchema,
+  getMessageSchema,
+  getModelProviderSchema,
+  getStreamToolCallSchema,
+  getToolCallPartSchema,
+  getToolCallPartWithArgsSchema,
+  getToolCallPartWithInputSchema,
+  getToolCallSchema,
+  getToolResultPartSchema,
   type MemoryConfig,
-  MemoryConfigSchema,
   type Message,
   type MessagePart,
-  MessagePartSchema,
-  MessageSchema,
   type ModelProvider,
-  modelProviderSchema,
   type StreamToolCall,
-  StreamToolCallSchema,
   type ToolCall,
   type ToolCallPart,
-  ToolCallPartSchema,
   type ToolCallPartWithArgs,
-  ToolCallPartWithArgsSchema,
   type ToolCallPartWithInput,
-  ToolCallPartWithInputSchema,
-  ToolCallSchema,
   type ToolResultPart,
-  ToolResultPartSchema,
 } from "./agent.schema.js";
 
-export { type AgentToolInput, AgentToolInputSchema } from "./tool.schema.js";
+export { type AgentToolInput, getAgentToolInputSchema } from "./tool.schema.js";