@opengeni/sdk 3.3.2-canary.1 → 3.4.0

package/dist/chat/index.js

@@ -0,0 +1,1369 @@
+import {
+  CHAT_SESSION_NAMESPACE,
+  chatIdempotencyKey,
+  chatIdentityName,
+  chatSessionId,
+  createWorkspaceIdResolver,
+  isUuid,
+  uuidV5
+} from "../chunk-XA7HVIHI.js";
+import {
+  OpenGeniEmbeddingClient
+} from "../chunk-6GYGMLX4.js";
+import "../chunk-UME3X7CP.js";
+import "../chunk-OI5YLASH.js";
+import {
+  chatDefaults
+} from "../chunk-UM4ZXXJR.js";
+import {
+  ChatPendingFold,
+  ChatTurnFold,
+  OpenGeniChatError,
+  approvalPending,
+  asRecord,
+  humanInputPending,
+  stringValue
+} from "../chunk-OV3POE62.js";
+import "../chunk-S2NLS3ES.js";
+import "../chunk-X5ITQVXE.js";
+import {
+  parseSseStream
+} from "../chunk-4AHR4KGA.js";
+import "../chunk-NCU5OAN7.js";
+import "../chunk-YJCHB7R3.js";
+import {
+  OpenGeniApiError,
+  OpenGeniSetupError
+} from "../chunk-7EWT3PV6.js";
+
+// src/chat/opengeni.ts
+var DEFAULT_OPENGENI_BASE_URL = "https://app.opengeni.ai";
+var DEFAULT_CHAT_SOURCE = "app";
+var MISSING_API_KEY_MESSAGE = "Opengeni requires an apiKey. Set OPENGENI_API_KEY in the server environment.";
+async function missingApiKeyFetch() {
+  throw new TypeError(MISSING_API_KEY_MESSAGE);
+}
+var IMPORTED_HISTORY_MAX_CHARS = 3e4;
+var MODEL_CONTEXT_MAX_CHARS = 32768;
+var IMPORTED_HISTORY_HEADER = "Earlier conversation imported from the product, oldest first:";
+var IMPORTED_HISTORY_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "system"]);
+var OpenGeni = class {
+  client;
+  /**
+   * The organization id: the one passed to the constructor, else the one
+   * derived from the API key once {@link resolveOrganizationId} (or any
+   * workspace lookup) has run. An empty string before that; prefer
+   * `await og.resolveOrganizationId()`.
+   */
+  organizationId;
+  source;
+  sessions;
+  resolveWorkspaceId;
+  implicitAgentAdmission;
+  pendingOrganizationId;
+  constructor(options) {
+    this.client = new OpenGeniEmbeddingClient({
+      // An empty value (a blank `OPENGENI_API_BASE_URL=` in .env) means the default.
+      baseUrl: options.baseUrl?.trim() || DEFAULT_OPENGENI_BASE_URL,
+      // A missing key fails each request, not construction: a module-scope
+      // `new Opengeni({ apiKey: process.env.OPENGENI_API_KEY! })` must not
+      // break `next build` (or any import) where the secret only exists at
+      // runtime.
+      ...options.apiKey ? { apiKey: options.apiKey, ...options.fetch ? { fetch: options.fetch } : {} } : { fetch: missingApiKeyFetch }
+    });
+    this.organizationId = options.organizationId?.trim() ?? "";
+    this.source = options.source ?? DEFAULT_CHAT_SOURCE;
+    this.resolveWorkspaceId = createWorkspaceIdResolver(this.client, {
+      organizationId: () => this.resolveOrganizationId(),
+      source: this.source,
+      workspaceName: options.workspaceName,
+      memberPermissions: options.memberPermissions
+    });
+    this.sessions = { list: (listOptions) => this.listSessions(listOptions) };
+  }
+  /**
+   * The organization that owns every workspace this facade creates. Uses the
+   * constructor's `organizationId`, else reads it once from the API key
+   * (`GET /v1/access/me`) and caches it.
+   */
+  async resolveOrganizationId() {
+    if (this.organizationId) return this.organizationId;
+    if (!this.pendingOrganizationId) {
+      const pending = this.client.getAccessContext().then((access) => {
+        const credential = access.credential;
+        if (credential && credential.kind !== "organization_api_key") {
+          throw new TypeError(
+            "Opengeni needs an organization API key to create workspaces; this is a workspace key."
+          );
+        }
+        const organizationId = credential?.accountId ?? access.defaultAccountId;
+        if (!organizationId) {
+          throw new TypeError(
+            "Could not derive the organization from this API key. Pass organizationId."
+          );
+        }
+        this.organizationId = organizationId;
+        return organizationId;
+      });
+      pending.catch(() => {
+        if (this.pendingOrganizationId === pending) this.pendingOrganizationId = void 0;
+      });
+      this.pendingOrganizationId = pending;
+    }
+    return await this.pendingOrganizationId;
+  }
+  /**
+   * Translate your own ids to the Opengeni workspace id, creating the
+   * workspace on first use (cached per instance):
+   * `{ tenant }` is one workspace per tenant, `{ user }` (no tenant) is one
+   * workspace per user, and `{ workspaceId }` is returned as is. Opengeni adds
+   * a tenant workspace's users on their first request; a per-user workspace
+   * gets its one owner from the SDK and admits nobody else.
+   */
+  async workspaceId(target) {
+    if (target.workspaceId === "" || target.tenant === "") {
+      throw new TypeError("tenant and workspaceId must be non-empty ids.");
+    }
+    if (target.workspaceId) return target.workspaceId;
+    if (target.tenant) {
+      return await this.workspaceIdFor({ tenant: target.tenant }, { isolation: "tenant" });
+    }
+    if ("tenant" in target || "workspaceId" in target) {
+      throw new TypeError(
+        "tenant or workspaceId is undefined. Pass a non-empty id, or omit the key for one workspace per user."
+      );
+    }
+    const user = "user" in target ? target.user : void 0;
+    if (user) {
+      return await this.workspaceIdFor({ user }, { isolation: "user" });
+    }
+    throw new TypeError("Pass tenant, user, or workspaceId.");
+  }
+  /**
+   * Resolve a tenant workspace or a user's own workspace (user isolation, per
+   * tenant when one is given). A user's own workspace is provisioned with that
+   * user as its only explicit member.
+   */
+  async workspaceIdFor(target, options) {
+    return await this.resolveWorkspaceId(target, options);
+  }
+  /** `chats: "isolated"` keeps its tenant-plus-user workspace; a user alone gets their own. */
+  async isolatedWorkspaceId(target) {
+    if (target.workspaceId) {
+      throw new TypeError('chats: "isolated" requires a tenant or user, not a workspaceId.');
+    }
+    return await this.workspaceIdFor(
+      { tenant: target.tenant, user: target.user },
+      { isolation: "user" }
+    );
+  }
+  /**
+   * Address one conversation; the session is created lazily on the first send.
+   * Identity selects authority, not the conversation address. The workspace
+   * is the tenant's, the user's own (user only), or the explicit id; Opengeni
+   * adds the user to it on their first request.
+   * Legacy user-namespaced conversations remain accessible by their session ID.
+   */
+  async chat(options) {
+    if (!options.conversation) throw new TypeError("chat() requires a conversation id.");
+    if (options.chats === "private" && !options.user) {
+      throw new OpenGeniChatError(
+        "chats_requires_user",
+        'chats: "private" requires an authenticated product user. Pass user or use chats: "shared".'
+      );
+    }
+    const legacy = options.chats === void 0 && !options.user;
+    const defaults = legacy ? {
+      visibility: "workspace",
+      agentAccess: "session",
+      memoryScope: "off"
+    } : chatDefaults(options.chats ?? "private");
+    const explicitAgent = options.agent !== void 0 || options.create?.agent !== void 0;
+    const agentAccess = options.agentAccess ?? defaults.agentAccess;
+    const memoryScope = options.memory === false ? "off" : options.memory ?? (legacy ? agentAccess === "session" ? "off" : agentAccess : defaults.memoryScope);
+    if (memoryScope === "user" && !options.user) {
+      throw new OpenGeniChatError(
+        "memory_scope_requires_user",
+        'memory: "user" requires an authenticated product user.'
+      );
+    }
+    const client = options.user ? this.client.asUser(options.user, { source: this.source }) : this.client;
+    const workspaceId = options.chats === "isolated" ? await this.isolatedWorkspaceId(options) : await this.workspaceId(options);
+    const sessionId = options.sessionId ?? await chatSessionId(workspaceId, options.conversation);
+    const session = await this.findSession(client, workspaceId, sessionId);
+    const buildCreate = (text, send) => {
+      const { modelContext: createContext, ...create } = options.create ?? {};
+      const messageContext = send.modelContext?.trim() || void 0;
+      const reserved = messageContext ? messageContext.length + 2 : 0;
+      const baseContext = createContext ?? (send.importedHistory ? formatImportedHistory(
+        send.importedHistory,
+        Math.min(IMPORTED_HISTORY_MAX_CHARS, MODEL_CONTEXT_MAX_CHARS - reserved)
+      ) : void 0);
+      const context = [baseContext, messageContext].filter(Boolean).join("\n\n") || void 0;
+      return {
+        ...options.model !== void 0 ? { model: options.model } : {},
+        ...options.instructions !== void 0 ? { instructions: options.instructions } : {},
+        ...options.skills !== void 0 ? { skills: options.skills } : {},
+        ...options.tools !== void 0 ? { tools: options.tools } : {},
+        ...create,
+        visibility: create.visibility ?? defaults.visibility,
+        agentAccess: create.agentAccess ?? agentAccess,
+        memoryScope: create.memoryScope ?? memoryScope,
+        agent: {
+          capabilities: create.agent?.capabilities ?? options.agent?.capabilities,
+          identity: create.agent?.identity !== void 0 ? create.agent.identity : options.agent?.identity,
+          instructions: create.agent?.instructions ?? options.agent?.instructions,
+          renderer: create.agent?.renderer ?? options.agent?.renderer ?? "markdown"
+        },
+        ...context !== void 0 ? { modelContext: context } : {},
+        ...messagePolicy(send),
+        initialMessage: text,
+        requestedSessionId: sessionId,
+        idempotencyKey: chatIdempotencyKey(sessionId)
+      };
+    };
+    return new Chat(client, {
+      workspaceId,
+      sessionId,
+      conversation: options.conversation,
+      session,
+      buildCreate,
+      submitCreate: (request) => this.createChatSession(client, workspaceId, request, explicitAgent)
+    });
+  }
+  async createChatSession(client, workspaceId, request, explicitAgent) {
+    const { agent, ...withoutAgent } = request;
+    const implicitAgent = !explicitAgent && this.implicitAgentAdmission !== false;
+    try {
+      return await client.createSession(
+        workspaceId,
+        explicitAgent || implicitAgent ? { ...withoutAgent, agent } : withoutAgent
+      );
+    } catch (error) {
+      if (!(error instanceof OpenGeniApiError) || error.status !== 422 || !(error.code === "agent_config_not_enabled" || error.code === "SESSION_CREATE_REJECTED" && error.details?.code === "agent_config_not_enabled") || error.outcomeUnknown)
+        throw error;
+      if (explicitAgent) {
+        throw new OpenGeniApiError(error.status, error.body, {
+          code: error.code,
+          retryable: false,
+          correlationId: error.correlationId,
+          displayMessage: "Explicit agent configuration requires the deployment operator to set OPENGENI_AGENT_CONFIG_ADMISSION_ENABLED=true. The SDK has kept your agent settings unchanged."
+        });
+      }
+      if (!implicitAgent) throw error;
+      this.implicitAgentAdmission = false;
+      return await client.createSession(workspaceId, withoutAgent);
+    }
+  }
+  /**
+   * Address an existing session with native API authorization. The same shared
+   * session can be opened by different authorized users. Pass null only for an
+   * explicitly service-owned operation; the API still enforces service access.
+   */
+  async chatBySessionId(target) {
+    const client = target.user !== null ? this.client.asUser(target.user, { source: this.source }) : this.client;
+    const session = await client.getSession(target.workspaceId, target.sessionId);
+    return new Chat(client, {
+      workspaceId: target.workspaceId,
+      sessionId: target.sessionId,
+      conversation: null,
+      session,
+      buildCreate: null
+    });
+  }
+  async findSession(client, workspaceId, sessionId) {
+    try {
+      return await client.getSession(workspaceId, sessionId);
+    } catch (error) {
+      if (error instanceof OpenGeniApiError && error.status === 404) return null;
+      throw error;
+    }
+  }
+  async listSessions(options) {
+    const workspaceId = options.chats === "isolated" ? await this.isolatedWorkspaceId(options) : await this.workspaceId(options);
+    const client = options.user ? this.client.asUser(options.user, { source: this.source }) : this.client;
+    return await client.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/sessions`,
+      void 0,
+      {
+        ...options.limit !== void 0 ? { limit: String(options.limit) } : {}
+      }
+    );
+  }
+};
+var Chat = class {
+  constructor(client, init) {
+    this.client = client;
+    this.workspaceId = init.workspaceId;
+    this.sessionId = init.sessionId;
+    this.conversation = init.conversation;
+    this.session = init.session;
+    this.buildCreate = init.buildCreate;
+    this.submitCreate = init.submitCreate ?? ((request) => this.client.createSession(this.workspaceId, request));
+  }
+  workspaceId;
+  sessionId;
+  /** The conversation id this chat was opened with; null when addressed by session id. */
+  conversation;
+  session;
+  buildCreate;
+  submitCreate;
+  pendingTurnId = null;
+  /** True once the session exists on the server. */
+  get created() {
+    return this.session !== null;
+  }
+  /** Send a message and wait for the agent's reply text. */
+  async send(text, options = {}) {
+    return await settle(this.stream(text, options));
+  }
+  /** Send a message and observe the reply as it streams. Ends with a `done` chunk. */
+  async *stream(text, options = {}) {
+    const submitted = options.steer ? await this.submitSteer(text, options) : await this.submit(text, options);
+    yield* this.streamTurn(submitted, options.signal);
+  }
+  /** Supersede the current inference with this message and wait for the reply. */
+  async steer(text, options = {}) {
+    return await this.send(text, { ...options, steer: true });
+  }
+  /** Answer a pending approval or human-input request, then wait for the reply. */
+  async respond(input, options = {}) {
+    return await settle(this.respondStream(input, options));
+  }
+  async *respondStream(input, options = {}) {
+    const submitted = await this.submitResponse(input);
+    yield* this.streamTurn(submitted, options.signal);
+  }
+  /** User and assistant text in order, from the durable event log. */
+  async history() {
+    return (await this.snapshot()).messages;
+  }
+  /** Restore history and pending decisions from the complete ordered timeline. */
+  async snapshot() {
+    if (!this.session) return { messages: [], pending: [], status: null };
+    const pending = new ChatPendingFold();
+    let status = this.session.status;
+    const messages = [];
+    let lastAssistantTurn = null;
+    let heldCommentary = null;
+    const releaseHeldCommentary = (turnId) => {
+      if (!heldCommentary || heldCommentary.turnId !== turnId) return;
+      const held = heldCommentary;
+      heldCommentary = null;
+      const index = messages.findIndex((message2) => message2.sequence > held.sequence);
+      const message = { role: "assistant", text: held.text, sequence: held.sequence };
+      if (index === -1) messages.push(message);
+      else messages.splice(index, 0, message);
+    };
+    let after = 0;
+    while (true) {
+      const result = await this.client.listEventPage(this.workspaceId, this.sessionId, {
+        after,
+        includeTypes: [
+          "user.message",
+          "agent.message.completed",
+          "session.requiresAction",
+          "session.humanInput.requested",
+          "user.approvalDecision",
+          "user.humanInputResponse",
+          "turn.completed",
+          "turn.failed",
+          "turn.cancelled",
+          "session.status.changed"
+        ]
+      });
+      for (const event of result.events) {
+        pending.push(event);
+        if (event.type === "session.status.changed") {
+          const next = asRecord(event.payload).status;
+          if (typeof next === "string") status = next;
+        }
+        const turnId = typeof event.turnId === "string" ? event.turnId : null;
+        if (event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled" || event.type === "session.requiresAction" || event.type === "session.humanInput.requested") {
+          releaseHeldCommentary(turnId);
+        }
+        const text = stringValue(asRecord(event.payload).text);
+        if (!text) continue;
+        if (event.type === "user.message") {
+          messages.push({ role: "user", text, sequence: event.sequence });
+          lastAssistantTurn = null;
+          continue;
+        }
+        if (event.type !== "agent.message.completed") continue;
+        if (asRecord(event.payload).phase === "commentary") {
+          heldCommentary = { turnId, text, sequence: event.sequence };
+          continue;
+        }
+        if (heldCommentary?.turnId === turnId) heldCommentary = null;
+        const last = messages.at(-1);
+        if (last?.role === "assistant" && turnId !== null && turnId === lastAssistantTurn && text.startsWith(last.text)) {
+          last.text = text;
+          last.sequence = event.sequence;
+          continue;
+        }
+        messages.push({ role: "assistant", text, sequence: event.sequence });
+        lastAssistantTurn = turnId;
+      }
+      if (!result.hasMore || result.nextAfter === null || result.events.length === 0) break;
+      if (result.nextAfter <= after) {
+        throw new OpenGeniChatError(
+          "history_cursor_stalled",
+          "History pagination did not advance."
+        );
+      }
+      after = result.nextAfter;
+    }
+    return { messages, pending: pending.pending(), status };
+  }
+  async submit(text, send) {
+    if (!this.session) {
+      if (!this.buildCreate) {
+        throw new OpenGeniChatError("session_missing", "This session no longer exists.");
+      }
+      const created = await this.submitCreate(this.buildCreate(text, send));
+      this.session = created;
+      if (created.initialMessage === text) {
+        return { after: 0, turnId: created.initialTurnId };
+      }
+    }
+    const event = await this.client.sendMessage(
+      this.workspaceId,
+      this.sessionId,
+      messageInput(text, send)
+    );
+    return submittedFrom(event);
+  }
+  async submitSteer(text, send) {
+    if (!this.session) return await this.submit(text, send);
+    const result = await this.client.steerMessage(
+      this.workspaceId,
+      this.sessionId,
+      messageInput(text, send)
+    );
+    return { after: result.accepted.sequence, turnId: result.turn.id ?? null };
+  }
+  async submitResponse(input) {
+    let event;
+    if ("decision" in input) {
+      event = await this.client.sendApprovalDecision(this.workspaceId, this.sessionId, {
+        approvalId: input.requestId,
+        decision: input.decision,
+        ...input.message !== void 0 ? { message: input.message } : {}
+      });
+    } else if ("answers" in input) {
+      event = await this.client.submitHumanInputResponse(
+        this.workspaceId,
+        this.sessionId,
+        input.requestId,
+        { outcome: "answered", answers: input.answers }
+      );
+    } else {
+      event = await this.client.submitHumanInputResponse(
+        this.workspaceId,
+        this.sessionId,
+        input.requestId,
+        { outcome: "skipped" }
+      );
+    }
+    const submitted = submittedFrom(event);
+    return { ...submitted, turnId: submitted.turnId ?? this.pendingTurnId };
+  }
+  async *streamTurn(submitted, signal) {
+    const upstream = new AbortController();
+    const onAbort = () => upstream.abort();
+    if (signal?.aborted) upstream.abort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
+    const fold = new ChatTurnFold(this.workspaceId, this.sessionId, submitted.turnId);
+    const events = this.client.streamEvents(this.workspaceId, this.sessionId, {
+      after: submitted.after,
+      signal: upstream.signal
+    });
+    try {
+      while (true) {
+        const next = await events.next();
+        if (next.done) break;
+        const event = next.value;
+        const step = fold.push(event);
+        for (const chunk of step.chunks) yield chunk;
+        if (!step.terminal && event.type === "session.status.changed" && asRecord(event.payload).status === "requires_action" && (event.turnId == null || fold.turnId === null || event.turnId === fold.turnId)) {
+          const pending = (await this.snapshot()).pending[0];
+          if (pending) {
+            fold.pending = pending;
+            this.pendingTurnId = fold.turnId;
+            yield { type: "pending", pending };
+            yield { type: "done", reply: fold.reply("pending") };
+            return;
+          }
+        }
+        if (!step.terminal) continue;
+        if (step.terminal === "failed") throw fold.failureError();
+        this.pendingTurnId = step.terminal === "pending" ? fold.turnId : null;
+        yield { type: "done", reply: fold.reply(step.terminal) };
+        return;
+      }
+      if (signal?.aborted) throw abortError();
+      throw new OpenGeniChatError(
+        "stream_ended",
+        "The event stream ended before the turn settled."
+      );
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      upstream.abort();
+      void Promise.resolve(events.return(void 0)).catch(() => void 0);
+    }
+  }
+};
+async function settle(chunks) {
+  for await (const chunk of chunks) {
+    if (chunk.type === "done") return chunk.reply;
+  }
+  throw new OpenGeniChatError("stream_ended", "The event stream ended before the turn settled.");
+}
+function messagePolicy(send) {
+  return {
+    ...send.model !== void 0 ? { model: send.model } : {},
+    ...send.reasoningEffort !== void 0 ? { reasoningEffort: send.reasoningEffort } : {},
+    ...send.latencyMode !== void 0 ? { latencyMode: send.latencyMode } : {}
+  };
+}
+function messageInput(text, send) {
+  const modelContext = send.modelContext?.trim();
+  return { text, ...messagePolicy(send), ...modelContext ? { modelContext } : {} };
+}
+function submittedFrom(event) {
+  return {
+    after: event.sequence,
+    turnId: typeof event.turnId === "string" ? event.turnId : null
+  };
+}
+function formatImportedHistory(messages, maxChars = IMPORTED_HISTORY_MAX_CHARS) {
+  const lines = messages.filter(
+    (message) => IMPORTED_HISTORY_ROLES.has(message.role) && typeof message.text === "string" && message.text.trim().length > 0
+  ).map((message) => `${message.role}: ${message.text}`);
+  if (lines.length === 0) return void 0;
+  let budget = Math.min(maxChars, IMPORTED_HISTORY_MAX_CHARS) - IMPORTED_HISTORY_HEADER.length;
+  const kept = [];
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index];
+    const cost = line.length + 1;
+    if (cost <= budget) {
+      kept.unshift(line);
+      budget -= cost;
+      continue;
+    }
+    if (kept.length === 0 && budget > 1) kept.unshift(line.slice(line.length - (budget - 1)));
+    break;
+  }
+  if (kept.length === 0) return void 0;
+  return `${IMPORTED_HISTORY_HEADER}
+${kept.join("\n")}`;
+}
+function abortError() {
+  const error = new Error("The chat request was aborted.");
+  error.name = "AbortError";
+  return error;
+}
+
+// src/chat/http.ts
+var CHAT_CONVERSATION_HEADER = "x-opengeni-conversation";
+var CHAT_ERROR_STATUS = {
+  memory_scope_requires_user: 400,
+  conversation_not_authorized: 403,
+  conversation_mismatch: 409
+};
+function jsonResponse(body, status = 200, headers = {}) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json; charset=utf-8", ...headers }
+  });
+}
+function errorResponse(status, message, code) {
+  return jsonResponse(
+    { error: { message, code, type: status >= 500 ? "server_error" : "invalid_request_error" } },
+    status
+  );
+}
+async function readJsonObject(request) {
+  try {
+    const parsed = await request.json();
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveChatRequest(request, resolve) {
+  const resolved = await resolve(request);
+  if (resolved instanceof Response) return { response: resolved };
+  return { resolution: resolved };
+}
+function clientConversation(request, protocolField) {
+  const header = request.headers.get(CHAT_CONVERSATION_HEADER);
+  if (header) return header;
+  return typeof protocolField === "string" && protocolField ? protocolField : void 0;
+}
+async function openResolvedChat(og, resolution, clientConversationId) {
+  if (!resolution.conversation && !resolution.user) {
+    return {
+      response: errorResponse(
+        400,
+        "Return a conversation from resolve, or a user so client conversation ids are scoped to that user.",
+        "conversation_required"
+      )
+    };
+  }
+  const conversationId = resolution.conversation ?? clientConversationId;
+  if (!conversationId) {
+    return {
+      response: errorResponse(
+        400,
+        `A conversation id is required: send the ${CHAT_CONVERSATION_HEADER} header or the protocol's conversation field.`,
+        "conversation_required"
+      )
+    };
+  }
+  try {
+    const chat = await og.chat({ ...resolution, conversation: conversationId });
+    return { chat };
+  } catch (error) {
+    const summary = chatErrorSummary(error);
+    return { response: errorResponse(summary.status, summary.message, summary.code) };
+  }
+}
+function chatErrorSummary(error) {
+  if (error instanceof OpenGeniChatError) {
+    const status = CHAT_ERROR_STATUS[error.code] ?? 502;
+    return { status, code: error.code, message: error.message };
+  }
+  if (error instanceof OpenGeniApiError) {
+    return {
+      status: error.status >= 500 ? 502 : error.status,
+      code: error.code ?? "opengeni_api_error",
+      message: error.message
+    };
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return { status: 499, code: "aborted", message: "The chat request was aborted." };
+  }
+  return { status: 500, code: "internal_error", message: "Chat request failed." };
+}
+function sseHeaders(extra = {}) {
+  return {
+    "Content-Type": "text/event-stream; charset=utf-8",
+    "Cache-Control": "no-cache, no-transform",
+    Connection: "keep-alive",
+    ...extra
+  };
+}
+function sseLine(data, event) {
+  return `${event ? `event: ${event}
+` : ""}data: ${data}
+
+`;
+}
+function sseByteStream(blocks, onCancel) {
+  const encoder = new TextEncoder();
+  const iterator = blocks[Symbol.asyncIterator]();
+  let cancelled = false;
+  return new ReadableStream({
+    pull: async (controller) => {
+      const result = await iterator.next();
+      if (cancelled) return;
+      if (result.done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(encoder.encode(result.value));
+    },
+    cancel: () => {
+      cancelled = true;
+      onCancel?.();
+      void Promise.resolve(iterator.return?.(void 0)).then(
+        () => void 0,
+        () => void 0
+      );
+    }
+  });
+}
+function messageContentText(content, partTypes) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const texts = content.map((part) => {
+    if (!part || typeof part !== "object") return null;
+    const record = part;
+    return partTypes.includes(String(record.type)) && typeof record.text === "string" ? record.text : null;
+  }).filter((text) => text !== null);
+  return texts.length > 0 ? texts.join("\n") : null;
+}
+function lastUserMessageIndex(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message && typeof message === "object" && message.role === "user") {
+      return index;
+    }
+  }
+  return -1;
+}
+function messageText(message, partTypes, partsField) {
+  if (!message || typeof message !== "object") return null;
+  const record = message;
+  return messageContentText(record[partsField], partTypes) ?? messageContentText(record.content, partTypes);
+}
+function lastUserMessageText(messages, partTypes, partsField) {
+  if (!Array.isArray(messages)) return null;
+  const index = lastUserMessageIndex(messages);
+  return index < 0 ? null : messageText(messages[index], partTypes, partsField);
+}
+function importedHistoryBefore(messages, partTypes, partsField) {
+  if (!Array.isArray(messages)) return [];
+  const lastUser = lastUserMessageIndex(messages);
+  if (lastUser < 0) return [];
+  const imported = [];
+  for (const message of messages.slice(0, lastUser)) {
+    const role = message?.role;
+    if (role !== "user" && role !== "assistant" && role !== "system") continue;
+    const text = messageText(message, partTypes, partsField);
+    if (text) imported.push({ role, text });
+  }
+  return imported;
+}
+
+// src/chat/openai.ts
+var DEFAULT_MODEL_LABEL = "opengeni";
+function replyExtension(reply) {
+  return {
+    sessionId: reply.sessionId,
+    workspaceId: reply.workspaceId,
+    turnId: reply.turnId,
+    status: reply.status,
+    pending: reply.pending
+  };
+}
+function conversationFromBody(body) {
+  const conversation = body?.conversation;
+  if (typeof conversation === "string" && conversation) return conversation;
+  if (conversation && typeof conversation === "object") {
+    const id = conversation.id;
+    if (typeof id === "string" && id) return id;
+  }
+  return void 0;
+}
+function modelLabel(body) {
+  return typeof body?.model === "string" && body.model ? body.model : DEFAULT_MODEL_LABEL;
+}
+function wantsStream(body) {
+  return body?.stream === true;
+}
+var CHAT_COMPLETION_PART_TYPES = ["text", "input_text"];
+function chatCompletionChunk(sessionId, model, created, delta, finishReason, extension) {
+  return sseLine(
+    JSON.stringify({
+      id: `chatcmpl-${sessionId}`,
+      object: "chat.completion.chunk",
+      created,
+      model,
+      choices: [{ index: 0, delta, finish_reason: finishReason }],
+      ...extension ? { opengeni: extension } : {}
+    })
+  );
+}
+async function* chatCompletionBlocks(chat, chunks, model) {
+  const created = Math.floor(Date.now() / 1e3);
+  yield chatCompletionChunk(
+    chat.sessionId,
+    model,
+    created,
+    { role: "assistant", content: "" },
+    null
+  );
+  try {
+    for await (const chunk of chunks) {
+      if (chunk.type === "text") {
+        yield chatCompletionChunk(chat.sessionId, model, created, { content: chunk.text }, null);
+      } else if (chunk.type === "done") {
+        yield chatCompletionChunk(
+          chat.sessionId,
+          model,
+          created,
+          {},
+          "stop",
+          replyExtension(chunk.reply)
+        );
+      }
+    }
+  } catch (error) {
+    const summary = chatErrorSummary(error);
+    yield sseLine(
+      JSON.stringify({
+        error: { message: summary.message, code: summary.code, type: "server_error" }
+      })
+    );
+  }
+  yield sseLine("[DONE]");
+}
+function chatCompletionObject(reply, model) {
+  return {
+    id: `chatcmpl-${reply.sessionId}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [
+      { index: 0, message: { role: "assistant", content: reply.text }, finish_reason: "stop" }
+    ],
+    opengeni: replyExtension(reply)
+  };
+}
+async function handleChatCompletionsRequest(og, request, resolve) {
+  const body = await readJsonObject(request);
+  const prompt = lastUserMessageText(body?.messages, CHAT_COMPLETION_PART_TYPES, "content")?.trim() ?? "";
+  if (!prompt) {
+    return errorResponse(400, "The last user message has no text.", "message_required");
+  }
+  const resolved = await resolveChatRequest(request, resolve);
+  if (resolved.response) return resolved.response;
+  const metadata = body?.metadata;
+  const metadataConversation = metadata && typeof metadata === "object" ? metadata.conversation_id : void 0;
+  const opened = await openResolvedChat(
+    og,
+    resolved.resolution,
+    clientConversation(request, metadataConversation)
+  );
+  if (opened.response) return opened.response;
+  const model = modelLabel(body);
+  const importedHistory = importedHistoryBefore(
+    body?.messages,
+    CHAT_COMPLETION_PART_TYPES,
+    "content"
+  );
+  if (wantsStream(body)) {
+    const chunks = opened.chat.stream(prompt, { signal: request.signal, importedHistory });
+    return new Response(sseByteStream(chatCompletionBlocks(opened.chat, chunks, model)), {
+      headers: sseHeaders()
+    });
+  }
+  try {
+    const reply = await opened.chat.send(prompt, { signal: request.signal, importedHistory });
+    return jsonResponse(chatCompletionObject(reply, model));
+  } catch (error) {
+    const summary = chatErrorSummary(error);
+    return errorResponse(summary.status, summary.message, summary.code);
+  }
+}
+function encodeResponseId(sessionId, sequence) {
+  return `resp_${sessionId}_${sequence}`;
+}
+function decodeResponseId(value) {
+  if (typeof value !== "string") return null;
+  const match = /^resp_([0-9a-f-]{36})(?:_(\d+|[0-9a-f-]{36}))?$/i.exec(value);
+  const sessionId = match?.[1];
+  const suffix = match?.[2];
+  if (suffix && !/^\d+$/.test(suffix) && !isUuid(suffix)) return null;
+  return sessionId && isUuid(sessionId) ? sessionId : null;
+}
+function responseOutputItem(itemId, status, text) {
+  return {
+    type: "message",
+    id: itemId,
+    status,
+    role: "assistant",
+    content: text === null ? [] : [{ type: "output_text", text, annotations: [] }]
+  };
+}
+function responseObject(reply, chat, model, status, previousResponseId, text, identity) {
+  const sequence = reply?.events.at(-1)?.sequence ?? 0;
+  return {
+    id: identity?.responseId ?? encodeResponseId(chat.sessionId, sequence),
+    object: "response",
+    created_at: identity?.createdAt ?? Math.floor(Date.now() / 1e3),
+    status,
+    model,
+    previous_response_id: previousResponseId,
+    output: status === "in_progress" ? [] : [
+      responseOutputItem(
+        identity?.itemId ?? `msg_${chat.sessionId}_${sequence}`,
+        status,
+        text
+      )
+    ],
+    output_text: text,
+    ...reply ? { opengeni: replyExtension(reply) } : {}
+  };
+}
+async function* responsesBlocks(chat, chunks, model, previousResponseId) {
+  let sequenceNumber = 0;
+  const requestId = crypto.randomUUID();
+  const identity = {
+    responseId: `resp_${chat.sessionId}_${requestId}`,
+    itemId: `msg_${chat.sessionId}_${requestId}`,
+    createdAt: Math.floor(Date.now() / 1e3)
+  };
+  const { itemId } = identity;
+  const event = (type, data) => sseLine(JSON.stringify({ type, sequence_number: sequenceNumber++, ...data }), type);
+  const initial = responseObject(
+    null,
+    chat,
+    model,
+    "in_progress",
+    previousResponseId,
+    "",
+    identity
+  );
+  yield event("response.created", { response: initial });
+  yield event("response.in_progress", { response: initial });
+  yield event("response.output_item.added", {
+    output_index: 0,
+    item: responseOutputItem(itemId, "in_progress", null)
+  });
+  yield event("response.content_part.added", {
+    item_id: itemId,
+    output_index: 0,
+    content_index: 0,
+    part: { type: "output_text", text: "", annotations: [] }
+  });
+  try {
+    for await (const chunk of chunks) {
+      if (chunk.type === "text") {
+        yield event("response.output_text.delta", {
+          item_id: itemId,
+          output_index: 0,
+          content_index: 0,
+          delta: chunk.text,
+          logprobs: []
+        });
+      } else if (chunk.type === "done") {
+        const status = chunk.reply.status === "completed" ? "completed" : "incomplete";
+        const item = responseOutputItem(itemId, status, chunk.reply.text);
+        yield event("response.output_text.done", {
+          item_id: itemId,
+          output_index: 0,
+          content_index: 0,
+          text: chunk.reply.text,
+          logprobs: []
+        });
+        yield event("response.content_part.done", {
+          item_id: itemId,
+          output_index: 0,
+          content_index: 0,
+          part: item.content[0]
+        });
+        yield event("response.output_item.done", { output_index: 0, item });
+        yield event(`response.${status}`, {
+          response: responseObject(
+            chunk.reply,
+            chat,
+            model,
+            status,
+            previousResponseId,
+            chunk.reply.text,
+            identity
+          )
+        });
+      }
+    }
+  } catch (error) {
+    const summary = chatErrorSummary(error);
+    yield event("error", { code: summary.code, message: summary.message, param: null });
+  }
+}
+function responsesInputText(input) {
+  if (typeof input === "string") return input;
+  if (!Array.isArray(input)) return null;
+  const fromRole = lastUserMessageText(input, ["input_text", "text"], "content");
+  if (fromRole !== null) return fromRole;
+  const last = input.at(-1);
+  return last && typeof last === "object" ? messageContentText(last.content, ["input_text", "text"]) : null;
+}
+async function handleResponsesRequest(og, request, resolve) {
+  const body = await readJsonObject(request);
+  const prompt = responsesInputText(body?.input)?.trim() ?? "";
+  if (!prompt) return errorResponse(400, "The input has no user text.", "message_required");
+  const resolved = await resolveChatRequest(request, resolve);
+  if (resolved.response) return resolved.response;
+  const previousResponseId = typeof body?.previous_response_id === "string" ? body.previous_response_id : null;
+  const conversation = clientConversation(request, conversationFromBody(body));
+  const previousSessionId = decodeResponseId(previousResponseId);
+  const namedConversation = resolved.resolution.conversation ?? (resolved.resolution.user ? conversation : void 0);
+  let chat;
+  if (previousSessionId && !namedConversation) {
+    if (!resolved.resolution.user) {
+      return errorResponse(
+        400,
+        "Return a conversation from resolve, or a user so client conversation ids are scoped to that user.",
+        "conversation_required"
+      );
+    }
+    try {
+      const workspaceId = await og.workspaceId(resolved.resolution);
+      chat = await og.chatBySessionId({
+        workspaceId,
+        sessionId: previousSessionId,
+        user: resolved.resolution.user
+      });
+    } catch (error) {
+      const summary = chatErrorSummary(error);
+      return errorResponse(summary.status, summary.message, summary.code);
+    }
+  } else {
+    const opened = await openResolvedChat(og, resolved.resolution, conversation);
+    if (opened.response) return opened.response;
+    chat = opened.chat;
+    if (previousSessionId && previousSessionId !== chat.sessionId) {
+      const summary = chatErrorSummary(
+        new OpenGeniChatError(
+          "conversation_mismatch",
+          "previous_response_id belongs to a different conversation than the one named for this request."
+        )
+      );
+      return errorResponse(summary.status, summary.message, summary.code);
+    }
+  }
+  const model = modelLabel(body);
+  const importedHistory = importedHistoryBefore(
+    body?.input,
+    ["input_text", "text", "output_text"],
+    "content"
+  );
+  if (wantsStream(body)) {
+    const chunks = chat.stream(prompt, { signal: request.signal, importedHistory });
+    return new Response(sseByteStream(responsesBlocks(chat, chunks, model, previousResponseId)), {
+      headers: sseHeaders()
+    });
+  }
+  try {
+    const reply = await chat.send(prompt, { signal: request.signal, importedHistory });
+    return jsonResponse(
+      responseObject(
+        reply,
+        chat,
+        model,
+        reply.status === "completed" ? "completed" : "incomplete",
+        previousResponseId,
+        reply.text
+      )
+    );
+  } catch (error) {
+    const summary = chatErrorSummary(error);
+    return errorResponse(summary.status, summary.message, summary.code);
+  }
+}
+
+// src/chat/vercel.ts
+var UI_MESSAGE_STREAM_HEADER = "x-vercel-ai-ui-message-stream";
+var UI_MESSAGE_STREAM_VERSION = "v1";
+async function* uiMessageStreamParts(chunks, options = {}) {
+  const messageId = options.messageId ?? crypto.randomUUID();
+  const textId = `text_${messageId}`;
+  let textOpen = false;
+  const closeText = () => {
+    if (!textOpen) return [];
+    textOpen = false;
+    return [{ type: "text-end", id: textId }];
+  };
+  const framing = options.framing ?? true;
+  if (framing) {
+    yield { type: "start", messageId };
+    yield { type: "start-step" };
+  }
+  try {
+    for await (const chunk of chunks) {
+      switch (chunk.type) {
+        case "text":
+          if (!textOpen) {
+            textOpen = true;
+            yield { type: "text-start", id: textId };
+          }
+          yield { type: "text-delta", id: textId, delta: chunk.text };
+          break;
+        case "tool": {
+          if (!options.toolParts) break;
+          yield* closeText();
+          const toolCallId = chunk.callId ?? `call_${crypto.randomUUID()}`;
+          const tool = { toolCallId, dynamic: true, providerExecuted: true };
+          if (chunk.status === "started") {
+            yield { type: "tool-input-start", ...tool, toolName: chunk.name };
+            yield {
+              type: "tool-input-available",
+              ...tool,
+              toolName: chunk.name,
+              input: chunk.input ?? {}
+            };
+          } else if (chunk.status === "failed") {
+            yield { type: "tool-output-error", ...tool, errorText: "The tool call failed." };
+          } else {
+            yield { type: "tool-output-available", ...tool, output: { status: chunk.status } };
+          }
+          break;
+        }
+        case "pending":
+          yield* closeText();
+          yield* pendingParts(chunk.pending);
+          break;
+        case "done":
+          yield* closeText();
+          break;
+      }
+    }
+    yield* closeText();
+    if (framing) {
+      yield { type: "finish-step" };
+      yield { type: "finish" };
+    }
+  } catch (error) {
+    yield* closeText();
+    yield { type: "error", errorText: chatErrorSummary(error).message };
+  }
+}
+function* pendingParts(pending) {
+  if (pending.kind === "approval") {
+    const raw = asRecord(pending.payload);
+    const rawItem = asRecord(raw.rawItem);
+    yield {
+      type: "tool-input-available",
+      toolCallId: pending.requestId,
+      toolName: pending.name ?? "tool",
+      dynamic: true,
+      providerExecuted: true,
+      input: raw.arguments ?? rawItem.arguments ?? {}
+    };
+    yield {
+      type: "tool-approval-request",
+      toolCallId: pending.requestId,
+      approvalId: pending.requestId
+    };
+    return;
+  }
+  yield { type: "data-opengeni-pending", data: pending };
+}
+async function* uiMessageStreamBlocks(chunks, options = {}) {
+  for await (const part of uiMessageStreamParts(chunks, options)) {
+    yield sseLine(JSON.stringify(part));
+  }
+  yield sseLine("[DONE]");
+}
+function chatChunksToUIMessageStream(chunks, options = {}) {
+  return sseByteStream(uiMessageStreamBlocks(chunks, options), options.onCancel);
+}
+function uiMessageStreamResponse(chunks, options = {}) {
+  return new Response(chatChunksToUIMessageStream(chunks, options), {
+    headers: sseHeaders({ [UI_MESSAGE_STREAM_HEADER]: UI_MESSAGE_STREAM_VERSION })
+  });
+}
+function lastUIMessageText(messages) {
+  return lastUserMessageText(messages, ["text"], "parts");
+}
+async function handleVercelChatRequest(og, request, resolve, options = {}) {
+  const body = await readJsonObject(request);
+  const prompt = lastUIMessageText(body?.messages)?.trim() ?? "";
+  if (!prompt) {
+    return errorResponse(400, "The last user message has no text.", "message_required");
+  }
+  const resolved = await resolveChatRequest(request, resolve);
+  if (resolved.response) return resolved.response;
+  const opened = await openResolvedChat(
+    og,
+    resolved.resolution,
+    clientConversation(request, body?.id)
+  );
+  if (opened.response) return opened.response;
+  const steer = body?.trigger === "regenerate-message";
+  const importedHistory = importedHistoryBefore(body?.messages, ["text"], "parts");
+  return uiMessageStreamResponse(
+    opened.chat.stream(prompt, { signal: request.signal, steer, importedHistory }),
+    options.toolParts ? { toolParts: true } : {}
+  );
+}
+
+// src/chat/handler.ts
+var CHAT_FORMAT_HEADER = "x-opengeni-chat-format";
+var CHAT_FORMATS = /* @__PURE__ */ new Set([
+  "native",
+  "vercel",
+  "openai-chat",
+  "openai-responses"
+]);
+function methodNotAllowed(allow) {
+  return new Response(
+    JSON.stringify({ error: { message: `Use ${allow}.`, code: "method_not_allowed" } }),
+    { status: 405, headers: { Allow: allow, "Content-Type": "application/json; charset=utf-8" } }
+  );
+}
+function createChatHandler(og, options) {
+  return async (request) => {
+    const isRespond = new URL(request.url).pathname.replace(/\/+$/, "").endsWith("/respond");
+    if (isRespond) {
+      if (request.method !== "POST") return methodNotAllowed("POST");
+      return await handleNativeRespondRequest(og, request, options.resolve);
+    }
+    if (request.method === "GET") {
+      return await handleNativeHistoryRequest(og, request, options.resolve);
+    }
+    if (request.method !== "POST") return methodNotAllowed("GET, POST");
+    const headerFormat = request.headers.get(CHAT_FORMAT_HEADER);
+    if (headerFormat !== null && !CHAT_FORMATS.has(headerFormat)) {
+      return errorResponse(400, `Unknown chat format: ${headerFormat}`, "unknown_format");
+    }
+    const format = headerFormat ?? options.format ?? "native";
+    switch (format) {
+      case "vercel":
+        return await handleVercelChatRequest(og, request, options.resolve, {
+          toolParts: options.toolParts
+        });
+      case "openai-chat":
+        return await handleChatCompletionsRequest(og, request, options.resolve);
+      case "openai-responses":
+        return await handleResponsesRequest(og, request, options.resolve);
+      default:
+        return await handleNativeChatRequest(og, request, options.resolve);
+    }
+  };
+}
+async function handleNativeChatRequest(og, request, resolve) {
+  const body = await readJsonObject(request);
+  const message = typeof body?.message === "string" ? body.message.trim() : "";
+  if (!message) {
+    return errorResponse(400, "Body must carry a non-empty message.", "message_required");
+  }
+  const resolved = await resolveChatRequest(request, resolve);
+  if (resolved.response) return resolved.response;
+  const opened = await openResolvedChat(og, resolved.resolution, clientConversation(request, null));
+  if (opened.response) return opened.response;
+  return chatChunksToSseResponse(opened.chat.stream(message, { signal: request.signal }));
+}
+async function handleNativeHistoryRequest(og, request, resolve) {
+  const resolved = await resolveChatRequest(request, resolve);
+  if (resolved.response) return resolved.response;
+  const opened = await openResolvedChat(og, resolved.resolution, clientConversation(request, null));
+  if (opened.response) return opened.response;
+  try {
+    const snapshot = await opened.chat.snapshot();
+    return jsonResponse({
+      conversation: opened.chat.conversation,
+      sessionId: opened.chat.sessionId,
+      created: opened.chat.created,
+      ...snapshot
+    });
+  } catch (error) {
+    const summary = chatErrorSummary(error);
+    return errorResponse(summary.status, summary.message, summary.code);
+  }
+}
+async function handleNativeRespondRequest(og, request, resolve) {
+  const body = await readJsonObject(request);
+  const input = respondInputFromBody(body);
+  if (!input) {
+    return errorResponse(
+      400,
+      "Body must carry requestId plus decision, answers, or skip.",
+      "respond_input_invalid"
+    );
+  }
+  const resolved = await resolveChatRequest(request, resolve);
+  if (resolved.response) return resolved.response;
+  const opened = await openResolvedChat(og, resolved.resolution, clientConversation(request, null));
+  if (opened.response) return opened.response;
+  return chatChunksToSseResponse(opened.chat.respondStream(input, { signal: request.signal }));
+}
+function respondInputFromBody(body) {
+  const requestId = typeof body?.requestId === "string" ? body.requestId : "";
+  if (!body || !requestId) return null;
+  if (body.decision === "approve" || body.decision === "reject") {
+    return {
+      requestId,
+      decision: body.decision,
+      ...typeof body.message === "string" ? { message: body.message } : {}
+    };
+  }
+  if (Array.isArray(body.answers)) {
+    const answers = body.answers.filter(
+      (answer) => !!answer && typeof answer === "object" && typeof answer.questionId === "string" && Array.isArray(answer.values)
+    );
+    return { requestId, answers };
+  }
+  if (body.skip === true) return { requestId, skip: true };
+  return null;
+}
+async function* chatChunksToSseBlocks(chunks) {
+  try {
+    for await (const chunk of chunks) {
+      yield sseLine(JSON.stringify(chunk), "chunk");
+    }
+  } catch (error) {
+    const summary = chatErrorSummary(error);
+    yield sseLine(JSON.stringify({ code: summary.code, message: summary.message }), "error");
+  }
+}
+function chatChunksToSseStream(chunks, onCancel) {
+  return sseByteStream(chatChunksToSseBlocks(chunks), onCancel);
+}
+function chatChunksToSseResponse(chunks) {
+  return new Response(chatChunksToSseStream(chunks), {
+    headers: sseHeaders({ [CHAT_FORMAT_HEADER]: "native" })
+  });
+}
+async function* parseChatChunkStream(stream) {
+  for await (const message of parseSseStream(stream)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(message.data);
+    } catch {
+      continue;
+    }
+    if (message.event === "error") {
+      const record = parsed ?? {};
+      throw new OpenGeniChatError(
+        typeof record.code === "string" ? record.code : "chat_error",
+        typeof record.message === "string" ? record.message : "Chat request failed."
+      );
+    }
+    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+      yield parsed;
+    }
+  }
+}
+export {
+  CHAT_CONVERSATION_HEADER,
+  CHAT_FORMAT_HEADER,
+  CHAT_SESSION_NAMESPACE,
+  Chat,
+  ChatTurnFold,
+  DEFAULT_CHAT_SOURCE,
+  DEFAULT_OPENGENI_BASE_URL,
+  IMPORTED_HISTORY_MAX_CHARS,
+  OpenGeni,
+  OpenGeniChatError,
+  OpenGeniSetupError,
+  OpenGeni as Opengeni,
+  UI_MESSAGE_STREAM_HEADER,
+  UI_MESSAGE_STREAM_VERSION,
+  approvalPending,
+  chatChunksToSseBlocks,
+  chatChunksToSseResponse,
+  chatChunksToSseStream,
+  chatChunksToUIMessageStream,
+  chatCompletionBlocks,
+  chatCompletionObject,
+  chatIdempotencyKey,
+  chatIdentityName,
+  chatSessionId,
+  createChatHandler,
+  decodeResponseId,
+  encodeResponseId,
+  formatImportedHistory,
+  handleChatCompletionsRequest,
+  handleNativeChatRequest,
+  handleNativeHistoryRequest,
+  handleNativeRespondRequest,
+  handleResponsesRequest,
+  handleVercelChatRequest,
+  humanInputPending,
+  lastUIMessageText,
+  parseChatChunkStream,
+  respondInputFromBody,
+  responsesBlocks,
+  responsesInputText,
+  uiMessageStreamBlocks,
+  uiMessageStreamParts,
+  uiMessageStreamResponse,
+  uuidV5
+};
+//# sourceMappingURL=index.js.map