@vm0/cli 9.84.1 → 9.84.2

package/{chunk-A5NPNEP5.js → chunk-UTY3UDKG.js}

@@ -47,7 +47,7 @@ if (DSN) {
   Sentry.init({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.84.1",
+    release: "9.84.2",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -66,7 +66,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.84.1",
+    version: "9.84.2",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -11415,54 +11415,170 @@ var updateModelRequestSchema = z16.object({
 });
 
 // ../../packages/core/src/contracts/sessions.ts
+import { z as z18 } from "zod";
+
+// ../../packages/core/src/contracts/chat-threads.ts
 import { z as z17 } from "zod";
 var c10 = initContract();
+var chatThreadListItemSchema = z17.object({
+  id: z17.string(),
+  title: z17.string().nullable(),
+  preview: z17.string().nullable(),
+  agentId: z17.string(),
+  createdAt: z17.string(),
+  updatedAt: z17.string()
+});
+var toolSummaryEntrySchema = z17.object({
+  kind: z17.literal("tool"),
+  name: z17.string(),
+  input: z17.record(z17.string(), z17.unknown()).optional()
+});
+var textSummaryEntrySchema = z17.object({
+  kind: z17.literal("text"),
+  text: z17.string()
+});
+var summaryEntrySchema = z17.union([
+  z17.string(),
+  toolSummaryEntrySchema,
+  textSummaryEntrySchema
+]);
 var storedChatMessageSchema = z17.object({
   role: z17.enum(["user", "assistant"]),
   content: z17.string(),
   runId: z17.string().optional(),
-  summaries: z17.array(z17.string()).optional(),
+  error: z17.string().optional(),
+  summaries: z17.array(summaryEntrySchema).optional(),
   createdAt: z17.string()
 });
-var sessionResponseSchema = z17.object({
+var unsavedRunSchema = z17.object({
+  runId: z17.string(),
+  status: z17.string(),
+  prompt: z17.string(),
+  error: z17.string().nullable()
+});
+var chatThreadDetailSchema = z17.object({
   id: z17.string(),
-  agentComposeId: z17.string(),
-  conversationId: z17.string().nullable(),
-  artifactName: z17.string().nullable(),
-  secretNames: z17.array(z17.string()).nullable(),
-  chatMessages: z17.array(storedChatMessageSchema).optional(),
+  title: z17.string().nullable(),
+  agentId: z17.string(),
+  chatMessages: z17.array(storedChatMessageSchema),
+  latestSessionId: z17.string().nullable(),
+  unsavedRuns: z17.array(unsavedRunSchema),
   createdAt: z17.string(),
   updatedAt: z17.string()
 });
-var sessionListItemSchema = z17.object({
-  id: z17.string(),
-  createdAt: z17.string(),
-  updatedAt: z17.string(),
-  messageCount: z17.number(),
-  preview: z17.string().nullable()
+var chatThreadsContract = c10.router({
+  create: {
+    method: "POST",
+    path: "/api/zero/chat-threads",
+    headers: authHeadersSchema,
+    body: z17.object({
+      agentId: z17.string().min(1),
+      title: z17.string().optional()
+    }),
+    responses: {
+      201: z17.object({
+        id: z17.string(),
+        title: z17.string().nullable(),
+        createdAt: z17.string()
+      }),
+      401: apiErrorSchema
+    },
+    summary: "Create a new chat thread"
+  },
+  list: {
+    method: "GET",
+    path: "/api/zero/chat-threads",
+    headers: authHeadersSchema,
+    query: z17.object({
+      agentId: z17.string().min(1, "agentId is required")
+    }),
+    responses: {
+      200: z17.object({ threads: z17.array(chatThreadListItemSchema) }),
+      401: apiErrorSchema
+    },
+    summary: "List chat threads for an agent"
+  }
 });
-var agentComposeSnapshotSchema = z17.object({
-  agentComposeVersionId: z17.string(),
-  vars: z17.record(z17.string(), z17.string()).optional(),
-  secretNames: z17.array(z17.string()).optional()
+var chatThreadByIdContract = c10.router({
+  get: {
+    method: "GET",
+    path: "/api/zero/chat-threads/:id",
+    headers: authHeadersSchema,
+    pathParams: z17.object({ id: z17.string() }),
+    responses: {
+      200: chatThreadDetailSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get chat thread detail with messages"
+  }
 });
-var artifactSnapshotSchema2 = z17.object({
-  artifactName: z17.string(),
-  artifactVersion: z17.string()
+var chatThreadRunsContract = c10.router({
+  addRun: {
+    method: "POST",
+    path: "/api/zero/chat-threads/:id/runs",
+    headers: authHeadersSchema,
+    pathParams: z17.object({ id: z17.string() }),
+    body: z17.object({
+      runId: z17.string().min(1)
+    }),
+    responses: {
+      204: c10.noBody(),
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Associate a run to a chat thread"
+  }
 });
-var volumeVersionsSnapshotSchema2 = z17.object({
-  versions: z17.record(z17.string(), z17.string())
+
+// ../../packages/core/src/contracts/sessions.ts
+var c11 = initContract();
+var storedChatMessageSchema2 = z18.object({
+  role: z18.enum(["user", "assistant"]),
+  content: z18.string(),
+  runId: z18.string().optional(),
+  summaries: z18.array(summaryEntrySchema).optional(),
+  createdAt: z18.string()
 });
-var checkpointResponseSchema = z17.object({
-  id: z17.string(),
-  runId: z17.string(),
-  conversationId: z17.string(),
+var sessionResponseSchema = z18.object({
+  id: z18.string(),
+  agentComposeId: z18.string(),
+  conversationId: z18.string().nullable(),
+  artifactName: z18.string().nullable(),
+  secretNames: z18.array(z18.string()).nullable(),
+  chatMessages: z18.array(storedChatMessageSchema2).optional(),
+  createdAt: z18.string(),
+  updatedAt: z18.string()
+});
+var sessionListItemSchema = z18.object({
+  id: z18.string(),
+  createdAt: z18.string(),
+  updatedAt: z18.string(),
+  messageCount: z18.number(),
+  preview: z18.string().nullable()
+});
+var agentComposeSnapshotSchema = z18.object({
+  agentComposeVersionId: z18.string(),
+  vars: z18.record(z18.string(), z18.string()).optional(),
+  secretNames: z18.array(z18.string()).optional()
+});
+var artifactSnapshotSchema2 = z18.object({
+  artifactName: z18.string(),
+  artifactVersion: z18.string()
+});
+var volumeVersionsSnapshotSchema2 = z18.object({
+  versions: z18.record(z18.string(), z18.string())
+});
+var checkpointResponseSchema = z18.object({
+  id: z18.string(),
+  runId: z18.string(),
+  conversationId: z18.string(),
   agentComposeSnapshot: agentComposeSnapshotSchema,
   artifactSnapshot: artifactSnapshotSchema2.nullable(),
   volumeVersionsSnapshot: volumeVersionsSnapshotSchema2.nullable(),
-  createdAt: z17.string()
+  createdAt: z18.string()
 });
-var sessionsContract = c10.router({
+var sessionsContract = c11.router({
   /**
    * GET /api/agent/sessions?agentComposeId=X
    * List chat sessions for an agent
@@ -11471,17 +11587,17 @@ var sessionsContract = c10.router({
     method: "GET",
     path: "/api/agent/sessions",
     headers: authHeadersSchema,
-    query: z17.object({
-      agentComposeId: z17.string().min(1, "agentComposeId is required")
+    query: z18.object({
+      agentComposeId: z18.string().min(1, "agentComposeId is required")
     }),
     responses: {
-      200: z17.object({ sessions: z17.array(sessionListItemSchema) }),
+      200: z18.object({ sessions: z18.array(sessionListItemSchema) }),
       401: apiErrorSchema
     },
     summary: "List chat sessions for an agent"
   }
 });
-var sessionsByIdContract = c10.router({
+var sessionsByIdContract = c11.router({
   /**
    * GET /api/agent/sessions/:id
    * Get session by ID
@@ -11490,8 +11606,8 @@ var sessionsByIdContract = c10.router({
     method: "GET",
     path: "/api/agent/sessions/:id",
     headers: authHeadersSchema,
-    pathParams: z17.object({
-      id: z17.string().min(1, "Session ID is required")
+    pathParams: z18.object({
+      id: z18.string().min(1, "Session ID is required")
     }),
     responses: {
       200: sessionResponseSchema,
@@ -11502,7 +11618,7 @@ var sessionsByIdContract = c10.router({
     summary: "Get session by ID"
   }
 });
-var sessionMessagesContract = c10.router({
+var sessionMessagesContract = c11.router({
   /**
    * POST /api/agent/sessions/:id/messages
    * Append chat messages to a session
@@ -11511,20 +11627,20 @@ var sessionMessagesContract = c10.router({
     method: "POST",
     path: "/api/agent/sessions/:id/messages",
     headers: authHeadersSchema,
-    pathParams: z17.object({
-      id: z17.string().min(1, "Session ID is required")
+    pathParams: z18.object({
+      id: z18.string().min(1, "Session ID is required")
     }),
-    body: z17.object({
-      messages: z17.array(
-        z17.object({
-          role: z17.enum(["user", "assistant"]),
-          content: z17.string(),
-          runId: z17.string().optional()
+    body: z18.object({
+      messages: z18.array(
+        z18.object({
+          role: z18.enum(["user", "assistant"]),
+          content: z18.string(),
+          runId: z18.string().optional()
         })
       )
     }),
     responses: {
-      200: z17.object({ success: z17.literal(true) }),
+      200: z18.object({ success: z18.literal(true) }),
       401: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema
@@ -11532,7 +11648,7 @@ var sessionMessagesContract = c10.router({
     summary: "Append chat messages to a session"
   }
 });
-var checkpointsByIdContract = c10.router({
+var checkpointsByIdContract = c11.router({
   /**
    * GET /api/agent/checkpoints/:id
    * Get checkpoint by ID
@@ -11541,8 +11657,8 @@ var checkpointsByIdContract = c10.router({
     method: "GET",
     path: "/api/agent/checkpoints/:id",
     headers: authHeadersSchema,
-    pathParams: z17.object({
-      id: z17.string().min(1, "Checkpoint ID is required")
+    pathParams: z18.object({
+      id: z18.string().min(1, "Checkpoint ID is required")
     }),
     responses: {
       200: checkpointResponseSchema,
@@ -11554,106 +11670,6 @@ var checkpointsByIdContract = c10.router({
   }
 });
 
-// ../../packages/core/src/contracts/chat-threads.ts
-import { z as z18 } from "zod";
-var c11 = initContract();
-var chatThreadListItemSchema = z18.object({
-  id: z18.string(),
-  title: z18.string().nullable(),
-  preview: z18.string().nullable(),
-  agentId: z18.string(),
-  createdAt: z18.string(),
-  updatedAt: z18.string()
-});
-var storedChatMessageSchema2 = z18.object({
-  role: z18.enum(["user", "assistant"]),
-  content: z18.string(),
-  runId: z18.string().optional(),
-  error: z18.string().optional(),
-  summaries: z18.array(z18.string()).optional(),
-  createdAt: z18.string()
-});
-var unsavedRunSchema = z18.object({
-  runId: z18.string(),
-  status: z18.string(),
-  prompt: z18.string(),
-  error: z18.string().nullable()
-});
-var chatThreadDetailSchema = z18.object({
-  id: z18.string(),
-  title: z18.string().nullable(),
-  agentId: z18.string(),
-  chatMessages: z18.array(storedChatMessageSchema2),
-  latestSessionId: z18.string().nullable(),
-  unsavedRuns: z18.array(unsavedRunSchema),
-  createdAt: z18.string(),
-  updatedAt: z18.string()
-});
-var chatThreadsContract = c11.router({
-  create: {
-    method: "POST",
-    path: "/api/zero/chat-threads",
-    headers: authHeadersSchema,
-    body: z18.object({
-      agentId: z18.string().min(1),
-      title: z18.string().optional()
-    }),
-    responses: {
-      201: z18.object({
-        id: z18.string(),
-        title: z18.string().nullable(),
-        createdAt: z18.string()
-      }),
-      401: apiErrorSchema
-    },
-    summary: "Create a new chat thread"
-  },
-  list: {
-    method: "GET",
-    path: "/api/zero/chat-threads",
-    headers: authHeadersSchema,
-    query: z18.object({
-      agentId: z18.string().min(1, "agentId is required")
-    }),
-    responses: {
-      200: z18.object({ threads: z18.array(chatThreadListItemSchema) }),
-      401: apiErrorSchema
-    },
-    summary: "List chat threads for an agent"
-  }
-});
-var chatThreadByIdContract = c11.router({
-  get: {
-    method: "GET",
-    path: "/api/zero/chat-threads/:id",
-    headers: authHeadersSchema,
-    pathParams: z18.object({ id: z18.string() }),
-    responses: {
-      200: chatThreadDetailSchema,
-      401: apiErrorSchema,
-      404: apiErrorSchema
-    },
-    summary: "Get chat thread detail with messages"
-  }
-});
-var chatThreadRunsContract = c11.router({
-  addRun: {
-    method: "POST",
-    path: "/api/zero/chat-threads/:id/runs",
-    headers: authHeadersSchema,
-    pathParams: z18.object({ id: z18.string() }),
-    body: z18.object({
-      runId: z18.string().min(1)
-    }),
-    responses: {
-      204: c11.noBody(),
-      401: apiErrorSchema,
-      404: apiErrorSchema
-    },
-    summary: "Associate a run to a chat thread"
-  }
-});
-
 // ../../packages/core/src/contracts/runners.ts
 import { z as z19 } from "zod";
 var c12 = initContract();
@@ -16289,7 +16305,7 @@ var zeroSessionResponseSchema = z34.object({
   conversationId: z34.string().nullable(),
   artifactName: z34.string().nullable(),
   secretNames: z34.array(z34.string()).nullable(),
-  chatMessages: z34.array(storedChatMessageSchema).optional(),
+  chatMessages: z34.array(storedChatMessageSchema2).optional(),
   createdAt: z34.string(),
   updatedAt: z34.string()
 });
@@ -18175,4 +18191,4 @@ export {
   promptSelect,
   promptPassword
 };
-//# sourceMappingURL=chunk-A5NPNEP5.js.map
+//# sourceMappingURL=chunk-UTY3UDKG.js.map