@agentskit/chat-protocol 0.1.0 → 0.2.0

package/README.md

@@ -13,4 +13,9 @@ The package transports snapshots of canonical AgentsKit state. It does not imple
 
 It also owns the accepted versioned site-config, local-knowledge, and unified-answer envelopes used by the deterministic answer plane. Decode untrusted data with `decodeDeterministicSiteConfig` and `decodeAnswerResponse`; cryptographically verify local artifacts with `verifyLocalKnowledgeArtifact`. See the [deterministic answer guide](../../docs/protocol/deterministic-answers.md).
 
+The package also validates the additive Ask request, trusted backend site
+configuration, grounded sources, CAS session records, typed diagnostics,
+usage, and privacy-safe metrics used by `createAskServiceHandler`. See the
+[backend guide](../../docs/backend.md).
+
 For one canonical assistant message containing both streamed prose and registered application components, use `createAssistantContentEncoder` and decode with `decodeAssistantContent`. Every text chunk must pass through the encoder; raw model output must never be appended to the envelope. See the [v1 protocol guide](../../docs/protocol/v1.md#ordered-assistant-content).

package/dist/index.cjs

@@ -24,6 +24,11 @@ __export(index_exports, {
   ANSWER_MAX_SUGGESTIONS: () => ANSWER_MAX_SUGGESTIONS,
   ANSWER_PROTOCOL: () => ANSWER_PROTOCOL,
   ANSWER_PROTOCOL_VERSION: () => ANSWER_PROTOCOL_VERSION,
+  ASK_BACKEND_MAX_MESSAGES: () => ASK_BACKEND_MAX_MESSAGES,
+  ASK_BACKEND_MAX_MESSAGE_CHARS: () => ASK_BACKEND_MAX_MESSAGE_CHARS,
+  ASK_BACKEND_MAX_SOURCES: () => ASK_BACKEND_MAX_SOURCES,
+  ASK_BACKEND_PROTOCOL: () => ASK_BACKEND_PROTOCOL,
+  ASK_BACKEND_PROTOCOL_VERSION: () => ASK_BACKEND_PROTOCOL_VERSION,
   ASK_EVENT_MAX_BYTES: () => ASK_EVENT_MAX_BYTES,
   ASK_EVENT_MAX_RECORDS: () => ASK_EVENT_MAX_RECORDS,
   ASK_SERVICE_PROTOCOL_VERSION: () => ASK_SERVICE_PROTOCOL_VERSION,
@@ -36,6 +41,15 @@ __export(index_exports, {
   AnswerConfidenceSchema: () => AnswerConfidenceSchema,
   AnswerResponseSchema: () => AnswerResponseSchema,
   AnswerSuggestionSchema: () => AnswerSuggestionSchema,
+  AskBackendDiagnosticSchema: () => AskBackendDiagnosticSchema,
+  AskBackendMessageSchema: () => AskBackendMessageSchema,
+  AskBackendMetricNameSchema: () => AskBackendMetricNameSchema,
+  AskBackendMetricSchema: () => AskBackendMetricSchema,
+  AskBackendRequestSchema: () => AskBackendRequestSchema,
+  AskBackendSessionRecordSchema: () => AskBackendSessionRecordSchema,
+  AskBackendSiteConfigSchema: () => AskBackendSiteConfigSchema,
+  AskBackendSourceSchema: () => AskBackendSourceSchema,
+  AskBackendUsageSchema: () => AskBackendUsageSchema,
   AskEventSchema: () => AskEventSchema,
   AssistantComponentPartSchema: () => AssistantComponentPartSchema,
   AssistantContentPartSchema: () => AssistantContentPartSchema,
@@ -93,7 +107,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_core = require("@agentskit/core");
 var import_memory_validation = require("@agentskit/core/memory-validation");
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/ask.ts
 var import_zod = require("zod");
@@ -105,7 +119,12 @@ var AskEventSchema = import_zod.z.discriminatedUnion("type", [
   import_zod.z.object({ type: import_zod.z.literal("text"), delta: import_zod.z.string().max(ASK_EVENT_MAX_BYTES) }).strict(),
   import_zod.z.object({ type: import_zod.z.literal("tool"), id: import_zod.z.string().max(256), name: import_zod.z.string().max(128), args: AskArgsSchema }).strict(),
   import_zod.z.object({ type: import_zod.z.literal("done"), model: import_zod.z.string().max(256).optional() }).strict(),
-  import_zod.z.object({ type: import_zod.z.literal("error"), message: import_zod.z.string().min(1).max(4096) }).strict()
+  import_zod.z.object({
+    type: import_zod.z.literal("error"),
+    message: import_zod.z.string().min(1).max(4096),
+    code: import_zod.z.string().regex(/^[A-Z][A-Z0-9_]{0,127}$/).optional(),
+    retryable: import_zod.z.boolean().optional()
+  }).strict()
 ]);
 var byteLength = (value) => new TextEncoder().encode(value).byteLength;
 function decodeAskEvents(buffer) {
@@ -135,6 +154,9 @@ function decodeAskEvents(buffer) {
   return { events: Object.freeze(events), rest: discardedPartial ? "" : partial, discardedPartial };
 }
 
+// src/backend.ts
+var import_zod3 = require("zod");
+
 // src/deterministic.ts
 var import_sha2 = require("@noble/hashes/sha2.js");
 var import_utils = require("@noble/hashes/utils.js");
@@ -405,6 +427,128 @@ var verifyLocalKnowledgeArtifactSync = (input, options) => {
 var verifyLocalKnowledgeArtifact = async (input, options) => verifyLocalKnowledgeArtifactSync(input, options);
 var decodeAnswerResponse = (input) => parseBoundedInput(input, AnswerResponseSchema, ANSWER_PROTOCOL, ANSWER_PROTOCOL_VERSION, 262144);
 
+// src/backend.ts
+var ASK_BACKEND_PROTOCOL = "agentskit.chat.ask";
+var ASK_BACKEND_PROTOCOL_VERSION = 1;
+var ASK_BACKEND_MAX_MESSAGES = 64;
+var ASK_BACKEND_MAX_MESSAGE_CHARS = 16384;
+var ASK_BACKEND_MAX_SOURCES = 8;
+var SafeIdentifierSchema2 = import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var SafeLabelSchema = import_zod3.z.string().trim().min(1).max(256);
+var SafeHrefSchema2 = import_zod3.z.string().min(1).max(2048).refine((value) => {
+  if (/[\u0000-\u001F\u007F\\]/u.test(value) || value.startsWith("//")) return false;
+  if (!/^[A-Za-z][A-Za-z0-9+.-]*:/.test(value)) return /^\/(?!\/)/.test(value);
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "";
+  } catch {
+    return false;
+  }
+}, "Source must use a safe relative, HTTP, or HTTPS URL.");
+var AskBackendMessageSchema = import_zod3.z.object({
+  role: import_zod3.z.enum(["user", "assistant"]),
+  content: import_zod3.z.string().max(ASK_BACKEND_MAX_MESSAGE_CHARS)
+}).strict().readonly();
+var DeterministicEscalationSchema = AnswerResponseSchema.refine(
+  (value) => value.outcome === "escalation",
+  "Deterministic context must be an escalation."
+);
+var AskBackendRequestSchema = import_zod3.z.object({
+  protocol: import_zod3.z.literal(ASK_BACKEND_PROTOCOL).optional(),
+  version: import_zod3.z.literal(ASK_BACKEND_PROTOCOL_VERSION).optional(),
+  sessionId: SafeIdentifierSchema2.optional(),
+  messages: import_zod3.z.array(AskBackendMessageSchema).min(1).max(ASK_BACKEND_MAX_MESSAGES).readonly(),
+  deterministic: DeterministicEscalationSchema.optional()
+}).strict().readonly();
+var AskBackendSourceSchema = import_zod3.z.object({
+  id: SafeIdentifierSchema2,
+  title: SafeLabelSchema,
+  href: SafeHrefSchema2,
+  excerpt: import_zod3.z.string().trim().min(1).max(4096)
+}).strict().readonly();
+var AskBackendSiteConfigSchema = import_zod3.z.object({
+  protocol: import_zod3.z.literal("agentskit.chat.backend-site"),
+  version: import_zod3.z.literal(1),
+  siteId: SafeIdentifierSchema2,
+  assistant: import_zod3.z.object({
+    id: SafeIdentifierSchema2,
+    name: SafeLabelSchema,
+    suggestions: import_zod3.z.array(SafeLabelSchema).max(8).readonly()
+  }).strict().readonly(),
+  corpus: import_zod3.z.object({
+    id: SafeIdentifierSchema2,
+    mode: import_zod3.z.enum(["local", "federated"])
+  }).strict().readonly(),
+  components: import_zod3.z.array(SafeIdentifierSchema2).max(64).readonly(),
+  actions: import_zod3.z.array(SafeIdentifierSchema2).max(64).readonly(),
+  limits: import_zod3.z.object({
+    requestTimeoutMs: import_zod3.z.number().int().min(100).max(12e4),
+    retrievalTimeoutMs: import_zod3.z.number().int().min(100).max(6e4),
+    generationTimeoutMs: import_zod3.z.number().int().min(100).max(12e4),
+    maxSources: import_zod3.z.number().int().min(1).max(ASK_BACKEND_MAX_SOURCES)
+  }).strict().readonly(),
+  persistence: import_zod3.z.object({ mode: import_zod3.z.enum(["required", "disabled"]) }).strict().readonly()
+}).strict().readonly();
+var AskBackendUsageSchema = import_zod3.z.object({
+  inputTokens: import_zod3.z.number().int().nonnegative().optional(),
+  outputTokens: import_zod3.z.number().int().nonnegative().optional(),
+  totalTokens: import_zod3.z.number().int().nonnegative().optional(),
+  costUsd: import_zod3.z.number().nonnegative().finite().optional(),
+  model: import_zod3.z.string().trim().min(1).max(256).optional()
+}).strict().readonly();
+var AskBackendSessionRecordSchema = import_zod3.z.object({
+  revision: import_zod3.z.number().int().nonnegative(),
+  messages: import_zod3.z.array(AskBackendMessageSchema).max(ASK_BACKEND_MAX_MESSAGES).readonly()
+}).strict().readonly();
+var AskBackendDiagnosticSchema = import_zod3.z.object({
+  code: import_zod3.z.enum([
+    "ASK_INVALID_REQUEST",
+    "ASK_UNAUTHORIZED",
+    "ASK_FORBIDDEN",
+    "ASK_RATE_LIMITED",
+    "ASK_TIMEOUT",
+    "ASK_CANCELLED",
+    "ASK_RETRIEVAL_FAILED",
+    "ASK_NO_GROUNDED_SOURCES",
+    "ASK_GENERATION_FAILED",
+    "ASK_PERSISTENCE_CONFLICT",
+    "ASK_INTERNAL"
+  ]),
+  message: import_zod3.z.string().trim().min(1).max(4096),
+  retryable: import_zod3.z.boolean()
+}).strict().readonly();
+var AskBackendMetricNameSchema = import_zod3.z.enum([
+  "request.total_ms",
+  "stream.first_event_ms",
+  "stream.first_token_ms",
+  "stream.bytes",
+  "stream.events",
+  "stream.snapshots",
+  "deterministic.fallback",
+  "retrieval.total_ms",
+  "retrieval.documents",
+  "persistence.total_ms",
+  "cancellation.count",
+  "conflict.count",
+  "error.count",
+  "usage.input_tokens",
+  "usage.output_tokens",
+  "usage.total_tokens",
+  "cost.usd"
+]);
+var AskBackendMetricSchema = import_zod3.z.object({
+  protocol: import_zod3.z.literal("agentskit.chat.backend-metric"),
+  version: import_zod3.z.literal(1),
+  name: AskBackendMetricNameSchema,
+  siteId: SafeIdentifierSchema2,
+  corpusId: SafeIdentifierSchema2,
+  requestId: SafeIdentifierSchema2,
+  value: import_zod3.z.number().finite().nonnegative(),
+  unit: import_zod3.z.enum(["ms", "bytes", "count", "tokens", "usd"]),
+  outcome: import_zod3.z.enum(["ok", "rejected", "cancelled", "error"]),
+  emittedAt: import_zod3.z.string().datetime({ offset: true })
+}).strict().readonly();
+
 // src/index.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isBoundedJsonValue = (input) => {
@@ -441,46 +585,46 @@ var ASSISTANT_CONTENT_PREFIX = `${ASSISTANT_CONTENT_PROTOCOL}/${ASSISTANT_CONTE
 var ASSISTANT_CONTENT_PREFIX_ROOT = `${ASSISTANT_CONTENT_PROTOCOL}/`;
 var ASSISTANT_CONTENT_MAX_BYTES = 262144;
 var ASSISTANT_CONTENT_MAX_RECORDS = 512;
-var ComponentKeySchema = import_zod3.z.string().regex(/^[a-z][a-z0-9-]{0,63}$/);
-var ComponentFallbackSchema = import_zod3.z.object({
-  kind: import_zod3.z.string().min(1).max(64),
-  summary: import_zod3.z.string().min(1).max(4096)
+var ComponentKeySchema = import_zod4.z.string().regex(/^[a-z][a-z0-9-]{0,63}$/);
+var ComponentFallbackSchema = import_zod4.z.object({
+  kind: import_zod4.z.string().min(1).max(64),
+  summary: import_zod4.z.string().min(1).max(4096)
 }).readonly();
-var ComponentRenderFrameSchema = import_zod3.z.object({
-  protocol: import_zod3.z.literal(COMPONENT_PROTOCOL),
-  version: import_zod3.z.literal(COMPONENT_PROTOCOL_VERSION),
-  type: import_zod3.z.literal("render"),
+var ComponentRenderFrameSchema = import_zod4.z.object({
+  protocol: import_zod4.z.literal(COMPONENT_PROTOCOL),
+  version: import_zod4.z.literal(COMPONENT_PROTOCOL_VERSION),
+  type: import_zod4.z.literal("render"),
   componentKey: ComponentKeySchema,
-  instanceId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  props: import_zod3.z.unknown().refine(isBoundedJsonValue),
+  instanceId: import_zod4.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  props: import_zod4.z.unknown().refine(isBoundedJsonValue),
   fallback: ComponentFallbackSchema
 }).readonly();
-var ComponentSelectionEventSchema = import_zod3.z.object({
-  protocol: import_zod3.z.literal(COMPONENT_PROTOCOL),
-  version: import_zod3.z.literal(COMPONENT_PROTOCOL_VERSION),
-  type: import_zod3.z.literal("select"),
+var ComponentSelectionEventSchema = import_zod4.z.object({
+  protocol: import_zod4.z.literal(COMPONENT_PROTOCOL),
+  version: import_zod4.z.literal(COMPONENT_PROTOCOL_VERSION),
+  type: import_zod4.z.literal("select"),
   componentKey: ComponentKeySchema,
-  instanceId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  choiceId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)
+  instanceId: import_zod4.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  choiceId: import_zod4.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)
 }).readonly();
-var ComponentInteractionEventSchema = import_zod3.z.object({
-  protocol: import_zod3.z.literal(COMPONENT_PROTOCOL),
-  version: import_zod3.z.literal(COMPONENT_PROTOCOL_VERSION),
-  type: import_zod3.z.literal("interact"),
+var ComponentInteractionEventSchema = import_zod4.z.object({
+  protocol: import_zod4.z.literal(COMPONENT_PROTOCOL),
+  version: import_zod4.z.literal(COMPONENT_PROTOCOL_VERSION),
+  type: import_zod4.z.literal("interact"),
   componentKey: ComponentKeySchema,
-  instanceId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  event: import_zod3.z.string().regex(/^[a-z][a-z0-9-]{0,63}$/),
-  value: import_zod3.z.unknown().refine(isBoundedJsonValue).optional()
+  instanceId: import_zod4.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  event: import_zod4.z.string().regex(/^[a-z][a-z0-9-]{0,63}$/),
+  value: import_zod4.z.unknown().refine(isBoundedJsonValue).optional()
 }).readonly();
-var AssistantTextPartSchema = import_zod3.z.object({
-  kind: import_zod3.z.literal("text"),
-  text: import_zod3.z.string().min(1).max(16384)
+var AssistantTextPartSchema = import_zod4.z.object({
+  kind: import_zod4.z.literal("text"),
+  text: import_zod4.z.string().min(1).max(16384)
 }).readonly();
-var AssistantComponentPartSchema = import_zod3.z.object({
-  kind: import_zod3.z.literal("component"),
+var AssistantComponentPartSchema = import_zod4.z.object({
+  kind: import_zod4.z.literal("component"),
   frame: ComponentRenderFrameSchema
 }).readonly();
-var AssistantContentPartSchema = import_zod3.z.discriminatedUnion("kind", [AssistantTextPartSchema, AssistantComponentPartSchema]);
+var AssistantContentPartSchema = import_zod4.z.discriminatedUnion("kind", [AssistantTextPartSchema, AssistantComponentPartSchema]);
 var createAssistantContentEncoder = () => {
   let started = false;
   return {
@@ -602,63 +746,63 @@ var createInteractionEvent = (frame, event, value) => ComponentInteractionEventS
   event,
   ...value === void 0 ? {} : { value }
 });
-var TokenUsageSchema = import_zod3.z.object({
-  promptTokens: import_zod3.z.number().int().nonnegative(),
-  completionTokens: import_zod3.z.number().int().nonnegative(),
-  totalTokens: import_zod3.z.number().int().nonnegative()
+var TokenUsageSchema = import_zod4.z.object({
+  promptTokens: import_zod4.z.number().int().nonnegative(),
+  completionTokens: import_zod4.z.number().int().nonnegative(),
+  totalTokens: import_zod4.z.number().int().nonnegative()
 });
-var TurnDiagnosticSchema = import_zod3.z.object({
-  version: import_zod3.z.literal(1),
-  code: import_zod3.z.string().regex(/^[A-Z][A-Z0-9_]*$/),
-  message: import_zod3.z.string().min(1),
-  retryable: import_zod3.z.boolean()
+var TurnDiagnosticSchema = import_zod4.z.object({
+  version: import_zod4.z.literal(1),
+  code: import_zod4.z.string().regex(/^[A-Z][A-Z0-9_]*$/),
+  message: import_zod4.z.string().min(1),
+  retryable: import_zod4.z.boolean()
 });
-var SafeIdentifierSchema2 = import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var SafeIdentifierSchema3 = import_zod4.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
 var EnvelopeFields = {
-  protocol: import_zod3.z.literal(TURN_PROTOCOL),
-  version: import_zod3.z.literal(TURN_PROTOCOL_VERSION),
-  eventId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  sessionId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  turnId: import_zod3.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  sequence: import_zod3.z.number().int().nonnegative(),
-  emittedAt: import_zod3.z.string().datetime({ offset: true })
+  protocol: import_zod4.z.literal(TURN_PROTOCOL),
+  version: import_zod4.z.literal(TURN_PROTOCOL_VERSION),
+  eventId: import_zod4.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  sessionId: import_zod4.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  turnId: import_zod4.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  sequence: import_zod4.z.number().int().nonnegative(),
+  emittedAt: import_zod4.z.string().datetime({ offset: true })
 };
-var MemoryMessagesSchema = import_zod3.z.array(import_zod3.z.unknown()).transform((messages, context) => {
+var MemoryMessagesSchema = import_zod4.z.array(import_zod4.z.unknown()).transform((messages, context) => {
   try {
     return (0, import_memory_validation.validateMemoryRecord)({ version: 1, messages }).messages;
   } catch {
     context.addIssue({ code: "custom", message: "Messages are not a valid AgentsKit memory record." });
-    return import_zod3.z.NEVER;
+    return import_zod4.z.NEVER;
   }
 });
-var TurnLineageSchema = import_zod3.z.discriminatedUnion("operation", [
-  import_zod3.z.object({ operation: import_zod3.z.literal("submit") }),
-  import_zod3.z.object({ operation: import_zod3.z.enum(["retry", "edit", "regenerate"]), parentTurnId: SafeIdentifierSchema2, sourceMessageId: SafeIdentifierSchema2 })
+var TurnLineageSchema = import_zod4.z.discriminatedUnion("operation", [
+  import_zod4.z.object({ operation: import_zod4.z.literal("submit") }),
+  import_zod4.z.object({ operation: import_zod4.z.enum(["retry", "edit", "regenerate"]), parentTurnId: SafeIdentifierSchema3, sourceMessageId: SafeIdentifierSchema3 })
 ]);
-var SubmitEventSchema = import_zod3.z.object({
+var SubmitEventSchema = import_zod4.z.object({
   ...EnvelopeFields,
-  event: import_zod3.z.literal("client.turn.submit"),
-  payload: import_zod3.z.object({
-    input: import_zod3.z.string().min(1).refine((value) => value.trim().length > 0)
+  event: import_zod4.z.literal("client.turn.submit"),
+  payload: import_zod4.z.object({
+    input: import_zod4.z.string().min(1).refine((value) => value.trim().length > 0)
   })
 });
-var SnapshotEventSchema = import_zod3.z.object({
+var SnapshotEventSchema = import_zod4.z.object({
   ...EnvelopeFields,
-  event: import_zod3.z.literal("server.turn.snapshot"),
-  payload: import_zod3.z.object({
+  event: import_zod4.z.literal("server.turn.snapshot"),
+  payload: import_zod4.z.object({
     messages: MemoryMessagesSchema,
-    status: import_zod3.z.enum(["idle", "streaming", "complete", "error"]),
+    status: import_zod4.z.enum(["idle", "streaming", "complete", "error"]),
     usage: TokenUsageSchema,
     error: TurnDiagnosticSchema.optional(),
     lineage: TurnLineageSchema.optional()
   })
 });
-var DiagnosticEventSchema = import_zod3.z.object({
+var DiagnosticEventSchema = import_zod4.z.object({
   ...EnvelopeFields,
-  event: import_zod3.z.literal("server.turn.diagnostic"),
+  event: import_zod4.z.literal("server.turn.diagnostic"),
   payload: TurnDiagnosticSchema
 });
-var TurnEventSchema = import_zod3.z.discriminatedUnion("event", [
+var TurnEventSchema = import_zod4.z.discriminatedUnion("event", [
   SubmitEventSchema,
   SnapshotEventSchema,
   DiagnosticEventSchema
@@ -686,7 +830,7 @@ var createSnapshotEvent = (options) => SnapshotEventSchema.parse({
   }
 });
 var createTurnSnapshotCursor = (sessionId) => {
-  const expectedSessionId = SafeIdentifierSchema2.parse(sessionId);
+  const expectedSessionId = SafeIdentifierSchema3.parse(sessionId);
   let snapshot;
   return {
     apply(input) {
@@ -704,7 +848,7 @@ var eventNames = /* @__PURE__ */ new Set(["client.turn.submit", "server.turn.sna
 var safeEventId = (input) => {
   try {
     if (!isRecord(input)) return void 0;
-    const parsed = SafeIdentifierSchema2.safeParse(input.eventId);
+    const parsed = SafeIdentifierSchema3.safeParse(input.eventId);
     return parsed.success ? parsed.data : void 0;
   } catch {
     return void 0;
@@ -759,22 +903,22 @@ var snapshotMessages = (event) => {
 };
 var SESSION_PROTOCOL = "agentskit.chat.session";
 var SESSION_PROTOCOL_VERSION = 1;
-var SessionDecisionSchema = import_zod3.z.object({
-  messageId: SafeIdentifierSchema2,
-  input: import_zod3.z.string().max(16384),
-  routeId: SafeIdentifierSchema2,
-  kind: import_zod3.z.enum(["deterministic", "repaired", "fallback"]),
-  content: import_zod3.z.string().max(65536),
-  fromState: import_zod3.z.string().min(1).max(128),
-  toState: import_zod3.z.string().min(1).max(128)
+var SessionDecisionSchema = import_zod4.z.object({
+  messageId: SafeIdentifierSchema3,
+  input: import_zod4.z.string().max(16384),
+  routeId: SafeIdentifierSchema3,
+  kind: import_zod4.z.enum(["deterministic", "repaired", "fallback"]),
+  content: import_zod4.z.string().max(65536),
+  fromState: import_zod4.z.string().min(1).max(128),
+  toState: import_zod4.z.string().min(1).max(128)
 }).readonly();
-var SessionConfirmationSchema = import_zod3.z.object({
-  token: SafeIdentifierSchema2,
-  action: SafeIdentifierSchema2,
-  input: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).refine(isBoundedJsonValue),
-  toolCallId: SafeIdentifierSchema2,
-  expiresAt: import_zod3.z.number().int().nonnegative(),
-  status: import_zod3.z.enum(["pending", "approving", "rejecting", "expiring", "approved", "rejected", "expired"])
+var SessionConfirmationSchema = import_zod4.z.object({
+  token: SafeIdentifierSchema3,
+  action: SafeIdentifierSchema3,
+  input: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).refine(isBoundedJsonValue),
+  toolCallId: SafeIdentifierSchema3,
+  expiresAt: import_zod4.z.number().int().nonnegative(),
+  status: import_zod4.z.enum(["pending", "approving", "rejecting", "expiring", "approved", "rejected", "expired"])
 }).readonly();
 var uniqueBy = (items, key, context, path) => {
   const seen = /* @__PURE__ */ new Set();
@@ -784,29 +928,29 @@ var uniqueBy = (items, key, context, path) => {
     seen.add(value);
   });
 };
-var SessionDecisionsSchema = import_zod3.z.array(SessionDecisionSchema).max(1e3).superRefine((items, context) => uniqueBy(items, (item) => item.messageId, context, "messageId"));
-var SessionConfirmationsSchema = import_zod3.z.array(SessionConfirmationSchema).max(1e3).superRefine((items, context) => {
+var SessionDecisionsSchema = import_zod4.z.array(SessionDecisionSchema).max(1e3).superRefine((items, context) => uniqueBy(items, (item) => item.messageId, context, "messageId"));
+var SessionConfirmationsSchema = import_zod4.z.array(SessionConfirmationSchema).max(1e3).superRefine((items, context) => {
   uniqueBy(items, (item) => item.token, context, "token");
   uniqueBy(items, (item) => item.toolCallId, context, "toolCallId");
 });
-var SessionSnapshotObjectSchema = import_zod3.z.object({
-  protocol: import_zod3.z.literal(SESSION_PROTOCOL),
-  version: import_zod3.z.literal(SESSION_PROTOCOL_VERSION),
-  sessionId: SafeIdentifierSchema2,
-  definitionId: SafeIdentifierSchema2,
-  definitionRevision: import_zod3.z.number().int().positive(),
-  updatedAt: import_zod3.z.string().datetime({ offset: true }),
-  cursor: import_zod3.z.number().int().nonnegative(),
-  activeTurn: import_zod3.z.object({ turnId: SafeIdentifierSchema2, expiresAt: import_zod3.z.number().int().nonnegative() }).readonly().optional(),
-  terminalTurns: import_zod3.z.array(import_zod3.z.object({ turnId: SafeIdentifierSchema2, outcome: import_zod3.z.enum(["completed", "indeterminate"]) }).readonly()).max(64).superRefine((items, context) => uniqueBy(items, (item) => item.turnId, context, "turnId")).readonly().optional(),
-  conversation: import_zod3.z.object({
-    state: import_zod3.z.string().min(1).max(128),
+var SessionSnapshotObjectSchema = import_zod4.z.object({
+  protocol: import_zod4.z.literal(SESSION_PROTOCOL),
+  version: import_zod4.z.literal(SESSION_PROTOCOL_VERSION),
+  sessionId: SafeIdentifierSchema3,
+  definitionId: SafeIdentifierSchema3,
+  definitionRevision: import_zod4.z.number().int().positive(),
+  updatedAt: import_zod4.z.string().datetime({ offset: true }),
+  cursor: import_zod4.z.number().int().nonnegative(),
+  activeTurn: import_zod4.z.object({ turnId: SafeIdentifierSchema3, expiresAt: import_zod4.z.number().int().nonnegative() }).readonly().optional(),
+  terminalTurns: import_zod4.z.array(import_zod4.z.object({ turnId: SafeIdentifierSchema3, outcome: import_zod4.z.enum(["completed", "indeterminate"]) }).readonly()).max(64).superRefine((items, context) => uniqueBy(items, (item) => item.turnId, context, "turnId")).readonly().optional(),
+  conversation: import_zod4.z.object({
+    state: import_zod4.z.string().min(1).max(128),
     decisions: SessionDecisionsSchema
   }).readonly().optional(),
   confirmations: SessionConfirmationsSchema
 });
 var SessionSnapshotSchema = SessionSnapshotObjectSchema.readonly();
-var LegacySessionSnapshotSchema = SessionSnapshotObjectSchema.omit({ protocol: true, version: true }).extend({ version: import_zod3.z.literal(0) });
+var LegacySessionSnapshotSchema = SessionSnapshotObjectSchema.omit({ protocol: true, version: true }).extend({ version: import_zod4.z.literal(0) });
 var decodeSessionSnapshot = (input) => {
   let candidate = input;
   if (typeof input === "string") {
@@ -834,6 +978,11 @@ var decodeSessionSnapshot = (input) => {
   ANSWER_MAX_SUGGESTIONS,
   ANSWER_PROTOCOL,
   ANSWER_PROTOCOL_VERSION,
+  ASK_BACKEND_MAX_MESSAGES,
+  ASK_BACKEND_MAX_MESSAGE_CHARS,
+  ASK_BACKEND_MAX_SOURCES,
+  ASK_BACKEND_PROTOCOL,
+  ASK_BACKEND_PROTOCOL_VERSION,
   ASK_EVENT_MAX_BYTES,
   ASK_EVENT_MAX_RECORDS,
   ASK_SERVICE_PROTOCOL_VERSION,
@@ -846,6 +995,15 @@ var decodeSessionSnapshot = (input) => {
   AnswerConfidenceSchema,
   AnswerResponseSchema,
   AnswerSuggestionSchema,
+  AskBackendDiagnosticSchema,
+  AskBackendMessageSchema,
+  AskBackendMetricNameSchema,
+  AskBackendMetricSchema,
+  AskBackendRequestSchema,
+  AskBackendSessionRecordSchema,
+  AskBackendSiteConfigSchema,
+  AskBackendSourceSchema,
+  AskBackendUsageSchema,
   AskEventSchema,
   AssistantComponentPartSchema,
   AssistantContentPartSchema,