@oddkin/ai 0.0.0-stage → 1.0.0-beta.1

package/dist/prod/contracts/models.js

@@ -0,0 +1,325 @@
+import { defineModel, m } from "@oddkin/core/model";
+const timestamp = () => m.optional(m.string({ description: "ISO 8601 timestamp." })), publicErrorSchema = m.object({
+  code: m.string({ minLength: 1, description: "Stable application-defined code." }),
+  message: m.string({ description: "User-presentable message, localized by the host." }),
+  retryable: m.optional(m.boolean("Whether retrying the same operation may succeed."))
+}, "An error safe to show to users. Diagnostic details stay in host logs."), capabilitySchema = m.object({
+  available: m.boolean("Whether the action is supported and allowed now."),
+  reason: m.optional(m.string({ description: "Why the action is unavailable, for users." }))
+}), capabilitiesSchema = m.object({
+  send: m.optional(capabilitySchema),
+  stop: m.optional(capabilitySchema),
+  disconnect: m.optional(capabilitySchema),
+  reconnect: m.optional(capabilitySchema),
+  resume: m.optional(capabilitySchema),
+  retry: m.optional(capabilitySchema),
+  edit: m.optional(capabilitySchema),
+  regenerate: m.optional(capabilitySchema),
+  switchBranch: m.optional(capabilitySchema),
+  respondToApproval: m.optional(capabilitySchema),
+  editApproval: m.optional(capabilitySchema),
+  restoreCheckpoint: m.optional(capabilitySchema),
+  voice: m.optional(capabilitySchema),
+  attachments: m.optional(capabilitySchema),
+  history: m.optional(capabilitySchema),
+  feedback: m.optional(capabilitySchema)
+}, "Actions the adapter and application actually support. Absent means unavailable."), textBody = {
+  id: m.id("Stable part id."),
+  text: m.string({ description: "Canonical source text (Markdown for assistant text)." }),
+  state: m.optional(m.enum(["streaming", "done"], "Whether more text may arrive."))
+}, partSchema = m.union("type", {
+  text: m.object(textBody),
+  reasoning: m.object(textBody),
+  file: m.object({
+    id: m.id(),
+    name: m.string({ description: "Untrusted file name; rendered as text." }),
+    mediaType: m.string(),
+    url: m.optional(m.url("Where the file can be fetched; checked by the URL policy.")),
+    size: m.optional(m.number({ integer: !0, minimum: 0, description: "Bytes." }))
+  }),
+  source: m.object({
+    id: m.id(),
+    sourceId: m.id("Citation key referenced from text as [^sourceId]."),
+    title: m.optional(m.string()),
+    url: m.optional(m.url()),
+    excerpt: m.optional(m.string()),
+    publisher: m.optional(m.string()),
+    kind: m.optional(m.enum(["web", "document", "file", "other"]))
+  }),
+  "tool-call": m.object({
+    id: m.id(),
+    toolCallId: m.id("Key of the tool call record; its state lives there.")
+  }),
+  approval: m.object({ id: m.id(), approvalId: m.id("Key of the approval record.") }),
+  artifact: m.object({
+    id: m.id(),
+    artifactId: m.id("Key of the artifact record."),
+    revisionId: m.optional(m.id("Revision this message produced."))
+  }),
+  data: m.object({
+    id: m.id(),
+    name: m.string({ minLength: 1, description: "Renderer registry key." }),
+    data: m.json({ description: "Validated by the registered renderer before use." })
+  }),
+  unsupported: m.object({
+    id: m.id(),
+    originalType: m.string({ description: "Type that could not be rendered." })
+  })
+}), provenanceSchema = m.object({
+  kind: m.enum(["generated", "assisted", "edited", "human"], "How the content was produced."),
+  label: m.optional(m.string({ description: "Host-supplied visible label." })),
+  model: m.optional(m.string()),
+  provider: m.optional(m.string()),
+  generatedAt: timestamp(),
+  notes: m.optional(m.string({ description: "Host-supplied explanation, shown as is." }))
+}, "Application-supplied origin information. Displayed as supplied, never verified."), MessageModel = defineModel("oddkin.ai.message", {
+  version: 1,
+  description: "One message. Parts are ordered; ids are stable across updates.",
+  schema: m.object({
+    id: m.id(),
+    role: m.enum(["user", "assistant", "system", "tool"]),
+    parentId: m.optional(m.id("Previous message on this branch; siblings are alternatives.")),
+    parts: m.array(partSchema),
+    attemptId: m.optional(m.id("Attempt that produced an assistant message.")),
+    createdAt: timestamp(),
+    provenance: m.optional(provenanceSchema)
+  })
+}), toolStatus = m.enum([
+  "input-streaming",
+  "input-available",
+  "awaiting-approval",
+  "executing",
+  "output-available",
+  "output-error",
+  "denied",
+  "cancelled"
+], "Argument generation, approval, and execution are separate states."), ToolCallModel = defineModel("oddkin.ai.tool-call", {
+  version: 1,
+  schema: m.object({
+    toolCallId: m.id(),
+    attemptId: m.optional(m.id()),
+    toolName: m.string({ minLength: 1 }),
+    title: m.optional(m.string({ description: "Human-readable tool name." })),
+    purpose: m.optional(m.string({ description: "Why the tool is being used." })),
+    status: toolStatus,
+    inputText: m.optional(m.string({ description: "Streamed argument text, possibly partial." })),
+    input: m.optional(m.json({ description: "Complete arguments." })),
+    output: m.optional(m.json({ description: "Result; untrusted." })),
+    error: m.optional(publicErrorSchema),
+    approvalId: m.optional(m.id()),
+    retryable: m.optional(m.boolean("The host can retry this tool call."))
+  })
+}), approvalStatusValues = [
+  "requested",
+  "decision-pending",
+  "approved",
+  "rejected",
+  "expired",
+  "superseded",
+  "decision-failed"
+], ApprovalModel = defineModel("oddkin.ai.approval", {
+  version: 1,
+  description: "A request to approve an action. Approval never implies the action succeeded.",
+  schema: m.object({
+    approvalId: m.id(),
+    attemptId: m.optional(m.id()),
+    toolCallId: m.optional(m.id()),
+    revision: m.number({ integer: !0, minimum: 1, description: "Proposal revision." }),
+    title: m.string({ minLength: 1 }),
+    summary: m.optional(m.string()),
+    target: m.optional(m.string({ description: "What the action affects." })),
+    changes: m.optional(m.array(m.object({
+      label: m.string(),
+      before: m.optional(m.string()),
+      after: m.optional(m.string())
+    }))),
+    risk: m.optional(m.enum(["low", "medium", "high"])),
+    status: m.enum(approvalStatusValues),
+    decision: m.optional(m.enum(["approve", "reject"])),
+    reason: m.optional(m.string()),
+    expiresAt: timestamp(),
+    error: m.optional(publicErrorSchema)
+  })
+}), ArtifactModel = defineModel("oddkin.ai.artifact", {
+  version: 1,
+  description: "A generated artifact with a stable identity across revisions.",
+  schema: m.object({
+    artifactId: m.id(),
+    title: m.string({ minLength: 1 }),
+    kind: m.string({ minLength: 1, description: "markdown, code, text, or a host renderer key." }),
+    language: m.optional(m.string()),
+    currentRevisionId: m.id(),
+    revisions: m.array(m.object({
+      revisionId: m.id(),
+      number: m.number({ integer: !0, minimum: 1 }),
+      createdAt: timestamp(),
+      summary: m.optional(m.string()),
+      content: m.string({ description: "Canonical source; exported as is." })
+    }), { minItems: 1 })
+  })
+}), usageEntrySchema = m.object({
+  kind: m.enum(["input-tokens", "output-tokens", "context", "quota", "cost", "other"]),
+  label: m.string({ minLength: 1 }),
+  used: m.optional(m.number({ minimum: 0 })),
+  limit: m.optional(m.number({ minimum: 0 })),
+  unit: m.optional(m.string({ description: "tokens, requests, \u2026 (cost uses currency)." })),
+  currency: m.optional(m.string({ pattern: "^[A-Z]{3}$", description: "ISO 4217." })),
+  precision: m.enum(["measured", "estimated", "unknown"], "Supplied by the host; never inferred.")
+}), UsageModel = defineModel("oddkin.ai.usage", {
+  version: 1,
+  schema: m.array(usageEntrySchema)
+}), CheckpointModel = defineModel("oddkin.ai.checkpoint", {
+  version: 1,
+  description: "A restore point. Restoration is shown only after the host confirms it.",
+  schema: m.object({
+    checkpointId: m.id(),
+    label: m.string({ minLength: 1 }),
+    description: m.string({ description: "Which state is restored." }),
+    restores: m.array(m.string(), { description: "Each item of state the restore replaces." }),
+    createdAt: timestamp(),
+    status: m.enum(["available", "restore-pending", "restored", "restore-failed", "unavailable"]),
+    outcome: m.optional(m.string({ description: "Host-confirmed result." })),
+    error: m.optional(publicErrorSchema)
+  })
+}), stepStatus = m.enum([
+  "pending",
+  "active",
+  "done",
+  "failed",
+  "blocked",
+  "skipped",
+  "needs-input"
+]), PlanModel = defineModel("oddkin.ai.plan", {
+  version: 1,
+  schema: m.object({
+    planId: m.id(),
+    title: m.optional(m.string()),
+    steps: m.array(m.object({
+      id: m.id(),
+      title: m.string({ minLength: 1 }),
+      detail: m.optional(m.string()),
+      status: stepStatus,
+      blocker: m.optional(m.string({ description: "Why the step cannot continue." })),
+      inputRequest: m.optional(m.string({ description: "What the agent needs from the user." })),
+      tasks: m.optional(m.array(m.object({
+        id: m.id(),
+        title: m.string({ minLength: 1 }),
+        status: stepStatus,
+        detail: m.optional(m.string())
+      }), { description: "Work running in parallel within the step." }))
+    }))
+  })
+}), QuestionModel = defineModel("oddkin.ai.question", {
+  version: 1,
+  schema: m.object({
+    questionId: m.id(),
+    revision: m.number({ integer: !0, minimum: 1 }),
+    prompt: m.string({ minLength: 1 }),
+    kind: m.enum(["choice", "multi-choice", "form", "text"]),
+    options: m.optional(m.array(m.object({ id: m.id(), label: m.label(), description: m.optional(m.string()) }))),
+    fields: m.optional(m.array(m.object({
+      id: m.id(),
+      label: m.label(),
+      type: m.enum(["text", "number", "select", "boolean"]),
+      required: m.optional(m.boolean()),
+      options: m.optional(m.array(m.string()))
+    }))),
+    allowCustom: m.optional(m.boolean("Offer a free-text answer.")),
+    status: m.enum(["requested", "submitting", "submitted", "skipped", "expired", "failed"]),
+    answer: m.optional(m.json()),
+    expiresAt: timestamp(),
+    error: m.optional(publicErrorSchema)
+  })
+}), ContextItemModel = defineModel("oddkin.ai.context-item", {
+  version: 1,
+  schema: m.object({
+    id: m.id(),
+    kind: m.enum(["file", "document", "url", "selection"]),
+    label: m.string({ minLength: 1, description: "Untrusted; rendered as text." }),
+    detail: m.optional(m.string()),
+    status: m.enum([
+      "selected",
+      "uploading",
+      "uploaded",
+      "processing",
+      "ready",
+      "failed",
+      "removed"
+    ]),
+    url: m.optional(m.url()),
+    preview: m.optional(m.string({ description: "Plain-text excerpt for inspection." })),
+    mediaType: m.optional(m.string()),
+    size: m.optional(m.number({ integer: !0, minimum: 0 })),
+    error: m.optional(publicErrorSchema)
+  })
+}), ModelOptionModel = defineModel("oddkin.ai.model-option", {
+  version: 1,
+  schema: m.object({
+    id: m.id(),
+    label: m.label(),
+    description: m.optional(m.string()),
+    provider: m.optional(m.string()),
+    capabilities: m.optional(m.array(m.string())),
+    available: m.boolean(),
+    reason: m.optional(m.string({ description: "Why the model is unavailable." }))
+  })
+}), FeedbackModel = defineModel("oddkin.ai.feedback", {
+  version: 1,
+  schema: m.object({
+    messageId: m.id(),
+    rating: m.optional(m.enum(["positive", "negative"])),
+    reasons: m.optional(m.array(m.string())),
+    comment: m.optional(m.string()),
+    status: m.enum(["idle", "pending", "submitted", "failed"]),
+    error: m.optional(publicErrorSchema)
+  })
+}), SuggestionModel = defineModel("oddkin.ai.suggestion", {
+  version: 1,
+  schema: m.object({
+    id: m.id(),
+    label: m.label(),
+    prompt: m.string({ description: "Text inserted or submitted." })
+  })
+}), TranscriptSegmentModel = defineModel("oddkin.ai.transcript-segment", {
+  version: 1,
+  schema: m.object({
+    id: m.id(),
+    text: m.string(),
+    final: m.boolean("Interim text may still change."),
+    speaker: m.optional(m.string())
+  })
+}), ConversationSnapshotModel = defineModel("oddkin.ai.conversation", {
+  version: 1,
+  description: "A persisted conversation as supplied by the host (untrusted until validated).",
+  schema: m.object({
+    conversationId: m.id(),
+    messages: m.array(MessageModel.schema),
+    activeLeafId: m.optional(m.id()),
+    tools: m.optional(m.array(ToolCallModel.schema)),
+    approvals: m.optional(m.array(ApprovalModel.schema)),
+    artifacts: m.optional(m.array(ArtifactModel.schema)),
+    hasMoreHistory: m.optional(m.boolean())
+  })
+});
+export {
+  ApprovalModel,
+  ArtifactModel,
+  CheckpointModel,
+  ContextItemModel,
+  ConversationSnapshotModel,
+  FeedbackModel,
+  MessageModel,
+  ModelOptionModel,
+  PlanModel,
+  QuestionModel,
+  SuggestionModel,
+  ToolCallModel,
+  TranscriptSegmentModel,
+  UsageModel,
+  approvalStatusValues,
+  capabilitiesSchema,
+  partSchema,
+  provenanceSchema,
+  publicErrorSchema,
+  usageEntrySchema
+};

