@agentskit/chat-protocol 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
 import { deserializeMessages, serializeMessages } from "@agentskit/core";
 import { validateMemoryRecord } from "@agentskit/core/memory-validation";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/ask.ts
 import { z } from "zod";
@@ -13,7 +13,12 @@ var AskEventSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("text"), delta: z.string().max(ASK_EVENT_MAX_BYTES) }).strict(),
   z.object({ type: z.literal("tool"), id: z.string().max(256), name: z.string().max(128), args: AskArgsSchema }).strict(),
   z.object({ type: z.literal("done"), model: z.string().max(256).optional() }).strict(),
-  z.object({ type: z.literal("error"), message: z.string().min(1).max(4096) }).strict()
+  z.object({
+    type: z.literal("error"),
+    message: z.string().min(1).max(4096),
+    code: z.string().regex(/^[A-Z][A-Z0-9_]{0,127}$/).optional(),
+    retryable: z.boolean().optional()
+  }).strict()
 ]);
 var byteLength = (value) => new TextEncoder().encode(value).byteLength;
 function decodeAskEvents(buffer) {
@@ -43,6 +48,9 @@ function decodeAskEvents(buffer) {
   return { events: Object.freeze(events), rest: discardedPartial ? "" : partial, discardedPartial };
 }
 
+// src/backend.ts
+import { z as z3 } from "zod";
+
 // src/deterministic.ts
 import { sha256 } from "@noble/hashes/sha2.js";
 import { bytesToHex } from "@noble/hashes/utils.js";
@@ -313,6 +321,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 = z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var SafeLabelSchema = z3.string().trim().min(1).max(256);
+var SafeHrefSchema2 = z3.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 = z3.object({
+  role: z3.enum(["user", "assistant"]),
+  content: z3.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 = z3.object({
+  protocol: z3.literal(ASK_BACKEND_PROTOCOL).optional(),
+  version: z3.literal(ASK_BACKEND_PROTOCOL_VERSION).optional(),
+  sessionId: SafeIdentifierSchema2.optional(),
+  messages: z3.array(AskBackendMessageSchema).min(1).max(ASK_BACKEND_MAX_MESSAGES).readonly(),
+  deterministic: DeterministicEscalationSchema.optional()
+}).strict().readonly();
+var AskBackendSourceSchema = z3.object({
+  id: SafeIdentifierSchema2,
+  title: SafeLabelSchema,
+  href: SafeHrefSchema2,
+  excerpt: z3.string().trim().min(1).max(4096)
+}).strict().readonly();
+var AskBackendSiteConfigSchema = z3.object({
+  protocol: z3.literal("agentskit.chat.backend-site"),
+  version: z3.literal(1),
+  siteId: SafeIdentifierSchema2,
+  assistant: z3.object({
+    id: SafeIdentifierSchema2,
+    name: SafeLabelSchema,
+    suggestions: z3.array(SafeLabelSchema).max(8).readonly()
+  }).strict().readonly(),
+  corpus: z3.object({
+    id: SafeIdentifierSchema2,
+    mode: z3.enum(["local", "federated"])
+  }).strict().readonly(),
+  components: z3.array(SafeIdentifierSchema2).max(64).readonly(),
+  actions: z3.array(SafeIdentifierSchema2).max(64).readonly(),
+  limits: z3.object({
+    requestTimeoutMs: z3.number().int().min(100).max(12e4),
+    retrievalTimeoutMs: z3.number().int().min(100).max(6e4),
+    generationTimeoutMs: z3.number().int().min(100).max(12e4),
+    maxSources: z3.number().int().min(1).max(ASK_BACKEND_MAX_SOURCES)
+  }).strict().readonly(),
+  persistence: z3.object({ mode: z3.enum(["required", "disabled"]) }).strict().readonly()
+}).strict().readonly();
+var AskBackendUsageSchema = z3.object({
+  inputTokens: z3.number().int().nonnegative().optional(),
+  outputTokens: z3.number().int().nonnegative().optional(),
+  totalTokens: z3.number().int().nonnegative().optional(),
+  costUsd: z3.number().nonnegative().finite().optional(),
+  model: z3.string().trim().min(1).max(256).optional()
+}).strict().readonly();
+var AskBackendSessionRecordSchema = z3.object({
+  revision: z3.number().int().nonnegative(),
+  messages: z3.array(AskBackendMessageSchema).max(ASK_BACKEND_MAX_MESSAGES).readonly()
+}).strict().readonly();
+var AskBackendDiagnosticSchema = z3.object({
+  code: z3.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: z3.string().trim().min(1).max(4096),
+  retryable: z3.boolean()
+}).strict().readonly();
+var AskBackendMetricNameSchema = z3.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 = z3.object({
+  protocol: z3.literal("agentskit.chat.backend-metric"),
+  version: z3.literal(1),
+  name: AskBackendMetricNameSchema,
+  siteId: SafeIdentifierSchema2,
+  corpusId: SafeIdentifierSchema2,
+  requestId: SafeIdentifierSchema2,
+  value: z3.number().finite().nonnegative(),
+  unit: z3.enum(["ms", "bytes", "count", "tokens", "usd"]),
+  outcome: z3.enum(["ok", "rejected", "cancelled", "error"]),
+  emittedAt: z3.string().datetime({ offset: true })
+}).strict().readonly();
+
 // src/index.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isBoundedJsonValue = (input) => {
@@ -349,46 +479,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 = z3.string().regex(/^[a-z][a-z0-9-]{0,63}$/);
-var ComponentFallbackSchema = z3.object({
-  kind: z3.string().min(1).max(64),
-  summary: z3.string().min(1).max(4096)
+var ComponentKeySchema = z4.string().regex(/^[a-z][a-z0-9-]{0,63}$/);
+var ComponentFallbackSchema = z4.object({
+  kind: z4.string().min(1).max(64),
+  summary: z4.string().min(1).max(4096)
 }).readonly();
-var ComponentRenderFrameSchema = z3.object({
-  protocol: z3.literal(COMPONENT_PROTOCOL),
-  version: z3.literal(COMPONENT_PROTOCOL_VERSION),
-  type: z3.literal("render"),
+var ComponentRenderFrameSchema = z4.object({
+  protocol: z4.literal(COMPONENT_PROTOCOL),
+  version: z4.literal(COMPONENT_PROTOCOL_VERSION),
+  type: z4.literal("render"),
   componentKey: ComponentKeySchema,
-  instanceId: z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  props: z3.unknown().refine(isBoundedJsonValue),
+  instanceId: z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  props: z4.unknown().refine(isBoundedJsonValue),
   fallback: ComponentFallbackSchema
 }).readonly();
-var ComponentSelectionEventSchema = z3.object({
-  protocol: z3.literal(COMPONENT_PROTOCOL),
-  version: z3.literal(COMPONENT_PROTOCOL_VERSION),
-  type: z3.literal("select"),
+var ComponentSelectionEventSchema = z4.object({
+  protocol: z4.literal(COMPONENT_PROTOCOL),
+  version: z4.literal(COMPONENT_PROTOCOL_VERSION),
+  type: z4.literal("select"),
   componentKey: ComponentKeySchema,
-  instanceId: z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  choiceId: z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)
+  instanceId: z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  choiceId: z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)
 }).readonly();
-var ComponentInteractionEventSchema = z3.object({
-  protocol: z3.literal(COMPONENT_PROTOCOL),
-  version: z3.literal(COMPONENT_PROTOCOL_VERSION),
-  type: z3.literal("interact"),
+var ComponentInteractionEventSchema = z4.object({
+  protocol: z4.literal(COMPONENT_PROTOCOL),
+  version: z4.literal(COMPONENT_PROTOCOL_VERSION),
+  type: z4.literal("interact"),
   componentKey: ComponentKeySchema,
-  instanceId: z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  event: z3.string().regex(/^[a-z][a-z0-9-]{0,63}$/),
-  value: z3.unknown().refine(isBoundedJsonValue).optional()
+  instanceId: z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  event: z4.string().regex(/^[a-z][a-z0-9-]{0,63}$/),
+  value: z4.unknown().refine(isBoundedJsonValue).optional()
 }).readonly();
-var AssistantTextPartSchema = z3.object({
-  kind: z3.literal("text"),
-  text: z3.string().min(1).max(16384)
+var AssistantTextPartSchema = z4.object({
+  kind: z4.literal("text"),
+  text: z4.string().min(1).max(16384)
 }).readonly();
-var AssistantComponentPartSchema = z3.object({
-  kind: z3.literal("component"),
+var AssistantComponentPartSchema = z4.object({
+  kind: z4.literal("component"),
   frame: ComponentRenderFrameSchema
 }).readonly();
-var AssistantContentPartSchema = z3.discriminatedUnion("kind", [AssistantTextPartSchema, AssistantComponentPartSchema]);
+var AssistantContentPartSchema = z4.discriminatedUnion("kind", [AssistantTextPartSchema, AssistantComponentPartSchema]);
 var createAssistantContentEncoder = () => {
   let started = false;
   return {
@@ -510,63 +640,63 @@ var createInteractionEvent = (frame, event, value) => ComponentInteractionEventS
   event,
   ...value === void 0 ? {} : { value }
 });
-var TokenUsageSchema = z3.object({
-  promptTokens: z3.number().int().nonnegative(),
-  completionTokens: z3.number().int().nonnegative(),
-  totalTokens: z3.number().int().nonnegative()
+var TokenUsageSchema = z4.object({
+  promptTokens: z4.number().int().nonnegative(),
+  completionTokens: z4.number().int().nonnegative(),
+  totalTokens: z4.number().int().nonnegative()
 });
-var TurnDiagnosticSchema = z3.object({
-  version: z3.literal(1),
-  code: z3.string().regex(/^[A-Z][A-Z0-9_]*$/),
-  message: z3.string().min(1),
-  retryable: z3.boolean()
+var TurnDiagnosticSchema = z4.object({
+  version: z4.literal(1),
+  code: z4.string().regex(/^[A-Z][A-Z0-9_]*$/),
+  message: z4.string().min(1),
+  retryable: z4.boolean()
 });
-var SafeIdentifierSchema2 = z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var SafeIdentifierSchema3 = z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
 var EnvelopeFields = {
-  protocol: z3.literal(TURN_PROTOCOL),
-  version: z3.literal(TURN_PROTOCOL_VERSION),
-  eventId: z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  sessionId: z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  turnId: z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
-  sequence: z3.number().int().nonnegative(),
-  emittedAt: z3.string().datetime({ offset: true })
+  protocol: z4.literal(TURN_PROTOCOL),
+  version: z4.literal(TURN_PROTOCOL_VERSION),
+  eventId: z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  sessionId: z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  turnId: z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  sequence: z4.number().int().nonnegative(),
+  emittedAt: z4.string().datetime({ offset: true })
 };
-var MemoryMessagesSchema = z3.array(z3.unknown()).transform((messages, context) => {
+var MemoryMessagesSchema = z4.array(z4.unknown()).transform((messages, context) => {
   try {
     return validateMemoryRecord({ version: 1, messages }).messages;
   } catch {
     context.addIssue({ code: "custom", message: "Messages are not a valid AgentsKit memory record." });
-    return z3.NEVER;
+    return z4.NEVER;
   }
 });
-var TurnLineageSchema = z3.discriminatedUnion("operation", [
-  z3.object({ operation: z3.literal("submit") }),
-  z3.object({ operation: z3.enum(["retry", "edit", "regenerate"]), parentTurnId: SafeIdentifierSchema2, sourceMessageId: SafeIdentifierSchema2 })
+var TurnLineageSchema = z4.discriminatedUnion("operation", [
+  z4.object({ operation: z4.literal("submit") }),
+  z4.object({ operation: z4.enum(["retry", "edit", "regenerate"]), parentTurnId: SafeIdentifierSchema3, sourceMessageId: SafeIdentifierSchema3 })
 ]);
-var SubmitEventSchema = z3.object({
+var SubmitEventSchema = z4.object({
   ...EnvelopeFields,
-  event: z3.literal("client.turn.submit"),
-  payload: z3.object({
-    input: z3.string().min(1).refine((value) => value.trim().length > 0)
+  event: z4.literal("client.turn.submit"),
+  payload: z4.object({
+    input: z4.string().min(1).refine((value) => value.trim().length > 0)
   })
 });
-var SnapshotEventSchema = z3.object({
+var SnapshotEventSchema = z4.object({
   ...EnvelopeFields,
-  event: z3.literal("server.turn.snapshot"),
-  payload: z3.object({
+  event: z4.literal("server.turn.snapshot"),
+  payload: z4.object({
     messages: MemoryMessagesSchema,
-    status: z3.enum(["idle", "streaming", "complete", "error"]),
+    status: z4.enum(["idle", "streaming", "complete", "error"]),
     usage: TokenUsageSchema,
     error: TurnDiagnosticSchema.optional(),
     lineage: TurnLineageSchema.optional()
   })
 });
-var DiagnosticEventSchema = z3.object({
+var DiagnosticEventSchema = z4.object({
   ...EnvelopeFields,
-  event: z3.literal("server.turn.diagnostic"),
+  event: z4.literal("server.turn.diagnostic"),
   payload: TurnDiagnosticSchema
 });
-var TurnEventSchema = z3.discriminatedUnion("event", [
+var TurnEventSchema = z4.discriminatedUnion("event", [
   SubmitEventSchema,
   SnapshotEventSchema,
   DiagnosticEventSchema
@@ -594,7 +724,7 @@ var createSnapshotEvent = (options) => SnapshotEventSchema.parse({
   }
 });
 var createTurnSnapshotCursor = (sessionId) => {
-  const expectedSessionId = SafeIdentifierSchema2.parse(sessionId);
+  const expectedSessionId = SafeIdentifierSchema3.parse(sessionId);
   let snapshot;
   return {
     apply(input) {
@@ -612,7 +742,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;
@@ -667,22 +797,22 @@ var snapshotMessages = (event) => {
 };
 var SESSION_PROTOCOL = "agentskit.chat.session";
 var SESSION_PROTOCOL_VERSION = 1;
-var SessionDecisionSchema = z3.object({
-  messageId: SafeIdentifierSchema2,
-  input: z3.string().max(16384),
-  routeId: SafeIdentifierSchema2,
-  kind: z3.enum(["deterministic", "repaired", "fallback"]),
-  content: z3.string().max(65536),
-  fromState: z3.string().min(1).max(128),
-  toState: z3.string().min(1).max(128)
+var SessionDecisionSchema = z4.object({
+  messageId: SafeIdentifierSchema3,
+  input: z4.string().max(16384),
+  routeId: SafeIdentifierSchema3,
+  kind: z4.enum(["deterministic", "repaired", "fallback"]),
+  content: z4.string().max(65536),
+  fromState: z4.string().min(1).max(128),
+  toState: z4.string().min(1).max(128)
 }).readonly();
-var SessionConfirmationSchema = z3.object({
-  token: SafeIdentifierSchema2,
-  action: SafeIdentifierSchema2,
-  input: z3.record(z3.string(), z3.unknown()).refine(isBoundedJsonValue),
-  toolCallId: SafeIdentifierSchema2,
-  expiresAt: z3.number().int().nonnegative(),
-  status: z3.enum(["pending", "approving", "rejecting", "expiring", "approved", "rejected", "expired"])
+var SessionConfirmationSchema = z4.object({
+  token: SafeIdentifierSchema3,
+  action: SafeIdentifierSchema3,
+  input: z4.record(z4.string(), z4.unknown()).refine(isBoundedJsonValue),
+  toolCallId: SafeIdentifierSchema3,
+  expiresAt: z4.number().int().nonnegative(),
+  status: z4.enum(["pending", "approving", "rejecting", "expiring", "approved", "rejected", "expired"])
 }).readonly();
 var uniqueBy = (items, key, context, path) => {
   const seen = /* @__PURE__ */ new Set();
@@ -692,29 +822,29 @@ var uniqueBy = (items, key, context, path) => {
     seen.add(value);
   });
 };
-var SessionDecisionsSchema = z3.array(SessionDecisionSchema).max(1e3).superRefine((items, context) => uniqueBy(items, (item) => item.messageId, context, "messageId"));
-var SessionConfirmationsSchema = z3.array(SessionConfirmationSchema).max(1e3).superRefine((items, context) => {
+var SessionDecisionsSchema = z4.array(SessionDecisionSchema).max(1e3).superRefine((items, context) => uniqueBy(items, (item) => item.messageId, context, "messageId"));
+var SessionConfirmationsSchema = z4.array(SessionConfirmationSchema).max(1e3).superRefine((items, context) => {
   uniqueBy(items, (item) => item.token, context, "token");
   uniqueBy(items, (item) => item.toolCallId, context, "toolCallId");
 });
-var SessionSnapshotObjectSchema = z3.object({
-  protocol: z3.literal(SESSION_PROTOCOL),
-  version: z3.literal(SESSION_PROTOCOL_VERSION),
-  sessionId: SafeIdentifierSchema2,
-  definitionId: SafeIdentifierSchema2,
-  definitionRevision: z3.number().int().positive(),
-  updatedAt: z3.string().datetime({ offset: true }),
-  cursor: z3.number().int().nonnegative(),
-  activeTurn: z3.object({ turnId: SafeIdentifierSchema2, expiresAt: z3.number().int().nonnegative() }).readonly().optional(),
-  terminalTurns: z3.array(z3.object({ turnId: SafeIdentifierSchema2, outcome: z3.enum(["completed", "indeterminate"]) }).readonly()).max(64).superRefine((items, context) => uniqueBy(items, (item) => item.turnId, context, "turnId")).readonly().optional(),
-  conversation: z3.object({
-    state: z3.string().min(1).max(128),
+var SessionSnapshotObjectSchema = z4.object({
+  protocol: z4.literal(SESSION_PROTOCOL),
+  version: z4.literal(SESSION_PROTOCOL_VERSION),
+  sessionId: SafeIdentifierSchema3,
+  definitionId: SafeIdentifierSchema3,
+  definitionRevision: z4.number().int().positive(),
+  updatedAt: z4.string().datetime({ offset: true }),
+  cursor: z4.number().int().nonnegative(),
+  activeTurn: z4.object({ turnId: SafeIdentifierSchema3, expiresAt: z4.number().int().nonnegative() }).readonly().optional(),
+  terminalTurns: z4.array(z4.object({ turnId: SafeIdentifierSchema3, outcome: z4.enum(["completed", "indeterminate"]) }).readonly()).max(64).superRefine((items, context) => uniqueBy(items, (item) => item.turnId, context, "turnId")).readonly().optional(),
+  conversation: z4.object({
+    state: z4.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: z3.literal(0) });
+var LegacySessionSnapshotSchema = SessionSnapshotObjectSchema.omit({ protocol: true, version: true }).extend({ version: z4.literal(0) });
 var decodeSessionSnapshot = (input) => {
   let candidate = input;
   if (typeof input === "string") {
@@ -741,6 +871,11 @@ export {
   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,
@@ -753,6 +888,15 @@ export {
   AnswerConfidenceSchema,
   AnswerResponseSchema,
   AnswerSuggestionSchema,
+  AskBackendDiagnosticSchema,
+  AskBackendMessageSchema,
+  AskBackendMetricNameSchema,
+  AskBackendMetricSchema,
+  AskBackendRequestSchema,
+  AskBackendSessionRecordSchema,
+  AskBackendSiteConfigSchema,
+  AskBackendSourceSchema,
+  AskBackendUsageSchema,
   AskEventSchema,
   AssistantComponentPartSchema,
   AssistantContentPartSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentskit/chat-protocol",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Versioned turn protocol for AgentsKit Chat.",
   "license": "MIT",
   "repository": {