@vm0/cli 9.234.0 → 9.235.0

package/{agent-TL6MTFM7.js → agent-3CDPJVR7.js}

@@ -4,10 +4,10 @@ const require = __createRequire(import.meta.url);
 import {
   loadConnectorPermissionInfos,
   policyIcon
-} from "./chunk-XYITXRVX.js";
+} from "./chunk-CKADUOUQ.js";
 import {
   permissionGrantsToFirewallPolicies
-} from "./chunk-RL5SDF24.js";
+} from "./chunk-GEXCW2ZR.js";
 import {
   isInteractive,
   promptConfirm
@@ -24,10 +24,10 @@ import {
   listZeroUserPermissionGrants,
   updateZeroAgent,
   updateZeroAgentInstructions
-} from "./chunk-FUZ73GKT.js";
+} from "./chunk-7YYQTMA3.js";
 import {
   withErrorHandler
-} from "./chunk-SJOPQIHJ.js";
+} from "./chunk-QHO4S7YW.js";
 import {
   source_default
 } from "./chunk-JUTUEPIR.js";
@@ -595,4 +595,4 @@ Notes:
 export {
   zeroAgentCommand
 };
-//# sourceMappingURL=agent-TL6MTFM7.js.map
+//# sourceMappingURL=agent-3CDPJVR7.js.map

package/{banking-6QADOXHV.js → banking-Y74Q3FAN.js}

@@ -4,10 +4,10 @@ const require = __createRequire(import.meta.url);
 import "./chunk-LTDQISD7.js";
 import {
   callZeroBanking
-} from "./chunk-FUZ73GKT.js";
+} from "./chunk-7YYQTMA3.js";
 import {
   withErrorHandler
-} from "./chunk-SJOPQIHJ.js";
+} from "./chunk-QHO4S7YW.js";
 import {
   source_default
 } from "./chunk-JUTUEPIR.js";
@@ -115,4 +115,4 @@ Notes:
 export {
   zeroBankingCommand
 };
-//# sourceMappingURL=banking-6QADOXHV.js.map
+//# sourceMappingURL=banking-Y74Q3FAN.js.map

package/{chat-ZKVV55AC.js → chat-5PWYHJBU.js}

@@ -3,17 +3,17 @@ import { createRequire as __createRequire } from "node:module";
 const require = __createRequire(import.meta.url);
 import {
   formatModelProviderRoute
-} from "./chunk-6AN3CHXL.js";
+} from "./chunk-FAHSAU2K.js";
 import "./chunk-LTDQISD7.js";
 import {
   getZeroChatThread,
   listZeroModelPolicies,
   renameZeroChatThread,
   updateZeroChatThreadModelSelection
-} from "./chunk-FUZ73GKT.js";
+} from "./chunk-7YYQTMA3.js";
 import {
   withErrorHandler
-} from "./chunk-SJOPQIHJ.js";
+} from "./chunk-QHO4S7YW.js";
 import {
   source_default
 } from "./chunk-JUTUEPIR.js";
@@ -244,4 +244,4 @@ Examples:
 export {
   zeroChatCommand
 };
-//# sourceMappingURL=chat-ZKVV55AC.js.map
+//# sourceMappingURL=chat-5PWYHJBU.js.map

package/{chunk-WC74FEVL.js → chunk-326FGQI5.js}