package/dist/prod/contracts/normalize.js

@@ -0,0 +1,151 @@
+import { ApprovalModel, ArtifactModel, ConversationSnapshotModel, MessageModel, ToolCallModel, partSchema } from "./models.js";
+function pickDeclared(node, value) {
+  switch (node.kind) {
+    case "optional":
+      return value === void 0 ? void 0 : pickDeclared(node.inner, value);
+    case "array":
+      return value.map((item) => pickDeclared(node.items, item));
+    case "object":
+      return pickShape(node.shape, value);
+    case "union": {
+      const record = value, tag = record[node.discriminator], variant = node.variants[tag];
+      return variant ? { [node.discriminator]: tag, ...pickShape(variant.shape, record) } : void 0;
+    }
+    case "recursive":
+      return pickDeclared(node.inner, value);
+    default:
+      return value;
+  }
+}
+function pickShape(shape, value) {
+  const out = {};
+  for (const [key, child] of Object.entries(shape))
+    value[key] !== void 0 && (out[key] = pickDeclared(child, value[key]));
+  return out;
+}
+const PART_TYPES = new Set(Object.keys(partSchema.variants));
+function toDiagnostics(items, prefix = "", strip = "") {
+  return items.map((d) => ({
+    code: d.code,
+    path: `${prefix}${strip && d.path.startsWith(strip) ? d.path.slice(strip.length) : d.path}`,
+    message: d.message
+  }));
+}
+let fallbackIds = 0;
+function normalizePart(raw, path = "") {
+  const record = typeof raw == "object" && raw !== null ? raw : {}, type = typeof record.type == "string" ? record.type : "unknown", id = typeof record.id == "string" && record.id ? record.id : `unsupported-${++fallbackIds}`;
+  if (!PART_TYPES.has(type) || type === "unsupported")
+    return {
+      part: { type: "unsupported", id, originalType: type },
+      diagnostics: [
+        { code: "ai.part.unsupported", path, message: `Part type "${type}" is not supported.` }
+      ]
+    };
+  const variant = partSchema.variants[type], check = MessageModel.validate({ id: "x", role: "assistant", parts: [record] }), errors = check.diagnostics.filter((d) => d.severity === "error");
+  if (errors.length)
+    return {
+      part: { type: "unsupported", id, originalType: type },
+      diagnostics: [
+        {
+          code: "ai.part.invalid",
+          path,
+          message: `Part "${type}" is invalid and is not rendered.`
+        },
+        ...toDiagnostics(errors, path, "/parts/0")
+      ]
+    };
+  const unknown = check.diagnostics.filter((d) => d.severity !== "error");
+  return {
+    part: { type, ...pickDeclared(variant, record) },
+    diagnostics: toDiagnostics(unknown, path, "/parts/0")
+  };
+}
+function normalizeMessage(raw, path = "") {
+  const record = typeof raw == "object" && raw !== null ? raw : {}, diagnostics = [], parts = Array.isArray(record.parts) ? record.parts.map((part, i) => {
+    const result2 = normalizePart(part, `${path}/parts/${i}`);
+    return diagnostics.push(...result2.diagnostics), result2.part;
+  }) : record.parts, candidate = { ...record, parts }, result = MessageModel.validate(candidate), errors = result.diagnostics.filter((d) => d.severity === "error");
+  return diagnostics.push(...toDiagnostics(result.diagnostics.filter((d) => !d.path.includes("/parts/")), path)), errors.length ? { ok: !1, value: void 0, diagnostics } : {
+    ok: !0,
+    value: pickDeclared(MessageModel.schema, candidate),
+    diagnostics
+  };
+}
+function normalizeRecord(model, raw, path = "") {
+  const result = model.validate(raw), diagnostics = toDiagnostics(result.diagnostics, path);
+  return result.ok ? { ok: !0, value: pickDeclared(model.schema, raw), diagnostics } : { ok: !1, value: void 0, diagnostics };
+}
+const normalizeToolCall = (raw, path = "") => normalizeRecord(ToolCallModel, raw, path), normalizeApproval = (raw, path = "") => normalizeRecord(ApprovalModel, raw, path), normalizeArtifact = (raw, path = "") => normalizeRecord(ArtifactModel, raw, path);
+function normalizeSnapshot(raw) {
+  const record = typeof raw == "object" && raw !== null ? raw : {}, diagnostics = [];
+  let failed = !1;
+  const messages = Array.isArray(record.messages) ? record.messages.map((message, i) => {
+    const result2 = normalizeMessage(message, `/messages/${i}`);
+    return diagnostics.push(...result2.diagnostics), result2.ok || (failed = !0), result2.value ?? message;
+  }) : record.messages, candidate = { ...record, messages }, result = ConversationSnapshotModel.validate(candidate);
+  return diagnostics.push(...toDiagnostics(result.diagnostics.filter((d) => !d.path.startsWith("/messages/")))), failed || result.diagnostics.some((d) => d.severity === "error") ? { ok: !1, value: void 0, diagnostics } : {
+    ok: !0,
+    value: pickDeclared(ConversationSnapshotModel.schema, candidate),
+    diagnostics
+  };
+}
+const CAPABILITY_NAMES = [
+  "send",
+  "stop",
+  "disconnect",
+  "reconnect",
+  "resume",
+  "retry",
+  "edit",
+  "regenerate",
+  "switchBranch",
+  "respondToApproval",
+  "editApproval",
+  "restoreCheckpoint",
+  "voice",
+  "attachments",
+  "history",
+  "feedback"
+];
+function can(capabilities, name) {
+  return capabilities?.[name]?.available === !0;
+}
+function unavailableReason(capabilities, name) {
+  const entry = capabilities?.[name];
+  return entry?.available ? void 0 : entry?.reason;
+}
+function intersectCapabilities(supported, granted) {
+  const out = {};
+  for (const name of CAPABILITY_NAMES) {
+    const s = supported[name], g = granted[name];
+    if (!s && !g)
+      continue;
+    const available = !!s?.available && (g ? g.available : !0), reason = s?.available ? g && !g.available ? g.reason : void 0 : s?.reason;
+    out[name] = reason === void 0 ? { available } : { available, reason };
+  }
+  return out;
+}
+function toPublicError(error, fallback) {
+  if (typeof error == "object" && error !== null) {
+    const record = error;
+    if (typeof record.code == "string" && typeof record.message == "string") {
+      const retryable = record.retryable;
+      return typeof retryable == "boolean" ? { code: record.code, message: record.message, retryable } : { code: record.code, message: record.message };
+    }
+  }
+  return fallback;
+}
+export {
+  CAPABILITY_NAMES,
+  can,
+  intersectCapabilities,
+  normalizeApproval,
+  normalizeArtifact,
+  normalizeMessage,
+  normalizePart,
+  normalizeSnapshot,
+  normalizeToolCall,
+  pickDeclared,
+  toPublicError,
+  unavailableReason
+};

