@vm0/runner 3.10.2 → 3.11.0

package/index.js

@@ -7665,14 +7665,20 @@ var modelProviderTypeSchema = z18.enum([
   "anthropic-api-key",
   "openrouter-api-key",
   "moonshot-api-key",
-  "minimax-api-key"
+  "minimax-api-key",
+  "aws-bedrock"
 ]);
 var modelProviderFrameworkSchema = z18.enum(["claude-code", "codex"]);
 var modelProviderResponseSchema = z18.object({
   id: z18.string().uuid(),
   type: modelProviderTypeSchema,
   framework: modelProviderFrameworkSchema,
-  credentialName: z18.string(),
+  credentialName: z18.string().nullable(),
+  // Legacy single-credential (deprecated for multi-auth)
+  authMethod: z18.string().nullable(),
+  // For multi-auth providers
+  credentialNames: z18.array(z18.string()).nullable(),
+  // For multi-auth providers
   isDefault: z18.boolean(),
   selectedModel: z18.string().nullable(),
   createdAt: z18.string(),
@@ -7683,7 +7689,12 @@ var modelProviderListResponseSchema = z18.object({
 });
 var upsertModelProviderRequestSchema = z18.object({
   type: modelProviderTypeSchema,
-  credential: z18.string().min(1, "Credential is required"),
+  credential: z18.string().min(1).optional(),
+  // Legacy single credential
+  authMethod: z18.string().optional(),
+  // For multi-auth providers
+  credentials: z18.record(z18.string(), z18.string()).optional(),
+  // For multi-auth providers
   convert: z18.boolean().optional(),
   selectedModel: z18.string().optional()
 });
@@ -8328,29 +8339,67 @@ var platformArtifactDownloadContract = c15.router({
   }
 });
 
-// ../../packages/core/src/contracts/public/agents.ts
+// ../../packages/core/src/contracts/llm.ts
 import { z as z24 } from "zod";
 var c16 = initContract();
-var publicAgentSchema = z24.object({
-  id: z24.string(),
-  name: z24.string(),
-  currentVersionId: z24.string().nullable(),
+var messageRoleSchema = z24.enum(["user", "assistant", "system"]);
+var chatMessageSchema = z24.object({
+  role: messageRoleSchema,
+  content: z24.string()
+});
+var tokenUsageSchema = z24.object({
+  promptTokens: z24.number(),
+  completionTokens: z24.number(),
+  totalTokens: z24.number()
+});
+var llmChatRequestSchema = z24.object({
+  model: z24.string().min(1).optional(),
+  messages: z24.array(chatMessageSchema).min(1, "At least one message is required"),
+  stream: z24.boolean().optional().default(false)
+});
+var llmChatResponseSchema = z24.object({
+  content: z24.string(),
+  model: z24.string(),
+  usage: tokenUsageSchema
+});
+var llmChatContract = c16.router({
+  chat: {
+    method: "POST",
+    path: "/api/llm/chat",
+    body: llmChatRequestSchema,
+    responses: {
+      200: llmChatResponseSchema,
+      400: apiErrorSchema,
+      500: apiErrorSchema,
+      503: apiErrorSchema
+    },
+    summary: "Send a chat completion request to OpenRouter"
+  }
+});
+
+// ../../packages/core/src/contracts/public/agents.ts
+import { z as z25 } from "zod";
+var c17 = initContract();
+var publicAgentSchema = z25.object({
+  id: z25.string(),
+  name: z25.string(),
+  currentVersionId: z25.string().nullable(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var agentVersionSchema = z24.object({
-  id: z24.string(),
-  agentId: z24.string(),
-  versionNumber: z24.number(),
+var agentVersionSchema = z25.object({
+  id: z25.string(),
+  agentId: z25.string(),
+  versionNumber: z25.number(),
   createdAt: timestampSchema
 });
 var publicAgentDetailSchema = publicAgentSchema;
 var paginatedAgentsSchema = createPaginatedResponseSchema(publicAgentSchema);
 var paginatedAgentVersionsSchema = createPaginatedResponseSchema(agentVersionSchema);
 var agentListQuerySchema = listQuerySchema.extend({
-  name: z24.string().optional()
+  name: z25.string().optional()
 });
-var publicAgentsListContract = c16.router({
+var publicAgentsListContract = c17.router({
   list: {
     method: "GET",
     path: "/v1/agents",
@@ -8365,13 +8414,13 @@ var publicAgentsListContract = c16.router({
     description: "List all agents in the current scope with pagination. Use the `name` query parameter to filter by agent name."
   }
 });
-var publicAgentByIdContract = c16.router({
+var publicAgentByIdContract = c17.router({
   get: {
     method: "GET",
     path: "/v1/agents/:id",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Agent ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Agent ID is required")
     }),
     responses: {
       200: publicAgentDetailSchema,
@@ -8383,13 +8432,13 @@ var publicAgentByIdContract = c16.router({
     description: "Get agent details by ID"
   }
 });
-var publicAgentVersionsContract = c16.router({
+var publicAgentVersionsContract = c17.router({
   list: {
     method: "GET",
     path: "/v1/agents/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Agent ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Agent ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -8404,9 +8453,9 @@ var publicAgentVersionsContract = c16.router({
 });
 
 // ../../packages/core/src/contracts/public/runs.ts
-import { z as z25 } from "zod";
-var c17 = initContract();
-var publicRunStatusSchema = z25.enum([
+import { z as z26 } from "zod";
+var c18 = initContract();
+var publicRunStatusSchema = z26.enum([
   "pending",
   "running",
   "completed",
@@ -8414,54 +8463,54 @@ var publicRunStatusSchema = z25.enum([
   "timeout",
   "cancelled"
 ]);
-var publicRunSchema = z25.object({
-  id: z25.string(),
-  agentId: z25.string(),
-  agentName: z25.string(),
+var publicRunSchema = z26.object({
+  id: z26.string(),
+  agentId: z26.string(),
+  agentName: z26.string(),
   status: publicRunStatusSchema,
-  prompt: z25.string(),
+  prompt: z26.string(),
   createdAt: timestampSchema,
   startedAt: timestampSchema.nullable(),
   completedAt: timestampSchema.nullable()
 });
 var publicRunDetailSchema = publicRunSchema.extend({
-  error: z25.string().nullable(),
-  executionTimeMs: z25.number().nullable(),
-  checkpointId: z25.string().nullable(),
-  sessionId: z25.string().nullable(),
-  artifactName: z25.string().nullable(),
-  artifactVersion: z25.string().nullable(),
-  volumes: z25.record(z25.string(), z25.string()).optional()
+  error: z26.string().nullable(),
+  executionTimeMs: z26.number().nullable(),
+  checkpointId: z26.string().nullable(),
+  sessionId: z26.string().nullable(),
+  artifactName: z26.string().nullable(),
+  artifactVersion: z26.string().nullable(),
+  volumes: z26.record(z26.string(), z26.string()).optional()
 });
 var paginatedRunsSchema = createPaginatedResponseSchema(publicRunSchema);
-var createRunRequestSchema = z25.object({
+var createRunRequestSchema = z26.object({
   // Agent identification (one of: agent, agentId, sessionId, checkpointId)
-  agent: z25.string().optional(),
+  agent: z26.string().optional(),
   // Agent name
-  agentId: z25.string().optional(),
+  agentId: z26.string().optional(),
   // Agent ID
-  agentVersion: z25.string().optional(),
+  agentVersion: z26.string().optional(),
   // Version specifier (e.g., "latest", "v1", specific ID)
   // Continue session
-  sessionId: z25.string().optional(),
+  sessionId: z26.string().optional(),
   // Resume from checkpoint
-  checkpointId: z25.string().optional(),
+  checkpointId: z26.string().optional(),
   // Required
-  prompt: z25.string().min(1, "Prompt is required"),
+  prompt: z26.string().min(1, "Prompt is required"),
   // Optional configuration
-  variables: z25.record(z25.string(), z25.string()).optional(),
-  secrets: z25.record(z25.string(), z25.string()).optional(),
-  artifactName: z25.string().optional(),
+  variables: z26.record(z26.string(), z26.string()).optional(),
+  secrets: z26.record(z26.string(), z26.string()).optional(),
+  artifactName: z26.string().optional(),
   // Artifact name to mount
-  artifactVersion: z25.string().optional(),
+  artifactVersion: z26.string().optional(),
   // Artifact version (defaults to latest)
-  volumes: z25.record(z25.string(), z25.string()).optional()
+  volumes: z26.record(z26.string(), z26.string()).optional()
   // volume_name -> version
 });
 var runListQuerySchema = listQuerySchema.extend({
   status: publicRunStatusSchema.optional()
 });
-var publicRunsListContract = c17.router({
+var publicRunsListContract = c18.router({
   list: {
     method: "GET",
     path: "/v1/runs",
@@ -8493,13 +8542,13 @@ var publicRunsListContract = c17.router({
     description: "Create and execute a new agent run. Returns 202 Accepted as runs execute asynchronously."
   }
 });
-var publicRunByIdContract = c17.router({
+var publicRunByIdContract = c18.router({
   get: {
     method: "GET",
     path: "/v1/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
     responses: {
       200: publicRunDetailSchema,
@@ -8511,15 +8560,15 @@ var publicRunByIdContract = c17.router({
     description: "Get run details by ID"
   }
 });
-var publicRunCancelContract = c17.router({
+var publicRunCancelContract = c18.router({
   cancel: {
     method: "POST",
     path: "/v1/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
-    body: z25.undefined(),
+    body: z26.undefined(),
     responses: {
       200: publicRunDetailSchema,
       400: publicApiErrorSchema,
@@ -8532,27 +8581,27 @@ var publicRunCancelContract = c17.router({
     description: "Cancel a pending or running execution"
   }
 });
-var logEntrySchema = z25.object({
+var logEntrySchema = z26.object({
   timestamp: timestampSchema,
-  type: z25.enum(["agent", "system", "network"]),
-  level: z25.enum(["debug", "info", "warn", "error"]),
-  message: z25.string(),
-  metadata: z25.record(z25.string(), z25.unknown()).optional()
+  type: z26.enum(["agent", "system", "network"]),
+  level: z26.enum(["debug", "info", "warn", "error"]),
+  message: z26.string(),
+  metadata: z26.record(z26.string(), z26.unknown()).optional()
 });
 var paginatedLogsSchema = createPaginatedResponseSchema(logEntrySchema);
 var logsQuerySchema = listQuerySchema.extend({
-  type: z25.enum(["agent", "system", "network", "all"]).default("all"),
+  type: z26.enum(["agent", "system", "network", "all"]).default("all"),
   since: timestampSchema.optional(),
   until: timestampSchema.optional(),
-  order: z25.enum(["asc", "desc"]).default("asc")
+  order: z26.enum(["asc", "desc"]).default("asc")
 });
-var publicRunLogsContract = c17.router({
+var publicRunLogsContract = c18.router({
   getLogs: {
     method: "GET",
     path: "/v1/runs/:id/logs",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
     query: logsQuerySchema,
     responses: {
@@ -8565,30 +8614,30 @@ var publicRunLogsContract = c17.router({
     description: "Get unified logs for a run. Combines agent, system, and network logs."
   }
 });
-var metricPointSchema = z25.object({
+var metricPointSchema = z26.object({
   timestamp: timestampSchema,
-  cpuPercent: z25.number(),
-  memoryUsedMb: z25.number(),
-  memoryTotalMb: z25.number(),
-  diskUsedMb: z25.number(),
-  diskTotalMb: z25.number()
-});
-var metricsSummarySchema = z25.object({
-  avgCpuPercent: z25.number(),
-  maxMemoryUsedMb: z25.number(),
-  totalDurationMs: z25.number().nullable()
-});
-var metricsResponseSchema2 = z25.object({
-  data: z25.array(metricPointSchema),
+  cpuPercent: z26.number(),
+  memoryUsedMb: z26.number(),
+  memoryTotalMb: z26.number(),
+  diskUsedMb: z26.number(),
+  diskTotalMb: z26.number()
+});
+var metricsSummarySchema = z26.object({
+  avgCpuPercent: z26.number(),
+  maxMemoryUsedMb: z26.number(),
+  totalDurationMs: z26.number().nullable()
+});
+var metricsResponseSchema2 = z26.object({
+  data: z26.array(metricPointSchema),
   summary: metricsSummarySchema
 });
-var publicRunMetricsContract = c17.router({
+var publicRunMetricsContract = c18.router({
   getMetrics: {
     method: "GET",
     path: "/v1/runs/:id/metrics",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
     responses: {
       200: metricsResponseSchema2,
@@ -8600,7 +8649,7 @@ var publicRunMetricsContract = c17.router({
     description: "Get CPU, memory, and disk metrics for a run"
   }
 });
-var sseEventTypeSchema = z25.enum([
+var sseEventTypeSchema = z26.enum([
   "status",
   // Run status change
   "output",
@@ -8612,26 +8661,26 @@ var sseEventTypeSchema = z25.enum([
   "heartbeat"
   // Keep-alive
 ]);
-var sseEventSchema = z25.object({
+var sseEventSchema = z26.object({
   event: sseEventTypeSchema,
-  data: z25.unknown(),
-  id: z25.string().optional()
+  data: z26.unknown(),
+  id: z26.string().optional()
   // For Last-Event-ID reconnection
 });
-var publicRunEventsContract = c17.router({
+var publicRunEventsContract = c18.router({
   streamEvents: {
     method: "GET",
     path: "/v1/runs/:id/events",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
-    query: z25.object({
-      lastEventId: z25.string().optional()
+    query: z26.object({
+      lastEventId: z26.string().optional()
       // For reconnection
     }),
     responses: {
-      200: z25.any(),
+      200: z26.any(),
       // SSE stream - actual content is text/event-stream
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -8643,28 +8692,28 @@ var publicRunEventsContract = c17.router({
 });
 
 // ../../packages/core/src/contracts/public/artifacts.ts
-import { z as z26 } from "zod";
-var c18 = initContract();
-var publicArtifactSchema = z26.object({
-  id: z26.string(),
-  name: z26.string(),
-  currentVersionId: z26.string().nullable(),
-  size: z26.number(),
+import { z as z27 } from "zod";
+var c19 = initContract();
+var publicArtifactSchema = z27.object({
+  id: z27.string(),
+  name: z27.string(),
+  currentVersionId: z27.string().nullable(),
+  size: z27.number(),
   // Total size in bytes
-  fileCount: z26.number(),
+  fileCount: z27.number(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var artifactVersionSchema = z26.object({
-  id: z26.string(),
+var artifactVersionSchema = z27.object({
+  id: z27.string(),
   // SHA-256 content hash
-  artifactId: z26.string(),
-  size: z26.number(),
+  artifactId: z27.string(),
+  size: z27.number(),
   // Size in bytes
-  fileCount: z26.number(),
-  message: z26.string().nullable(),
+  fileCount: z27.number(),
+  message: z27.string().nullable(),
   // Optional commit message
-  createdBy: z26.string(),
+  createdBy: z27.string(),
   createdAt: timestampSchema
 });
 var publicArtifactDetailSchema = publicArtifactSchema.extend({
@@ -8674,7 +8723,7 @@ var paginatedArtifactsSchema = createPaginatedResponseSchema(publicArtifactSchem
 var paginatedArtifactVersionsSchema = createPaginatedResponseSchema(
   artifactVersionSchema
 );
-var publicArtifactsListContract = c18.router({
+var publicArtifactsListContract = c19.router({
   list: {
     method: "GET",
     path: "/v1/artifacts",
@@ -8689,13 +8738,13 @@ var publicArtifactsListContract = c18.router({
     description: "List all artifacts in the current scope with pagination"
   }
 });
-var publicArtifactByIdContract = c18.router({
+var publicArtifactByIdContract = c19.router({
   get: {
     method: "GET",
     path: "/v1/artifacts/:id",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Artifact ID is required")
+    pathParams: z27.object({
+      id: z27.string().min(1, "Artifact ID is required")
     }),
     responses: {
       200: publicArtifactDetailSchema,
@@ -8707,13 +8756,13 @@ var publicArtifactByIdContract = c18.router({
     description: "Get artifact details by ID"
   }
 });
-var publicArtifactVersionsContract = c18.router({
+var publicArtifactVersionsContract = c19.router({
   list: {
     method: "GET",
     path: "/v1/artifacts/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Artifact ID is required")
+    pathParams: z27.object({
+      id: z27.string().min(1, "Artifact ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -8726,20 +8775,20 @@ var publicArtifactVersionsContract = c18.router({
     description: "List all versions of an artifact with pagination"
   }
 });
-var publicArtifactDownloadContract = c18.router({
+var publicArtifactDownloadContract = c19.router({
   download: {
     method: "GET",
     path: "/v1/artifacts/:id/download",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Artifact ID is required")
+    pathParams: z27.object({
+      id: z27.string().min(1, "Artifact ID is required")
     }),
-    query: z26.object({
-      versionId: z26.string().optional()
+    query: z27.object({
+      versionId: z27.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z26.undefined(),
+      302: z27.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -8751,28 +8800,28 @@ var publicArtifactDownloadContract = c18.router({
 });
 
 // ../../packages/core/src/contracts/public/volumes.ts
-import { z as z27 } from "zod";
-var c19 = initContract();
-var publicVolumeSchema = z27.object({
-  id: z27.string(),
-  name: z27.string(),
-  currentVersionId: z27.string().nullable(),
-  size: z27.number(),
+import { z as z28 } from "zod";
+var c20 = initContract();
+var publicVolumeSchema = z28.object({
+  id: z28.string(),
+  name: z28.string(),
+  currentVersionId: z28.string().nullable(),
+  size: z28.number(),
   // Total size in bytes
-  fileCount: z27.number(),
+  fileCount: z28.number(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var volumeVersionSchema = z27.object({
-  id: z27.string(),
+var volumeVersionSchema = z28.object({
+  id: z28.string(),
   // SHA-256 content hash
-  volumeId: z27.string(),
-  size: z27.number(),
+  volumeId: z28.string(),
+  size: z28.number(),
   // Size in bytes
-  fileCount: z27.number(),
-  message: z27.string().nullable(),
+  fileCount: z28.number(),
+  message: z28.string().nullable(),
   // Optional commit message
-  createdBy: z27.string(),
+  createdBy: z28.string(),
   createdAt: timestampSchema
 });
 var publicVolumeDetailSchema = publicVolumeSchema.extend({
@@ -8780,7 +8829,7 @@ var publicVolumeDetailSchema = publicVolumeSchema.extend({
 });
 var paginatedVolumesSchema = createPaginatedResponseSchema(publicVolumeSchema);
 var paginatedVolumeVersionsSchema = createPaginatedResponseSchema(volumeVersionSchema);
-var publicVolumesListContract = c19.router({
+var publicVolumesListContract = c20.router({
   list: {
     method: "GET",
     path: "/v1/volumes",
@@ -8795,13 +8844,13 @@ var publicVolumesListContract = c19.router({
     description: "List all volumes in the current scope with pagination"
   }
 });
-var publicVolumeByIdContract = c19.router({
+var publicVolumeByIdContract = c20.router({
   get: {
     method: "GET",
     path: "/v1/volumes/:id",
     headers: authHeadersSchema,
-    pathParams: z27.object({
-      id: z27.string().min(1, "Volume ID is required")
+    pathParams: z28.object({
+      id: z28.string().min(1, "Volume ID is required")
     }),
     responses: {
       200: publicVolumeDetailSchema,
@@ -8813,13 +8862,13 @@ var publicVolumeByIdContract = c19.router({
     description: "Get volume details by ID"
   }
 });
-var publicVolumeVersionsContract = c19.router({
+var publicVolumeVersionsContract = c20.router({
   list: {
     method: "GET",
     path: "/v1/volumes/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z27.object({
-      id: z27.string().min(1, "Volume ID is required")
+    pathParams: z28.object({
+      id: z28.string().min(1, "Volume ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -8832,20 +8881,20 @@ var publicVolumeVersionsContract = c19.router({
     description: "List all versions of a volume with pagination"
   }
 });
-var publicVolumeDownloadContract = c19.router({
+var publicVolumeDownloadContract = c20.router({
   download: {
     method: "GET",
     path: "/v1/volumes/:id/download",
     headers: authHeadersSchema,
-    pathParams: z27.object({
-      id: z27.string().min(1, "Volume ID is required")
+    pathParams: z28.object({
+      id: z28.string().min(1, "Volume ID is required")
     }),
-    query: z27.object({
-      versionId: z27.string().optional()
+    query: z28.object({
+      versionId: z28.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z27.undefined(),
+      302: z28.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -11156,7 +11205,7 @@ var benchmarkCommand = new Command4("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "3.10.2" : "0.1.0";
+var version = true ? "3.11.0" : "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": "3.10.2",
+  "version": "3.11.0",
   "description": "Self-hosted runner for VM0 agents",
   "repository": {
     "type": "git",