@x12i/ai 0.0.0-stage → 1.1.0

package/dist/chunk-RP5SPJKM.js

@@ -0,0 +1,1179 @@
+// src/messages.ts
+function messageText(message) {
+  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function messageReasoning(message) {
+  return message.parts.filter((part) => part.type === "reasoning").map((part) => part.text).join("\n\n");
+}
+function pendingApprovals(message) {
+  return message.parts.filter(
+    (part) => part.type === "tool" && part.state === "needs-approval"
+  );
+}
+function threadPendingApprovals(messages) {
+  return messages.flatMap(pendingApprovals);
+}
+function messageToolCalls(message) {
+  return message.parts.filter((part) => part.type === "tool");
+}
+function messageSources(message) {
+  return message.parts.filter((part) => part.type === "source");
+}
+function messageFiles(message) {
+  return message.parts.filter((part) => part.type === "file");
+}
+function messageData(message) {
+  return message.parts.filter((part) => part.type === "data");
+}
+function findToolCall(messages, callId) {
+  for (let m = messages.length - 1; m >= 0; m -= 1) {
+    const message = messages[m];
+    if (!message) continue;
+    for (let p = message.parts.length - 1; p >= 0; p -= 1) {
+      const part = message.parts[p];
+      if (part && part.type === "tool" && part.id === callId) return { message, part };
+    }
+  }
+  return void 0;
+}
+function isStreaming(message) {
+  return message.status === "streaming";
+}
+function lastMessageWithRole(messages, role) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (message && message.role === role) return message;
+  }
+  return void 0;
+}
+
+// src/thread-state.ts
+var TERMINAL_TOOL_STATES = /* @__PURE__ */ new Set(["succeeded", "failed", "denied"]);
+function isTerminalToolState(state) {
+  return TERMINAL_TOOL_STATES.has(state);
+}
+function isBusy(state) {
+  return state.status === "submitted" || state.status === "streaming";
+}
+function createThreadState(messages = []) {
+  return {
+    messages: [...messages],
+    status: "idle",
+    error: null,
+    activeMessageId: null,
+    branches: {}
+  };
+}
+function defined(value) {
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry !== void 0) result[key] = entry;
+  }
+  return result;
+}
+function shallowEqual(a, b) {
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  const left = a;
+  const right = b;
+  return aKeys.every((key) => Object.is(left[key], right[key]));
+}
+function indexOfMessage(messages, id) {
+  return messages.findIndex((message) => message.id === id);
+}
+function replaceAt(items, index, item) {
+  const copy = items.slice();
+  copy[index] = item;
+  return copy;
+}
+function withMessage(state, index, message) {
+  const current = state.messages[index];
+  if (current === message) return state;
+  return { ...state, messages: replaceAt(state.messages, index, message) };
+}
+function uniqueId(messages, prefix, start) {
+  let n = start;
+  while (messages.some((message) => message.id === `${prefix}${n}`)) n += 1;
+  return `${prefix}${n}`;
+}
+function closeReasoning(parts, at, durationMs) {
+  const last = parts[parts.length - 1];
+  if (!last || last.type !== "reasoning" || last.durationMs !== void 0) return parts;
+  let duration = durationMs;
+  if (duration === void 0 && at !== void 0 && last.startedAt !== void 0) {
+    duration = Math.max(0, at - last.startedAt);
+  }
+  if (duration === void 0) return parts;
+  return replaceAt(parts, parts.length - 1, { ...last, durationMs: duration });
+}
+function appendPart(parts, part, at) {
+  return [...closeReasoning(parts, at), part];
+}
+function completeMessage(messages, id) {
+  const index = indexOfMessage(messages, id);
+  const message = messages[index];
+  if (index < 0 || !message || message.status !== "streaming") return messages;
+  return replaceAt(messages, index, { ...message, status: "complete" });
+}
+function beginAssistant(state, action) {
+  const id = action.id ?? uniqueId(state.messages, "assistant-", state.messages.length + 1);
+  let messages = state.messages;
+  if (state.activeMessageId !== null && state.activeMessageId !== id) {
+    messages = completeMessage(messages, state.activeMessageId);
+  }
+  const index = indexOfMessage(messages, id);
+  if (index >= 0) {
+    const existing = messages[index];
+    if (!existing || existing.role !== "assistant") return state;
+    if (existing.status === "streaming" && state.activeMessageId === id && state.status === "streaming" && messages === state.messages) {
+      return state;
+    }
+    const reopened = { ...existing, status: "streaming" };
+    delete reopened.error;
+    messages = replaceAt(messages, index, reopened);
+  } else {
+    messages = [
+      ...messages,
+      defined({
+        id,
+        role: "assistant",
+        parts: [],
+        status: "streaming",
+        createdAt: action.createdAt,
+        metadata: action.metadata
+      })
+    ];
+  }
+  return { ...state, messages, status: "streaming", error: null, activeMessageId: id };
+}
+function resolveTarget(state, messageId, options = {}) {
+  const id = messageId ?? state.activeMessageId ?? void 0;
+  if (id !== void 0) {
+    const index2 = indexOfMessage(state.messages, id);
+    const message2 = state.messages[index2];
+    if (index2 >= 0 && message2) {
+      if (!options.anyRole) {
+        if (message2.role !== "assistant") return null;
+        if (message2.status === "stopped" || message2.status === "error") return null;
+      }
+      return { state, index: index2, message: message2 };
+    }
+  }
+  if (options.createIfMissing === false) return null;
+  const created = beginAssistant(state, { id });
+  if (created === state || created.activeMessageId === null) return null;
+  const index = indexOfMessage(created.messages, created.activeMessageId);
+  const message = created.messages[index];
+  if (!message) return null;
+  return { state: created, index, message };
+}
+function writeParts(target, parts) {
+  if (parts === target.message.parts) return target.state;
+  return withMessage(target.state, target.index, { ...target.message, parts });
+}
+function findToolLocation(messages, callId) {
+  for (let m = messages.length - 1; m >= 0; m -= 1) {
+    const message = messages[m];
+    if (!message) continue;
+    for (let p = message.parts.length - 1; p >= 0; p -= 1) {
+      const part = message.parts[p];
+      if (part && part.type === "tool" && part.id === callId) {
+        return { messageIndex: m, partIndex: p, part };
+      }
+    }
+  }
+  return null;
+}
+function writeToolPart(state, location, next) {
+  if (next === location.part) return state;
+  const message = state.messages[location.messageIndex];
+  if (!message) return state;
+  const parts = replaceAt(message.parts, location.partIndex, next);
+  return withMessage(state, location.messageIndex, { ...message, parts });
+}
+function applyToolPatch(part, patch, at) {
+  const next = { ...part };
+  if (patch.name !== void 0) next.name = patch.name;
+  if (patch.input !== void 0) next.input = patch.input;
+  if (patch.output !== void 0) next.output = patch.output;
+  if (patch.error !== void 0) next.error = patch.error;
+  if (patch.errorCode !== void 0) next.errorCode = patch.errorCode;
+  if (patch.durationMs !== void 0) next.durationMs = patch.durationMs;
+  if (patch.approval !== void 0) next.approval = { ...part.approval, ...patch.approval };
+  if (patch.state !== void 0) {
+    const regressing = isTerminalToolState(part.state) && !isTerminalToolState(patch.state);
+    if (!regressing) next.state = patch.state;
+  }
+  if (isTerminalToolState(next.state) && next.durationMs === void 0 && next.startedAt !== void 0 && at !== void 0) {
+    next.durationMs = Math.max(0, at - next.startedAt);
+  }
+  return shallowEqual(next, part) ? part : next;
+}
+function newToolPart(callId, name, state, at) {
+  return defined({ type: "tool", id: callId, name, state, startedAt: at });
+}
+function addUserMessage(state, action) {
+  if (indexOfMessage(state.messages, action.id) >= 0) return state;
+  const parts = [];
+  if (action.parts) parts.push(...action.parts);
+  if (action.text !== void 0 && action.text !== "") parts.push({ type: "text", text: action.text });
+  for (const file of action.attachments ?? []) parts.push(file);
+  if (parts.length === 0) return state;
+  let messages = state.messages;
+  if (state.activeMessageId !== null) messages = completeMessage(messages, state.activeMessageId);
+  const message = defined({
+    id: action.id,
+    role: "user",
+    parts,
+    createdAt: action.createdAt
+  });
+  const status = action.status ?? "submitted";
+  return {
+    ...state,
+    messages: [...messages, message],
+    status,
+    error: status === "error" ? state.error : null,
+    activeMessageId: null
+  };
+}
+function appendText(state, action) {
+  if (action.delta === "") return state;
+  const target = resolveTarget(state, action.messageId);
+  if (!target) return state;
+  const parts = closeReasoning(target.message.parts, action.at);
+  const last = parts[parts.length - 1];
+  const next = last && last.type === "text" ? replaceAt(parts, parts.length - 1, { ...last, text: last.text + action.delta }) : [...parts, { type: "text", text: action.delta }];
+  return writeParts(target, next);
+}
+function appendReasoning(state, action) {
+  if (action.delta === "") return state;
+  const target = resolveTarget(state, action.messageId);
+  if (!target) return state;
+  const parts = target.message.parts;
+  const last = parts[parts.length - 1];
+  if (last && last.type === "reasoning" && last.durationMs === void 0) {
+    return writeParts(target, replaceAt(parts, parts.length - 1, { ...last, text: last.text + action.delta }));
+  }
+  const part = defined({
+    type: "reasoning",
+    text: action.delta,
+    startedAt: action.at
+  });
+  return writeParts(target, [...parts, part]);
+}
+function endReasoning(state, action) {
+  const id = action.messageId ?? state.activeMessageId;
+  if (id === null || id === void 0) return state;
+  const index = indexOfMessage(state.messages, id);
+  const message = state.messages[index];
+  if (index < 0 || !message) return state;
+  const parts = closeReasoning(message.parts, action.at, action.durationMs);
+  if (parts === message.parts) return state;
+  return withMessage(state, index, { ...message, parts });
+}
+function startToolCall(state, action) {
+  const wanted = action.state ?? (action.requiresApproval ? "needs-approval" : "running");
+  const existing = findToolLocation(state.messages, action.callId);
+  if (existing) {
+    const patch = { name: action.name, state: wanted };
+    if (action.input !== void 0) patch.input = action.input;
+    if (action.approvalPrompt !== void 0) patch.approval = { prompt: action.approvalPrompt };
+    return writeToolPart(state, existing, applyToolPatch(existing.part, patch, action.at));
+  }
+  const target = resolveTarget(state, action.messageId);
+  if (!target) return state;
+  const part = newToolPart(action.callId, action.name, wanted, action.at);
+  if (action.input !== void 0) part.input = action.input;
+  if (action.approvalPrompt !== void 0) part.approval = { prompt: action.approvalPrompt };
+  return writeParts(target, appendPart(target.message.parts, part, action.at));
+}
+function updateToolCall(state, action) {
+  const existing = findToolLocation(state.messages, action.callId);
+  if (existing) {
+    return writeToolPart(state, existing, applyToolPatch(existing.part, action.patch, action.at));
+  }
+  const target = resolveTarget(state, action.messageId);
+  if (!target) return state;
+  const created = applyToolPatch(
+    newToolPart(action.callId, action.patch.name ?? action.callId, action.patch.state ?? "running", action.at),
+    action.patch,
+    action.at
+  );
+  return writeParts(target, appendPart(target.message.parts, created, action.at));
+}
+function finishToolCall(state, action) {
+  const failed = action.error !== void 0 || action.errorCode !== void 0;
+  const patch = { state: failed ? "failed" : "succeeded" };
+  if (action.output !== void 0) patch.output = action.output;
+  if (action.error !== void 0) patch.error = action.error;
+  if (action.errorCode !== void 0) patch.errorCode = action.errorCode;
+  if (action.durationMs !== void 0) patch.durationMs = action.durationMs;
+  const existing = findToolLocation(state.messages, action.callId);
+  if (existing) {
+    if (existing.part.state === "denied") return state;
+    return writeToolPart(state, existing, applyToolPatch(existing.part, patch, action.at));
+  }
+  const target = resolveTarget(state, action.messageId);
+  if (!target) return state;
+  const created = applyToolPatch(
+    newToolPart(action.callId, action.name ?? action.callId, "running", action.at),
+    patch,
+    action.at
+  );
+  return writeParts(target, appendPart(target.message.parts, created, action.at));
+}
+function toolDecision(state, action) {
+  const location = findToolLocation(state.messages, action.callId);
+  if (!location || location.part.state !== "needs-approval") return state;
+  const reason = action.reason?.trim();
+  const approval = { ...location.part.approval };
+  if (reason) approval.reason = reason;
+  const next = { ...location.part, state: action.decision, approval };
+  if (Object.keys(approval).length === 0) delete next.approval;
+  return writeToolPart(state, location, next);
+}
+function addSource(state, action) {
+  const target = resolveTarget(state, action.messageId);
+  if (!target) return state;
+  const parts = target.message.parts;
+  const existingIndex = parts.findIndex((part) => part.type === "source" && part.id === action.source.id);
+  const incoming = { type: "source", ...defined(action.source) };
+  if (existingIndex >= 0) {
+    const current = parts[existingIndex];
+    const merged = { ...current, ...incoming };
+    return writeParts(target, shallowEqual(current, merged) ? parts : replaceAt(parts, existingIndex, merged));
+  }
+  return writeParts(target, [...parts, incoming]);
+}
+function addPart(state, action) {
+  const { part } = action;
+  if (part.type === "source") {
+    return addSource(state, {
+      type: "add-source",
+      source: { id: part.id, title: part.title, url: part.url, snippet: part.snippet },
+      ...action.messageId ? { messageId: action.messageId } : {}
+    });
+  }
+  if (part.type === "tool" && findToolLocation(state.messages, part.id)) return state;
+  const target = resolveTarget(state, action.messageId);
+  if (!target) return state;
+  return writeParts(target, appendPart(target.message.parts, part, void 0));
+}
+function attachFiles(state, action) {
+  if (action.files.length === 0) return state;
+  const fallback = state.messages[state.messages.length - 1]?.id;
+  const id = action.messageId ?? state.activeMessageId ?? fallback;
+  if (id === void 0 || id === null) return state;
+  const target = resolveTarget(state, id, { anyRole: true, createIfMissing: false });
+  if (!target) return state;
+  const known = new Set(
+    target.message.parts.filter((part) => part.type === "file").map((part) => part.id ?? part.url)
+  );
+  const added = action.files.filter((file) => {
+    const key = file.id ?? file.url;
+    if (known.has(key)) return false;
+    known.add(key);
+    return true;
+  });
+  if (added.length === 0) return state;
+  return writeParts(target, [...target.message.parts, ...added.map((file) => ({ ...file, type: "file" }))]);
+}
+function finishMessage(state, action) {
+  const id = action.messageId ?? state.activeMessageId;
+  let next = state;
+  if (id !== null && id !== void 0) {
+    const index = indexOfMessage(state.messages, id);
+    const message = state.messages[index];
+    if (index >= 0 && message) {
+      const parts = closeReasoning(message.parts, action.at);
+      const status = message.status === "stopped" || message.status === "error" ? message.status : "complete";
+      const updated = defined({
+        ...message,
+        parts,
+        status,
+        usage: action.usage ?? message.usage,
+        finishReason: action.finishReason ?? message.finishReason
+      });
+      next = shallowEqual(updated, message) ? state : withMessage(state, index, updated);
+    }
+  }
+  const concernsActive = id === next.activeMessageId || next.activeMessageId === null;
+  if (concernsActive && (next.status === "streaming" || next.status === "submitted")) {
+    return { ...next, status: "idle", activeMessageId: null };
+  }
+  return next;
+}
+function toThreadErrorValue(error) {
+  return typeof error === "string" ? { message: error, kind: "unknown", retryable: true } : error;
+}
+function failMessage(state, action) {
+  const error = toThreadErrorValue(action.error);
+  const id = action.messageId ?? state.activeMessageId;
+  let messages = state.messages;
+  if (id !== null && id !== void 0) {
+    const index = indexOfMessage(messages, id);
+    const message = messages[index];
+    if (index >= 0 && message && message.role === "assistant") {
+      if (message.status === "streaming" && message.parts.length === 0) {
+        messages = messages.filter((_, i) => i !== index);
+      } else {
+        messages = replaceAt(messages, index, {
+          ...message,
+          parts: closeReasoning(message.parts, action.at),
+          status: "error",
+          error
+        });
+      }
+    }
+  }
+  return { ...state, messages, status: "error", error, activeMessageId: null };
+}
+function abortMessage(state, action) {
+  const id = action.messageId ?? state.activeMessageId;
+  let messages = state.messages;
+  if (id !== null && id !== void 0) {
+    const index = indexOfMessage(messages, id);
+    const message = messages[index];
+    if (index >= 0 && message && message.role === "assistant" && message.status === "streaming") {
+      if (message.parts.length === 0) {
+        messages = messages.filter((_, i) => i !== index);
+      } else {
+        const parts = closeReasoning(message.parts, action.at).map((part) => {
+          if (part.type === "tool" && (part.state === "running" || part.state === "queued")) {
+            return { ...part, state: "failed", errorCode: "aborted" };
+          }
+          return part;
+        });
+        messages = replaceAt(messages, index, { ...message, parts, status: "stopped" });
+      }
+    }
+  }
+  if (!isBusy(state) && messages === state.messages) return state;
+  return {
+    ...state,
+    messages,
+    status: isBusy(state) ? "idle" : state.status,
+    activeMessageId: null
+  };
+}
+function regenerate(state) {
+  let end = state.messages.length;
+  while (end > 0) {
+    const last2 = state.messages[end - 1];
+    if (last2 && (last2.role === "assistant" || last2.role === "tool")) end -= 1;
+    else break;
+  }
+  const last = state.messages[end - 1];
+  if (!last || last.role !== "user") return state;
+  const messages = state.messages.slice(0, end);
+  return {
+    ...state,
+    messages,
+    branches: pruneBranches(state.branches, messages),
+    status: "submitted",
+    error: null,
+    activeMessageId: null
+  };
+}
+function editedParts(old, action) {
+  if (action.parts) return action.parts;
+  const text = action.text ?? "";
+  const parts = [];
+  let placed = false;
+  for (const part of old.parts) {
+    if (part.type === "text") {
+      if (!placed && text !== "") parts.push({ type: "text", text });
+      placed = true;
+    } else {
+      parts.push(part);
+    }
+  }
+  if (!placed && text !== "") parts.unshift({ type: "text", text });
+  return parts;
+}
+function branchParentKey(messages, index) {
+  return index <= 0 ? "" : messages[index - 1]?.id ?? "";
+}
+function insertAt(items, index, item) {
+  const copy = items.slice();
+  copy.splice(Math.min(Math.max(index, 0), copy.length), 0, item);
+  return copy;
+}
+function editMessage(state, action) {
+  const index = indexOfMessage(state.messages, action.messageId);
+  const old = state.messages[index];
+  if (index < 0 || !old) return state;
+  const parts = editedParts(old, action);
+  if (parts.length === 0) return state;
+  if (old.role !== "user") {
+    const edited2 = {
+      ...old,
+      parts,
+      metadata: { ...old.metadata, edited: true }
+    };
+    return withMessage(state, index, edited2);
+  }
+  const mode = action.mode ?? "truncate";
+  const baseMetadata = { ...old.metadata, edited: true };
+  if (mode === "truncate") {
+    const edited2 = defined({
+      ...old,
+      parts,
+      metadata: baseMetadata,
+      createdAt: action.createdAt ?? old.createdAt
+    });
+    const messages2 = [...state.messages.slice(0, index), edited2];
+    return {
+      ...state,
+      messages: messages2,
+      branches: pruneBranches(state.branches, messages2),
+      status: "submitted",
+      error: null,
+      activeMessageId: null
+    };
+  }
+  const newId = action.newId ?? uniqueId(state.messages, `${old.id}~`, (state.branches[branchParentKey(state.messages, index)]?.alternatives.length ?? 0) + 1);
+  if (newId !== old.id && indexOfMessage(state.messages, newId) >= 0) return state;
+  const parentKey = branchParentKey(state.messages, index);
+  const currentTail = state.messages.slice(index);
+  const edited = defined({
+    id: newId,
+    role: "user",
+    parts,
+    parentId: old.id,
+    createdAt: action.createdAt,
+    metadata: baseMetadata
+  });
+  const existing = state.branches[parentKey];
+  const all = existing ? insertAt(existing.alternatives, existing.activeIndex, currentTail) : [currentTail];
+  const point = { parentId: parentKey, alternatives: all, activeIndex: all.length };
+  const messages = [...state.messages.slice(0, index), edited];
+  return {
+    ...state,
+    messages,
+    branches: pruneBranches({ ...state.branches, [parentKey]: point }, messages),
+    status: "submitted",
+    error: null,
+    activeMessageId: null
+  };
+}
+function switchBranch(state, action) {
+  if (isBusy(state)) return state;
+  const point = state.branches[action.parentId];
+  if (!point) return state;
+  const count = point.alternatives.length + 1;
+  if (!Number.isInteger(action.index) || action.index < 0 || action.index >= count) return state;
+  if (action.index === point.activeIndex) return state;
+  let forkIndex = 0;
+  if (action.parentId !== "") {
+    const parentIndex = indexOfMessage(state.messages, action.parentId);
+    if (parentIndex < 0) return state;
+    forkIndex = parentIndex + 1;
+  }
+  const all = insertAt(point.alternatives, point.activeIndex, state.messages.slice(forkIndex));
+  const nextTail = all[action.index];
+  if (!nextTail) return state;
+  const alternatives = all.filter((_, i) => i !== action.index);
+  const messages = [...state.messages.slice(0, forkIndex), ...nextTail];
+  return {
+    ...state,
+    messages,
+    branches: { ...state.branches, [action.parentId]: { parentId: action.parentId, alternatives, activeIndex: action.index } }
+  };
+}
+function pruneBranches(branches, messages) {
+  const keys = Object.keys(branches);
+  if (keys.length === 0) return branches;
+  const reachable = /* @__PURE__ */ new Set([""]);
+  for (const message of messages) reachable.add(message.id);
+  const kept = /* @__PURE__ */ new Set();
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const key of keys) {
+      const point = branches[key];
+      if (!point || kept.has(key) || !reachable.has(key)) continue;
+      kept.add(key);
+      changed = true;
+      for (const tail of point.alternatives) for (const message of tail) reachable.add(message.id);
+    }
+  }
+  if (kept.size === keys.length) return branches;
+  const result = {};
+  for (const key of keys) {
+    const point = branches[key];
+    if (point && kept.has(key)) result[key] = point;
+  }
+  return result;
+}
+function threadReducer(state, action) {
+  switch (action.type) {
+    case "batch": {
+      let next = state;
+      for (const inner of action.actions) next = threadReducer(next, inner);
+      return next;
+    }
+    case "set-messages":
+      return { ...createThreadState(action.messages) };
+    case "add-message": {
+      if (indexOfMessage(state.messages, action.message.id) >= 0) return state;
+      return { ...state, messages: [...state.messages, action.message] };
+    }
+    case "add-user-message":
+      return addUserMessage(state, action);
+    case "begin-assistant-message":
+      return beginAssistant(state, action);
+    case "append-text":
+      return appendText(state, action);
+    case "append-reasoning":
+      return appendReasoning(state, action);
+    case "end-reasoning":
+      return endReasoning(state, action);
+    case "start-tool-call":
+      return startToolCall(state, action);
+    case "update-tool-call":
+      return updateToolCall(state, action);
+    case "finish-tool-call":
+      return finishToolCall(state, action);
+    case "tool-decision":
+      return toolDecision(state, action);
+    case "add-source":
+      return addSource(state, action);
+    case "add-part":
+      return addPart(state, action);
+    case "attach-files":
+      return attachFiles(state, action);
+    case "finish":
+      return finishMessage(state, action);
+    case "error":
+      return failMessage(state, action);
+    case "abort":
+      return abortMessage(state, action);
+    case "regenerate":
+      return regenerate(state);
+    case "edit-message":
+      return editMessage(state, action);
+    case "switch-branch":
+      return switchBranch(state, action);
+    case "dismiss-error": {
+      if (state.error === null && state.status !== "error") return state;
+      return { ...state, error: null, status: state.status === "error" ? "idle" : state.status };
+    }
+    case "clear": {
+      if (state.messages.length === 0 && state.status === "idle" && state.error === null && Object.keys(state.branches).length === 0) {
+        return state;
+      }
+      return createThreadState();
+    }
+    default:
+      return state;
+  }
+}
+function getBranchInfo(state, messageId) {
+  const index = indexOfMessage(state.messages, messageId);
+  if (index < 0) return void 0;
+  const parentId = branchParentKey(state.messages, index);
+  const point = state.branches[parentId];
+  if (!point) return void 0;
+  return { parentId, index: point.activeIndex, count: point.alternatives.length + 1 };
+}
+function getBranchInfoMap(state) {
+  const result = {};
+  for (const message of state.messages) {
+    const info = getBranchInfo(state, message.id);
+    if (info) result[message.id] = info;
+  }
+  return result;
+}
+function lastUserMessage(state) {
+  for (let i = state.messages.length - 1; i >= 0; i -= 1) {
+    const message = state.messages[i];
+    if (message && message.role === "user") return message;
+  }
+  return void 0;
+}
+
+// src/errors.ts
+function readNumber(source, key) {
+  if (typeof source !== "object" || source === null) return void 0;
+  const value = source[key];
+  return typeof value === "number" ? value : void 0;
+}
+function readString(source, key) {
+  if (typeof source !== "object" || source === null) return void 0;
+  const value = source[key];
+  return typeof value === "string" ? value : void 0;
+}
+function isAbortError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const name = readString(error, "name");
+  return name === "AbortError" || readString(error, "code") === "ABORT_ERR";
+}
+function defaultRetryable(kind) {
+  return kind !== "moderation" && kind !== "auth";
+}
+function toThreadError(error) {
+  if (typeof error === "string") {
+    return { message: error, kind: "unknown", retryable: true };
+  }
+  const status = readNumber(error, "status") ?? readNumber(error, "statusCode");
+  const code = readString(error, "code") ?? readString(error, "type");
+  const message = readString(error, "message") ?? (error === void 0 || error === null ? "" : String(error));
+  const haystack = `${code ?? ""} ${message}`.toLowerCase();
+  let kind = "unknown";
+  if (status === 429 || /rate[\s_-]?limit|too many requests|quota/.test(haystack)) {
+    kind = "rate-limit";
+  } else if (status === 401 || status === 403 || /unauthori[sz]ed|invalid[\s_-]?api[\s_-]?key|authentication/.test(haystack)) {
+    kind = "auth";
+  } else if (typeof error === "object" && error !== null && readString(error, "name") === "TypeError" || /failed to fetch|network|offline|econn\w*|enotfound|etimedout|timeout|socket hang up|load failed/.test(
+    haystack
+  )) {
+    kind = "network";
+  } else if (/content[\s_-]?(filter|policy)|moderation|safety|refusal|flagged/.test(haystack)) {
+    kind = "moderation";
+  } else if (status !== void 0 && status >= 500) {
+    kind = "network";
+  }
+  const result = { message, kind, retryable: defaultRetryable(kind) };
+  if (code !== void 0) result.code = code;
+  return result;
+}
+
+// src/stream.ts
+function streamEventToAction(state, event, options = {}) {
+  const messageId = event.messageId ?? state.activeMessageId ?? options.messageId;
+  const at = options.at;
+  const withId = messageId === void 0 ? {} : { messageId };
+  const withAt = at === void 0 ? {} : { at };
+  switch (event.type) {
+    case "start": {
+      const id = event.messageId ?? options.messageId;
+      return {
+        type: "begin-assistant-message",
+        ...id === void 0 ? {} : { id },
+        ...event.createdAt === void 0 ? {} : { createdAt: event.createdAt },
+        ...event.metadata === void 0 ? {} : { metadata: event.metadata }
+      };
+    }
+    case "text-delta":
+      return { type: "append-text", delta: event.delta, ...withId, ...withAt };
+    case "reasoning-delta":
+      return { type: "append-reasoning", delta: event.delta, ...withId, ...withAt };
+    case "reasoning-end":
+      return {
+        type: "end-reasoning",
+        ...event.durationMs === void 0 ? {} : { durationMs: event.durationMs },
+        ...withId,
+        ...withAt
+      };
+    case "tool-call":
+      return {
+        type: "start-tool-call",
+        callId: event.callId,
+        name: event.name,
+        ...event.input === void 0 ? {} : { input: event.input },
+        ...event.state === void 0 ? {} : { state: event.state },
+        ...event.requiresApproval === void 0 ? {} : { requiresApproval: event.requiresApproval },
+        ...event.approvalPrompt === void 0 ? {} : { approvalPrompt: event.approvalPrompt },
+        ...withId,
+        ...withAt
+      };
+    case "tool-update": {
+      const patch = {};
+      if (event.state !== void 0) patch.state = event.state;
+      if (event.name !== void 0) patch.name = event.name;
+      if (event.input !== void 0) patch.input = event.input;
+      if (event.output !== void 0) patch.output = event.output;
+      if (event.error !== void 0) patch.error = event.error;
+      if (event.approval !== void 0) patch.approval = event.approval;
+      return { type: "update-tool-call", callId: event.callId, patch, ...withId, ...withAt };
+    }
+    case "tool-result":
+      return {
+        type: "finish-tool-call",
+        callId: event.callId,
+        ...event.name === void 0 ? {} : { name: event.name },
+        ...event.output === void 0 ? {} : { output: event.output },
+        ...event.error === void 0 ? {} : { error: event.error },
+        ...event.durationMs === void 0 ? {} : { durationMs: event.durationMs },
+        ...withId,
+        ...withAt
+      };
+    case "source":
+      return {
+        type: "add-source",
+        source: {
+          id: event.id,
+          title: event.title,
+          url: event.url,
+          ...event.snippet === void 0 ? {} : { snippet: event.snippet }
+        },
+        ...withId
+      };
+    case "file":
+      return {
+        type: "attach-files",
+        files: [
+          {
+            type: "file",
+            ...event.id === void 0 ? {} : { id: event.id },
+            name: event.name,
+            mediaType: event.mediaType,
+            url: event.url,
+            ...event.size === void 0 ? {} : { size: event.size }
+          }
+        ],
+        ...withId
+      };
+    case "data":
+      return { type: "add-part", part: { type: "data", kind: event.kind, data: event.data }, ...withId };
+    case "finish":
+      return {
+        type: "finish",
+        ...event.usage === void 0 ? {} : { usage: event.usage },
+        ...event.finishReason === void 0 ? {} : { finishReason: event.finishReason },
+        ...withId,
+        ...withAt
+      };
+    case "error":
+      return { type: "error", error: event.error, ...withId, ...withAt };
+    case "abort":
+      return { type: "abort", ...withId, ...withAt };
+    default:
+      return null;
+  }
+}
+function applyStreamEvent(state, event, options = {}) {
+  const action = streamEventToAction(state, event, options);
+  return action === null ? state : threadReducer(state, action);
+}
+function applyStreamEvents(state, events, options = {}) {
+  return events.reduce((current, event) => applyStreamEvent(current, event, options), state);
+}
+function isTerminalStreamEvent(event) {
+  return event.type === "finish" || event.type === "error" || event.type === "abort";
+}
+function createAbortableStream(source, signal) {
+  async function* run() {
+    if (signal.aborted) return;
+    const iterator = source[Symbol.asyncIterator]();
+    let onAbort;
+    const aborted = new Promise((resolve) => {
+      onAbort = () => resolve({ aborted: true });
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+      while (true) {
+        let result;
+        try {
+          result = await Promise.race([iterator.next(), aborted]);
+        } catch (error) {
+          if (signal.aborted) return;
+          throw error;
+        }
+        if ("aborted" in result) return;
+        if (result.done) return;
+        yield result.value;
+        if (signal.aborted) return;
+      }
+    } finally {
+      if (onAbort) signal.removeEventListener("abort", onAbort);
+      try {
+        Promise.resolve(iterator.return?.()).catch(() => {
+        });
+      } catch {
+      }
+    }
+  }
+  return run();
+}
+function errorEvent(error) {
+  return { type: "error", error: toThreadError(error) };
+}
+
+// src/citations.ts
+var MARKER = /(?<![\\\]!])\[(\d{1,3}(?:\s*[,–-]\s*\d{1,3})*)\](?![([:])/g;
+function expand(list) {
+  const numbers = [];
+  for (const piece of list.split(",")) {
+    const range = piece.trim().split(/\s*[–-]\s*/);
+    const first = Number(range[0]);
+    const last = range.length > 1 ? Number(range[1]) : first;
+    if (!Number.isInteger(first) || !Number.isInteger(last)) return null;
+    if (last < first || last - first > 20) return null;
+    for (let n = first; n <= last; n += 1) numbers.push(n);
+  }
+  return [...new Set(numbers)];
+}
+function parseCitations(text, options = {}) {
+  const segments = [];
+  let cursor = 0;
+  for (const match of text.matchAll(MARKER)) {
+    const numbers = expand(match[1] ?? "");
+    if (!numbers || numbers.length === 0) continue;
+    if (options.maxIndex !== void 0 && numbers.some((n) => n < 1 || n > (options.maxIndex ?? 0))) continue;
+    if (match.index > cursor) segments.push({ type: "text", text: text.slice(cursor, match.index) });
+    segments.push({ type: "citation", numbers, raw: match[0] });
+    cursor = match.index + match[0].length;
+  }
+  if (cursor < text.length) segments.push({ type: "text", text: text.slice(cursor) });
+  return segments;
+}
+function citedNumbers(text, options = {}) {
+  const numbers = /* @__PURE__ */ new Set();
+  for (const segment of parseCitations(text, options)) {
+    if (segment.type === "citation") for (const n of segment.numbers) numbers.add(n);
+  }
+  return [...numbers].sort((a, b) => a - b);
+}
+
+// src/format.ts
+function totalTokens(usage) {
+  if (usage.totalTokens !== void 0) return usage.totalTokens;
+  if (usage.inputTokens === void 0 && usage.outputTokens === void 0) return void 0;
+  return (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+}
+function mergeUsage(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  const result = {};
+  const keys = [
+    "inputTokens",
+    "outputTokens",
+    "totalTokens",
+    "reasoningTokens",
+    "cachedInputTokens"
+  ];
+  for (const key of keys) {
+    const left = a[key];
+    const right = b[key];
+    if (left === void 0 && right === void 0) continue;
+    result[key] = (left ?? 0) + (right ?? 0);
+  }
+  return result;
+}
+function formatTokenCount(count, locale) {
+  if (!Number.isFinite(count)) return "";
+  return new Intl.NumberFormat(locale, { notation: "compact", maximumFractionDigits: 1 }).format(count);
+}
+function formatUsage(usage, locale) {
+  const result = {};
+  if (usage.inputTokens !== void 0) result.input = formatTokenCount(usage.inputTokens, locale);
+  if (usage.outputTokens !== void 0) result.output = formatTokenCount(usage.outputTokens, locale);
+  const total = totalTokens(usage);
+  if (total !== void 0) result.total = formatTokenCount(total, locale);
+  if (usage.reasoningTokens !== void 0) result.reasoning = formatTokenCount(usage.reasoningTokens, locale);
+  if (usage.cachedInputTokens !== void 0) result.cachedInput = formatTokenCount(usage.cachedInputTokens, locale);
+  return result;
+}
+function unitFormat(locale, unit, maximumFractionDigits = 0) {
+  return new Intl.NumberFormat(locale, { style: "unit", unit, unitDisplay: "narrow", maximumFractionDigits });
+}
+function formatDuration(ms, locale) {
+  if (!Number.isFinite(ms) || ms < 0) return "";
+  if (ms < 1e3) return unitFormat(locale, "millisecond").format(Math.round(ms));
+  const totalSeconds = ms / 1e3;
+  if (totalSeconds < 10) return unitFormat(locale, "second", 1).format(Math.round(totalSeconds * 10) / 10);
+  if (totalSeconds < 60) return unitFormat(locale, "second").format(Math.round(totalSeconds));
+  const wholeSeconds = Math.round(totalSeconds);
+  const hours = Math.floor(wholeSeconds / 3600);
+  const minutes = Math.floor(wholeSeconds % 3600 / 60);
+  const seconds = wholeSeconds % 60;
+  const pieces = [];
+  if (hours > 0) pieces.push(unitFormat(locale, "hour").format(hours));
+  if (minutes > 0 || hours > 0) pieces.push(unitFormat(locale, "minute").format(minutes));
+  if (hours === 0 && seconds > 0) pieces.push(unitFormat(locale, "second").format(seconds));
+  return new Intl.ListFormat(locale, { type: "unit", style: "narrow" }).format(pieces);
+}
+function formatBytes(bytes, locale) {
+  if (!Number.isFinite(bytes) || bytes < 0) return "";
+  const units = ["byte", "kilobyte", "megabyte", "gigabyte"];
+  let value = bytes;
+  let index = 0;
+  while (value >= 1e3 && index < units.length - 1) {
+    value /= 1e3;
+    index += 1;
+  }
+  const unit = units[index] ?? "byte";
+  return new Intl.NumberFormat(locale, {
+    style: "unit",
+    unit,
+    unitDisplay: "short",
+    maximumFractionDigits: index === 0 ? 0 : 1
+  }).format(value);
+}
+function splitCompletedSentences(text) {
+  let boundary = 0;
+  let inFence = false;
+  let offset = 0;
+  const lines = text.split("\n");
+  lines.forEach((line, index) => {
+    const isLast = index === lines.length - 1;
+    const start = offset;
+    offset += line.length + 1;
+    if (/^\s{0,3}(```|~~~)/.test(line)) {
+      inFence = !inFence;
+      if (!inFence && !isLast) boundary = Math.max(boundary, offset - 1);
+      return;
+    }
+    if (inFence) return;
+    const stops = isLast ? /[.!?…。！？]+(?=\s)/g : /[.!?…。！？]+(?=\s|$)/g;
+    for (const match of line.matchAll(stops)) {
+      boundary = Math.max(boundary, start + match.index + match[0].length);
+    }
+    if (!isLast) boundary = Math.max(boundary, offset - 1);
+  });
+  return { complete: text.slice(0, boundary), rest: text.slice(boundary) };
+}
+function markdownToPlainText(markdown) {
+  return markdown.replace(/```[^\n]*\n([\s\S]*?)(?:```|$)/g, "$1").replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/\[\d{1,3}(?:\s*[,–-]\s*\d{1,3})*\]/g, "").replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/^\s{0,3}>\s?/gm, "").replace(/^\s*[-*+]\s+/gm, "").replace(/^\s*\|?[\s:|-]{3,}\|?\s*$/gm, "").replace(/\|/g, " ").replace(/(\*\*|__|~~|`)/g, "").replace(/(^|[\s(])[*_]([^\s*_][^*_]*)[*_](?=$|[\s).,!?:;])/g, "$1$2").replace(/\s+/g, " ").trim();
+}
+
+// src/markdown-safety.ts
+var SAFE_LINK_PROTOCOLS = ["http:", "https:", "mailto:", "tel:"];
+var SAFE_IMAGE_PROTOCOLS = ["http:", "https:"];
+var IGNORED_IN_SCHEME = /[\u0000-\u0020\u007f-\u009f\u00ad\u200b-\u200f\u2028\u2029\ufeff]/g;
+var SCHEME = /^([a-z][a-z0-9+.-]*):/i;
+function sanitizeUrl(url, options = {}) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (trimmed === "") return null;
+  const protocols = options.protocols ?? SAFE_LINK_PROTOCOLS;
+  const allowRelative = options.allowRelative ?? true;
+  const probe = trimmed.replace(IGNORED_IN_SCHEME, "");
+  const colon = probe.indexOf(":");
+  const firstSeparator = probe.search(/[/?#]/);
+  const hasScheme = colon !== -1 && (firstSeparator === -1 || colon < firstSeparator);
+  if (!hasScheme) {
+    return allowRelative ? trimmed : null;
+  }
+  const scheme = SCHEME.exec(probe);
+  if (!scheme) return null;
+  const protocol = `${(scheme[1] ?? "").toLowerCase()}:`;
+  return protocols.includes(protocol) ? trimmed : null;
+}
+function isSafeUrl(url, options = {}) {
+  return sanitizeUrl(url, options) !== null;
+}
+var DATA_IMAGE = /^data:image\/(?:png|jpe?g|gif|webp|avif);base64,[a-z0-9+/=\s]+$/i;
+function sanitizeImageUrl(url, options = {}) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (options.allowDataImages && DATA_IMAGE.test(trimmed)) return trimmed;
+  if (options.allowBlob && /^blob:/i.test(trimmed)) return trimmed;
+  return sanitizeUrl(trimmed, { protocols: SAFE_IMAGE_PROTOCOLS });
+}
+function isExternalUrl(url) {
+  return /^(?:https?:)?\/\//i.test(url.trim().replace(IGNORED_IN_SCHEME, ""));
+}
+function getUrlHostname(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+    return parsed.hostname.replace(/^www\./i, "");
+  } catch {
+    return null;
+  }
+}
+function splitMarkdownBlocks(markdown) {
+  if (markdown === "") return [];
+  if (/^ {0,3}\[[^\]\n]+\]:/m.test(markdown) || /\[\^[^\]\n]+\]/.test(markdown)) return [markdown];
+  const LIST_MARKER = /^ {0,3}(?:[-*+]|\d{1,9}[.)])(?:\s|$)/;
+  const lines = markdown.split("\n");
+  const blocks = [];
+  let current = "";
+  let kind = null;
+  let fence = null;
+  let afterBlank = false;
+  const flush = () => {
+    if (current !== "") blocks.push(current);
+    current = "";
+    kind = null;
+    afterBlank = false;
+  };
+  const continues = (line, previous) => {
+    if (previous === "sticky") return true;
+    if (previous === "list") return LIST_MARKER.test(line) || /^(?: {2,}|\t)/.test(line);
+    if (previous === "quote") return /^ {0,3}>/.test(line);
+    return false;
+  };
+  lines.forEach((line, index) => {
+    const text = index === lines.length - 1 ? line : `${line}
+`;
+    const fenceMatch = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    if (fence !== null) {
+      current += text;
+      if (fenceMatch && fenceMatch[1] && fenceMatch[1][0] === fence[0] && fenceMatch[1].length >= fence.length && (fenceMatch[2] ?? "").trim() === "") {
+        fence = null;
+      }
+      return;
+    }
+    if (line.trim() === "") {
+      current += text;
+      afterBlank = kind !== null;
+      return;
+    }
+    if (afterBlank && !continues(line, kind)) flush();
+    afterBlank = false;
+    if (kind === null) {
+      if (LIST_MARKER.test(line)) kind = "list";
+      else if (/^ {0,3}>/.test(line)) kind = "quote";
+      else if (/^(?:\t| {4,}| {0,3}<)/.test(line)) kind = "sticky";
+      else kind = "plain";
+    }
+    current += text;
+    const marker = fenceMatch?.[1];
+    if (marker && !(marker[0] === "`" && (fenceMatch?.[2] ?? "").includes("`"))) fence = marker;
+  });
+  flush();
+  return blocks;
+}
+
+export {
+  messageText,
+  messageReasoning,
+  pendingApprovals,
+  threadPendingApprovals,
+  messageToolCalls,
+  messageSources,
+  messageFiles,
+  messageData,
+  findToolCall,
+  isStreaming,
+  lastMessageWithRole,
+  isTerminalToolState,
+  isBusy,
+  createThreadState,
+  threadReducer,
+  getBranchInfo,
+  getBranchInfoMap,
+  lastUserMessage,
+  isAbortError,
+  toThreadError,
+  streamEventToAction,
+  applyStreamEvent,
+  applyStreamEvents,
+  isTerminalStreamEvent,
+  createAbortableStream,
+  errorEvent,
+  parseCitations,
+  citedNumbers,
+  totalTokens,
+  mergeUsage,
+  formatTokenCount,
+  formatUsage,
+  formatDuration,
+  formatBytes,
+  splitCompletedSentences,
+  markdownToPlainText,
+  SAFE_LINK_PROTOCOLS,
+  SAFE_IMAGE_PROTOCOLS,
+  sanitizeUrl,
+  isSafeUrl,
+  sanitizeImageUrl,
+  isExternalUrl,
+  getUrlHostname,
+  splitMarkdownBlocks
+};
+//# sourceMappingURL=chunk-RP5SPJKM.js.map