@frontera-sdk/chat 1.52.45 → 1.52.46

package/dist/chunk-LS26G2N6.js

@@ -0,0 +1,120 @@
+import { mintPublicChatToken } from './chunk-UCUVHMJC.js';
+import { startChat } from './chunk-KZEGEV3P.js';
+import { chatErrorCode } from './chunk-YKQ5Z5EK.js';
+import { FronteraClient } from '@frontera-sdk/core/client';
+import { FronteraError } from '@frontera-sdk/core/errors';
+
+function newId() {
+  return typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `m-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+async function* chatEvents(response) {
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const parse = (block) => {
+    const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+    if (!data || data === "[DONE]") return null;
+    try {
+      const value = JSON.parse(data);
+      return value && typeof value === "object" ? value : null;
+    } catch {
+      return null;
+    }
+  };
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (value) buffer += decoder.decode(value, { stream: true });
+    let end = buffer.indexOf("\n\n");
+    while (end !== -1) {
+      const event = parse(buffer.slice(0, end));
+      buffer = buffer.slice(end + 2);
+      if (event) yield event;
+      end = buffer.indexOf("\n\n");
+    }
+    if (done) break;
+  }
+  const last = parse(buffer);
+  if (last) yield last;
+}
+var PublicChat = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  token = null;
+  conversationId = null;
+  /** Shown before the first message; sent back with it, so the conversation keeps it. */
+  openingMessage = null;
+  opened = false;
+  /** Mint the visitor's token, and learn the Agent's opening message. Called by `send` when needed. */
+  async open() {
+    const minted = await mintPublicChatToken({ ...this.options, ...this.options.fetchImpl ? { fetchImpl: this.options.fetchImpl } : {} });
+    this.token = minted.token;
+    if (!this.opened) this.openingMessage = minted.openingMessage ?? null;
+    this.opened = true;
+    return { openingMessage: this.openingMessage };
+  }
+  client() {
+    return new FronteraClient(
+      { apiBaseUrl: this.options.apiBaseUrl, credential: { kind: "token", token: this.token } },
+      this.options.fetchImpl ?? fetch
+    );
+  }
+  messagesFor(text) {
+    const user = { id: newId(), role: "user", parts: [{ type: "text", text }] };
+    if (this.conversationId || !this.openingMessage) return [user];
+    return [{ id: newId(), role: "assistant", parts: [{ type: "text", text: this.openingMessage }] }, user];
+  }
+  /** Send one message and read the reply: `waiting`, then the reply's text as it grows, then `done` (or `error`). */
+  async *send(text, signal) {
+    yield { type: "waiting" };
+    let response;
+    try {
+      if (!this.token) await this.open();
+      const start = () => startChat(this.client(), { messages: this.messagesFor(text), ...this.conversationId ? { conversationId: this.conversationId } : {} }, { signal });
+      let run;
+      try {
+        run = await start();
+      } catch (err) {
+        if (chatErrorCode(err) !== "UNAUTHORIZED") throw err;
+        await this.open();
+        run = await start();
+      }
+      this.conversationId = run.conversationId;
+      response = run.response;
+    } catch (err) {
+      yield { type: "error", error: asFronteraError(err) };
+      return;
+    }
+    const parts = /* @__PURE__ */ new Map();
+    const order = [];
+    const whole = () => order.map((id) => parts.get(id) ?? "").filter(Boolean).join("\n\n");
+    try {
+      for await (const event of chatEvents(response)) {
+        if (event.type === "text-delta" && typeof event.delta === "string") {
+          const id = typeof event.id === "string" ? event.id : "text";
+          if (!parts.has(id)) order.push(id);
+          parts.set(id, (parts.get(id) ?? "") + event.delta);
+          yield { type: "text", text: whole() };
+        } else if (event.type === "error") {
+          const message = typeof event.errorText === "string" ? event.errorText : "The reply failed.";
+          yield { type: "error", error: new FronteraError(message, { code: "INTERNAL_ERROR" }) };
+          return;
+        }
+      }
+    } catch (err) {
+      yield { type: "error", error: asFronteraError(err) };
+      return;
+    }
+    yield { type: "done" };
+  }
+};
+function asFronteraError(err) {
+  if (err instanceof FronteraError) return err;
+  return new FronteraError(err instanceof Error ? err.message : String(err), { code: "INTERNAL_ERROR" });
+}
+
+export { PublicChat, chatEvents };
+//# sourceMappingURL=chunk-LS26G2N6.js.map
+//# sourceMappingURL=chunk-LS26G2N6.js.map

package/dist/chunk-RLHHRJWS.js

@@ -0,0 +1,371 @@
+import { chatDoctor } from './chunk-VWUR3ECR.js';
+import { startChat, resumeStream } from './chunk-KZEGEV3P.js';
+import { FronteraError } from '@frontera-sdk/core/errors';
+
+var ChatClient = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+  }
+  client;
+  options;
+  async authorize(conversationId) {
+    const gate = this.options.authorizeConversation;
+    if (!gate) return;
+    if (!await gate(conversationId)) {
+      throw new FronteraError(`access to conversation ${conversationId} denied locally`, {
+        code: "FORBIDDEN_LOCAL"
+      });
+    }
+  }
+  // --- chat runs ---
+  /** Start (or continue) a run. See `stream.ts` for stream semantics. */
+  async startChat(request, options) {
+    if (request.conversationId) await this.authorize(request.conversationId);
+    return startChat(this.client, request, options);
+  }
+  /**
+   * Re-attach to a run's stream. Run ids are capabilities: they only leave the
+   * server through a response the caller was already authorized to receive, so
+   * there is no conversation gate here — treat them accordingly.
+   */
+  resumeStream(runId, options) {
+    return resumeStream(this.client, runId, options);
+  }
+  cancelRun(runId) {
+    return this.client.request(`/v1/chat/${encodeURIComponent(runId)}/cancel`, { method: "POST" });
+  }
+  steerRun(runId, message) {
+    return this.client.request(`/v1/chat/${encodeURIComponent(runId)}/steer`, {
+      method: "POST",
+      body: { message }
+    });
+  }
+  // --- approvals ---
+  /**
+   * The tool calls this conversation has parked, waiting on a person.
+   *
+   * Poll or call this on mount: a run blocked on an approval stays blocked
+   * across a page reload, and the `tool-approval-request` chunk that announced
+   * it is not replayed by a fresh `useChat`. Without reading them back, the
+   * conversation looks like an agent that stopped for no reason.
+   *
+   * End-user (`cht_`) tokens only — see `respondToApproval`.
+   */
+  async listPendingApprovals(conversationId) {
+    chatDoctor.resolved("approval");
+    chatDoctor.resolved("connect");
+    await this.authorize(conversationId);
+    const envelope = await this.client.requestEnvelope(
+      "/v1/chat/approvals",
+      { query: { conversationId } }
+    );
+    return envelope.data;
+  }
+  /**
+   * Approve or deny a parked tool call, releasing (or refusing) the run.
+   *
+   * Requires an end-user `cht_` token: the decision is recorded against the
+   * person who made it, and an `sak_` key is one credential shared by every
+   * user of your product — there is nobody it could be deciding as, so the
+   * server answers 403 (`FORBIDDEN`). An integration that wants its agent to
+   * act unattended sets the agent's approval mode to `auto` instead.
+   *
+   * Deciding twice is not an error: the first decision wins and this reports
+   * the settled status. A lapsed request answers `expired`.
+   */
+  respondToApproval(approvalId, decision) {
+    chatDoctor.resolved("approval");
+    return this.client.request(`/v1/chat/approvals/${encodeURIComponent(approvalId)}`, {
+      method: "POST",
+      body: { decision }
+    });
+  }
+  // --- app connections ---
+  /**
+   * Begin connecting the end user's own account for a parked `needs_connect`
+   * call, and get the URL to send them to.
+   *
+   * Three things must line up before this answers, and all three are one-time
+   * setup rather than per-user work:
+   *   1. the workspace has ITS OWN OAuth client for the provider (the
+   *      deployment-managed one cannot serve this — your users are authorising
+   *      your application, and only its owner can register your callback);
+   *   2. `redirectUri` is registered with that client AND on the workspace's
+   *      embed allowlist;
+   *   3. the install allows external users, and this user's token carries the
+   *      `plugin-connect` capability you granted when you minted it.
+   *
+   * Open the returned `authUrl` in a popup. Your callback receives `code` and
+   * `state` — hand them to `completeAppConnection`, then `resumeToolCall`.
+   */
+  startAppConnection(request) {
+    chatDoctor.resolved("connect");
+    return this.client.request("/v1/chat/app-connections/start", {
+      method: "POST",
+      body: request
+    });
+  }
+  /**
+   * Finish a connect from the code your own callback received.
+   *
+   * `state` is signed by us and names the install, the user and the redirect
+   * URI, so none of the three can be swapped between the authorize request and
+   * this call. Pass it back exactly as it arrived.
+   */
+  completeAppConnection(request) {
+    return this.client.request("/v1/chat/app-connections/exchange", {
+      method: "POST",
+      body: request
+    });
+  }
+  /**
+   * Re-run the tool call that was waiting on the connection.
+   *
+   * Not optional: the agent is blocked on a tool RESULT, not on an account, so
+   * a connect without this leaves the conversation exactly as stuck as before.
+   */
+  resumeToolCall(pendingToolCallId) {
+    return this.client.request("/v1/chat/app-connections/resume", {
+      method: "POST",
+      body: { pendingToolCallId }
+    });
+  }
+  /**
+   * The agents this credential may talk to — what an agent picker renders.
+   *
+   * Scoped to the credential, so a token bound to one agent lists exactly that
+   * agent while a workspace-wide token lists them all. The Console listing is
+   * session-only and returns configuration an end user has no business seeing,
+   * which is why this exists separately.
+   */
+  listAgents() {
+    return this.client.request("/v1/chat-agents");
+  }
+  /**
+   * Upload a file for this user, then reference the result in
+   * `startChat({ fileAttachments: [uploaded] })`.
+   *
+   * A chat-scoped route, not the platform's `/v1/upload`: that one authorises
+   * through workspace membership, which an end user of a customer's product
+   * does not have and should not need.
+   */
+  async upload(file, filename) {
+    const form = new FormData();
+    form.append("file", file, filename ?? file.name ?? "upload");
+    const response = await this.client.requestRaw("/v1/chat-uploads", {
+      method: "POST",
+      body: form
+    });
+    const payload = await response.json();
+    return payload.data ?? payload;
+  }
+  /**
+   * A live URL for a stored upload.
+   *
+   * The URL saved on a message is presigned and expires about an hour after
+   * upload, so anything rendered later re-signs from the stored path — without
+   * this, attachments in yesterday's messages become broken images.
+   */
+  async signUpload(storagePath) {
+    const { url } = await this.client.request("/v1/chat-uploads/sign", {
+      method: "POST",
+      body: { path: storagePath }
+    });
+    return url;
+  }
+  /** The artifacts this user owns — documents, decks and images the agent made. */
+  async listArtifacts(query = {}) {
+    const envelope = await this.client.requestEnvelope("/v1/chat-artifacts", { query });
+    return { data: envelope.data, nextCursor: envelope.nextCursor ?? void 0 };
+  }
+  getArtifact(id) {
+    return this.client.request(`/v1/chat-artifacts/${encodeURIComponent(id)}`);
+  }
+  /**
+   * The artifact's contents as TEXT.
+   *
+   * Only for artifacts that are text — markdown, csv, code. Reading a PNG or a
+   * spreadsheet through here destroys it: `.text()` decodes the bytes as UTF-8,
+   * and every byte that is not valid UTF-8 becomes a replacement character on
+   * the way. Use `getArtifactFile` for anything binary.
+   */
+  async getArtifactContent(id) {
+    const response = await this.client.requestRaw(
+      `/v1/chat-artifacts/${encodeURIComponent(id)}/file`
+    );
+    return response.text();
+  }
+  /**
+   * The artifact's raw bytes, with the server's own content type.
+   *
+   * The Blob carries the type the route reported rather than one guessed from
+   * the format, so an <img> or a PDF reader gets what it needs without the
+   * caller restating it — and a wrong guess here is an image that silently
+   * will not display.
+   */
+  async getArtifactFile(id) {
+    const response = await this.client.requestRaw(
+      `/v1/chat-artifacts/${encodeURIComponent(id)}/file`
+    );
+    return response.blob();
+  }
+  /**
+   * A PDF rendering of an artifact a browser cannot open itself.
+   *
+   * `.docx` and `.pptx` are bytes with no source to fall back on, so the
+   * service renders a PDF beside them and this returns it — displaying one
+   * without shipping an OOXML reader.
+   *
+   * Only artifacts with `previewKey` set have one; anything else answers 404
+   * as `NOT_FOUND`. Check the field before asking, or catch it.
+   */
+  /**
+   * Save an edit made in the viewer — a sheet cell, a document's text.
+   *
+   * Produces a new REVISION rather than overwriting: the service re-renders to
+   * a versioned storage key and bumps the version, so the artifact keeps the
+   * history an edit implies.
+   */
+  async updateArtifact(id, patch) {
+    return this.client.request(
+      `/v1/chat-artifacts/${encodeURIComponent(id)}`,
+      { method: "PATCH", body: patch }
+    );
+  }
+  /** One revision's content — what the inline "viewing v1" panel shows. */
+  async getArtifactVersion(id, version) {
+    return this.client.request(
+      `/v1/chat-artifacts/${encodeURIComponent(id)}/versions/${encodeURIComponent(String(version))}`
+    );
+  }
+  /**
+   * Roll back to a revision.
+   *
+   * Writes a new revision holding the old content — nothing is deleted, so a
+   * restore made in error is itself undoable.
+   */
+  async restoreArtifactVersion(id, version) {
+    return this.client.request(
+      `/v1/chat-artifacts/${encodeURIComponent(id)}/versions/${encodeURIComponent(String(version))}/restore`,
+      { method: "POST" }
+    );
+  }
+  /** Revisions of one artifact, newest first. Metadata only. */
+  async listArtifactVersions(id) {
+    return this.client.request(
+      `/v1/chat-artifacts/${encodeURIComponent(id)}/versions`
+    );
+  }
+  /**
+   * The rendition of a PAST version, for the viewer's version picker.
+   *
+   * Separate from `getArtifactPreview` rather than an optional argument: the
+   * current preview lives at a different path, and a version of `0` or `NaN`
+   * silently falling back to "current" is how a reader ends up looking at
+   * today's document under yesterday's heading.
+   */
+  async getArtifactVersionPreview(id, version) {
+    const response = await this.client.requestRaw(
+      `/v1/chat-artifacts/${encodeURIComponent(id)}/versions/${encodeURIComponent(String(version))}/preview`
+    );
+    return response.blob();
+  }
+  async getArtifactPreview(id) {
+    const response = await this.client.requestRaw(
+      `/v1/chat-artifacts/${encodeURIComponent(id)}/preview`
+    );
+    return response.blob();
+  }
+  // --- sessions ---
+  async listSessions(query = {}) {
+    const envelope = await this.client.requestEnvelope("/v1/sessions", {
+      query: {
+        cursor: query.cursor,
+        limit: query.limit,
+        status: query.status,
+        label: query.label,
+        group: query.group,
+        search: query.search,
+        pinned: query.pinned,
+        source: query.source,
+        agentName: query.agentName,
+        agentId: query.agentId,
+        updatedAfter: query.updatedAfter,
+        updatedBefore: query.updatedBefore,
+        surface: query.surface
+      }
+    });
+    return { data: envelope.data, nextCursor: envelope.nextCursor ?? void 0 };
+  }
+  createSession(request = {}) {
+    return this.client.request("/v1/sessions", { method: "POST", body: request });
+  }
+  async getSession(id) {
+    await this.authorize(id);
+    return this.client.request(`/v1/sessions/${encodeURIComponent(id)}`);
+  }
+  async getMessages(id, options = {}) {
+    await this.authorize(id);
+    return this.client.request(`/v1/sessions/${encodeURIComponent(id)}/messages`, {
+      query: { limit: options.limit }
+    });
+  }
+  // The four below act on ONE person's own session, so they need a credential
+  // that names one: a `cht_` end-user token works, an `sak_` key answers 403
+  // (`FORBIDDEN`) because it stands for every user of your product at once.
+  //
+  // `getShare`/`createShare` are deliberately absent: a share link works with
+  // no credential at all, and whether your end users may publish a
+  // conversation is your product's decision to implement, not a default they
+  // inherit from us. Those routes are platform-only and answer 403.
+  /**
+   * Rename, pin, or restatus a conversation.
+   *
+   * Answers `{ success: true }` rather than the updated row — the service
+   * confirms the write and nothing more. Typed as what actually arrives: a
+   * `Session` here would be a promise the server never made, and the first
+   * caller to read `.title` off it would get `undefined` with no explanation.
+   * Re-read with `getSession` when you need the new state.
+   */
+  async updateSession(id, patch) {
+    await this.authorize(id);
+    return this.client.request(`/v1/sessions/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body: patch
+    });
+  }
+  async deleteSession(id) {
+    await this.authorize(id);
+    await this.client.request(`/v1/sessions/${encodeURIComponent(id)}`, { method: "DELETE" });
+  }
+  async forkSession(id, messageId) {
+    await this.authorize(id);
+    return this.client.request(`/v1/sessions/${encodeURIComponent(id)}/fork`, {
+      method: "POST",
+      body: { messageId }
+    });
+  }
+  /** Returns the export as a raw string — this route has no JSON envelope. */
+  async exportSession(id, format) {
+    await this.authorize(id);
+    const response = await this.client.requestRaw(
+      `/v1/sessions/${encodeURIComponent(id)}/export`,
+      { query: { format } }
+    );
+    return response.text();
+  }
+  // --- aux ---
+  async getFollowUps(conversationId, messageId) {
+    await this.authorize(conversationId);
+    return this.client.request("/v1/follow-ups", { query: { conversationId, messageId } });
+  }
+  async getMessageMetadata(conversationId, messageId) {
+    await this.authorize(conversationId);
+    return this.client.request("/v1/message-metadata", { query: { conversationId, messageId } });
+  }
+};
+
+export { ChatClient };
+//# sourceMappingURL=chunk-RLHHRJWS.js.map
+//# sourceMappingURL=chunk-RLHHRJWS.js.map