@@ -50,7 +50,7 @@ if (DSN) {
   Sentry.init({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.234.0",
+    release: "9.235.0",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -69,7 +69,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.234.0",
+    version: "9.235.0",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -146,4 +146,4 @@ async function configureGlobalProxyFromEnv() {
 export {
   configureGlobalProxyFromEnv
 };
-//# sourceMappingURL=chunk-WC74FEVL.js.map
+//# sourceMappingURL=chunk-326FGQI5.js.map

package/{chunk-FUZ73GKT.js → chunk-7YYQTMA3.js}

@@ -14,7 +14,7 @@ import {
   headersWithCliClientHeaders,
   initClient,
   initContract
-} from "./chunk-SJOPQIHJ.js";
+} from "./chunk-QHO4S7YW.js";
 import {
   init_esm_shims
 } from "./chunk-DIRAZ3YX.js";
@@ -761,7 +761,14 @@ var MODEL_PROVIDER_TYPES = {
       CHATGPT_ACCOUNT_ID: "$secrets.CHATGPT_ACCOUNT_ID",
       OPENAI_MODEL: "$model"
     },
-    models: ["gpt-5.5", "gpt-5.4", "gpt-5.4-mini"],
+    models: [
+      "gpt-5.6-sol",
+      "gpt-5.6-terra",
+      "gpt-5.6-luna",
+      "gpt-5.5",
+      "gpt-5.4",
+      "gpt-5.4-mini"
+    ],
     defaultModel: "gpt-5.5"
   },
   "azure-foundry": {
@@ -27895,6 +27902,17 @@ var memoryRecallItemKindSchema = external_exports.enum([
   "preference",
   "open_loop"
 ]);
+var memoryKindSchema = external_exports.enum([
+  "key_fact",
+  "preference",
+  "open_loop",
+  "role",
+  "project",
+  "communication_style",
+  "recent_context"
+]);
+var memoryStatusSchema = external_exports.enum(["active", "archived"]);
+var memoryDocumentStatusSchema = external_exports.enum(["active", "archived", "deleted"]);
 var memorySearchModeSchema = external_exports.enum(["hybrid", "memories", "documents"]);
 var memoryContextSpaceTypeSchema = external_exports.enum([
   "user",
@@ -27905,6 +27923,13 @@ var memoryContextSpaceTypeSchema = external_exports.enum([
   "agent",
   "workflow"
 ]);
+var memoryVersionTargetKindSchema = external_exports.enum(["memory", "document", "profile"]);
+var memoryTombstoneTargetKindSchema = external_exports.enum([
+  "memory",
+  "document",
+  "document_chunk",
+  "profile"
+]);
 var memoryInjectionItemKindSchema = external_exports.enum([
   "key_fact",
   "preference",
@@ -28070,6 +28095,148 @@ var memorySearchResponseSchema = external_exports.object({
     ])
   )
 });
+var memoryContextSpaceSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  type: memoryContextSpaceTypeSchema,
+  key: external_exports.string(),
+  displayName: external_exports.string()
+});
+var memoryContextSpaceInputSchema = external_exports.object({
+  type: memoryContextSpaceTypeSchema,
+  key: external_exports.string().min(1).max(512),
+  displayName: external_exports.string().min(1).max(300)
+});
+var memoryLifecycleEntitySchema = external_exports.object({
+  id: external_exports.string().uuid().nullable(),
+  type: external_exports.enum(["person", "organization", "project", "channel"]).nullable(),
+  displayName: external_exports.string().nullable()
+});
+var memoryLifecycleMemorySchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  kind: memoryKindSchema,
+  status: memoryStatusSchema,
+  text: external_exports.string(),
+  confidence: external_exports.number().int().min(0).max(100),
+  sourceCount: external_exports.number().int().nonnegative(),
+  lastSeenAt: external_exports.string(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string(),
+  contextSpace: memoryContextSpaceSchema.nullable(),
+  entity: memoryLifecycleEntitySchema
+});
+var memoryListResponseSchema = external_exports.object({
+  memories: external_exports.array(memoryLifecycleMemorySchema),
+  pagination: external_exports.object({
+    page: external_exports.number().int().positive(),
+    pageSize: external_exports.number().int().positive(),
+    total: external_exports.number().int().nonnegative(),
+    totalPages: external_exports.number().int().positive(),
+    hasMore: external_exports.boolean()
+  })
+});
+var memoryCreateRequestSchema = external_exports.object({
+  text: external_exports.string().min(1).max(4e3),
+  kind: memoryKindSchema.default("key_fact"),
+  confidence: external_exports.number().int().min(0).max(100).default(90),
+  contextSpace: memoryContextSpaceInputSchema.optional(),
+  entityDisplayName: external_exports.string().min(1).max(300).optional()
+});
+var memoryUpdateRequestSchema = external_exports.object({
+  text: external_exports.string().min(1).max(4e3).optional(),
+  kind: memoryKindSchema.optional(),
+  confidence: external_exports.number().int().min(0).max(100).optional(),
+  contextSpace: memoryContextSpaceInputSchema.optional(),
+  entityDisplayName: external_exports.string().min(1).max(300).optional()
+});
+var memoryLifecycleMemoryResponseSchema = external_exports.object({
+  memory: memoryLifecycleMemorySchema
+});
+var memoryForgetRequestSchema = external_exports.object({
+  reason: external_exports.string().min(1).max(500).optional()
+});
+var memoryForgetTargetKindSchema = external_exports.enum(["all", "memories", "documents"]);
+var memoryForgetByPromptRequestSchema = external_exports.object({
+  prompt: external_exports.string().min(1).max(500),
+  targetKind: memoryForgetTargetKindSchema.default("all"),
+  provider: memorySourceProviderSchema.optional(),
+  limit: external_exports.number().int().min(1).max(10).default(5),
+  reason: external_exports.string().min(1).max(500).optional()
+});
+var memoryTombstoneSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  targetKind: memoryTombstoneTargetKindSchema,
+  fingerprint: external_exports.string(),
+  reason: external_exports.string().nullable(),
+  prompt: external_exports.string().nullable(),
+  targetId: external_exports.string().nullable(),
+  targetTitle: external_exports.string().nullable(),
+  targetText: external_exports.string().nullable(),
+  contextSpace: memoryContextSpaceSchema.nullable(),
+  createdAt: external_exports.string()
+});
+var memoryForgetResponseSchema = external_exports.object({
+  forgotten: external_exports.array(memoryTombstoneSchema)
+});
+var memoryTombstoneListResponseSchema = external_exports.object({
+  forgotten: external_exports.array(memoryTombstoneSchema)
+});
+var memoryVersionSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  targetKind: memoryVersionTargetKindSchema,
+  targetId: external_exports.string().uuid(),
+  version: external_exports.number().int().positive(),
+  contentHash: external_exports.string(),
+  operation: external_exports.enum(["create", "update", "forget", "derive"]).nullable(),
+  reason: external_exports.string().nullable(),
+  text: external_exports.string().nullable(),
+  title: external_exports.string().nullable(),
+  status: external_exports.string().nullable(),
+  confidence: external_exports.number().int().min(0).max(100).nullable(),
+  kind: external_exports.string().nullable(),
+  contextSpace: memoryContextSpaceSchema.nullable(),
+  createdAt: external_exports.string()
+});
+var memoryHistoryResponseSchema = external_exports.object({
+  history: external_exports.array(memoryVersionSchema)
+});
+var memoryDocumentListItemSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  status: memoryDocumentStatusSchema,
+  title: external_exports.string().nullable(),
+  provider: memorySourceProviderSchema,
+  sourceType: memorySourceTypeSchema,
+  externalId: external_exports.string(),
+  contentHash: external_exports.string(),
+  occurredAt: external_exports.string().nullable(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string(),
+  chunkCount: external_exports.number().int().nonnegative(),
+  contextSpace: memoryContextSpaceSchema,
+  citationUrl: external_exports.string().nullable()
+});
+var memoryDocumentListResponseSchema = external_exports.object({
+  documents: external_exports.array(memoryDocumentListItemSchema),
+  pagination: external_exports.object({
+    page: external_exports.number().int().positive(),
+    pageSize: external_exports.number().int().positive(),
+    total: external_exports.number().int().nonnegative(),
+    totalPages: external_exports.number().int().positive(),
+    hasMore: external_exports.boolean()
+  })
+});
+var memoryProfileListItemSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  section: external_exports.string(),
+  content: external_exports.string(),
+  sourceMemoryCount: external_exports.number().int().nonnegative(),
+  entity: memoryLifecycleEntitySchema,
+  contextSpace: memoryContextSpaceSchema.nullable(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var memoryProfileListResponseSchema = external_exports.object({
+  profiles: external_exports.array(memoryProfileListItemSchema)
+});
 var memoryInjectionItemSchema = external_exports.object({
   id: external_exports.string().uuid(),
   kind: memoryInjectionItemKindSchema,
@@ -28287,6 +28454,12 @@ var zeroMemoryContract = c36.router({
       q: external_exports.string().min(1).max(300),
       mode: memorySearchModeSchema.default("hybrid"),
       provider: memorySourceProviderSchema.optional(),
+      sourceType: memorySourceTypeSchema.optional(),
+      contextSpaceType: memoryContextSpaceTypeSchema.optional(),
+      contextSpaceKey: external_exports.string().min(1).max(512).optional(),
+      memoryKind: memoryKindSchema.optional(),
+      occurredAfter: external_exports.string().datetime().optional(),
+      occurredBefore: external_exports.string().datetime().optional(),
       limit: external_exports.coerce.number().int().min(1).max(25).default(10)
     }),
     responses: {
@@ -28298,6 +28471,173 @@ var zeroMemoryContract = c36.router({
     },
     summary: "Search structured memories and document chunks for the current user"
   },
+  memories: {
+    method: "GET",
+    path: "/api/zero/memory/memories",
+    headers: authHeadersSchema,
+    query: external_exports.object({
+      status: memoryStatusSchema.default("active"),
+      kind: memoryKindSchema.optional(),
+      page: external_exports.coerce.number().int().positive().default(1),
+      limit: external_exports.coerce.number().int().min(1).max(100).default(50)
+    }),
+    responses: {
+      200: memoryListResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List lifecycle-aware structured memories"
+  },
+  createMemory: {
+    method: "POST",
+    path: "/api/zero/memory/memories",
+    headers: authHeadersSchema,
+    body: memoryCreateRequestSchema,
+    responses: {
+      200: memoryLifecycleMemoryResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Create a direct structured memory"
+  },
+  updateMemory: {
+    method: "PATCH",
+    path: "/api/zero/memory/memories/:memoryId",
+    pathParams: external_exports.object({
+      memoryId: external_exports.string().uuid()
+    }),
+    headers: authHeadersSchema,
+    body: memoryUpdateRequestSchema,
+    responses: {
+      200: memoryLifecycleMemoryResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Update a structured memory and record a new version"
+  },
+  forgetMemory: {
+    method: "POST",
+    path: "/api/zero/memory/memories/:memoryId/forget",
+    pathParams: external_exports.object({
+      memoryId: external_exports.string().uuid()
+    }),
+    headers: authHeadersSchema,
+    body: memoryForgetRequestSchema,
+    responses: {
+      200: memoryForgetResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Forget a structured memory and record a tombstone"
+  },
+  documents: {
+    method: "GET",
+    path: "/api/zero/memory/documents",
+    headers: authHeadersSchema,
+    query: external_exports.object({
+      status: memoryDocumentStatusSchema.default("active"),
+      provider: memorySourceProviderSchema.optional(),
+      page: external_exports.coerce.number().int().positive().default(1),
+      limit: external_exports.coerce.number().int().min(1).max(100).default(50)
+    }),
+    responses: {
+      200: memoryDocumentListResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List indexed memory documents"
+  },
+  forgetDocument: {
+    method: "POST",
+    path: "/api/zero/memory/documents/:documentId/forget",
+    pathParams: external_exports.object({
+      documentId: external_exports.string().uuid()
+    }),
+    headers: authHeadersSchema,
+    body: memoryForgetRequestSchema,
+    responses: {
+      200: memoryForgetResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Forget a memory document and record a tombstone"
+  },
+  forgetPrompt: {
+    method: "POST",
+    path: "/api/zero/memory/forget",
+    headers: authHeadersSchema,
+    body: memoryForgetByPromptRequestSchema,
+    responses: {
+      200: memoryForgetResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Forget memories or documents matching a prompt"
+  },
+  history: {
+    method: "GET",
+    path: "/api/zero/memory/history",
+    headers: authHeadersSchema,
+    query: external_exports.object({
+      targetKind: memoryVersionTargetKindSchema,
+      targetId: external_exports.string().uuid(),
+      limit: external_exports.coerce.number().int().min(1).max(100).default(50)
+    }),
+    responses: {
+      200: memoryHistoryResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List memory, document, or profile version history"
+  },
+  forgotten: {
+    method: "GET",
+    path: "/api/zero/memory/forgotten",
+    headers: authHeadersSchema,
+    query: external_exports.object({
+      targetKind: memoryTombstoneTargetKindSchema.optional(),
+      limit: external_exports.coerce.number().int().min(1).max(100).default(50)
+    }),
+    responses: {
+      200: memoryTombstoneListResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List forgotten memory tombstones"
+  },
+  profiles: {
+    method: "GET",
+    path: "/api/zero/memory/profiles",
+    headers: authHeadersSchema,
+    query: external_exports.object({
+      limit: external_exports.coerce.number().int().min(1).max(100).default(50)
+    }),
+    responses: {
+      200: memoryProfileListResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List derived memory profiles"
+  },
   context: {
     method: "GET",
     path: "/api/zero/memory/context",
@@ -28571,6 +28911,106 @@ async function searchZeroMemory(options) {
   }
   handleError(result, "Failed to search memory");
 }
+async function listZeroMemory(options) {
+  const config = await getClientConfig();
+  const client = initClient(zeroMemoryContract, config);
+  const result = await client.memories({
+    query: {
+      status: options.status,
+      kind: options.kind,
+      limit: options.limit
+    }
+  });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to list memory");
+}
+async function createZeroMemory(request) {
+  const config = await getClientConfig();
+  const client = initClient(zeroMemoryContract, config);
+  const result = await client.createMemory({ body: request });
+  if (result.status === 200) {
+    return result.body.memory;
+  }
+  handleError(result, "Failed to create memory");
+}
+async function updateZeroMemory(memoryId, request) {
+  const config = await getClientConfig();
+  const client = initClient(zeroMemoryContract, config);
+  const result = await client.updateMemory({
+    params: { memoryId },
+    body: request
+  });
+  if (result.status === 200) {
+    return result.body.memory;
+  }
+  handleError(result, "Failed to update memory");
+}
+async function forgetZeroMemory(memoryId, request) {
+  const config = await getClientConfig();
+  const client = initClient(zeroMemoryContract, config);
+  const result = await client.forgetMemory({
+    params: { memoryId },
+    body: request
+  });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to forget memory");
+}
+async function forgetZeroMemoryByPrompt(request) {
+  const config = await getClientConfig();
+  const client = initClient(zeroMemoryContract, config);
+  const result = await client.forgetPrompt({ body: request });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to forget memory by prompt");
+}
+async function listZeroMemoryHistory(options) {
+  const config = await getClientConfig();
+  const client = initClient(zeroMemoryContract, config);
+  const result = await client.history({
+    query: {
+      targetKind: options.targetKind,
+      targetId: options.targetId,
+      limit: options.limit
+    }
+  });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to list memory history");
+}
+async function listZeroMemoryDocuments(options) {
+  const config = await getClientConfig();
+  const client = initClient(zeroMemoryContract, config);
+  const result = await client.documents({
+    query: {
+      status: options.status,
+      provider: options.provider,
+      limit: options.limit
+    }
+  });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to list memory documents");
+}
+async function listZeroMemoryForgotten(options) {
+  const config = await getClientConfig();
+  const client = initClient(zeroMemoryContract, config);
+  const result = await client.forgotten({
+    query: {
+      limit: options.limit
+    }
+  });
+  if (result.status === 200) {
+    return result.body;
+  }
+  handleError(result, "Failed to list forgotten memory");
+}
 
 // src/lib/api/domains/logs.ts
 init_esm_shims();
@@ -28916,6 +29356,14 @@ export {
   recallZeroMemory,
   getZeroMemoryContext,
   searchZeroMemory,
+  listZeroMemory,
+  createZeroMemory,
+  updateZeroMemory,
+  forgetZeroMemory,
+  forgetZeroMemoryByPrompt,
+  listZeroMemoryHistory,
+  listZeroMemoryDocuments,
+  listZeroMemoryForgotten,
   getSystemLog,
   getMetrics,
   getAgentEvents,
@@ -28940,4 +29388,4 @@ export {
   completeHostedSite,
   getHostedSiteFiles
 };
-//# sourceMappingURL=chunk-FUZ73GKT.js.map
+//# sourceMappingURL=chunk-7YYQTMA3.js.map