veryfront 0.1.502 → 0.1.503

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

@@ -1,14 +1,16 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema, Schema } from "../extensions/schema/index.js";
 import {
-  AgUiRuntimeContextItemSchema,
-  AgUiRuntimeContextSchema,
-  AgUiRuntimeInjectedToolSchema,
+  type AgUiRuntimeContextItem,
   type AgUiRuntimeMessage,
-  AgUiRuntimeMessageSchema,
   type AgUiRuntimeRequest,
-  AgUiRuntimeRequestSchema,
-  AgUiRuntimeRunIdSchema,
-  AgUiRuntimeToolCallSchema,
+  getAgUiRuntimeContextItemSchema,
+  getAgUiRuntimeContextSchema,
+  getAgUiRuntimeInjectedToolSchema,
+  getAgUiRuntimeMessageSchema,
+  getAgUiRuntimeRequestSchema,
+  getAgUiRuntimeRunIdSchema,
+  getAgUiRuntimeToolCallSchema,
 } from "../agent/runtime-ag-ui-contract.js";
 import { stripLeadingEmptyObjectPlaceholder } from "../agent/data-stream.js";
 
@@ -27,63 +29,73 @@ function isWithinJsonSizeLimit(value: unknown, maxBytes: number): boolean {
   }
 }
 
-export const RunIdSchema = AgUiRuntimeRunIdSchema;
-
-export const AgentIdSchema = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
-
-export const RuntimeAgentSourceContextSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("branch"),
-    branch: z.string().min(1).max(255),
-  }),
-  z.object({
-    type: z.literal("environment"),
-    environmentName: z.string().min(1).max(255),
-    releaseId: z.string().min(1).max(255).optional(),
-  }),
-  z.object({
-    type: z.literal("release"),
-    releaseId: z.string().min(1).max(255),
-  }),
-]);
-
-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"]),
-  parts: z.array(z.object({ type: z.string().min(1) }).passthrough()).default([]),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string().optional(),
-});
-
-export const InternalAgentStreamRequestSchema = z.object({
-  agentId: AgentIdSchema,
-  threadId: z.string().uuid(),
-  runId: RunIdSchema,
-  parentRunId: RunIdSchema.optional(),
-  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, 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" },
-  ),
-});
+export const getRunIdSchema = getAgUiRuntimeRunIdSchema;
+
+export const getAgentIdSchema = defineSchema((v) =>
+  v.string().min(1).max(128).regex(AGENT_ID_PATTERN)
+);
+
+export const getRuntimeAgentSourceContextSchema = defineSchema((v) =>
+  v.discriminatedUnion("type", [
+    v.object({
+      type: v.literal("branch"),
+      branch: v.string().min(1).max(255),
+    }),
+    v.object({
+      type: v.literal("environment"),
+      environmentName: v.string().min(1).max(255),
+      releaseId: v.string().min(1).max(255).optional(),
+    }),
+    v.object({
+      type: v.literal("release"),
+      releaseId: v.string().min(1).max(255),
+    }),
+  ])
+);
+
+export const getRuntimeInjectedToolSchema = getAgUiRuntimeInjectedToolSchema;
+export const getRuntimeContextItemSchema = getAgUiRuntimeContextItemSchema;
+export const getRuntimeMessageSchema = getAgUiRuntimeMessageSchema;
+export const getRuntimeContextSchema = getAgUiRuntimeContextSchema;
+export const getRuntimeRunAgentInputSchema = getAgUiRuntimeRequestSchema;
+
+export const getInternalAgentCompatibilityMessageSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().min(1),
+    role: v.enum(["user", "assistant", "system", "tool"] as const),
+    parts: v.array(v.object({ type: v.string().min(1) }).passthrough()).default([]),
+    metadata: v.record(v.string(), v.unknown()).optional(),
+    createdAt: v.string().optional(),
+  })
+);
+
+export const getInternalAgentStreamRequestSchema = defineSchema((v) =>
+  v.object({
+    agentId: getAgentIdSchema(),
+    threadId: v.string().uuid(),
+    runId: getRunIdSchema(),
+    parentRunId: getRunIdSchema().optional(),
+    state: v.unknown().optional(),
+    messages: v.array(
+      v.union([getRuntimeMessageSchema(), getInternalAgentCompatibilityMessageSchema()]),
+    ).max(MAX_RUNTIME_MESSAGES),
+    tools: v.array(getRuntimeInjectedToolSchema()).max(50).default([]),
+    context: v.array(getRuntimeContextSchema()).max(10).default([]).refine(
+      (value) => isWithinJsonSizeLimit(value, 65_536),
+      { message: "context must be less than 64 KB total" },
+    ),
+    agentSource: getRuntimeAgentSourceContextSchema().optional(),
+    forwardedProps: v.record(v.string(), v.unknown()).optional().refine(
+      (value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES),
+      { message: "forwardedProps must be less than 64 KB" },
+    ),
+  })
+);
 
 type RuntimeMessage = AgUiRuntimeMessage;