package/dist/chunk-UCUVHMJC.js

@@ -0,0 +1,62 @@
+import { errorFromResponse } from '@frontera-sdk/core/errors';
+
+// src/public-token.ts
+function browserLanguage() {
+  try {
+    return typeof navigator === "undefined" ? void 0 : navigator.language || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function visitorPassStorageKey(publishableKey) {
+  return `frontera:visitor:${publishableKey.slice(0, 12)}`;
+}
+function defaultStorage() {
+  try {
+    return typeof localStorage === "undefined" ? null : localStorage;
+  } catch {
+    return null;
+  }
+}
+function read(storage, key) {
+  try {
+    return storage?.getItem(key) ?? null;
+  } catch {
+    return null;
+  }
+}
+function write(storage, key, value) {
+  try {
+    storage?.setItem(key, value);
+  } catch {
+  }
+}
+async function mintPublicChatToken(options) {
+  const storage = options.storage === void 0 ? defaultStorage() : options.storage;
+  const passKey = visitorPassStorageKey(options.publishableKey);
+  const visitorPass = read(storage, passKey);
+  const language = options.language ?? browserLanguage();
+  const response = await (options.fetchImpl ?? fetch)(`${options.apiBaseUrl}/v1/chat-tokens/public`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    // Never `include`: this call carries the key, not anyone's cookies.
+    credentials: "omit",
+    body: JSON.stringify({
+      publishableKey: options.publishableKey,
+      ...visitorPass ? { visitorPass } : {},
+      ...language ? { language } : {}
+    })
+  });
+  const body = await response.json().catch(() => null);
+  if (!response.ok || !body?.data) throw errorFromResponse(response.status, body);
+  if (body.data.visitorPass) write(storage, passKey, body.data.visitorPass);
+  return {
+    token: body.data.token,
+    expiresAt: body.data.expiresAt,
+    ...body.data.openingMessage ? { openingMessage: body.data.openingMessage } : {}
+  };
+}
+
+export { mintPublicChatToken, visitorPassStorageKey };
+//# sourceMappingURL=chunk-UCUVHMJC.js.map
+//# sourceMappingURL=chunk-UCUVHMJC.js.map

package/dist/chunk-VWUR3ECR.js

@@ -0,0 +1,115 @@
+// src/doctor.ts
+var DEFAULT_GRACE_MS = 1e4;
+function defaultEnabled() {
+  const mode = typeof process !== "undefined" ? "development" : void 0;
+  return mode !== "production";
+}
+var ADVICE = {
+  approval: [
+    "A tool call is parked waiting for a person to approve it, and nothing has answered.",
+    "The run is alive and BLOCKED \u2014 it will not continue until it is settled or expires.",
+    "",
+    "  const pending = await chat.listPendingApprovals(conversationId)",
+    "  await chat.respondToApproval(pending[0].id, 'approve')",
+    "",
+    "Using @frontera-sdk/chat-ui, render <PendingCards conversationId={\u2026} />.",
+    "Read the pending list on mount too: a reload loses the stream chunk, not the block."
+  ].join("\n"),
+  connect: [
+    "A tool needs this user's own account and returned `needs_connect`; nothing has started a connection.",
+    "The agent has been told NOT to ask in prose, so if your UI stays silent, nothing is said.",
+    "",
+    "  await runAppConnection(chat, { pendingToolCallId, installId, redirectUri })",
+    "",
+    "Using @frontera-sdk/chat-ui, pass `connectRedirectUri` to <FronteraChat>."
+  ].join("\n"),
+  unauthorized: [
+    "A request was refused with UNAUTHORIZED and no refresh is wired, so the next send will fail too.",
+    "",
+    "  const session = createTokenSession({ apiBaseUrl, getToken })",
+    "  createChatTransport(session.getClient, { onUnauthorized: session.refresh })"
+  ].join("\n")
+};
+var ChatDoctor = class {
+  options = {};
+  timers = /* @__PURE__ */ new Map();
+  configure(options) {
+    this.options = { ...this.options, ...options };
+  }
+  get enabled() {
+    return this.options.enabled ?? defaultEnabled();
+  }
+  warn(concern) {
+    const message = `[frontera-chat] ${ADVICE[concern]}`;
+    if (this.options.onWarn) this.options.onWarn(concern, message);
+    else console.warn(message);
+  }
+  /**
+   * Something parked. Start counting; `resolved` before the grace period ends
+   * cancels it.
+   */
+  parked(concern) {
+    if (!this.enabled || this.timers.has(concern)) return;
+    const timer = setTimeout(() => {
+      this.timers.delete(concern);
+      this.warn(concern);
+    }, this.options.graceMs ?? DEFAULT_GRACE_MS);
+    timer.unref?.();
+    this.timers.set(concern, timer);
+  }
+  /** The integration did the thing. Nothing to warn about. */
+  resolved(concern) {
+    const timer = this.timers.get(concern);
+    if (!timer) return;
+    clearTimeout(timer);
+    this.timers.delete(concern);
+  }
+  /** Immediate, not timed: nothing about a missing refresh improves by waiting. */
+  noticed(concern) {
+    if (this.enabled) this.warn(concern);
+  }
+  /** For tests, and for a host that unmounts a chat mid-run. */
+  reset() {
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+  }
+  /**
+   * Watch a chat stream for the two things that park a run.
+   *
+   * The body is teed rather than parsed: this reads a copy as text and matches
+   * two markers, leaving the real stream untouched for the AI SDK. A full parse
+   * here would be a second implementation of the protocol, kept in step with
+   * the first by hope.
+   */
+  observe(response) {
+    if (!this.enabled || !response.body) return response;
+    const [forCaller, forDoctor] = response.body.tee();
+    void this.scan(forDoctor);
+    return new Response(forCaller, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  async scan(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const text = decoder.decode(value, { stream: true });
+        if (text.includes("tool-approval-request")) this.parked("approval");
+        if (text.includes("needs_connect")) this.parked("connect");
+      }
+    } catch {
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+var chatDoctor = new ChatDoctor();
+
+export { chatDoctor };
+//# sourceMappingURL=chunk-VWUR3ECR.js.map
+//# sourceMappingURL=chunk-VWUR3ECR.js.map