@vm0/runner 2.7.0 → 2.7.1

package/index.js

@@ -6287,9 +6287,207 @@ var checkpointsByIdContract = c10.router({
   }
 });
 
-// ../../packages/core/src/contracts/public/common.ts
+// ../../packages/core/src/contracts/schedules.ts
 import { z as z15 } from "zod";
-var publicApiErrorTypeSchema = z15.enum([
+var c11 = initContract();
+var scheduleTriggerSchema = z15.object({
+  cron: z15.string().optional(),
+  at: z15.string().optional(),
+  timezone: z15.string().default("UTC")
+}).refine((data) => data.cron && !data.at || !data.cron && data.at, {
+  message: "Exactly one of 'cron' or 'at' must be specified"
+});
+var scheduleRunConfigSchema = z15.object({
+  agent: z15.string().min(1, "Agent reference required"),
+  prompt: z15.string().min(1, "Prompt required"),
+  vars: z15.record(z15.string(), z15.string()).optional(),
+  secrets: z15.record(z15.string(), z15.string()).optional(),
+  artifactName: z15.string().optional(),
+  artifactVersion: z15.string().optional(),
+  volumeVersions: z15.record(z15.string(), z15.string()).optional()
+});
+var scheduleDefinitionSchema = z15.object({
+  on: scheduleTriggerSchema,
+  run: scheduleRunConfigSchema
+});
+var scheduleYamlSchema = z15.object({
+  version: z15.literal("1.0"),
+  schedules: z15.record(z15.string(), scheduleDefinitionSchema)
+});
+var deployScheduleRequestSchema = z15.object({
+  name: z15.string().min(1).max(64, "Schedule name max 64 chars"),
+  cronExpression: z15.string().optional(),
+  atTime: z15.string().optional(),
+  timezone: z15.string().default("UTC"),
+  prompt: z15.string().min(1, "Prompt required"),
+  vars: z15.record(z15.string(), z15.string()).optional(),
+  secrets: z15.record(z15.string(), z15.string()).optional(),
+  artifactName: z15.string().optional(),
+  artifactVersion: z15.string().optional(),
+  volumeVersions: z15.record(z15.string(), z15.string()).optional(),
+  // Resolved agent compose ID (CLI resolves scope/name:version → composeId)
+  composeId: z15.string().uuid("Invalid compose ID")
+}).refine(
+  (data) => data.cronExpression && !data.atTime || !data.cronExpression && data.atTime,
+  {
+    message: "Exactly one of 'cronExpression' or 'atTime' must be specified"
+  }
+);
+var scheduleResponseSchema = z15.object({
+  id: z15.string().uuid(),
+  composeId: z15.string().uuid(),
+  composeName: z15.string(),
+  scopeSlug: z15.string(),
+  name: z15.string(),
+  cronExpression: z15.string().nullable(),
+  atTime: z15.string().nullable(),
+  timezone: z15.string(),
+  prompt: z15.string(),
+  vars: z15.record(z15.string(), z15.string()).nullable(),
+  // Secret names only (values are never returned)
+  secretNames: z15.array(z15.string()).nullable(),
+  artifactName: z15.string().nullable(),
+  artifactVersion: z15.string().nullable(),
+  volumeVersions: z15.record(z15.string(), z15.string()).nullable(),
+  enabled: z15.boolean(),
+  nextRunAt: z15.string().nullable(),
+  lastRunAt: z15.string().nullable(),
+  lastRunId: z15.string().nullable(),
+  createdAt: z15.string(),
+  updatedAt: z15.string()
+});
+var scheduleListResponseSchema = z15.object({
+  schedules: z15.array(scheduleResponseSchema)
+});
+var deployScheduleResponseSchema = z15.object({
+  schedule: scheduleResponseSchema,
+  created: z15.boolean()
+  // true if created, false if updated
+});
+var schedulesMainContract = c11.router({
+  /**
+   * POST /api/agent/schedules
+   * Deploy (create or update) a schedule
+   */
+  deploy: {
+    method: "POST",
+    path: "/api/agent/schedules",
+    body: deployScheduleRequestSchema,
+    responses: {
+      200: deployScheduleResponseSchema,
+      // Updated
+      201: deployScheduleResponseSchema,
+      // Created
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      409: apiErrorSchema
+      // Schedule limit reached
+    },
+    summary: "Deploy schedule (create or update)"
+  },
+  /**
+   * GET /api/agent/schedules
+   * List all schedules for the user
+   */
+  list: {
+    method: "GET",
+    path: "/api/agent/schedules",
+    responses: {
+      200: scheduleListResponseSchema,
+      401: apiErrorSchema
+    },
+    summary: "List all schedules"
+  }
+});
+var schedulesByNameContract = c11.router({
+  /**
+   * GET /api/agent/schedules/:name
+   * Get schedule by name
+   */
+  getByName: {
+    method: "GET",
+    path: "/api/agent/schedules/:name",
+    pathParams: z15.object({
+      name: z15.string().min(1, "Schedule name required")
+    }),
+    query: z15.object({
+      composeId: z15.string().uuid("Compose ID required")
+    }),
+    responses: {
+      200: scheduleResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get schedule by name"
+  },
+  /**
+   * DELETE /api/agent/schedules/:name
+   * Delete schedule by name
+   */
+  delete: {
+    method: "DELETE",
+    path: "/api/agent/schedules/:name",
+    pathParams: z15.object({
+      name: z15.string().min(1, "Schedule name required")
+    }),
+    query: z15.object({
+      composeId: z15.string().uuid("Compose ID required")
+    }),
+    responses: {
+      204: z15.undefined(),
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Delete schedule"
+  }
+});
+var schedulesEnableContract = c11.router({
+  /**
+   * POST /api/agent/schedules/:name/enable
+   * Enable a disabled schedule
+   */
+  enable: {
+    method: "POST",
+    path: "/api/agent/schedules/:name/enable",
+    pathParams: z15.object({
+      name: z15.string().min(1, "Schedule name required")
+    }),
+    body: z15.object({
+      composeId: z15.string().uuid("Compose ID required")
+    }),
+    responses: {
+      200: scheduleResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Enable schedule"
+  },
+  /**
+   * POST /api/agent/schedules/:name/disable
+   * Disable an enabled schedule
+   */
+  disable: {
+    method: "POST",
+    path: "/api/agent/schedules/:name/disable",
+    pathParams: z15.object({
+      name: z15.string().min(1, "Schedule name required")
+    }),
+    body: z15.object({
+      composeId: z15.string().uuid("Compose ID required")
+    }),
+    responses: {
+      200: scheduleResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Disable schedule"
+  }
+});
+
+// ../../packages/core/src/contracts/public/common.ts
+import { z as z16 } from "zod";
+var publicApiErrorTypeSchema = z16.enum([
   "api_error",
   // Internal server error (5xx)
   "invalid_request_error",
@@ -6301,55 +6499,55 @@ var publicApiErrorTypeSchema = z15.enum([
   "conflict_error"
   // Resource conflict (409)
 ]);
-var publicApiErrorSchema = z15.object({
-  error: z15.object({
+var publicApiErrorSchema = z16.object({
+  error: z16.object({
     type: publicApiErrorTypeSchema,
-    code: z15.string(),
-    message: z15.string(),
-    param: z15.string().optional(),
-    doc_url: z15.string().url().optional()
+    code: z16.string(),
+    message: z16.string(),
+    param: z16.string().optional(),
+    doc_url: z16.string().url().optional()
   })
 });
-var paginationSchema = z15.object({
-  has_more: z15.boolean(),
-  next_cursor: z15.string().nullable()
+var paginationSchema = z16.object({
+  has_more: z16.boolean(),
+  next_cursor: z16.string().nullable()
 });
 function createPaginatedResponseSchema(dataSchema) {
-  return z15.object({
-    data: z15.array(dataSchema),
+  return z16.object({
+    data: z16.array(dataSchema),
     pagination: paginationSchema
   });
 }
-var listQuerySchema = z15.object({
-  cursor: z15.string().optional(),
-  limit: z15.coerce.number().min(1).max(100).default(20)
+var listQuerySchema = z16.object({
+  cursor: z16.string().optional(),
+  limit: z16.coerce.number().min(1).max(100).default(20)
 });
-var requestIdSchema = z15.string().uuid();
-var timestampSchema = z15.string().datetime();
+var requestIdSchema = z16.string().uuid();
+var timestampSchema = z16.string().datetime();
 
 // ../../packages/core/src/contracts/public/agents.ts
-import { z as z16 } from "zod";
-var c11 = initContract();
-var publicAgentSchema = z16.object({
-  id: z16.string(),
-  name: z16.string(),
-  current_version_id: z16.string().nullable(),
+import { z as z17 } from "zod";
+var c12 = initContract();
+var publicAgentSchema = z17.object({
+  id: z17.string(),
+  name: z17.string(),
+  current_version_id: z17.string().nullable(),
   created_at: timestampSchema,
   updated_at: timestampSchema
 });
-var agentVersionSchema = z16.object({
-  id: z16.string(),
-  agent_id: z16.string(),
-  version_number: z16.number(),
+var agentVersionSchema = z17.object({
+  id: z17.string(),
+  agent_id: z17.string(),
+  version_number: z17.number(),
   created_at: timestampSchema
 });
 var publicAgentDetailSchema = publicAgentSchema;
 var paginatedAgentsSchema = createPaginatedResponseSchema(publicAgentSchema);
 var paginatedAgentVersionsSchema = createPaginatedResponseSchema(agentVersionSchema);
 var agentListQuerySchema = listQuerySchema.extend({
-  name: z16.string().optional()
+  name: z17.string().optional()
 });
-var publicAgentsListContract = c11.router({
+var publicAgentsListContract = c12.router({
   list: {
     method: "GET",
     path: "/v1/agents",
@@ -6363,12 +6561,12 @@ var publicAgentsListContract = c11.router({
     description: "List all agents in the current scope with pagination. Use the `name` query parameter to filter by agent name."
   }
 });
-var publicAgentByIdContract = c11.router({
+var publicAgentByIdContract = c12.router({
   get: {
     method: "GET",
     path: "/v1/agents/:id",
-    pathParams: z16.object({
-      id: z16.string().min(1, "Agent ID is required")
+    pathParams: z17.object({
+      id: z17.string().min(1, "Agent ID is required")
     }),
     responses: {
       200: publicAgentDetailSchema,
@@ -6380,12 +6578,12 @@ var publicAgentByIdContract = c11.router({
     description: "Get agent details by ID"
   }
 });
-var publicAgentVersionsContract = c11.router({
+var publicAgentVersionsContract = c12.router({
   list: {
     method: "GET",
     path: "/v1/agents/:id/versions",
-    pathParams: z16.object({
-      id: z16.string().min(1, "Agent ID is required")
+    pathParams: z17.object({
+      id: z17.string().min(1, "Agent ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -6400,9 +6598,9 @@ var publicAgentVersionsContract = c11.router({
 });
 
 // ../../packages/core/src/contracts/public/runs.ts
-import { z as z17 } from "zod";
-var c12 = initContract();
-var publicRunStatusSchema = z17.enum([
+import { z as z18 } from "zod";
+var c13 = initContract();
+var publicRunStatusSchema = z18.enum([
   "pending",
   "running",
   "completed",
@@ -6410,56 +6608,56 @@ var publicRunStatusSchema = z17.enum([
   "timeout",
   "cancelled"
 ]);
-var publicRunSchema = z17.object({
-  id: z17.string(),
-  agent_id: z17.string(),
-  agent_name: z17.string(),
+var publicRunSchema = z18.object({
+  id: z18.string(),
+  agent_id: z18.string(),
+  agent_name: z18.string(),
   status: publicRunStatusSchema,
-  prompt: z17.string(),
+  prompt: z18.string(),
   created_at: timestampSchema,
   started_at: timestampSchema.nullable(),
   completed_at: timestampSchema.nullable()
 });
 var publicRunDetailSchema = publicRunSchema.extend({
-  error: z17.string().nullable(),
-  execution_time_ms: z17.number().nullable(),
-  checkpoint_id: z17.string().nullable(),
-  session_id: z17.string().nullable(),
-  artifact_name: z17.string().nullable(),
-  artifact_version: z17.string().nullable(),
-  volumes: z17.record(z17.string(), z17.string()).optional()
+  error: z18.string().nullable(),
+  execution_time_ms: z18.number().nullable(),
+  checkpoint_id: z18.string().nullable(),
+  session_id: z18.string().nullable(),
+  artifact_name: z18.string().nullable(),
+  artifact_version: z18.string().nullable(),
+  volumes: z18.record(z18.string(), z18.string()).optional()
 });
 var paginatedRunsSchema = createPaginatedResponseSchema(publicRunSchema);
-var createRunRequestSchema = z17.object({
+var createRunRequestSchema = z18.object({
   // Agent identification (one of: agent, agent_id, session_id, checkpoint_id)
-  agent: z17.string().optional(),
+  agent: z18.string().optional(),
   // Agent name
-  agent_id: z17.string().optional(),
+  agent_id: z18.string().optional(),
   // Agent ID
-  agent_version: z17.string().optional(),
+  agent_version: z18.string().optional(),
   // Version specifier (e.g., "latest", "v1", specific ID)
   // Continue session
-  session_id: z17.string().optional(),
+  session_id: z18.string().optional(),
   // Resume from checkpoint
-  checkpoint_id: z17.string().optional(),
+  checkpoint_id: z18.string().optional(),
   // Required
-  prompt: z17.string().min(1, "Prompt is required"),
+  prompt: z18.string().min(1, "Prompt is required"),
   // Optional configuration
-  variables: z17.record(z17.string(), z17.string()).optional(),
-  secrets: z17.record(z17.string(), z17.string()).optional(),
-  artifact_name: z17.string().optional(),
+  variables: z18.record(z18.string(), z18.string()).optional(),
+  secrets: z18.record(z18.string(), z18.string()).optional(),
+  artifact_name: z18.string().optional(),
   // Artifact name to mount
-  artifact_version: z17.string().optional(),
+  artifact_version: z18.string().optional(),
   // Artifact version (defaults to latest)
-  volumes: z17.record(z17.string(), z17.string()).optional()
+  volumes: z18.record(z18.string(), z18.string()).optional()
   // volume_name -> version
 });
 var runListQuerySchema = listQuerySchema.extend({
-  agent_id: z17.string().optional(),
+  agent_id: z18.string().optional(),
   status: publicRunStatusSchema.optional(),
   since: timestampSchema.optional()
 });
-var publicRunsListContract = c12.router({
+var publicRunsListContract = c13.router({
   list: {
     method: "GET",
     path: "/v1/runs",
@@ -6488,12 +6686,12 @@ var publicRunsListContract = c12.router({
     description: "Create and execute a new agent run. Returns 202 Accepted as runs execute asynchronously."
   }
 });
-var publicRunByIdContract = c12.router({
+var publicRunByIdContract = c13.router({
   get: {
     method: "GET",
     path: "/v1/runs/:id",
-    pathParams: z17.object({
-      id: z17.string().min(1, "Run ID is required")
+    pathParams: z18.object({
+      id: z18.string().min(1, "Run ID is required")
     }),
     responses: {
       200: publicRunDetailSchema,
@@ -6505,14 +6703,14 @@ var publicRunByIdContract = c12.router({
     description: "Get run details by ID"
   }
 });
-var publicRunCancelContract = c12.router({
+var publicRunCancelContract = c13.router({
   cancel: {
     method: "POST",
     path: "/v1/runs/:id/cancel",
-    pathParams: z17.object({
-      id: z17.string().min(1, "Run ID is required")
+    pathParams: z18.object({
+      id: z18.string().min(1, "Run ID is required")
     }),
-    body: z17.undefined(),
+    body: z18.undefined(),
     responses: {
       200: publicRunDetailSchema,
       400: publicApiErrorSchema,
@@ -6525,26 +6723,26 @@ var publicRunCancelContract = c12.router({
     description: "Cancel a pending or running execution"
   }
 });
-var logEntrySchema = z17.object({
+var logEntrySchema = z18.object({
   timestamp: timestampSchema,
-  type: z17.enum(["agent", "system", "network"]),
-  level: z17.enum(["debug", "info", "warn", "error"]),
-  message: z17.string(),
-  metadata: z17.record(z17.string(), z17.unknown()).optional()
+  type: z18.enum(["agent", "system", "network"]),
+  level: z18.enum(["debug", "info", "warn", "error"]),
+  message: z18.string(),
+  metadata: z18.record(z18.string(), z18.unknown()).optional()
 });
 var paginatedLogsSchema = createPaginatedResponseSchema(logEntrySchema);
 var logsQuerySchema = listQuerySchema.extend({
-  type: z17.enum(["agent", "system", "network", "all"]).default("all"),
+  type: z18.enum(["agent", "system", "network", "all"]).default("all"),
   since: timestampSchema.optional(),
   until: timestampSchema.optional(),
-  order: z17.enum(["asc", "desc"]).default("asc")
+  order: z18.enum(["asc", "desc"]).default("asc")
 });
-var publicRunLogsContract = c12.router({
+var publicRunLogsContract = c13.router({
   getLogs: {
     method: "GET",
     path: "/v1/runs/:id/logs",
-    pathParams: z17.object({
-      id: z17.string().min(1, "Run ID is required")
+    pathParams: z18.object({
+      id: z18.string().min(1, "Run ID is required")
     }),
     query: logsQuerySchema,
     responses: {
@@ -6557,29 +6755,29 @@ var publicRunLogsContract = c12.router({
     description: "Get unified logs for a run. Combines agent, system, and network logs."
   }
 });
-var metricPointSchema = z17.object({
+var metricPointSchema = z18.object({
   timestamp: timestampSchema,
-  cpu_percent: z17.number(),
-  memory_used_mb: z17.number(),
-  memory_total_mb: z17.number(),
-  disk_used_mb: z17.number(),
-  disk_total_mb: z17.number()
-});
-var metricsSummarySchema = z17.object({
-  avg_cpu_percent: z17.number(),
-  max_memory_used_mb: z17.number(),
-  total_duration_ms: z17.number().nullable()
-});
-var metricsResponseSchema2 = z17.object({
-  data: z17.array(metricPointSchema),
+  cpu_percent: z18.number(),
+  memory_used_mb: z18.number(),
+  memory_total_mb: z18.number(),
+  disk_used_mb: z18.number(),
+  disk_total_mb: z18.number()
+});
+var metricsSummarySchema = z18.object({
+  avg_cpu_percent: z18.number(),
+  max_memory_used_mb: z18.number(),
+  total_duration_ms: z18.number().nullable()
+});
+var metricsResponseSchema2 = z18.object({
+  data: z18.array(metricPointSchema),
   summary: metricsSummarySchema
 });
-var publicRunMetricsContract = c12.router({
+var publicRunMetricsContract = c13.router({
   getMetrics: {
     method: "GET",
     path: "/v1/runs/:id/metrics",
-    pathParams: z17.object({
-      id: z17.string().min(1, "Run ID is required")
+    pathParams: z18.object({
+      id: z18.string().min(1, "Run ID is required")
     }),
     responses: {
       200: metricsResponseSchema2,
@@ -6591,7 +6789,7 @@ var publicRunMetricsContract = c12.router({
     description: "Get CPU, memory, and disk metrics for a run"
   }
 });
-var sseEventTypeSchema = z17.enum([
+var sseEventTypeSchema = z18.enum([
   "status",
   // Run status change
   "output",
@@ -6603,25 +6801,25 @@ var sseEventTypeSchema = z17.enum([
   "heartbeat"
   // Keep-alive
 ]);
-var sseEventSchema = z17.object({
+var sseEventSchema = z18.object({
   event: sseEventTypeSchema,
-  data: z17.unknown(),
-  id: z17.string().optional()
+  data: z18.unknown(),
+  id: z18.string().optional()
   // For Last-Event-ID reconnection
 });
-var publicRunEventsContract = c12.router({
+var publicRunEventsContract = c13.router({
   streamEvents: {
     method: "GET",
     path: "/v1/runs/:id/events",
-    pathParams: z17.object({
-      id: z17.string().min(1, "Run ID is required")
+    pathParams: z18.object({
+      id: z18.string().min(1, "Run ID is required")
     }),
-    query: z17.object({
-      last_event_id: z17.string().optional()
+    query: z18.object({
+      last_event_id: z18.string().optional()
       // For reconnection
     }),
     responses: {
-      200: z17.any(),
+      200: z18.any(),
       // SSE stream - actual content is text/event-stream
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -6633,28 +6831,28 @@ var publicRunEventsContract = c12.router({
 });
 
 // ../../packages/core/src/contracts/public/artifacts.ts
-import { z as z18 } from "zod";
-var c13 = initContract();
-var publicArtifactSchema = z18.object({
-  id: z18.string(),
-  name: z18.string(),
-  current_version_id: z18.string().nullable(),
-  size: z18.number(),
+import { z as z19 } from "zod";
+var c14 = initContract();
+var publicArtifactSchema = z19.object({
+  id: z19.string(),
+  name: z19.string(),
+  current_version_id: z19.string().nullable(),
+  size: z19.number(),
   // Total size in bytes
-  file_count: z18.number(),
+  file_count: z19.number(),
   created_at: timestampSchema,
   updated_at: timestampSchema
 });
-var artifactVersionSchema = z18.object({
-  id: z18.string(),
+var artifactVersionSchema = z19.object({
+  id: z19.string(),
   // SHA-256 content hash
-  artifact_id: z18.string(),
-  size: z18.number(),
+  artifact_id: z19.string(),
+  size: z19.number(),
   // Size in bytes
-  file_count: z18.number(),
-  message: z18.string().nullable(),
+  file_count: z19.number(),
+  message: z19.string().nullable(),
   // Optional commit message
-  created_by: z18.string(),
+  created_by: z19.string(),
   created_at: timestampSchema
 });
 var publicArtifactDetailSchema = publicArtifactSchema.extend({
@@ -6664,7 +6862,7 @@ var paginatedArtifactsSchema = createPaginatedResponseSchema(publicArtifactSchem
 var paginatedArtifactVersionsSchema = createPaginatedResponseSchema(
   artifactVersionSchema
 );
-var publicArtifactsListContract = c13.router({
+var publicArtifactsListContract = c14.router({
   list: {
     method: "GET",
     path: "/v1/artifacts",
@@ -6678,12 +6876,12 @@ var publicArtifactsListContract = c13.router({
     description: "List all artifacts in the current scope with pagination"
   }
 });
-var publicArtifactByIdContract = c13.router({
+var publicArtifactByIdContract = c14.router({
   get: {
     method: "GET",
     path: "/v1/artifacts/:id",
-    pathParams: z18.object({
-      id: z18.string().min(1, "Artifact ID is required")
+    pathParams: z19.object({
+      id: z19.string().min(1, "Artifact ID is required")
     }),
     responses: {
       200: publicArtifactDetailSchema,
@@ -6695,12 +6893,12 @@ var publicArtifactByIdContract = c13.router({
     description: "Get artifact details by ID"
   }
 });
-var publicArtifactVersionsContract = c13.router({
+var publicArtifactVersionsContract = c14.router({
   list: {
     method: "GET",
     path: "/v1/artifacts/:id/versions",
-    pathParams: z18.object({
-      id: z18.string().min(1, "Artifact ID is required")
+    pathParams: z19.object({
+      id: z19.string().min(1, "Artifact ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -6713,19 +6911,19 @@ var publicArtifactVersionsContract = c13.router({
     description: "List all versions of an artifact with pagination"
   }
 });
-var publicArtifactDownloadContract = c13.router({
+var publicArtifactDownloadContract = c14.router({
   download: {
     method: "GET",
     path: "/v1/artifacts/:id/download",
-    pathParams: z18.object({
-      id: z18.string().min(1, "Artifact ID is required")
+    pathParams: z19.object({
+      id: z19.string().min(1, "Artifact ID is required")
     }),
-    query: z18.object({
-      version_id: z18.string().optional()
+    query: z19.object({
+      version_id: z19.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z18.undefined(),
+      302: z19.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -6737,28 +6935,28 @@ var publicArtifactDownloadContract = c13.router({
 });
 
 // ../../packages/core/src/contracts/public/volumes.ts
-import { z as z19 } from "zod";
-var c14 = initContract();
-var publicVolumeSchema = z19.object({
-  id: z19.string(),
-  name: z19.string(),
-  current_version_id: z19.string().nullable(),
-  size: z19.number(),
+import { z as z20 } from "zod";
+var c15 = initContract();
+var publicVolumeSchema = z20.object({
+  id: z20.string(),
+  name: z20.string(),
+  current_version_id: z20.string().nullable(),
+  size: z20.number(),
   // Total size in bytes
-  file_count: z19.number(),
+  file_count: z20.number(),
   created_at: timestampSchema,
   updated_at: timestampSchema
 });
-var volumeVersionSchema = z19.object({
-  id: z19.string(),
+var volumeVersionSchema = z20.object({
+  id: z20.string(),
   // SHA-256 content hash
-  volume_id: z19.string(),
-  size: z19.number(),
+  volume_id: z20.string(),
+  size: z20.number(),
   // Size in bytes
-  file_count: z19.number(),
-  message: z19.string().nullable(),
+  file_count: z20.number(),
+  message: z20.string().nullable(),
   // Optional commit message
-  created_by: z19.string(),
+  created_by: z20.string(),
   created_at: timestampSchema
 });
 var publicVolumeDetailSchema = publicVolumeSchema.extend({
@@ -6766,7 +6964,7 @@ var publicVolumeDetailSchema = publicVolumeSchema.extend({
 });
 var paginatedVolumesSchema = createPaginatedResponseSchema(publicVolumeSchema);
 var paginatedVolumeVersionsSchema = createPaginatedResponseSchema(volumeVersionSchema);
-var publicVolumesListContract = c14.router({
+var publicVolumesListContract = c15.router({
   list: {
     method: "GET",
     path: "/v1/volumes",
@@ -6780,12 +6978,12 @@ var publicVolumesListContract = c14.router({
     description: "List all volumes in the current scope with pagination"
   }
 });
-var publicVolumeByIdContract = c14.router({
+var publicVolumeByIdContract = c15.router({
   get: {
     method: "GET",
     path: "/v1/volumes/:id",
-    pathParams: z19.object({
-      id: z19.string().min(1, "Volume ID is required")
+    pathParams: z20.object({
+      id: z20.string().min(1, "Volume ID is required")
     }),
     responses: {
       200: publicVolumeDetailSchema,
@@ -6797,12 +6995,12 @@ var publicVolumeByIdContract = c14.router({
     description: "Get volume details by ID"
   }
 });
-var publicVolumeVersionsContract = c14.router({
+var publicVolumeVersionsContract = c15.router({
   list: {
     method: "GET",
     path: "/v1/volumes/:id/versions",
-    pathParams: z19.object({
-      id: z19.string().min(1, "Volume ID is required")
+    pathParams: z20.object({
+      id: z20.string().min(1, "Volume ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -6815,19 +7013,19 @@ var publicVolumeVersionsContract = c14.router({
     description: "List all versions of a volume with pagination"
   }
 });
-var publicVolumeDownloadContract = c14.router({
+var publicVolumeDownloadContract = c15.router({
   download: {
     method: "GET",
     path: "/v1/volumes/:id/download",
-    pathParams: z19.object({
-      id: z19.string().min(1, "Volume ID is required")
+    pathParams: z20.object({
+      id: z20.string().min(1, "Volume ID is required")
     }),
-    query: z19.object({
-      version_id: z19.string().optional()
+    query: z20.object({
+      version_id: z20.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z19.undefined(),
+      302: z20.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -10898,7 +11096,7 @@ var benchmarkCommand = new Command3("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "2.7.0" : "0.1.0";
+var version = true ? "2.7.1" : "0.1.0";
 program.name("vm0-runner").version(version).description("Self-hosted runner for VM0 agents");
 program.addCommand(startCommand);
 program.addCommand(statusCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vm0/runner",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "Self-hosted runner for VM0 agents",
   "repository": {
     "type": "git",