-type InternalAgentCompatibilityMessage = z.infer<typeof InternalAgentCompatibilityMessageSchema>;
+type InternalAgentCompatibilityMessage = InferSchema<
+  ReturnType<typeof getInternalAgentCompatibilityMessageSchema>
+>;
 
 function extractToolArgs(
   part: Record<string, unknown>,
@@ -161,9 +173,11 @@ function isCanonicalToolCallPart(part: Record<string, unknown>): boolean {
       type !== "tool_result");
 }
 
+type AgUiRuntimeToolCall = InferSchema<ReturnType<typeof getAgUiRuntimeToolCallSchema>>;
+
 function getToolCallShape(
   part: Record<string, unknown>,
-): z.infer<typeof AgUiRuntimeToolCallSchema> | null {
+): AgUiRuntimeToolCall | null {
   const id = getPartString(part, "toolCallId", "tool_call_id", "id");
   const name = getPartString(part, "toolName", "tool_name", "name");
 
@@ -205,11 +219,19 @@ function toRuntimeMessage(
     return message;
   }
 
-  const textContent = message.parts
+  // The compatibility schema's parts use `passthrough()` so unknown fields
+  // (like `text`) survive parsing but the inferred TS type only exposes the
+  // explicit `{ type }` shape. Cast to a loose record to read those passthrough
+  // fields.
+  const textContent = (message.parts as ReadonlyArray<Record<string, unknown>>)
     .filter((part) => part.type === "text" && typeof part.text === "string")
-    .map((part) => part.text)
+    .map((part) => part.text as string)
     .join("\n");
 
+  // Use the conditional-spread pattern (omitting keys entirely when not
+  // present) to preserve the pre-migration runtime semantics. Cast the
+  // return literal to `RuntimeMessage` to satisfy the contract DSL's strict
+  // object shape (optional fields type as required-key, `T | undefined`).
   const sharedFields = {
     ...(message.metadata ? { metadata: message.metadata } : {}),
     ...(message.createdAt ? { createdAt: message.createdAt } : {}),
@@ -222,14 +244,14 @@ function toRuntimeMessage(
         role: "system",
         content: textContent,
         ...sharedFields,
-      };
+      } as RuntimeMessage;
     case "user":
       return {
         id: message.id,
         role: "user",
         content: textContent,
         ...sharedFields,
-      };
+      } as RuntimeMessage;
     case "assistant": {
       const toolCalls = message.parts.flatMap((part) => {
         if (!isCanonicalToolCallPart(part) && !isLegacyToolCallPart(part)) {
@@ -246,7 +268,7 @@ function toRuntimeMessage(
         ...(textContent ? { content: textContent } : {}),
         ...(toolCalls.length ? { toolCalls } : {}),
         ...sharedFields,
-      };
+      } as RuntimeMessage;
     }
     case "tool": {
       const toolResultPart = message.parts.find(
@@ -270,13 +292,13 @@ function toRuntimeMessage(
         content: toolResult !== undefined ? stringifyToolResult(toolResult) : textContent,
         ...(toolError ? { error: toolError } : {}),
         ...sharedFields,
-      };
+      } as RuntimeMessage;
     }
   }
 }
 
 export function toRuntimeRunAgentInput(
-  input: z.infer<typeof InternalAgentStreamRequestSchema>,
+  input: InferSchema<ReturnType<typeof getInternalAgentStreamRequestSchema>>,
 ): AgUiRuntimeRequest {
   return {
     threadId: input.threadId,
@@ -287,24 +309,33 @@ export function toRuntimeRunAgentInput(
     tools: input.tools,
     context: input.context,
     ...(input.forwardedProps ? { forwardedProps: input.forwardedProps } : {}),
-  };
+  } as AgUiRuntimeRequest;
 }
 
