@vm0/runner 2.13.3 → 2.13.5

package/index.js

@@ -5638,6 +5638,8 @@ var unifiedRunRequestSchema = z6.object({
   volumeVersions: z6.record(z6.string(), z6.string()).optional(),
   // Debug flag to force real Claude in mock environments (internal use only)
   debugNoMockClaude: z6.boolean().optional(),
+  // Model provider for automatic LLM credential injection
+  modelProvider: z6.string().optional(),
   // Required
   prompt: z6.string().min(1, "Missing prompt")
 });
@@ -6651,10 +6653,12 @@ var credentialNameSchema = z14.string().min(1, "Credential name is required").ma
   /^[A-Z][A-Z0-9_]*$/,
   "Credential name must contain only uppercase letters, numbers, and underscores, and must start with a letter (e.g., MY_API_KEY)"
 );
+var credentialTypeSchema = z14.enum(["user", "model-provider"]);
 var credentialResponseSchema = z14.object({
   id: z14.string().uuid(),
   name: z14.string(),
   description: z14.string().nullable(),
+  type: credentialTypeSchema,
   createdAt: z14.string(),
   updatedAt: z14.string()
 });
@@ -6738,43 +6742,171 @@ var credentialsByNameContract = c10.router({
   }
 });
 
-// ../../packages/core/src/contracts/sessions.ts
+// ../../packages/core/src/contracts/model-providers.ts
 import { z as z15 } from "zod";
 var c11 = initContract();
