@opengeni/sdk 3.1.0 → 3.1.2

package/dist/chunk-JXXCTW5W.js

@@ -0,0 +1,1392 @@
+import {
+  OpenGeniToolsClient,
+  createSharedCatalogLoader
+} from "./chunk-P7UWKORG.js";
+import {
+  OpenGeniClient
+} from "./chunk-NEM5N6C6.js";
+import {
+  OpenGeniApiError
+} from "./chunk-7EWT3PV6.js";
+
+// ../contracts/src/site-operations.ts
+var ID = "[A-Za-z0-9_-]{1,128}";
+var DATA = "/published-artifacts/current/(?:data|files)(?:/[A-Za-z0-9._~:@!$&'()*+,;=-]+)*";
+var SITE_OPERATIONS = Object.freeze([
+  { id: "config.client", method: "GET", pattern: /^\/v1\/config\/client$/u },
+  { id: "workspace.get", method: "GET", pattern: /^$/u },
+  { id: "site.config", method: "GET", pattern: /^\/site\/config$/u },
+  { id: "models.list", method: "GET", pattern: /^\/model-catalog$/u },
+  { id: "sessions.list", method: "GET", pattern: /^\/sessions$/u },
+  { id: "sessions.create", method: "POST", pattern: /^\/sessions$/u, agent: true },
+  { id: "sessions.get", method: "GET", pattern: new RegExp(`^/sessions/${ID}$`, "u") },
+  { id: "sessions.events", method: "GET", pattern: new RegExp(`^/sessions/${ID}/events$`, "u") },
+  {
+    id: "sessions.stream",
+    method: "GET",
+    pattern: new RegExp(`^/sessions/${ID}/events/stream$`, "u"),
+    stream: true
+  },
+  {
+    id: "sessions.send",
+    method: "POST",
+    pattern: new RegExp(`^/sessions/${ID}/events$`, "u"),
+    agent: true
+  },
+  {
+    id: "sessions.steer",
+    method: "POST",
+    pattern: new RegExp(`^/sessions/${ID}/steer$`, "u"),
+    agent: true
+  },
+  {
+    id: "sessions.control",
+    method: "POST",
+    pattern: new RegExp(`^/sessions/${ID}/control$`, "u"),
+    agent: true
+  },
+  { id: "sessions.queue", method: "GET", pattern: new RegExp(`^/sessions/${ID}/queue$`, "u") },
+  // SessionConversation's documented queue edit/delete/steer/move.
+  {
+    id: "sessions.queue.item",
+    method: "POST",
+    pattern: new RegExp(`^/sessions/${ID}/queue/${ID}/(?:move|edit|steer|delete)$`, "u"),
+    agent: true
+  },
+  // SessionConversation's durable composer draft and its Send.
+  {
+    id: "sessions.composerDraft.get",
+    method: "GET",
+    pattern: new RegExp(`^/sessions/${ID}/composer-draft$`, "u")
+  },
+  {
+    id: "sessions.composerDraft.put",
+    method: "PUT",
+    pattern: new RegExp(`^/sessions/${ID}/composer-draft$`, "u")
+  },
+  {
+    id: "sessions.composerDraft.submit",
+    method: "POST",
+    pattern: new RegExp(`^/sessions/${ID}/composer-draft/submit$`, "u"),
+    agent: true
+  },
+  {
+    id: "sessions.humanInput",
+    method: "GET",
+    pattern: new RegExp(`^/sessions/${ID}/human-input-requests$`, "u")
+  },
+  // SessionConversation's human-input form reads the one open request.
+  {
+    id: "sessions.humanInput.get",
+    method: "GET",
+    pattern: new RegExp(`^/sessions/${ID}/human-input-requests/${ID}$`, "u")
+  },
+  { id: "data.read", method: "GET", pattern: new RegExp(`^${DATA}$`, "u") },
+  { id: "data.write", method: "POST", pattern: new RegExp(`^${DATA}$`, "u") },
+  { id: "data.put", method: "PUT", pattern: new RegExp(`^${DATA}$`, "u") },
+  { id: "data.patch", method: "PATCH", pattern: new RegExp(`^${DATA}$`, "u") },
+  { id: "data.delete", method: "DELETE", pattern: new RegExp(`^${DATA}$`, "u") },
+  // Site SQL (PR B): run one named query the owner defined; never raw SQL.
+  {
+    id: "sql.run",
+    method: "POST",
+    pattern: /^\/published-artifacts\/current\/sql\/queries\/[A-Za-z][A-Za-z0-9_-]{0,63}$/u
+  },
+  { id: "site.report", method: "POST", pattern: /^\/site\/reports$/u }
+]);
+var SITE_TOOL_METHODS = Object.freeze([
+  "catalog",
+  "declarations",
+  "call",
+  "resolve",
+  "invoke"
+]);
+var SITE_HOST_PREFIX = "/v1/workspaces/site-host";
+function matchSiteOperation(method, path) {
+  if (/[%\\#\u0000-\u0020\u007f]/u.test(path)) return null;
+  if (path.split("/").some((part) => part === "." || part === "..")) return null;
+  const upper = method.toUpperCase();
+  let suffix;
+  if (path === "/v1/config/client") suffix = path;
+  else if (path === SITE_HOST_PREFIX) suffix = "";
+  else if (path.startsWith(`${SITE_HOST_PREFIX}/`)) suffix = path.slice(SITE_HOST_PREFIX.length);
+  else return null;
+  const operation = SITE_OPERATIONS.find(
+    (candidate) => candidate.method === upper && candidate.pattern.test(suffix)
+  );
+  return operation ? { operation, suffix } : null;
+}
+
+// ../contracts/src/site-session-http.ts
+var SITE_WORKSPACE_PREFIX = "/v1/workspaces/site-host";
+var SITE_DATA_PATH = /^\/v1\/workspaces\/site-host\/published-artifacts\/([^/]+)\/(?:data|files|sql)(?:\/|$)/u;
+var SITE_NO_ORIGIN_ID = "00000000-0000-0000-0000-000000000000";
+var SITE_FRAME_HEADER = "x-opengeni-site-frame";
+var SITE_FRAME_ID_HEADER = "x-opengeni-site-frame-id";
+var SITE_ID_HEADER = "x-opengeni-site-id";
+var SITE_VERSION_HEADER = "x-opengeni-site-version";
+var SiteSessionPathError = class extends Error {
+  code = "site_session_path_unsupported";
+  constructor() {
+    super("Unsupported Site session API path");
+    this.name = "SiteSessionPathError";
+  }
+};
+var SiteDataUnsupportedError = class extends Error {
+  code = "site_data_unsupported";
+  constructor() {
+    super("This Site host does not provide Site Data");
+    this.name = "SiteDataUnsupportedError";
+  }
+};
+function unsafePathname(pathname) {
+  return /[%\\#\u0000-\u0020\u007f]/u.test(pathname) || pathname.split("/").some((part) => part === "." || part === "..");
+}
+function hostWorkspacePath(path, workspaceId) {
+  return path.replace("/workspaces/site-host", `/workspaces/${encodeURIComponent(workspaceId)}`);
+}
+function siteDataPath(path, rewritten, workspaceId, siteId) {
+  if (workspaceId === "site-host") return path;
+  if (!siteId) throw new SiteDataUnsupportedError();
+  return rewritten.replace(
+    "/published-artifacts/current/",
+    `/published-artifacts/${encodeURIComponent(siteId)}/`
+  );
+}
+function siteSessionPath(path, workspaceId, method = "GET", siteId) {
+  const pathname = path.split("?")[0];
+  const match = matchSiteOperation(method, pathname);
+  if (!match) throw new SiteSessionPathError();
+  const rewritten = hostWorkspacePath(path, workspaceId);
+  if (SITE_DATA_PATH.test(pathname)) return siteDataPath(path, rewritten, workspaceId, siteId);
+  if (match.operation.id !== "sessions.list") return rewritten;
+  const url = new URL(rewritten, "http://site.invalid");
+  const origins = url.searchParams.getAll("originSiteId");
+  if (origins.length !== 1 || origins[0] !== "current") throw new SiteSessionPathError();
+  if (workspaceId === "site-host") return path;
+  url.searchParams.set("originSiteId", siteId ?? SITE_NO_ORIGIN_ID);
+  return url.pathname + url.search;
+}
+function siteFrameOperation(method, pathname, workspaceId, frameSiteId) {
+  if (unsafePathname(pathname)) return null;
+  let sitePath = pathname;
+  if (pathname !== "/v1/config/client") {
+    const prefix = `/v1/workspaces/${workspaceId}`;
+    if (pathname !== prefix && !pathname.startsWith(`${prefix}/`)) return null;
+    sitePath = `${SITE_WORKSPACE_PREFIX}${pathname.slice(prefix.length)}`;
+    const data = /^\/v1\/workspaces\/site-host\/published-artifacts\/([^/]+)\//u.exec(sitePath);
+    if (data) {
+      if (!frameSiteId || data[1] !== frameSiteId) return null;
+      sitePath = sitePath.replace(
+        `/published-artifacts/${frameSiteId}/`,
+        "/published-artifacts/current/"
+      );
+    }
+  }
+  const match = matchSiteOperation(method, sitePath);
+  if (!match) return null;
+  const session = /^\/sessions\/([^/]+)(?:\/|$)/u.exec(match.suffix);
+  return { ...match, sessionId: session ? session[1] : null };
+}
+function siteRequestHeaders(input) {
+  const headers = new Headers(input);
+  const connectionHeaders = (headers.get("connection") ?? "").split(",").map((value) => value.trim().toLowerCase());
+  for (const name of [...headers.keys()]) {
+    if (connectionHeaders.includes(name) || /^(authorization|proxy-authorization|cookie|cookie2|host|origin|referer|connection|keep-alive|proxy-connection|te|trailer|transfer-encoding|upgrade|content-length|accept-encoding|forwarded|x-api-key)$/i.test(
+      name
+    ) || /^(sec-|x-forwarded-|x-opengeni-(access-key|external-actor|site-|managed-actor))/i.test(name))
+      headers.delete(name);
+  }
+  return headers;
+}
+var SITE_FRAME_MESSAGE_FIELDS = [
+  "text",
+  "annotations",
+  "model",
+  "reasoningEffort",
+  "latencyMode",
+  "controlEtag",
+  "expectedDraftRevision"
+];
+var SITE_FRAME_BODY_FIELDS = Object.freeze({
+  "sessions.send": ["type", "payload", "clientEventId"],
+  "sessions.steer": [...SITE_FRAME_MESSAGE_FIELDS, "clientEventId"],
+  "sessions.control": ["action", "reason", "clientEventId", "expectedControlEtag"],
+  "sessions.composerDraft.put": [
+    "text",
+    "annotations",
+    "resources",
+    "model",
+    "reasoningEffort",
+    "latencyMode",
+    "expectedRevision"
+  ],
+  "sessions.composerDraft.submit": [
+    ...SITE_FRAME_MESSAGE_FIELDS,
+    "resources",
+    "connectionAccounts",
+    "clientEventId",
+    "delivery"
+  ],
+  "sessions.queue.move": ["clientEventId", "expectedQueueVersion", "beforeTurnId"],
+  "sessions.queue.edit": [
+    "clientEventId",
+    "expectedTurnVersion",
+    "expectedDraftRevision",
+    "replaceDraft"
+  ],
+  "sessions.queue.steer": ["clientEventId", "expectedTurnVersion", "controlEtag"],
+  "sessions.queue.delete": ["clientEventId", "expectedTurnVersion", "reason"]
+});
+var SITE_FRAME_EMPTY_ONLY_FIELDS = /* @__PURE__ */ new Set(["resources", "connectionAccounts"]);
+var SITE_FRAME_SESSION_CREATE_FIELDS = Object.freeze([
+  "initialMessage",
+  "requestedSessionId",
+  "idempotencyKey",
+  "clientEventId",
+  "model",
+  "reasoningEffort",
+  "latencyMode",
+  "startMode",
+  "metadata"
+]);
+function bodyRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function emptyBodyValue(value) {
+  if (value === void 0 || value === null) return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function refusedField(body, allowed, prefix = "") {
+  for (const [name, value] of Object.entries(body)) {
+    if (emptyBodyValue(value)) continue;
+    if (!allowed.includes(name) || SITE_FRAME_EMPTY_ONLY_FIELDS.has(name))
+      return `${prefix}${name}`;
+  }
+  return null;
+}
+function siteFrameBodyRefusal(operationId, suffix, body) {
+  const record = bodyRecord(body);
+  if (!record) return null;
+  if (operationId === "sessions.create")
+    return refusedField(record, SITE_FRAME_SESSION_CREATE_FIELDS);
+  const action = operationId === "sessions.queue.item" ? /\/queue\/[^/]+\/(move|edit|steer|delete)$/u.exec(suffix)?.[1] : void 0;
+  const key = action ? `sessions.queue.${action}` : operationId;
+  const allowed = SITE_FRAME_BODY_FIELDS[key];
+  if (!allowed) return null;
+  const refused = refusedField(record, allowed);
+  if (refused) return refused;
+  if (operationId !== "sessions.send") return null;
+  if (record.type !== "user.message") return "type";
+  const payload = bodyRecord(record.payload);
+  return payload ? refusedField(payload, SITE_FRAME_MESSAGE_FIELDS, "payload.") : null;
+}
+
+// src/site-http.ts
+var SITE_HTTP = "opengeni.site.http";
+var SITE_WORKSPACE = "site-host";
+function isSiteHttpRequest(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.type === SITE_HTTP && typeof v.requestId === "string" && typeof v.path === "string" && typeof v.method === "string" && /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u.test(v.method) && (v.body === void 0 || typeof v.body === "string" || v.body instanceof ArrayBuffer) && Array.isArray(v.headers) && v.headers.every(
+    (h) => Array.isArray(h) && h.length === 2 && h.every((x) => typeof x === "string")
+  );
+}
+async function serveSiteHttp(message, port, fetchResponse, signal) {
+  let reader;
+  let wake;
+  let pulling = false;
+  const onMessage = (event) => {
+    if (event.data === "pull") {
+      pulling = true;
+      wake?.();
+    }
+  };
+  const abort = () => {
+    void reader?.cancel(signal.reason).catch(() => {
+    });
+    wake?.();
+  };
+  port.addEventListener("message", onMessage);
+  signal.addEventListener("abort", abort, { once: true });
+  port.start();
+  try {
+    if (signal.aborted) throw signal.reason;
+    const response = await fetchResponse(message, signal);
+    reader = response.body?.getReader();
+    port.postMessage({ status: response.status, headers: [...response.headers], body: !!reader });
+    if (reader)
+      while (!signal.aborted) {
+        if (!pulling)
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+        wake = void 0;
+        if (signal.aborted) break;
+        pulling = false;
+        const part = await reader.read();
+        if (part.done) {
+          port.postMessage({ done: true });
+          break;
+        }
+        port.postMessage({ chunk: part.value });
+      }
+    if (signal.aborted) throw signal.reason;
+  } catch (error) {
+    port.postMessage({ error: error instanceof Error ? error.message : "Site request failed" });
+  } finally {
+    signal.removeEventListener("abort", abort);
+    port.removeEventListener("message", onMessage);
+    await reader?.cancel().catch(() => {
+    });
+    port.close();
+  }
+}
+async function sitePortFetch(port, input, init) {
+  const request = new Request(input, init);
+  const url = new URL(request.url);
+  const path = `${url.pathname}${url.search}`;
+  siteSessionPath(path, SITE_WORKSPACE, request.method);
+  const channel = new MessageChannel();
+  const requestId = crypto.randomUUID();
+  const binary = init?.body instanceof ArrayBuffer || ArrayBuffer.isView(init?.body) || typeof Blob !== "undefined" && init?.body instanceof Blob;
+  const body = request.body ? binary ? await request.arrayBuffer() : await request.text() : void 0;
+  return await new Promise((resolve, reject) => {
+    let controller;
+    let finished = false;
+    const cleanup = () => {
+      finished = true;
+      request.signal.removeEventListener("abort", abort);
+      channel.port1.close();
+    };
+    const abort = () => {
+      if (finished) return;
+      port.postMessage({ type: "opengeni.site.cancel", version: 2, requestId });
+      const error = request.signal.reason ?? new DOMException("Cancelled", "AbortError");
+      controller?.error(error);
+      reject(error);
+      cleanup();
+    };
+    channel.port1.onmessage = (event) => {
+      const data = event.data;
+      if (data.error) {
+        const error = new Error(data.error);
+        controller?.error(error);
+        reject(error);
+        cleanup();
+      } else if (data.status) {
+        const stream = data.body ? new ReadableStream({
+          start(c) {
+            controller = c;
+          },
+          pull() {
+            channel.port1.postMessage("pull");
+          },
+          cancel() {
+            controller = void 0;
+            abort();
+          }
+        }) : null;
+        resolve(new Response(stream, { status: data.status, headers: data.headers }));
+        if (!data.body) cleanup();
+      } else if (data.done) {
+        controller?.close();
+        cleanup();
+      } else if (data.chunk) controller?.enqueue(data.chunk);
+    };
+    if (request.signal.aborted) {
+      abort();
+      return;
+    }
+    request.signal.addEventListener("abort", abort, { once: true });
+    port.postMessage(
+      {
+        type: SITE_HTTP,
+        requestId,
+        path,
+        method: request.method,
+        headers: [...request.headers],
+        ...body === void 0 ? {} : { body }
+      },
+      [channel.port2]
+    );
+  });
+}
+
+// src/site-tool-bridge.ts
+function createSiteToolBridge(input) {
+  const allowed = input.requestedTools ? new Set(input.requestedTools.map(identityKey)) : null;
+  const frameId = crypto.randomUUID();
+  const targeted = input.workspaceTools.$targetProtocol === 1 && input.workspaceTools.$resolve && input.workspaceTools.$invoke && input.workspaceTools.$manifest;
+  const context = input.artifactId ? { siteArtifactId: input.artifactId, siteVersionId: input.siteVersionId } : {};
+  const manifests = /* @__PURE__ */ new Map();
+  const resolve = async (request, { signal }) => {
+    if (allowed && "identity" in request.target && !allowed.has(identityKey(request.target.identity)))
+      throw new Error("This tool is not available to the Site");
+    const tool = await input.workspaceTools.$resolve(request.target, { signal, ...context });
+    if (allowed && !allowed.has(identityKey(tool.entry.identity)))
+      throw new Error("This tool is not available to the Site");
+    return tool;
+  };
+  const invoke = async (request, { signal }) => {
+    if (allowed && "identity" in request.target && !allowed.has(identityKey(request.target.identity)))
+      throw new Error("This tool is not available to the Site");
+    return await input.workspaceTools.$invoke(
+      {
+        target: request.target,
+        operationId: request.operationId,
+        arguments: request.arguments,
+        ...request.expectedDefinitionDigest === void 0 ? {} : { expectedDefinitionDigest: request.expectedDefinitionDigest },
+        ...context
+      },
+      { signal }
+    );
+  };
+  const projectedCatalog = createSharedCatalogLoader(
+    async (refresh, signal) => {
+      if (targeted && input.requestedTools) {
+        const manifest = await input.workspaceTools.$manifest(
+          { identities: [...input.requestedTools], ...context },
+          { signal }
+        );
+        signal.throwIfAborted();
+        if (manifests.size >= 4) manifests.delete(manifests.keys().next().value);
+        manifests.set(manifest.digest, manifest.tools);
+        return {
+          version: 1,
+          generation: 1,
+          digest: manifest.digest,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          entries: manifest.tools.map((tool) => tool.entry)
+        };
+      }
+      const current = await input.workspaceTools.$catalog({
+        signal,
+        ...refresh ? { refresh } : {}
+      });
+      if (current.workspaceId !== input.workspaceId)
+        throw new Error("Site catalog workspace mismatch");
+      return {
+        version: current.version,
+        generation: current.generation,
+        digest: current.digest,
+        createdAt: current.createdAt,
+        entries: current.entries.filter(
+          (entry) => !allowed || allowed.has(identityKey(entry.identity))
+        )
+      };
+    }
+  );
+  const loadCatalog = async ({
+    signal,
+    staleDigest
+  }) => {
+    signal.throwIfAborted();
+    const catalog = staleDigest === void 0 ? await projectedCatalog.load({ signal }) : await projectedCatalog.reloadAfterStale(staleDigest, signal);
+    signal.throwIfAborted();
+    return catalog;
+  };
+  return {
+    ...targeted ? { resolve, invoke } : {},
+    ...input.fetchResponse && input.artifactId ? { siteData: true } : {},
+    ...input.fetchResponse ? {
+      fetch: async (message, signal) => {
+        const path = siteSessionPath(
+          message.path,
+          input.workspaceId,
+          message.method,
+          input.artifactId
+        );
+        const refused = siteFrameBodyFieldRefusal(path, message, input);
+        if (refused) return refused;
+        const headers = siteRequestHeaders(message.headers);
+        headers.set(SITE_FRAME_HEADER, "1");
+        headers.set(SITE_FRAME_ID_HEADER, frameId);
+        if (input.artifactId) {
+          headers.set(SITE_ID_HEADER, input.artifactId);
+          headers.set(SITE_VERSION_HEADER, input.siteVersionId);
+        }
+        return input.fetchResponse(path, {
+          method: message.method,
+          signal,
+          headers: Object.fromEntries(headers),
+          ...message.body === void 0 ? {} : { body: message.body }
+        });
+      }
+    } : {},
+    catalog: async ({ signal }) => await loadCatalog({ signal }),
+    call: async (request, { signal }) => {
+      if (allowed && !allowed.has(identityKey(request.identity)))
+        throw new Error("This tool is not available to the Site");
+      if (targeted && input.requestedTools) {
+        const tool = manifests.get(request.catalogDigest)?.find(
+          (candidate) => identityKey(candidate.entry.identity) === identityKey(request.identity)
+        );
+        if (!tool)
+          throw new OpenGeniApiError(
+            409,
+            JSON.stringify({
+              error: { code: "conflict", details: { code: "catalog_stale" }, retryable: true }
+            })
+          );
+        try {
+          const response = await invoke(
+            {
+              operationId: request.operationId ?? crypto.randomUUID(),
+              target: { identity: request.identity },
+              arguments: request.arguments,
+              expectedDefinitionDigest: tool.definitionDigest
+            },
+            { signal }
+          );
+          return {
+            operationId: response.operationId,
+            catalogDigest: request.catalogDigest,
+            result: legacySiteToolResult(response.result)
+          };
+        } catch (error) {
+          if (error instanceof OpenGeniApiError && error.retryable !== false && !error.outcomeUnknown && error.details?.code === "tool_definition_stale") {
+            projectedCatalog.invalidate(request.catalogDigest);
+            manifests.delete(request.catalogDigest);
+            throw new OpenGeniApiError(
+              409,
+              JSON.stringify({
+                error: {
+                  code: "catalog_stale",
+                  details: { code: "catalog_stale" },
+                  retryable: true
+                }
+              })
+            );
+          }
+          throw error;
+        }
+      }
+      let usedDigest;
+      const call = async (staleDigest) => {
+        const catalog = await loadCatalog({
+          signal,
+          ...staleDigest === void 0 ? {} : { staleDigest }
+        });
+        usedDigest = catalog.digest;
+        if (!catalog.entries.some(
+          (entry) => identityKey(entry.identity) === identityKey(request.identity)
+        ))
+          throw new Error("This requested tool is not enabled in the workspace");
+        const response = await input.callTool({
+          workspaceId: input.workspaceId,
+          signal,
+          request: {
+            ...request.operationId ? { operationId: request.operationId } : {},
+            catalogDigest: catalog.digest,
+            identity: request.identity,
+            arguments: request.arguments,
+            ...input.artifactId ? { siteArtifactId: input.artifactId, siteVersionId: input.siteVersionId } : {}
+          }
+        });
+        return { ...response, result: legacySiteToolResult(response.result) };
+      };
+      try {
+        return await call();
+      } catch (error) {
+        if (staleRetryVetoed(error) || !(input.isCatalogStale ?? isSiteCatalogStaleError)(error) || usedDigest === void 0)
+          throw error;
+        return await call(usedDigest);
+      }
+    }
+  };
+}
+function legacySiteToolResult(result) {
+  if (!result?.isError) return result;
+  const structured = result.structuredContent;
+  const error = structured?.error;
+  if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "catalog_stale" && error.code !== "tool_definition_stale")
+    return result;
+  return {
+    ...result,
+    structuredContent: {
+      ...structured,
+      error: {
+        code: "site_tool_execution_failed",
+        message: "message" in error && typeof error.message === "string" ? error.message : "Site tool execution failed",
+        retryable: false,
+        outcomeUnknown: "outcomeUnknown" in error && error.outcomeUnknown === true,
+        providerError: error
+      }
+    }
+  };
+}
+function isSiteCatalogStaleError(error) {
+  return !staleRetryVetoed(error) && error instanceof OpenGeniApiError && error.status === 409 && error.details?.code === "catalog_stale";
+}
+function staleRetryVetoed(error) {
+  return typeof error === "object" && error !== null && ("outcomeUnknown" in error && error.outcomeUnknown === true || "retryable" in error && error.retryable === false);
+}
+function identityKey(identity) {
+  return `${identity.serverId}\0${identity.toolName}`;
+}
+function siteFrameBodyFieldRefusal(path, message, input) {
+  if (typeof message.body !== "string" || message.method === "GET") return null;
+  const operation = siteFrameOperation(
+    message.method,
+    path.split("?")[0],
+    input.workspaceId,
+    input.artifactId ?? null
+  );
+  if (!operation) return null;
+  let body;
+  try {
+    body = JSON.parse(message.body);
+  } catch {
+    return null;
+  }
+  const field = siteFrameBodyRefusal(operation.operation.id, operation.suffix, body);
+  if (!field) return null;
+  return Response.json(
+    {
+      error: {
+        status: 403,
+        code: "forbidden",
+        message: "A Site page can send message text only. Approvals, answers, resources, credentials and connection choices happen in the console.",
+        retryable: false,
+        details: { code: "site_frame_field_forbidden", field }
+      }
+    },
+    { status: 403 }
+  );
+}
+
+// src/site-data.ts
+var OpenGeniSiteDataError = class extends Error {
+  constructor(code, message, status, details = {}) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "OpenGeniSiteDataError";
+  }
+};
+var SITE_DATA_PATH_PREFIX = "/v1/workspaces/site-host/published-artifacts/current";
+function createOpenGeniSiteData(fetchSite, ready) {
+  const send = async (path, init = {}) => {
+    if (!await ready())
+      throw new OpenGeniSiteDataError(
+        "site_data_unsupported",
+        "This Site host does not provide Site Data",
+        0
+      );
+    const response = await fetchSite(`${SITE_DATA_PATH_PREFIX}${path}`, init);
+    const text = await response.text();
+    let value = null;
+    try {
+      value = text ? JSON.parse(text) : null;
+    } catch {
+      value = null;
+    }
+    if (response.ok) return value;
+    throw siteDataErrorFromResponse(response.status, value);
+  };
+  const json = (body) => ({
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const write = async (operations) => (await send("/data/write", json({ operations }))).results;
+  const one = async (operation) => {
+    const [result] = await write([operation]);
+    if (!result || !("record" in result))
+      throw new OpenGeniSiteDataError("request_failed", "Unexpected Site Data response", 200);
+    return result.record;
+  };
+  const count = async (collection, where, scope) => (await send(
+    "/data/query",
+    json({
+      collection,
+      limit: 1,
+      count: true,
+      ...where ? { where } : {},
+      ...scope ? { scope } : {}
+    })
+  )).count ?? 0;
+  const data = {
+    collection(name) {
+      const collection = {
+        name,
+        list: async (options = {}) => await send(
+          "/data/query",
+          json({ collection: name, ...options })
+        ),
+        get: async (ref) => {
+          try {
+            return (await send(
+              "/data/get",
+              json({ collection: name, ...refFields(ref) })
+            )).record;
+          } catch (error) {
+            if (error instanceof OpenGeniSiteDataError && error.code === "not_found") return null;
+            throw error;
+          }
+        },
+        insert: async (value, options = {}) => await one({
+          op: "insert",
+          collection: name,
+          data: value,
+          ...options.key === void 0 ? {} : { key: options.key }
+        }),
+        put: async (key, value, options = {}) => await one({
+          op: "put",
+          collection: name,
+          key,
+          data: value,
+          ...options
+        }),
+        patch: async (ref, value, options = {}) => await one({
+          op: "patch",
+          collection: name,
+          ...refFields(ref),
+          data: value,
+          ...options
+        }),
+        delete: async (ref, options = {}) => {
+          await write([{ op: "delete", collection: name, ...refFields(ref), ...options }]);
+        },
+        increment: async (ref, field, by) => await one({
+          op: "increment",
+          collection: name,
+          ...refFields(ref),
+          field,
+          ...by === void 0 ? {} : { by }
+        }),
+        count: async (where, options = {}) => await count(name, where, options.scope)
+      };
+      return collection;
+    },
+    batch: write,
+    count: async (collection, where) => await count(collection, where)
+  };
+  const files = {
+    upload: async (file, options = {}) => {
+      const blob = file instanceof Blob ? file : new Blob([file instanceof Uint8Array ? file.slice() : file], {
+        type: options.contentType ?? "application/octet-stream"
+      });
+      const name = options.name ?? (typeof File !== "undefined" && file instanceof File ? file.name : "file");
+      const query = new URLSearchParams({ name, scope: options.scope ?? "shared" });
+      return await send(`/files?${query}`, {
+        method: "POST",
+        headers: {
+          "content-type": options.contentType ?? (blob.type || "application/octet-stream")
+        },
+        body: await blob.arrayBuffer()
+      });
+    },
+    list: async (options = {}) => {
+      const query = new URLSearchParams();
+      if (options.limit !== void 0) query.set("limit", String(options.limit));
+      if (options.cursor) query.set("cursor", options.cursor);
+      const suffix = query.size ? `?${query}` : "";
+      return await send(`/files${suffix}`, { method: "GET" });
+    },
+    url: async (fileId) => await send(`/files/${encodeURIComponent(fileId)}`, { method: "GET" }),
+    delete: async (fileId) => {
+      await send(`/files/${encodeURIComponent(fileId)}`, { method: "DELETE" });
+    }
+  };
+  return { data, files };
+}
+function refFields(ref) {
+  if (typeof ref === "string") return { key: ref };
+  if ("id" in ref) return { id: ref.id };
+  return { key: ref.key };
+}
+var KNOWN_CODES = /* @__PURE__ */ new Set([
+  "validation",
+  "conflict",
+  "not_found",
+  "forbidden",
+  "not_available_for_viewer",
+  "quota_exceeded",
+  "rate_limited"
+]);
+function siteDataErrorFromResponse(status, value) {
+  const error = typeof value === "object" && value !== null && "error" in value ? value.error : null;
+  const record = typeof error === "object" && error !== null ? error : {};
+  const details = typeof record.details === "object" && record.details !== null ? record.details : {};
+  const detailCode = details.code;
+  const code = detailCode && KNOWN_CODES.has(detailCode) ? detailCode : status === 404 ? "not_found" : status === 403 ? "forbidden" : status === 413 ? "quota_exceeded" : status === 429 ? "rate_limited" : "request_failed";
+  const message = typeof record.message === "string" && record.message ? record.message : `Site Data request failed with HTTP ${status}`;
+  return new OpenGeniSiteDataError(code, message, status, details);
+}
+
+// src/site-sql.ts
+var OpenGeniSiteSqlError = class extends Error {
+  constructor(code, message, status, details = {}) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "OpenGeniSiteSqlError";
+  }
+};
+var QUERY_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/u;
+var KNOWN_CODES2 = /* @__PURE__ */ new Set([
+  "validation",
+  "not_found",
+  "forbidden",
+  "not_available_for_viewer",
+  "conflict",
+  "quota_exceeded",
+  "rate_limited",
+  "sql_error",
+  "unavailable",
+  "disabled"
+]);
+function createOpenGeniSiteSql(fetchSite, ready) {
+  return {
+    async run(name, params = {}) {
+      if (!QUERY_NAME.test(name))
+        throw new OpenGeniSiteSqlError("validation", "Invalid query name", 0);
+      if (Object.keys(params).some((key) => key === "viewer" || key.startsWith("viewer_")))
+        throw new OpenGeniSiteSqlError(
+          "validation",
+          "viewer parameters are bound by the host, not the Site",
+          0
+        );
+      if (!await ready())
+        throw new OpenGeniSiteSqlError(
+          "site_sql_unsupported",
+          "This Site host does not provide Site SQL",
+          0
+        );
+      const response = await fetchSite(
+        `${SITE_DATA_PATH_PREFIX}/sql/queries/${encodeURIComponent(name)}`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ params })
+        }
+      );
+      const text = await response.text();
+      let value = null;
+      try {
+        value = text ? JSON.parse(text) : null;
+      } catch {
+        value = null;
+      }
+      if (response.ok) return value;
+      throw siteSqlErrorFromResponse(response.status, value);
+    }
+  };
+}
+function siteSqlErrorFromResponse(status, value) {
+  const error = typeof value === "object" && value !== null && "error" in value ? value.error : null;
+  const record = typeof error === "object" && error !== null ? error : {};
+  const details = typeof record.details === "object" && record.details !== null ? record.details : {};
+  const detailCode = typeof details.code === "string" ? details.code : void 0;
+  const code = detailCode && KNOWN_CODES2.has(detailCode) ? detailCode : status === 404 ? "not_found" : status === 403 ? "forbidden" : status === 413 ? "quota_exceeded" : status === 429 ? "rate_limited" : "request_failed";
+  const message = typeof record.message === "string" && record.message ? record.message : `Site SQL request failed with HTTP ${status}`;
+  return new OpenGeniSiteSqlError(code, message, status, details);
+}
+
+// src/site.ts
+var OPENGENI_SITE_BRIDGE_VERSION = 2;
+var OPENGENI_SITE_BRIDGE_CONNECT = "opengeni.site.connect";
+var OPENGENI_SITE_BRIDGE_READY = "opengeni.site.ready";
+var OPENGENI_SITE_BRIDGE_REQUEST = "opengeni.site.request";
+var OPENGENI_SITE_BRIDGE_RESPONSE = "opengeni.site.response";
+var OPENGENI_SITE_BRIDGE_CANCEL = "opengeni.site.cancel";
+var OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL = "__opengeniSiteBridgeBootstrapV2";
+var OPENGENI_SITE_LOCAL_CODEMODE_PATH = "/__opengeni/site-tools";
+var OPENGENI_SITE_BRIDGE_VIEWER_METHOD = "viewer";
+var OPENGENI_SITE_BRIDGE_SIGN_IN_METHOD = "auth.signIn";
+var OpenGeniSiteBridgeError = class extends Error {
+  constructor(code, message, retryable = false, outcomeUnknown = false) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.outcomeUnknown = outcomeUnknown;
+    this.name = "OpenGeniSiteBridgeError";
+  }
+};
+function createOpenGeniSiteClient(options = {}) {
+  const transport = shouldUseLocalCodemode(options) ? new OpenGeniSiteLocalCodemodeTransport(options) : new OpenGeniSiteBridgeTransport(options);
+  const siteData = createOpenGeniSiteData(
+    (path, init) => transport.fetch(`https://site.opengeni.invalid${path}`, init),
+    () => transport.siteDataSupported()
+  );
+  const siteSql = createOpenGeniSiteSql(
+    (path, init) => transport.fetch(`https://site.opengeni.invalid${path}`, init),
+    () => transport.siteDataSupported()
+  );
+  let viewer = null;
+  let capabilities = null;
+  return {
+    client: new OpenGeniClient({
+      baseUrl: "https://site.opengeni.invalid",
+      toolGatewayMode: options.toolGatewayMode ?? "target",
+      fetch: (input, init) => transport.fetch(input, init)
+    }),
+    workspaceId: SITE_WORKSPACE,
+    tools: new OpenGeniToolsClient(transport).forWorkspace("site-host"),
+    data: siteData.data,
+    files: siteData.files,
+    sql: siteSql,
+    get viewer() {
+      if (!viewer) {
+        const pending = transport.viewer();
+        viewer = pending;
+        pending.catch(() => {
+          if (viewer === pending) viewer = null;
+        });
+      }
+      return viewer;
+    },
+    get capabilities() {
+      capabilities ??= readSiteCapabilities(transport);
+      return capabilities;
+    },
+    auth: { signIn: () => transport.signIn() },
+    close: () => transport.close()
+  };
+}
+var OpenGeniSiteLocalCodemodeTransport = class {
+  toolGatewayMode;
+  fetchImpl;
+  basePath;
+  constructor(options) {
+    this.toolGatewayMode = options.toolGatewayMode ?? "target";
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    const configured = options.localCodemodePath;
+    this.basePath = (typeof configured === "string" ? configured : OPENGENI_SITE_LOCAL_CODEMODE_PATH).replace(/\/+$/u, "");
+  }
+  close() {
+  }
+  /** Local previews have no published Site, so no Site Data. */
+  async siteDataSupported() {
+    return false;
+  }
+  /** Local previews run outside any host that knows the viewer. */
+  async viewer() {
+    return null;
+  }
+  async signIn() {
+    return { started: false };
+  }
+  async fetch(input, init) {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    const path = `${url.pathname}${url.search}`;
+    siteSessionPath(path, SITE_WORKSPACE, request.method);
+    return this.fetchImpl(`${this.basePath}/sdk${path}`, {
+      method: request.method,
+      headers: request.headers,
+      signal: request.signal,
+      ...request.body ? { body: await request.text() } : {}
+    });
+  }
+  async requestJson(method, path, body, _query, options = {}) {
+    const suffix = localCodemodeSuffix(method, path);
+    const response = await this.fetchImpl(`${this.basePath}${suffix}`, {
+      method,
+      ...options.signal ? { signal: options.signal } : {},
+      ...body === void 0 ? {} : {
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body)
+      }
+    });
+    const value = await response.json();
+    if (response.ok) return value;
+    const envelope = isRecord(value) && isRecord(value.error) ? value.error : {};
+    throw new OpenGeniSiteBridgeError(
+      typeof envelope.code === "string" ? envelope.code : "local_codemode_error",
+      typeof envelope.message === "string" ? envelope.message : `Local Site tool request failed with HTTP ${response.status}`,
+      envelope.retryable === true,
+      envelope.outcomeUnknown === true
+    );
+  }
+};
+function shouldUseLocalCodemode(options) {
+  if (options.localCodemodePath === false || options.bootstrapPort) return false;
+  if (typeof options.localCodemodePath === "string") return true;
+  const siteWindow = options.siteWindow ?? globalThis.window;
+  return Boolean(siteWindow && siteWindow.parent === siteWindow);
+}
+function localCodemodeSuffix(method, path) {
+  if (method === "GET" && path.endsWith("/tools/catalog")) return "/catalog";
+  if (method === "GET" && path.endsWith("/tools/declarations")) return "/declarations";
+  if (method === "POST" && path.endsWith("/tools/calls")) return "/calls";
+  if (method === "POST" && path.endsWith("/tools/resolve")) return "/resolve";
+  if (method === "POST" && path.endsWith("/tools/invoke")) return "/invoke";
+  throw new OpenGeniSiteBridgeError("unsupported_request", "Unsupported Site tool request");
+}
+function isOpenGeniSiteBridgeConnectMessage(value) {
+  return isRecord(value) && value.type === OPENGENI_SITE_BRIDGE_CONNECT && value.version === OPENGENI_SITE_BRIDGE_VERSION;
+}
+function isOpenGeniSiteBridgeRequestMessage(value) {
+  if (!isRecord(value) || value.type !== OPENGENI_SITE_BRIDGE_REQUEST || value.version !== OPENGENI_SITE_BRIDGE_VERSION || typeof value.requestId !== "string" || !value.requestId) {
+    return false;
+  }
+  if (value.method === "catalog" || value.method === "declarations" || value.method === OPENGENI_SITE_BRIDGE_VIEWER_METHOD || value.method === OPENGENI_SITE_BRIDGE_SIGN_IN_METHOD)
+    return true;
+  return ["call", "resolve", "invoke"].includes(String(value.method)) && isRecord(value.payload);
+}
+function isOpenGeniSiteBridgeCancelMessage(value) {
+  return isRecord(value) && value.type === OPENGENI_SITE_BRIDGE_CANCEL && value.version === OPENGENI_SITE_BRIDGE_VERSION && typeof value.requestId === "string" && Boolean(value.requestId);
+}
+function sanitizeOpenGeniSiteToolCallRequest(value) {
+  return {
+    ...value.operationId === void 0 ? {} : { operationId: value.operationId },
+    catalogDigest: value.catalogDigest,
+    identity: value.identity,
+    arguments: value.arguments
+  };
+}
+function sanitizeOpenGeniSiteToolInvokeRequest(value) {
+  return {
+    target: value.target,
+    operationId: value.operationId,
+    arguments: value.arguments,
+    ...value.expectedDefinitionDigest === void 0 ? {} : { expectedDefinitionDigest: value.expectedDefinitionDigest }
+  };
+}
+var OpenGeniSiteBridgeTransport = class {
+  toolGatewayMode;
+  targetTools = false;
+  siteData = false;
+  viewerSupported = false;
+  options;
+  bootstrap;
+  port = null;
+  connecting = null;
+  closed = false;
+  constructor(options) {
+    this.toolGatewayMode = options.toolGatewayMode ?? "target";
+    this.options = options;
+    this.bootstrap = createSiteBridgeBootstrap(options);
+  }
+  async fetch(input, init) {
+    return sitePortFetch(await this.connect(), input, init);
+  }
+  async siteDataSupported() {
+    await this.connect();
+    return this.siteData;
+  }
+  async viewer() {
+    await this.connect();
+    if (!this.viewerSupported) return null;
+    const value = await this.request({ method: OPENGENI_SITE_BRIDGE_VIEWER_METHOD }, {});
+    if (!isOpenGeniSiteViewer(value))
+      throw new OpenGeniSiteBridgeError(
+        "invalid_viewer",
+        "The Site host returned an invalid viewer"
+      );
+    return value;
+  }
+  async signIn() {
+    await this.connect();
+    if (!this.viewerSupported) return { started: false };
+    const value = await this.request({ method: OPENGENI_SITE_BRIDGE_SIGN_IN_METHOD }, {});
+    return { started: isRecord(value) && value.started === true };
+  }
+  async requestJson(method, path, body, _query, requestOptions = {}) {
+    if (method === "POST" && (path.endsWith("/tools/resolve") || path.endsWith("/tools/invoke"))) {
+      await this.connect();
+      if (!this.targetTools)
+        throw new OpenGeniSiteBridgeError(
+          "target_tools_unsupported",
+          "Upgrade the Site host to use targeted tools"
+        );
+      if (!isRecord(body)) throw new TypeError("Site target payload is required");
+      const request = body;
+      return await this.request(
+        path.endsWith("/tools/resolve") ? { method: "resolve", payload: { target: request.target } } : { method: "invoke", payload: sanitizeOpenGeniSiteToolInvokeRequest(request) },
+        requestOptions
+      );
+    }
+    if (method === "GET" && path.endsWith("/tools/catalog")) {
+      return await this.request({ method: "catalog" }, requestOptions);
+    }
+    if (method === "GET" && path.endsWith("/tools/declarations")) {
+      return await this.request({ method: "declarations" }, requestOptions);
+    }
+    if (method === "POST" && path.endsWith("/tools/calls")) {
+      if (!isRecord(body)) throw new TypeError("Site tool call payload is required");
+      return await this.request(
+        {
+          method: "call",
+          payload: sanitizeOpenGeniSiteToolCallRequest(body)
+        },
+        requestOptions
+      );
+    }
+    throw new OpenGeniSiteBridgeError("unsupported_request", "Unsupported Site bridge request");
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.bootstrap.close();
+    this.port?.close();
+    this.port = null;
+  }
+  async request(request, options) {
+    const port = await this.connect();
+    const requestId = crypto.randomUUID();
+    const timeoutMs = positiveTimeout(
+      options.timeoutMs ?? this.options.requestTimeoutMs ?? 12e4,
+      "requestTimeoutMs"
+    );
+    return await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        cancel(port, requestId);
+        reject(
+          request.method === "call" || request.method === "invoke" ? new OpenGeniSiteBridgeError(
+            "timeout",
+            "Site tool request timed out after execution may have started",
+            false,
+            true
+          ) : new OpenGeniSiteBridgeError("timeout", "Site tool request timed out", true)
+        );
+      }, timeoutMs);
+      const abort = () => {
+        cleanup();
+        cancel(port, requestId);
+        reject(options.signal?.reason ?? new DOMException("Request aborted", "AbortError"));
+      };
+      const onMessage = (event) => {
+        const response = event.data;
+        if (!isRecord(response) || response.type !== OPENGENI_SITE_BRIDGE_RESPONSE || response.version !== OPENGENI_SITE_BRIDGE_VERSION || response.requestId !== requestId || typeof response.ok !== "boolean") {
+          return;
+        }
+        cleanup();
+        if (response.ok) {
+          resolve(response.value);
+          return;
+        }
+        const error = isRecord(response.error) ? response.error : {};
+        reject(
+          new OpenGeniSiteBridgeError(
+            typeof error.code === "string" ? error.code : "bridge_error",
+            typeof error.message === "string" ? error.message : "Site tool request failed",
+            error.retryable === true,
+            error.outcomeUnknown === true
+          )
+        );
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener("abort", abort);
+        port.removeEventListener("message", onMessage);
+      };
+      if (options.signal?.aborted) {
+        abort();
+        return;
+      }
+      options.signal?.addEventListener("abort", abort, { once: true });
+      port.addEventListener("message", onMessage);
+      port.postMessage({
+        type: OPENGENI_SITE_BRIDGE_REQUEST,
+        version: OPENGENI_SITE_BRIDGE_VERSION,
+        requestId,
+        ...request
+      });
+    });
+  }
+  async connect() {
+    if (this.closed) throw new OpenGeniSiteBridgeError("closed", "Site bridge is closed");
+    if (this.port) return this.port;
+    if (this.connecting) return await this.connecting;
+    const channel = (this.options.createMessageChannel ?? (() => new MessageChannel()))();
+    const timeoutMs = positiveTimeout(this.options.connectTimeoutMs ?? 1e4, "connectTimeoutMs");
+    this.connecting = new Promise((resolve, reject) => {
+      let active = true;
+      const timeout = setTimeout(() => {
+        cleanup();
+        channel.port1.close();
+        reject(new OpenGeniSiteBridgeError("host_timeout", "Opengeni Site host did not respond"));
+      }, timeoutMs);
+      const onMessage = (event) => {
+        const message = event.data;
+        if (!isRecord(message) || message.type !== OPENGENI_SITE_BRIDGE_READY || message.version !== OPENGENI_SITE_BRIDGE_VERSION) {
+          return;
+        }
+        cleanup();
+        this.targetTools = message.targetTools === 1;
+        this.siteData = message.siteData === 1;
+        this.viewerSupported = message.viewer === 1;
+        this.port = channel.port1;
+        resolve(channel.port1);
+      };
+      const cleanup = () => {
+        active = false;
+        clearTimeout(timeout);
+        channel.port1.removeEventListener("message", onMessage);
+      };
+      channel.port1.addEventListener("message", onMessage);
+      channel.port1.start();
+      void this.bootstrap.port().then((bootstrapPort) => {
+        if (!active) return;
+        if (this.closed) throw new OpenGeniSiteBridgeError("closed", "Site bridge is closed");
+        bootstrapPort.postMessage(
+          {
+            type: OPENGENI_SITE_BRIDGE_CONNECT,
+            version: OPENGENI_SITE_BRIDGE_VERSION
+          },
+          [channel.port2]
+        );
+      }).catch((error) => {
+        cleanup();
+        channel.port1.close();
+        reject(error);
+      });
+    }).finally(() => {
+      this.connecting = null;
+    });
+    return await this.connecting;
+  }
+};
+function createSiteBridgeBootstrap(options) {
+  if (options.bootstrapPort) {
+    return {
+      port: async () => options.bootstrapPort,
+      close: () => options.bootstrapPort?.close()
+    };
+  }
+  const siteWindow = options.siteWindow ?? globalThis.window;
+  const parentWindow = options.parentWindow ?? siteWindow?.parent;
+  if (!siteWindow || !parentWindow || parentWindow === siteWindow) {
+    return {
+      port: async () => {
+        throw new OpenGeniSiteBridgeError(
+          "host_unavailable",
+          "Opengeni Site client must run inside a hosted iframe"
+        );
+      },
+      close: () => void 0
+    };
+  }
+  const retainedPort = retainedSiteBridgeBootstrapPort(siteWindow);
+  if (retainedPort) {
+    return {
+      port: async () => retainedPort,
+      close: () => void 0
+    };
+  }
+  let settledPort = null;
+  let rejectBootstrap = null;
+  const onMessage = (event) => {
+    if (event.source !== parentWindow || !isOpenGeniSiteBridgeReadyMessage(event.data) || event.ports.length !== 1) {
+      return;
+    }
+    cleanup();
+    settledPort = event.ports[0];
+    settledPort.start();
+    retainSiteBridgeBootstrapPort(siteWindow, settledPort);
+    resolveBootstrap?.(settledPort);
+  };
+  let resolveBootstrap = null;
+  const cleanup = () => siteWindow.removeEventListener("message", onMessage);
+  const port = new Promise((resolve, reject) => {
+    resolveBootstrap = resolve;
+    rejectBootstrap = reject;
+    siteWindow.addEventListener("message", onMessage);
+  });
+  void port.catch(() => void 0);
+  return {
+    port: async () => await port,
+    close: () => {
+      cleanup();
+      rejectBootstrap?.(new OpenGeniSiteBridgeError("closed", "Site bridge is closed"));
+      resolveBootstrap = null;
+      rejectBootstrap = null;
+    }
+  };
+}
+function retainedSiteBridgeBootstrapPort(siteWindow) {
+  const state = siteWindow[OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL];
+  if (!isRecord(state)) return null;
+  const candidate = state.port;
+  return candidate && typeof candidate.postMessage === "function" && typeof candidate.addEventListener === "function" && typeof candidate.start === "function" ? candidate : null;
+}
+function retainSiteBridgeBootstrapPort(siteWindow, port) {
+  try {
+    Object.defineProperty(siteWindow, OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL, {
+      configurable: true,
+      value: { port }
+    });
+  } catch {
+  }
+}
+function isOpenGeniSiteBridgeReadyMessage(value) {
+  return isRecord(value) && value.type === OPENGENI_SITE_BRIDGE_READY && value.version === OPENGENI_SITE_BRIDGE_VERSION;
+}
+var SITE_VIEWER_KINDS = ["member", "invited", "user", "guest"];
+async function readSiteCapabilities(transport) {
+  try {
+    if (!await transport.siteDataSupported()) return null;
+    const response = await transport.fetch(
+      "https://site.opengeni.invalid/v1/workspaces/site-host/site/config",
+      { method: "GET", headers: { accept: "application/json" } }
+    );
+    if (!response.ok) {
+      await response.body?.cancel();
+      return null;
+    }
+    const value = (await response.json())?.capabilities;
+    return isOpenGeniSiteCapabilities(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function isOpenGeniSiteCapabilities(value) {
+  return isRecord(value) && typeof value.agent === "boolean" && typeof value.workspaceTools === "boolean" && (value.siteData === "viewer" || value.siteData === "guest") && Array.isArray(value.sqlQueryAudiences) && value.sqlQueryAudiences.every(
+    (audience) => audience === "everyone" || audience === "signed_in"
+  ) && (value.viewAs === null || value.viewAs === "invited" || value.viewAs === "public");
+}
+function isOpenGeniSiteViewer(value) {
+  return isRecord(value) && SITE_VIEWER_KINDS.includes(String(value.kind)) && typeof value.id === "string" && value.id.length > 0 && (value.name === null || typeof value.name === "string") && (value.email === null || typeof value.email === "string") && typeof value.signedIn === "boolean";
+}
+function cancel(port, requestId) {
+  port.postMessage({
+    type: OPENGENI_SITE_BRIDGE_CANCEL,
+    version: OPENGENI_SITE_BRIDGE_VERSION,
+    requestId
+  });
+}
+function positiveTimeout(value, label) {
+  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${label} must be positive`);
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  siteSessionPath,
+  isSiteHttpRequest,
+  serveSiteHttp,
+  createSiteToolBridge,
+  isSiteCatalogStaleError,
+  OpenGeniSiteDataError,
+  SITE_DATA_PATH_PREFIX,
+  OpenGeniSiteSqlError,
+  OPENGENI_SITE_BRIDGE_VERSION,
+  OPENGENI_SITE_BRIDGE_CONNECT,
+  OPENGENI_SITE_BRIDGE_READY,
+  OPENGENI_SITE_BRIDGE_REQUEST,
+  OPENGENI_SITE_BRIDGE_RESPONSE,
+  OPENGENI_SITE_BRIDGE_CANCEL,
+  OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL,
+  OPENGENI_SITE_LOCAL_CODEMODE_PATH,
+  OPENGENI_SITE_BRIDGE_VIEWER_METHOD,
+  OPENGENI_SITE_BRIDGE_SIGN_IN_METHOD,
+  OpenGeniSiteBridgeError,
+  createOpenGeniSiteClient,
+  isOpenGeniSiteBridgeConnectMessage,
+  isOpenGeniSiteBridgeRequestMessage,
+  isOpenGeniSiteBridgeCancelMessage,
+  sanitizeOpenGeniSiteToolCallRequest,
+  sanitizeOpenGeniSiteToolInvokeRequest
+};
+//# sourceMappingURL=chunk-JXXCTW5W.js.map