-export const ResumeSignalSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("tool_result"),
-    toolCallId: z.string().min(1).max(128),
-    result: z.unknown().refine(
-      (value) => isWithinJsonSizeLimit(value, MAX_TOOL_RESULT_BYTES),
-      { message: "Tool result must be less than 64 KB" },
-    ),
-    isError: z.boolean().optional().default(false),
-  }),
-]);
-
-export type RuntimeInjectedTool = z.infer<typeof RuntimeInjectedToolSchema>;
-export type RuntimeContextItem = z.infer<typeof RuntimeContextItemSchema>;
-export type RuntimeAgentSourceContext = z.infer<typeof RuntimeAgentSourceContextSchema>;
+export const getResumeSignalSchema = defineSchema((v) =>
+  v.discriminatedUnion("type", [
+    v.object({
+      type: v.literal("tool_result"),
+      toolCallId: v.string().min(1).max(128),
+      result: v.unknown().refine(
+        (value) => isWithinJsonSizeLimit(value, MAX_TOOL_RESULT_BYTES),
+        { message: "Tool result must be less than 64 KB" },
+      ),
+      isError: v.boolean().optional().default(false),
+    }),
+  ])
+);
+
+export type RuntimeInjectedTool = InferSchema<ReturnType<typeof getRuntimeInjectedToolSchema>>;
+export type RuntimeContextItem = AgUiRuntimeContextItem;
+export type RuntimeAgentSourceContext = InferSchema<
+  ReturnType<typeof getRuntimeAgentSourceContextSchema>
+>;
 export type RuntimeRunAgentInput = AgUiRuntimeRequest;
-export type InternalAgentStreamRequest = z.infer<typeof InternalAgentStreamRequestSchema>;
-export type ResumeSignal = z.infer<typeof ResumeSignalSchema>;
+export type InternalAgentStreamRequest = InferSchema<
+  ReturnType<typeof getInternalAgentStreamRequestSchema>
+>;
+export type ResumeSignal = InferSchema<ReturnType<typeof getResumeSignalSchema>>;
+
+// Convenience local Schema export for downstream consumers.
+export type { Schema };

package/src/src/issues/core.ts

@@ -329,7 +329,9 @@ export class IssuesManager {
       if (sortKey === "id") {
         comparison = a.metadata.id.localeCompare(b.metadata.id);
       } else {
-        comparison = String(a.metadata[sortKey]).localeCompare(String(b.metadata[sortKey]));
+        comparison = String((a.metadata as Record<string, unknown>)[sortKey]).localeCompare(
+          String((b.metadata as Record<string, unknown>)[sortKey]),
+        );
       }
       return sortDirection === "desc" ? -comparison : comparison;
     });

package/src/src/issues/mcp.ts