-var sessionResponseSchema = z15.object({
-  id: z15.string(),
-  agentComposeId: z15.string(),
-  agentComposeVersionId: z15.string().nullable(),
-  conversationId: z15.string().nullable(),
-  artifactName: z15.string().nullable(),
-  vars: z15.record(z15.string(), z15.string()).nullable(),
-  secretNames: z15.array(z15.string()).nullable(),
-  volumeVersions: z15.record(z15.string(), z15.string()).nullable(),
+var modelProviderTypeSchema = z15.enum([
+  "claude-code-oauth-token",
+  "anthropic-api-key",
+  "openai-api-key"
+]);
+var modelProviderFrameworkSchema = z15.enum(["claude-code", "codex"]);
+var modelProviderResponseSchema = z15.object({
+  id: z15.string().uuid(),
+  type: modelProviderTypeSchema,
+  framework: modelProviderFrameworkSchema,
+  credentialName: z15.string(),
+  isDefault: z15.boolean(),
   createdAt: z15.string(),
   updatedAt: z15.string()
 });
-var agentComposeSnapshotSchema = z15.object({
-  agentComposeVersionId: z15.string(),
-  vars: z15.record(z15.string(), z15.string()).optional(),
-  secretNames: z15.array(z15.string()).optional()
+var modelProviderListResponseSchema = z15.object({
+  modelProviders: z15.array(modelProviderResponseSchema)
+});
+var upsertModelProviderRequestSchema = z15.object({
+  type: modelProviderTypeSchema,
+  credential: z15.string().min(1, "Credential is required"),
+  convert: z15.boolean().optional()
 });
-var artifactSnapshotSchema2 = z15.object({
-  artifactName: z15.string(),
-  artifactVersion: z15.string()
+var upsertModelProviderResponseSchema = z15.object({
+  provider: modelProviderResponseSchema,
+  created: z15.boolean()
+});
+var checkCredentialResponseSchema = z15.object({
+  exists: z15.boolean(),
+  credentialName: z15.string(),
+  currentType: z15.enum(["user", "model-provider"]).optional()
+});
+var modelProvidersMainContract = c11.router({
+  list: {
+    method: "GET",
+    path: "/api/model-providers",
+    responses: {
+      200: modelProviderListResponseSchema,
+      401: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List all model providers"
+  },
+  upsert: {
+    method: "PUT",
+    path: "/api/model-providers",
+    body: upsertModelProviderRequestSchema,
+    responses: {
+      200: upsertModelProviderResponseSchema,
+      201: upsertModelProviderResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      409: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Create or update a model provider"
+  }
+});
+var modelProvidersCheckContract = c11.router({
+  check: {
+    method: "GET",
+    path: "/api/model-providers/check/:type",
+    pathParams: z15.object({
+      type: modelProviderTypeSchema
+    }),
+    responses: {
+      200: checkCredentialResponseSchema,
+      401: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Check if credential exists for a model provider type"
+  }
 });
-var volumeVersionsSnapshotSchema2 = z15.object({
-  versions: z15.record(z15.string(), z15.string())
+var modelProvidersByTypeContract = c11.router({
+  delete: {
+    method: "DELETE",
+    path: "/api/model-providers/:type",
+    pathParams: z15.object({
+      type: modelProviderTypeSchema
+    }),
+    responses: {
+      204: z15.undefined(),
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Delete a model provider"
+  }
 });
-var checkpointResponseSchema = z15.object({
-  id: z15.string(),
-  runId: z15.string(),
-  conversationId: z15.string(),
+var modelProvidersConvertContract = c11.router({
+  convert: {
+    method: "POST",
+    path: "/api/model-providers/:type/convert",
+    pathParams: z15.object({
+      type: modelProviderTypeSchema
+    }),
+    body: z15.undefined(),
+    responses: {
+      200: modelProviderResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Convert existing user credential to model provider"
+  }
+});
+var modelProvidersSetDefaultContract = c11.router({
+  setDefault: {
+    method: "POST",
+    path: "/api/model-providers/:type/set-default",
+    pathParams: z15.object({
+      type: modelProviderTypeSchema
+    }),
+    body: z15.undefined(),
+    responses: {
+      200: modelProviderResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Set a model provider as default for its framework"
+  }
+});
+
+// ../../packages/core/src/contracts/sessions.ts
+import { z as z16 } from "zod";
+var c12 = initContract();
+var sessionResponseSchema = z16.object({
+  id: z16.string(),
+  agentComposeId: z16.string(),
+  agentComposeVersionId: z16.string().nullable(),
+  conversationId: z16.string().nullable(),
+  artifactName: z16.string().nullable(),
+  vars: z16.record(z16.string(), z16.string()).nullable(),
+  secretNames: z16.array(z16.string()).nullable(),
+  volumeVersions: z16.record(z16.string(), z16.string()).nullable(),
+  createdAt: z16.string(),
+  updatedAt: z16.string()
+});
+var agentComposeSnapshotSchema = z16.object({
+  agentComposeVersionId: z16.string(),
+  vars: z16.record(z16.string(), z16.string()).optional(),
+  secretNames: z16.array(z16.string()).optional()
+});
+var artifactSnapshotSchema2 = z16.object({
+  artifactName: z16.string(),
+  artifactVersion: z16.string()
+});
+var volumeVersionsSnapshotSchema2 = z16.object({
+  versions: z16.record(z16.string(), z16.string())
+});
+var checkpointResponseSchema = z16.object({
+  id: z16.string(),
+  runId: z16.string(),
+  conversationId: z16.string(),
   agentComposeSnapshot: agentComposeSnapshotSchema,
   artifactSnapshot: artifactSnapshotSchema2.nullable(),
   volumeVersionsSnapshot: volumeVersionsSnapshotSchema2.nullable(),
-  createdAt: z15.string()
+  createdAt: z16.string()
 });
-var sessionsByIdContract = c11.router({
+var sessionsByIdContract = c12.router({
   /**
    * GET /api/agent/sessions/:id
    * Get session by ID
@@ -6782,8 +6914,8 @@ var sessionsByIdContract = c11.router({
   getById: {
     method: "GET",
     path: "/api/agent/sessions/:id",
-    pathParams: z15.object({
-      id: z15.string().min(1, "Session ID is required")
+    pathParams: z16.object({
+      id: z16.string().min(1, "Session ID is required")
     }),
     responses: {
       200: sessionResponseSchema,
@@ -6794,7 +6926,7 @@ var sessionsByIdContract = c11.router({
     summary: "Get session by ID"
   }
 });
-var checkpointsByIdContract = c11.router({
+var checkpointsByIdContract = c12.router({
   /**
    * GET /api/agent/checkpoints/:id
    * Get checkpoint by ID
@@ -6802,8 +6934,8 @@ var checkpointsByIdContract = c11.router({
   getById: {
     method: "GET",
     path: "/api/agent/checkpoints/:id",
-    pathParams: z15.object({
-      id: z15.string().min(1, "Checkpoint ID is required")
+    pathParams: z16.object({
+      id: z16.string().min(1, "Checkpoint ID is required")
     }),
     responses: {
       200: checkpointResponseSchema,
@@ -6816,91 +6948,91 @@ var checkpointsByIdContract = c11.router({
 });
 
 // ../../packages/core/src/contracts/schedules.ts
-import { z as z16 } from "zod";
-var c12 = initContract();
-var scheduleTriggerSchema = z16.object({
-  cron: z16.string().optional(),
-  at: z16.string().optional(),
-  timezone: z16.string().default("UTC")
+import { z as z17 } from "zod";
+var c13 = initContract();
+var scheduleTriggerSchema = z17.object({
+  cron: z17.string().optional(),
+  at: z17.string().optional(),
+  timezone: z17.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 = z16.object({
-  agent: z16.string().min(1, "Agent reference required"),
-  prompt: z16.string().min(1, "Prompt required"),
-  vars: z16.record(z16.string(), z16.string()).optional(),
-  secrets: z16.record(z16.string(), z16.string()).optional(),
-  artifactName: z16.string().optional(),
-  artifactVersion: z16.string().optional(),
-  volumeVersions: z16.record(z16.string(), z16.string()).optional()
+var scheduleRunConfigSchema = z17.object({
+  agent: z17.string().min(1, "Agent reference required"),
+  prompt: z17.string().min(1, "Prompt required"),
+  vars: z17.record(z17.string(), z17.string()).optional(),
+  secrets: z17.record(z17.string(), z17.string()).optional(),
+  artifactName: z17.string().optional(),
+  artifactVersion: z17.string().optional(),
+  volumeVersions: z17.record(z17.string(), z17.string()).optional()
 });
-var scheduleDefinitionSchema = z16.object({
+var scheduleDefinitionSchema = z17.object({
   on: scheduleTriggerSchema,
   run: scheduleRunConfigSchema
 });
-var scheduleYamlSchema = z16.object({
-  version: z16.literal("1.0"),
-  schedules: z16.record(z16.string(), scheduleDefinitionSchema)
-});
-var deployScheduleRequestSchema = z16.object({
-  name: z16.string().min(1).max(64, "Schedule name max 64 chars"),
-  cronExpression: z16.string().optional(),
-  atTime: z16.string().optional(),
-  timezone: z16.string().default("UTC"),
-  prompt: z16.string().min(1, "Prompt required"),
-  vars: z16.record(z16.string(), z16.string()).optional(),
-  secrets: z16.record(z16.string(), z16.string()).optional(),
-  artifactName: z16.string().optional(),
-  artifactVersion: z16.string().optional(),
-  volumeVersions: z16.record(z16.string(), z16.string()).optional(),
+var scheduleYamlSchema = z17.object({
+  version: z17.literal("1.0"),
+  schedules: z17.record(z17.string(), scheduleDefinitionSchema)
+});
+var deployScheduleRequestSchema = z17.object({
+  name: z17.string().min(1).max(64, "Schedule name max 64 chars"),
+  cronExpression: z17.string().optional(),
+  atTime: z17.string().optional(),
+  timezone: z17.string().default("UTC"),
+  prompt: z17.string().min(1, "Prompt required"),
+  vars: z17.record(z17.string(), z17.string()).optional(),
+  secrets: z17.record(z17.string(), z17.string()).optional(),
+  artifactName: z17.string().optional(),
+  artifactVersion: z17.string().optional(),
+  volumeVersions: z17.record(z17.string(), z17.string()).optional(),
   // Resolved agent compose ID (CLI resolves scope/name:version → composeId)
-  composeId: z16.string().uuid("Invalid compose ID")
+  composeId: z17.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 = z16.object({
-  id: z16.string().uuid(),
-  composeId: z16.string().uuid(),
-  composeName: z16.string(),
-  scopeSlug: z16.string(),
-  name: z16.string(),
-  cronExpression: z16.string().nullable(),
-  atTime: z16.string().nullable(),
-  timezone: z16.string(),
-  prompt: z16.string(),
-  vars: z16.record(z16.string(), z16.string()).nullable(),
+var scheduleResponseSchema = z17.object({
+  id: z17.string().uuid(),
+  composeId: z17.string().uuid(),
+  composeName: z17.string(),
+  scopeSlug: z17.string(),
+  name: z17.string(),
+  cronExpression: z17.string().nullable(),
+  atTime: z17.string().nullable(),
+  timezone: z17.string(),
+  prompt: z17.string(),
+  vars: z17.record(z17.string(), z17.string()).nullable(),
   // Secret names only (values are never returned)
-  secretNames: z16.array(z16.string()).nullable(),
-  artifactName: z16.string().nullable(),
-  artifactVersion: z16.string().nullable(),
-  volumeVersions: z16.record(z16.string(), z16.string()).nullable(),
-  enabled: z16.boolean(),
-  nextRunAt: z16.string().nullable(),
-  createdAt: z16.string(),
-  updatedAt: z16.string()
-});
-var runSummarySchema = z16.object({
-  id: z16.string().uuid(),
-  status: z16.enum(["pending", "running", "completed", "failed", "timeout"]),
-  createdAt: z16.string(),
-  completedAt: z16.string().nullable(),
-  error: z16.string().nullable()
-});
-var scheduleRunsResponseSchema = z16.object({
-  runs: z16.array(runSummarySchema)
-});
-var scheduleListResponseSchema = z16.object({
-  schedules: z16.array(scheduleResponseSchema)
-});
-var deployScheduleResponseSchema = z16.object({
+  secretNames: z17.array(z17.string()).nullable(),
+  artifactName: z17.string().nullable(),
+  artifactVersion: z17.string().nullable(),
+  volumeVersions: z17.record(z17.string(), z17.string()).nullable(),
+  enabled: z17.boolean(),
+  nextRunAt: z17.string().nullable(),
+  createdAt: z17.string(),
+  updatedAt: z17.string()
+});
+var runSummarySchema = z17.object({
+  id: z17.string().uuid(),
+  status: z17.enum(["pending", "running", "completed", "failed", "timeout"]),
+  createdAt: z17.string(),
+  completedAt: z17.string().nullable(),
+  error: z17.string().nullable()
+});
+var scheduleRunsResponseSchema = z17.object({
+  runs: z17.array(runSummarySchema)
+});
+var scheduleListResponseSchema = z17.object({
+  schedules: z17.array(scheduleResponseSchema)
+});
+var deployScheduleResponseSchema = z17.object({
   schedule: scheduleResponseSchema,
-  created: z16.boolean()
+  created: z17.boolean()
   // true if created, false if updated
 });
-var schedulesMainContract = c12.router({
+var schedulesMainContract = c13.router({
   /**
    * POST /api/agent/schedules
    * Deploy (create or update) a schedule
@@ -6936,7 +7068,7 @@ var schedulesMainContract = c12.router({
     summary: "List all schedules"
   }
 });
-var schedulesByNameContract = c12.router({
+var schedulesByNameContract = c13.router({
   /**
    * GET /api/agent/schedules/:name
    * Get schedule by name
@@ -6944,11 +7076,11 @@ var schedulesByNameContract = c12.router({
   getByName: {
     method: "GET",
     path: "/api/agent/schedules/:name",
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    query: z16.object({
-      composeId: z16.string().uuid("Compose ID required")
+    query: z17.object({
+      composeId: z17.string().uuid("Compose ID required")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -6964,21 +7096,21 @@ var schedulesByNameContract = c12.router({
   delete: {
     method: "DELETE",
     path: "/api/agent/schedules/:name",
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    query: z16.object({
-      composeId: z16.string().uuid("Compose ID required")
+    query: z17.object({
+      composeId: z17.string().uuid("Compose ID required")
     }),
     responses: {
-      204: z16.undefined(),
+      204: z17.undefined(),
       401: apiErrorSchema,
       404: apiErrorSchema
     },
     summary: "Delete schedule"
   }
 });
-var schedulesEnableContract = c12.router({
+var schedulesEnableContract = c13.router({
   /**
    * POST /api/agent/schedules/:name/enable
    * Enable a disabled schedule
@@ -6986,11 +7118,11 @@ var schedulesEnableContract = c12.router({
   enable: {
     method: "POST",
     path: "/api/agent/schedules/:name/enable",
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    body: z16.object({
-      composeId: z16.string().uuid("Compose ID required")
+    body: z17.object({
+      composeId: z17.string().uuid("Compose ID required")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -7006,11 +7138,11 @@ var schedulesEnableContract = c12.router({
   disable: {
     method: "POST",
     path: "/api/agent/schedules/:name/disable",
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    body: z16.object({
-      composeId: z16.string().uuid("Compose ID required")
+    body: z17.object({
+      composeId: z17.string().uuid("Compose ID required")
     }),
     responses: {
       200: scheduleResponseSchema,
@@ -7020,7 +7152,7 @@ var schedulesEnableContract = c12.router({
     summary: "Disable schedule"
   }
 });
-var scheduleRunsContract = c12.router({
+var scheduleRunsContract = c13.router({
   /**
    * GET /api/agent/schedules/:name/runs
    * List recent runs for a schedule
@@ -7028,12 +7160,12 @@ var scheduleRunsContract = c12.router({
   listRuns: {
     method: "GET",
     path: "/api/agent/schedules/:name/runs",
-    pathParams: z16.object({
-      name: z16.string().min(1, "Schedule name required")
+    pathParams: z17.object({
+      name: z17.string().min(1, "Schedule name required")
     }),
-    query: z16.object({
-      composeId: z16.string().uuid("Compose ID required"),
-      limit: z16.coerce.number().min(0).max(100).default(5)
+    query: z17.object({
+      composeId: z17.string().uuid("Compose ID required"),
+      limit: z17.coerce.number().min(0).max(100).default(5)
     }),
     responses: {
       200: scheduleRunsResponseSchema,
@@ -7045,18 +7177,18 @@ var scheduleRunsContract = c12.router({
 });
 
 // ../../packages/core/src/contracts/realtime.ts
-import { z as z17 } from "zod";
-var c13 = initContract();
-var ablyTokenRequestSchema = z17.object({
-  keyName: z17.string(),
-  ttl: z17.number().optional(),
-  timestamp: z17.number(),
-  capability: z17.string(),
-  clientId: z17.string().optional(),
-  nonce: z17.string(),
-  mac: z17.string()
-});
-var realtimeTokenContract = c13.router({
+import { z as z18 } from "zod";
+var c14 = initContract();
+var ablyTokenRequestSchema = z18.object({
+  keyName: z18.string(),
+  ttl: z18.number().optional(),
+  timestamp: z18.number(),
+  capability: z18.string(),
+  clientId: z18.string().optional(),
+  nonce: z18.string(),
+  mac: z18.string()
+});
+var realtimeTokenContract = c14.router({
   /**
    * POST /api/realtime/token
    * Get an Ably token to subscribe to a run's events channel
@@ -7064,8 +7196,8 @@ var realtimeTokenContract = c13.router({
   create: {
     method: "POST",
     path: "/api/realtime/token",
-    body: z17.object({
-      runId: z17.string().uuid("runId must be a valid UUID")
+    body: z18.object({
+      runId: z18.string().uuid("runId must be a valid UUID")
     }),
     responses: {
       200: ablyTokenRequestSchema,
@@ -7079,8 +7211,8 @@ var realtimeTokenContract = c13.router({
 });
 
 // ../../packages/core/src/contracts/public/common.ts
-import { z as z18 } from "zod";
-var publicApiErrorTypeSchema = z18.enum([
+import { z as z19 } from "zod";
+var publicApiErrorTypeSchema = z19.enum([
   "api_error",
   // Internal server error (5xx)
   "invalid_request_error",
@@ -7092,55 +7224,55 @@ var publicApiErrorTypeSchema = z18.enum([
   "conflict_error"
   // Resource conflict (409)
 ]);
-var publicApiErrorSchema = z18.object({
-  error: z18.object({
+var publicApiErrorSchema = z19.object({
+  error: z19.object({
     type: publicApiErrorTypeSchema,
-    code: z18.string(),
-    message: z18.string(),
-    param: z18.string().optional(),
-    doc_url: z18.string().url().optional()
+    code: z19.string(),
+    message: z19.string(),
+    param: z19.string().optional(),
+    doc_url: z19.string().url().optional()
   })
 });
-var paginationSchema = z18.object({
-  has_more: z18.boolean(),
-  next_cursor: z18.string().nullable()
+var paginationSchema = z19.object({
+  has_more: z19.boolean(),
+  next_cursor: z19.string().nullable()
 });
 function createPaginatedResponseSchema(dataSchema) {
-  return z18.object({
-    data: z18.array(dataSchema),
+  return z19.object({
+    data: z19.array(dataSchema),
     pagination: paginationSchema
   });
 }
-var listQuerySchema = z18.object({
-  cursor: z18.string().optional(),
-  limit: z18.coerce.number().min(1).max(100).default(20)
+var listQuerySchema = z19.object({
+  cursor: z19.string().optional(),
+  limit: z19.coerce.number().min(1).max(100).default(20)
 });
-var requestIdSchema = z18.string().uuid();
-var timestampSchema = z18.string().datetime();
+var requestIdSchema = z19.string().uuid();
+var timestampSchema = z19.string().datetime();
 
 // ../../packages/core/src/contracts/public/agents.ts
-import { z as z19 } from "zod";
-var c14 = initContract();
-var publicAgentSchema = z19.object({
-  id: z19.string(),
-  name: z19.string(),
-  current_version_id: z19.string().nullable(),
+import { z as z20 } from "zod";
+var c15 = initContract();
+var publicAgentSchema = z20.object({
+  id: z20.string(),
+  name: z20.string(),
+  current_version_id: z20.string().nullable(),
   created_at: timestampSchema,
   updated_at: timestampSchema
 });
-var agentVersionSchema = z19.object({
-  id: z19.string(),
-  agent_id: z19.string(),
-  version_number: z19.number(),
+var agentVersionSchema = z20.object({
+  id: z20.string(),
+  agent_id: z20.string(),
+  version_number: z20.number(),
   created_at: timestampSchema
 });
 var publicAgentDetailSchema = publicAgentSchema;
 var paginatedAgentsSchema = createPaginatedResponseSchema(publicAgentSchema);
 var paginatedAgentVersionsSchema = createPaginatedResponseSchema(agentVersionSchema);
 var agentListQuerySchema = listQuerySchema.extend({
-  name: z19.string().optional()
+  name: z20.string().optional()
 });
-var publicAgentsListContract = c14.router({
+var publicAgentsListContract = c15.router({
   list: {
     method: "GET",
     path: "/v1/agents",
@@ -7154,12 +7286,12 @@ var publicAgentsListContract = c14.router({
     description: "List all agents in the current scope with pagination. Use the `name` query parameter to filter by agent name."
   }
 });
-var publicAgentByIdContract = c14.router({
+var publicAgentByIdContract = c15.router({
   get: {
     method: "GET",
     path: "/v1/agents/:id",
-    pathParams: z19.object({
-      id: z19.string().min(1, "Agent ID is required")
+    pathParams: z20.object({
+      id: z20.string().min(1, "Agent ID is required")
     }),
     responses: {
       200: publicAgentDetailSchema,
@@ -7171,12 +7303,12 @@ var publicAgentByIdContract = c14.router({
     description: "Get agent details by ID"
   }
 });
-var publicAgentVersionsContract = c14.router({
+var publicAgentVersionsContract = c15.router({
   list: {
     method: "GET",
     path: "/v1/agents/:id/versions",
-    pathParams: z19.object({
-      id: z19.string().min(1, "Agent ID is required")
+    pathParams: z20.object({
+      id: z20.string().min(1, "Agent ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -7191,9 +7323,9 @@ var publicAgentVersionsContract = c14.router({
 });
 
 // ../../packages/core/src/contracts/public/runs.ts
-import { z as z20 } from "zod";
-var c15 = initContract();
-var publicRunStatusSchema = z20.enum([
+import { z as z21 } from "zod";
+var c16 = initContract();
+var publicRunStatusSchema = z21.enum([
   "pending",
   "running",
   "completed",
@@ -7201,56 +7333,56 @@ var publicRunStatusSchema = z20.enum([
   "timeout",
   "cancelled"
 ]);
-var publicRunSchema = z20.object({
-  id: z20.string(),
-  agent_id: z20.string(),
-  agent_name: z20.string(),
+var publicRunSchema = z21.object({
+  id: z21.string(),
+  agent_id: z21.string(),
+  agent_name: z21.string(),
   status: publicRunStatusSchema,
-  prompt: z20.string(),
+  prompt: z21.string(),
   created_at: timestampSchema,
   started_at: timestampSchema.nullable(),
   completed_at: timestampSchema.nullable()
 });
 var publicRunDetailSchema = publicRunSchema.extend({
-  error: z20.string().nullable(),
-  execution_time_ms: z20.number().nullable(),
-  checkpoint_id: z20.string().nullable(),
-  session_id: z20.string().nullable(),
-  artifact_name: z20.string().nullable(),
-  artifact_version: z20.string().nullable(),
-  volumes: z20.record(z20.string(), z20.string()).optional()
+  error: z21.string().nullable(),
+  execution_time_ms: z21.number().nullable(),
+  checkpoint_id: z21.string().nullable(),
+  session_id: z21.string().nullable(),
+  artifact_name: z21.string().nullable(),
+  artifact_version: z21.string().nullable(),
+  volumes: z21.record(z21.string(), z21.string()).optional()
 });
 var paginatedRunsSchema = createPaginatedResponseSchema(publicRunSchema);
-var createRunRequestSchema = z20.object({
+var createRunRequestSchema = z21.object({
   // Agent identification (one of: agent, agent_id, session_id, checkpoint_id)
-  agent: z20.string().optional(),
+  agent: z21.string().optional(),
   // Agent name
-  agent_id: z20.string().optional(),
+  agent_id: z21.string().optional(),
   // Agent ID
-  agent_version: z20.string().optional(),
+  agent_version: z21.string().optional(),
   // Version specifier (e.g., "latest", "v1", specific ID)
   // Continue session
-  session_id: z20.string().optional(),
+  session_id: z21.string().optional(),
   // Resume from checkpoint
-  checkpoint_id: z20.string().optional(),
+  checkpoint_id: z21.string().optional(),
   // Required
-  prompt: z20.string().min(1, "Prompt is required"),
+  prompt: z21.string().min(1, "Prompt is required"),
   // Optional configuration
-  variables: z20.record(z20.string(), z20.string()).optional(),
-  secrets: z20.record(z20.string(), z20.string()).optional(),
-  artifact_name: z20.string().optional(),
+  variables: z21.record(z21.string(), z21.string()).optional(),
+  secrets: z21.record(z21.string(), z21.string()).optional(),
+  artifact_name: z21.string().optional(),
   // Artifact name to mount
-  artifact_version: z20.string().optional(),
+  artifact_version: z21.string().optional(),
   // Artifact version (defaults to latest)
-  volumes: z20.record(z20.string(), z20.string()).optional()
+  volumes: z21.record(z21.string(), z21.string()).optional()
   // volume_name -> version
 });
 var runListQuerySchema = listQuerySchema.extend({
-  agent_id: z20.string().optional(),
+  agent_id: z21.string().optional(),
   status: publicRunStatusSchema.optional(),
   since: timestampSchema.optional()
 });
-var publicRunsListContract = c15.router({
+var publicRunsListContract = c16.router({
   list: {
     method: "GET",
     path: "/v1/runs",
@@ -7279,12 +7411,12 @@ var publicRunsListContract = c15.router({
     description: "Create and execute a new agent run. Returns 202 Accepted as runs execute asynchronously."
   }
 });
-var publicRunByIdContract = c15.router({
+var publicRunByIdContract = c16.router({
   get: {
     method: "GET",
     path: "/v1/runs/:id",
-    pathParams: z20.object({
-      id: z20.string().min(1, "Run ID is required")
+    pathParams: z21.object({
+      id: z21.string().min(1, "Run ID is required")
     }),
     responses: {
       200: publicRunDetailSchema,
@@ -7296,14 +7428,14 @@ var publicRunByIdContract = c15.router({
     description: "Get run details by ID"
   }
 });
-var publicRunCancelContract = c15.router({
+var publicRunCancelContract = c16.router({
   cancel: {
     method: "POST",
     path: "/v1/runs/:id/cancel",
-    pathParams: z20.object({
-      id: z20.string().min(1, "Run ID is required")
+    pathParams: z21.object({
+      id: z21.string().min(1, "Run ID is required")
     }),
-    body: z20.undefined(),
+    body: z21.undefined(),
     responses: {
       200: publicRunDetailSchema,
       400: publicApiErrorSchema,
@@ -7316,26 +7448,26 @@ var publicRunCancelContract = c15.router({
     description: "Cancel a pending or running execution"
   }
 });
-var logEntrySchema = z20.object({
+var logEntrySchema = z21.object({
   timestamp: timestampSchema,
-  type: z20.enum(["agent", "system", "network"]),
-  level: z20.enum(["debug", "info", "warn", "error"]),
-  message: z20.string(),
-  metadata: z20.record(z20.string(), z20.unknown()).optional()
+  type: z21.enum(["agent", "system", "network"]),
+  level: z21.enum(["debug", "info", "warn", "error"]),
+  message: z21.string(),
+  metadata: z21.record(z21.string(), z21.unknown()).optional()
 });
 var paginatedLogsSchema = createPaginatedResponseSchema(logEntrySchema);
 var logsQuerySchema = listQuerySchema.extend({
-  type: z20.enum(["agent", "system", "network", "all"]).default("all"),
+  type: z21.enum(["agent", "system", "network", "all"]).default("all"),
   since: timestampSchema.optional(),
   until: timestampSchema.optional(),
-  order: z20.enum(["asc", "desc"]).default("asc")
+  order: z21.enum(["asc", "desc"]).default("asc")
 });
-var publicRunLogsContract = c15.router({
+var publicRunLogsContract = c16.router({
   getLogs: {
     method: "GET",
     path: "/v1/runs/:id/logs",
-    pathParams: z20.object({
-      id: z20.string().min(1, "Run ID is required")
+    pathParams: z21.object({
+      id: z21.string().min(1, "Run ID is required")
     }),
     query: logsQuerySchema,
     responses: {
@@ -7348,29 +7480,29 @@ var publicRunLogsContract = c15.router({
     description: "Get unified logs for a run. Combines agent, system, and network logs."
   }
 });
-var metricPointSchema = z20.object({
+var metricPointSchema = z21.object({
   timestamp: timestampSchema,
-  cpu_percent: z20.number(),
-  memory_used_mb: z20.number(),
-  memory_total_mb: z20.number(),
-  disk_used_mb: z20.number(),
-  disk_total_mb: z20.number()
-});
-var metricsSummarySchema = z20.object({
-  avg_cpu_percent: z20.number(),
-  max_memory_used_mb: z20.number(),
-  total_duration_ms: z20.number().nullable()
-});
-var metricsResponseSchema2 = z20.object({
-  data: z20.array(metricPointSchema),
+  cpu_percent: z21.number(),
+  memory_used_mb: z21.number(),
+  memory_total_mb: z21.number(),
+  disk_used_mb: z21.number(),
+  disk_total_mb: z21.number()
+});
+var metricsSummarySchema = z21.object({
+  avg_cpu_percent: z21.number(),
+  max_memory_used_mb: z21.number(),
+  total_duration_ms: z21.number().nullable()
+});
+var metricsResponseSchema2 = z21.object({
+  data: z21.array(metricPointSchema),
   summary: metricsSummarySchema
 });
-var publicRunMetricsContract = c15.router({
+var publicRunMetricsContract = c16.router({
   getMetrics: {
     method: "GET",
     path: "/v1/runs/:id/metrics",
-    pathParams: z20.object({
-      id: z20.string().min(1, "Run ID is required")
+    pathParams: z21.object({
+      id: z21.string().min(1, "Run ID is required")
     }),
     responses: {
       200: metricsResponseSchema2,
@@ -7382,7 +7514,7 @@ var publicRunMetricsContract = c15.router({
     description: "Get CPU, memory, and disk metrics for a run"
   }
 });
-var sseEventTypeSchema = z20.enum([
+var sseEventTypeSchema = z21.enum([
   "status",
   // Run status change
   "output",
@@ -7394,25 +7526,25 @@ var sseEventTypeSchema = z20.enum([
   "heartbeat"
   // Keep-alive
 ]);
-var sseEventSchema = z20.object({
+var sseEventSchema = z21.object({
   event: sseEventTypeSchema,
-  data: z20.unknown(),
-  id: z20.string().optional()
+  data: z21.unknown(),
+  id: z21.string().optional()
   // For Last-Event-ID reconnection
 });
-var publicRunEventsContract = c15.router({
+var publicRunEventsContract = c16.router({
   streamEvents: {
     method: "GET",
     path: "/v1/runs/:id/events",
-    pathParams: z20.object({
-      id: z20.string().min(1, "Run ID is required")
+    pathParams: z21.object({
+      id: z21.string().min(1, "Run ID is required")
     }),
-    query: z20.object({
-      last_event_id: z20.string().optional()
+    query: z21.object({
+      last_event_id: z21.string().optional()
       // For reconnection
     }),
     responses: {
-      200: z20.any(),
+      200: z21.any(),
       // SSE stream - actual content is text/event-stream
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -7424,28 +7556,28 @@ var publicRunEventsContract = c15.router({
 });
 
 // ../../packages/core/src/contracts/public/artifacts.ts
-import { z as z21 } from "zod";
-var c16 = initContract();
-var publicArtifactSchema = z21.object({
-  id: z21.string(),
-  name: z21.string(),
-  current_version_id: z21.string().nullable(),
-  size: z21.number(),
+import { z as z22 } from "zod";
+var c17 = initContract();
+var publicArtifactSchema = z22.object({
+  id: z22.string(),
+  name: z22.string(),
+  current_version_id: z22.string().nullable(),
+  size: z22.number(),
   // Total size in bytes
-  file_count: z21.number(),
+  file_count: z22.number(),
   created_at: timestampSchema,
   updated_at: timestampSchema
 });
-var artifactVersionSchema = z21.object({
-  id: z21.string(),
+var artifactVersionSchema = z22.object({
+  id: z22.string(),
   // SHA-256 content hash
-  artifact_id: z21.string(),
-  size: z21.number(),
+  artifact_id: z22.string(),
+  size: z22.number(),
   // Size in bytes
-  file_count: z21.number(),
-  message: z21.string().nullable(),
+  file_count: z22.number(),
+  message: z22.string().nullable(),
   // Optional commit message
-  created_by: z21.string(),
+  created_by: z22.string(),
   created_at: timestampSchema
 });
 var publicArtifactDetailSchema = publicArtifactSchema.extend({
@@ -7455,7 +7587,7 @@ var paginatedArtifactsSchema = createPaginatedResponseSchema(publicArtifactSchem
 var paginatedArtifactVersionsSchema = createPaginatedResponseSchema(
   artifactVersionSchema
 );
-var publicArtifactsListContract = c16.router({
+var publicArtifactsListContract = c17.router({
   list: {
     method: "GET",
     path: "/v1/artifacts",
@@ -7469,12 +7601,12 @@ var publicArtifactsListContract = c16.router({
     description: "List all artifacts in the current scope with pagination"
   }
 });
-var publicArtifactByIdContract = c16.router({
+var publicArtifactByIdContract = c17.router({
   get: {
     method: "GET",
     path: "/v1/artifacts/:id",
-    pathParams: z21.object({
-      id: z21.string().min(1, "Artifact ID is required")
+    pathParams: z22.object({
+      id: z22.string().min(1, "Artifact ID is required")
     }),
     responses: {
       200: publicArtifactDetailSchema,
@@ -7486,12 +7618,12 @@ var publicArtifactByIdContract = c16.router({
     description: "Get artifact details by ID"
   }
 });
-var publicArtifactVersionsContract = c16.router({
+var publicArtifactVersionsContract = c17.router({
   list: {
     method: "GET",
     path: "/v1/artifacts/:id/versions",
-    pathParams: z21.object({
-      id: z21.string().min(1, "Artifact ID is required")
+    pathParams: z22.object({
+      id: z22.string().min(1, "Artifact ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -7504,19 +7636,19 @@ var publicArtifactVersionsContract = c16.router({
     description: "List all versions of an artifact with pagination"
   }
 });
-var publicArtifactDownloadContract = c16.router({
+var publicArtifactDownloadContract = c17.router({
   download: {
     method: "GET",
     path: "/v1/artifacts/:id/download",
-    pathParams: z21.object({
-      id: z21.string().min(1, "Artifact ID is required")
+    pathParams: z22.object({
+      id: z22.string().min(1, "Artifact ID is required")
     }),
-    query: z21.object({
-      version_id: z21.string().optional()
+    query: z22.object({
+      version_id: z22.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z21.undefined(),
+      302: z22.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -7528,28 +7660,28 @@ var publicArtifactDownloadContract = c16.router({
 });
 
 // ../../packages/core/src/contracts/public/volumes.ts
-import { z as z22 } from "zod";
-var c17 = initContract();
-var publicVolumeSchema = z22.object({
-  id: z22.string(),
-  name: z22.string(),
-  current_version_id: z22.string().nullable(),
-  size: z22.number(),
+import { z as z23 } from "zod";
+var c18 = initContract();
+var publicVolumeSchema = z23.object({
+  id: z23.string(),
+  name: z23.string(),
+  current_version_id: z23.string().nullable(),
+  size: z23.number(),
   // Total size in bytes
-  file_count: z22.number(),
+  file_count: z23.number(),
   created_at: timestampSchema,
   updated_at: timestampSchema
 });
-var volumeVersionSchema = z22.object({
-  id: z22.string(),
+var volumeVersionSchema = z23.object({
+  id: z23.string(),
   // SHA-256 content hash
-  volume_id: z22.string(),
-  size: z22.number(),
+  volume_id: z23.string(),
+  size: z23.number(),
   // Size in bytes
-  file_count: z22.number(),
-  message: z22.string().nullable(),
+  file_count: z23.number(),
+  message: z23.string().nullable(),
   // Optional commit message
-  created_by: z22.string(),
+  created_by: z23.string(),
   created_at: timestampSchema
 });
 var publicVolumeDetailSchema = publicVolumeSchema.extend({
@@ -7557,7 +7689,7 @@ var publicVolumeDetailSchema = publicVolumeSchema.extend({
 });
 var paginatedVolumesSchema = createPaginatedResponseSchema(publicVolumeSchema);
 var paginatedVolumeVersionsSchema = createPaginatedResponseSchema(volumeVersionSchema);
-var publicVolumesListContract = c17.router({
+var publicVolumesListContract = c18.router({
   list: {
     method: "GET",
     path: "/v1/volumes",
@@ -7571,12 +7703,12 @@ var publicVolumesListContract = c17.router({
     description: "List all volumes in the current scope with pagination"
   }
 });
-var publicVolumeByIdContract = c17.router({
+var publicVolumeByIdContract = c18.router({
   get: {
     method: "GET",
     path: "/v1/volumes/:id",
-    pathParams: z22.object({
-      id: z22.string().min(1, "Volume ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Volume ID is required")
     }),
     responses: {
       200: publicVolumeDetailSchema,
@@ -7588,12 +7720,12 @@ var publicVolumeByIdContract = c17.router({
     description: "Get volume details by ID"
   }
 });
-var publicVolumeVersionsContract = c17.router({
+var publicVolumeVersionsContract = c18.router({
   list: {
     method: "GET",
     path: "/v1/volumes/:id/versions",
-    pathParams: z22.object({
-      id: z22.string().min(1, "Volume ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Volume ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -7606,19 +7738,19 @@ var publicVolumeVersionsContract = c17.router({
     description: "List all versions of a volume with pagination"
   }
 });
-var publicVolumeDownloadContract = c17.router({
+var publicVolumeDownloadContract = c18.router({
   download: {
     method: "GET",
     path: "/v1/volumes/:id/download",
-    pathParams: z22.object({
-      id: z22.string().min(1, "Volume ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Volume ID is required")
     }),
-    query: z22.object({
-      version_id: z22.string().optional()
+    query: z23.object({
+      version_id: z23.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z22.undefined(),
+      302: z23.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -9949,7 +10081,7 @@ var benchmarkCommand = new Command4("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "2.13.3" : "0.1.0";
+var version = true ? "2.13.5" : "0.1.0";
 program.name("vm0-runner").version(version).description("Self-hosted runner for VM0 agents");
 program.addCommand(startCommand);
 program.addCommand(doctorCommand);

package/package.json

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