package/dist/prod/controllers/announcer.js

@@ -0,0 +1,136 @@
+import { format } from "@oddkin/core/i18n";
+const DEFAULT_ANNOUNCEMENTS = {
+  sent: "Message sent.",
+  responding: "Assistant is responding.",
+  completed: "Response complete.",
+  stopped: "Response stopped.",
+  stopping: "Stopping\u2026",
+  stopTooLate: "The response finished before it could be stopped.",
+  stopUnknown: "Stop could not be confirmed. The response may still be running.",
+  failed: "Response failed: {message}",
+  interrupted: "Connection lost. The response may be incomplete.",
+  disconnected: "Disconnected from the response.",
+  awaitingInput: "The assistant is waiting for your input.",
+  approvalRequested: "Approval needed: {title}",
+  approvalApproved: "Approved: {title}",
+  approvalRejected: "Rejected: {title}",
+  approvalExpired: "Approval expired: {title}",
+  approvalSuperseded: "The proposal changed: {title}. Review it again.",
+  toolFailed: "{tool} failed.",
+  historyLoaded: "Earlier messages loaded."
+};
+function describeConversationChange(previous, next, level, strings = DEFAULT_ANNOUNCEMENTS) {
+  if (!previous || level === "none" || previous.conversationId !== next.conversationId)
+    return [];
+  const out = [];
+  for (const attempt of Object.values(next.attempts)) {
+    const before = previous.attempts[attempt.attemptId], key = (what) => `attempt:${attempt.attemptId}:${what}`;
+    if (!before) {
+      attempt.relation === "new" && out.push({ text: strings.sent, priority: "polite", key: key("sent"), level: "important" });
+      continue;
+    }
+    if (before.status !== attempt.status)
+      switch (attempt.status) {
+        case "streaming":
+          before.status !== "awaiting-input" && before.status !== "interrupted" && out.push({
+            text: strings.responding,
+            priority: "polite",
+            key: key("streaming"),
+            level: "all"
+          });
+          break;
+        case "completed":
+          out.push({
+            text: strings.completed,
+            priority: "polite",
+            key: key("completed"),
+            level: "important"
+          });
+          break;
+        case "cancelled":
+          out.push({
+            text: strings.stopped,
+            priority: "polite",
+            key: key("cancelled"),
+            level: "important"
+          });
+          break;
+        case "failed":
+          out.push({
+            text: format(strings.failed, { message: attempt.error?.message ?? "" }),
+            priority: "assertive",
+            key: key("failed"),
+            level: "important"
+          });
+          break;
+        case "interrupted":
+          out.push({
+            text: strings.interrupted,
+            priority: "polite",
+            key: key("interrupted"),
+            level: "important"
+          });
+          break;
+        case "awaiting-input":
+          out.push({
+            text: strings.awaitingInput,
+            priority: "polite",
+            key: key("awaiting"),
+            level: "important"
+          });
+          break;
+      }
+    if (before.stop !== attempt.stop) {
+      const stop = attempt.stop;
+      stop === "requested" && out.push({
+        text: strings.stopping,
+        priority: "polite",
+        key: key("stopping"),
+        level: "all"
+      }), stop === "too-late" && out.push({
+        text: strings.stopTooLate,
+        priority: "polite",
+        key: key("too-late"),
+        level: "important"
+      }), (stop === "unknown" || stop === "failed") && out.push({
+        text: strings.stopUnknown,
+        priority: "polite",
+        key: key("stop-unknown"),
+        level: "important"
+      });
+    }
+    before.connection !== attempt.connection && attempt.connection === "disconnected" && out.push({
+      text: strings.disconnected,
+      priority: "polite",
+      key: key("disconnected"),
+      level: "important"
+    });
+  }
+  for (const approval of Object.values(next.approvals)) {
+    const before = previous.approvals[approval.approvalId];
+    if (before && before.revision === approval.revision && before.status === approval.status)
+      continue;
+    const key = `approval:${approval.approvalId}:${approval.revision}:${approval.status}`, title = approval.title, text = approval.status === "requested" ? format(before && before.revision !== approval.revision ? strings.approvalSuperseded : strings.approvalRequested, { title }) : approval.status === "approved" ? format(strings.approvalApproved, { title }) : approval.status === "rejected" ? format(strings.approvalRejected, { title }) : approval.status === "expired" ? format(strings.approvalExpired, { title }) : void 0;
+    text && out.push({ text, priority: "polite", key, level: "important" });
+  }
+  for (const tool of Object.values(next.tools)) {
+    const before = previous.tools[tool.toolCallId];
+    before && before.status !== tool.status && tool.status === "output-error" && out.push({
+      text: format(strings.toolFailed, { tool: tool.title ?? tool.toolName }),
+      priority: "polite",
+      key: `tool:${tool.toolCallId}:error`,
+      level: "all"
+    });
+  }
+  return previous.history === "loading" && next.history !== "loading" && next.history !== "error" && out.push({
+    text: strings.historyLoaded,
+    priority: "polite",
+    key: `history:${next.revision}`,
+    level: "all"
+  }), out.filter((entry) => level === "all" || entry.level === "important").map(({ text, priority, key }) => ({ text, priority, key }));
+}
+export {
+  DEFAULT_ANNOUNCEMENTS,
+  describeConversationChange,
+  format
+};