@@ -6,20 +6,21 @@
  * @module issues/mcp
  */
 
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import { cwd } from "../platform/compat/process.js";
 import type { MCPTool } from "../mcp/types.js";
 import { createIssuesManager } from "./core.js";
 import type { Issue } from "./schemas/index.js";
 import {
-  createIssueSchema,
-  issueIdSchema,
-  issuePrefixSchema,
-  issueStateSchema,
-  labelSchema,
-  listIssuesSchema,
+  getCreateIssueSchema,
+  getIssueIdSchema,
+  getIssuePrefixSchema,
+  getIssueStateSchema,
+  getLabelSchema,
+  getListIssuesSchema,
+  getUpdateIssueSchema,
   parseState,
-  updateIssueSchema,
 } from "./schemas/index.js";
 
 function getManager(projectDir?: string) {
@@ -30,26 +31,31 @@ function getManager(projectDir?: string) {
 // Shared schema extension for projectDir
 // ============================================================================
 
-const projectDirSchema = z.object({
-  projectDir: z.string().optional().describe("Project directory (defaults to cwd)"),
-});
+const getProjectDirSchema = defineSchema((v) =>
+  v.object({
+    projectDir: v.string().optional().describe("Project directory (defaults to cwd)"),
+  })
+);
 
 // ============================================================================
 // Tool: issues_create
 // ============================================================================
 
-const issuesCreateInput = createIssueSchema.extend({
-  title: z.string().describe("Issue title"),
-  body: z.string().optional().describe("Issue description in markdown"),
-  labels: z.array(labelSchema).optional().describe(
-    "Labels to apply (e.g., ['bug', 'priority:high'])",
-  ),
-  milestone: z.string().optional().describe("Milestone to assign"),
-  assignees: z.array(z.string()).optional().describe("Users to assign"),
-  prefix: issuePrefixSchema.optional().describe("ID prefix: ISSUE, TASK, or PLAN"),
-}).merge(projectDirSchema);
-
-type IssuesCreateInput = z.infer<typeof issuesCreateInput>;
+const getIssuesCreateInput = defineSchema((v) =>
+  getCreateIssueSchema().extend({
+    title: v.string().describe("Issue title"),
+    body: v.string().optional().describe("Issue description in markdown"),
+    labels: v.array(getLabelSchema()).optional().describe(
+      "Labels to apply (e.g., ['bug', 'priority:high'])",
+    ),
+    milestone: v.string().optional().describe("Milestone to assign"),
+    assignees: v.array(v.string()).optional().describe("Users to assign"),
+    prefix: getIssuePrefixSchema().optional().describe("ID prefix: ISSUE, TASK, or PLAN"),
+  }).merge(getProjectDirSchema())
+);
+const issuesCreateInput = getIssuesCreateInput();
+
+type IssuesCreateInput = InferSchema<ReturnType<typeof getIssuesCreateInput>>;
 
 const issuesCreate: MCPTool<IssuesCreateInput, Issue> = {
   name: "issues_create",
@@ -76,11 +82,14 @@ const issuesCreate: MCPTool<IssuesCreateInput, Issue> = {
 // Tool: issues_get
 // ============================================================================
 
-const issuesGetInput = projectDirSchema.extend({
-  id: issueIdSchema.describe("Issue ID (e.g., ISSUE-001, TASK-042)"),
-});
+const getIssuesGetInput = defineSchema((_v) =>
+  getProjectDirSchema().extend({
+    id: getIssueIdSchema().describe("Issue ID (e.g., ISSUE-001, TASK-042)"),
+  })
+);
+const issuesGetInput = getIssuesGetInput();
 
-type IssuesGetInput = z.infer<typeof issuesGetInput>;
+type IssuesGetInput = InferSchema<ReturnType<typeof getIssuesGetInput>>;
 
 const issuesGet: MCPTool<IssuesGetInput, Issue | null> = {
   name: "issues_get",
@@ -99,17 +108,22 @@ const issuesGet: MCPTool<IssuesGetInput, Issue | null> = {
 // Tool: issues_update
 // ============================================================================
 
-const issuesUpdateInput = updateIssueSchema.extend({
-  id: issueIdSchema.describe("Issue ID to update"),
-  title: z.string().optional().describe("New title"),
-  body: z.string().optional().describe("New body content"),
-  state: z.string().optional().describe("New state: 'open' or 'closed' (aliases: done, resolved)"),
-  labels: z.array(labelSchema).optional().describe("Labels to set (replaces existing)"),
-  milestone: z.string().nullable().optional().describe("Milestone (set to null to remove)"),
-  assignees: z.array(z.string()).optional().describe("Assignees to set (replaces existing)"),
-}).merge(projectDirSchema);
-
-type IssuesUpdateInput = z.infer<typeof issuesUpdateInput>;
+const getIssuesUpdateInput = defineSchema((v) =>
+  getUpdateIssueSchema().extend({
+    id: getIssueIdSchema().describe("Issue ID to update"),
+    title: v.string().optional().describe("New title"),
+    body: v.string().optional().describe("New body content"),
+    state: v.string().optional().describe(
+      "New state: 'open' or 'closed' (aliases: done, resolved)",
+    ),
+    labels: v.array(getLabelSchema()).optional().describe("Labels to set (replaces existing)"),
+    milestone: v.string().nullable().optional().describe("Milestone (set to null to remove)"),
+    assignees: v.array(v.string()).optional().describe("Assignees to set (replaces existing)"),
+  }).merge(getProjectDirSchema())
+);
+const issuesUpdateInput = getIssuesUpdateInput();
+
+type IssuesUpdateInput = InferSchema<ReturnType<typeof getIssuesUpdateInput>>;
 
 const issuesUpdate: MCPTool<IssuesUpdateInput, Issue | null> = {
   name: "issues_update",
@@ -147,18 +161,21 @@ const issuesUpdate: MCPTool<IssuesUpdateInput, Issue | null> = {
 // Tool: issues_list
 // ============================================================================
 
-const issuesListInput = listIssuesSchema.extend({
-  state: issueStateSchema.optional().describe("Filter by state"),
-  labels: z.array(labelSchema).optional().describe("Filter by labels (must have ALL)"),
-  milestone: z.string().optional().describe("Filter by milestone"),
-  assignee: z.string().optional().describe("Filter by assignee"),
-  prefix: issuePrefixSchema.optional().describe("Filter by prefix (ISSUE, TASK, PLAN)"),
-  sortBy: z.enum(["created_at", "updated_at", "id"]).optional().describe("Sort field"),
-  sortDirection: z.enum(["asc", "desc"]).optional().describe("Sort direction"),
-  limit: z.number().optional().describe("Maximum results"),
-}).merge(projectDirSchema);
-
-type IssuesListInput = z.infer<typeof issuesListInput>;
+const getIssuesListInput = defineSchema((v) =>
+  getListIssuesSchema().extend({
+    state: getIssueStateSchema().optional().describe("Filter by state"),
+    labels: v.array(getLabelSchema()).optional().describe("Filter by labels (must have ALL)"),
+    milestone: v.string().optional().describe("Filter by milestone"),
+    assignee: v.string().optional().describe("Filter by assignee"),
+    prefix: getIssuePrefixSchema().optional().describe("Filter by prefix (ISSUE, TASK, PLAN)"),
+    sortBy: v.enum(["created_at", "updated_at", "id"]).optional().describe("Sort field"),
+    sortDirection: v.enum(["asc", "desc"]).optional().describe("Sort direction"),
+    limit: v.number().optional().describe("Maximum results"),
+  }).merge(getProjectDirSchema())
+);
+const issuesListInput = getIssuesListInput();
+
+type IssuesListInput = InferSchema<ReturnType<typeof getIssuesListInput>>;
 
 interface IssuesListOutput {
   issues: Issue[];
@@ -191,11 +208,14 @@ const issuesList: MCPTool<IssuesListInput, IssuesListOutput> = {
 // Tool: issues_close
 // ============================================================================
 
-const issuesCloseInput = projectDirSchema.extend({
-  id: issueIdSchema.describe("Issue ID to close"),
-});
+const getIssuesCloseInput = defineSchema((_v) =>
+  getProjectDirSchema().extend({
+    id: getIssueIdSchema().describe("Issue ID to close"),
+  })
+);
+const issuesCloseInput = getIssuesCloseInput();
 
-type IssuesCloseInput = z.infer<typeof issuesCloseInput>;
+type IssuesCloseInput = InferSchema<ReturnType<typeof getIssuesCloseInput>>;
 
 const issuesClose: MCPTool<IssuesCloseInput, Issue | null> = {
   name: "issues_close",
@@ -219,11 +239,14 @@ const issuesClose: MCPTool<IssuesCloseInput, Issue | null> = {
 // Tool: issues_delete
 // ============================================================================
 
-const issuesDeleteInput = projectDirSchema.extend({
-  id: issueIdSchema.describe("Issue ID to delete"),
-});
+const getIssuesDeleteInput = defineSchema((_v) =>
+  getProjectDirSchema().extend({
+    id: getIssueIdSchema().describe("Issue ID to delete"),
+  })
+);
+const issuesDeleteInput = getIssuesDeleteInput();
 
-type IssuesDeleteInput = z.infer<typeof issuesDeleteInput>;
+type IssuesDeleteInput = InferSchema<ReturnType<typeof getIssuesDeleteInput>>;
 
 interface IssuesDeleteOutput {
   deleted: boolean;

package/src/src/issues/schemas/index.ts

@@ -8,6 +8,17 @@ export {
   type CreateIssueOptions,
   createIssueSchema,
   generateIssueId,
+  getCreateIssueSchema,
+  getIsoDateSchema,
+  getIssueIdSchema,
+  getIssueMetadataSchema,
+  getIssuePrefixSchema,
+  getIssueSchema,
+  getIssueStateSchema,
+  getLabelSchema,
+  getListIssuesResultSchema,
+  getListIssuesSchema,
+  getUpdateIssueSchema,
   isoDateSchema,
   type Issue,
   ISSUE_ID_PATTERN,