@agents24/chat-react 0.5.0 → 0.5.1

package/dist/runtime/index.cjs

@@ -0,0 +1,594 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  SUPPORTED_INPUT_MIME_TYPES: () => SUPPORTED_INPUT_MIME_TYPES,
+  agentChatRuntimeErrorMessage: () => agentChatRuntimeErrorMessage,
+  agentChatRuntimeStateFromError: () => agentChatRuntimeStateFromError,
+  canonicalInputMimeType: () => canonicalInputMimeType,
+  inputMimeTypes: () => inputMimeTypes,
+  modelsFromAgentChatBootstrap: () => modelsFromAgentChatBootstrap,
+  useAgentChatRuntime: () => useAgentChatRuntime,
+  validateAgentChatSubmission: () => validateAgentChatSubmission,
+  validateWorkflowInputSubmission: () => validateWorkflowInputSubmission,
+  workflowInputRule: () => workflowInputRule
+});
+module.exports = __toCommonJS(runtime_exports);
+
+// src/runtime/use-agent-chat-runtime.ts
+var import_react = require("@agents24/react");
+var React = __toESM(require("react"), 1);
+
+// src/mcp-oauth.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function browserChatCrypto() {
+  const value = globalThis.crypto;
+  if (!value?.subtle || !value.randomUUID) {
+    throw new Error("Secure browser crypto is required for MCP authorization.");
+  }
+  return value;
+}
+function base64Url(bytes) {
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+async function createMcpPkceProof() {
+  const crypto = browserChatCrypto();
+  const verifier = base64Url(crypto.getRandomValues(new Uint8Array(32)));
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return { challenge: base64Url(new Uint8Array(digest)), verifier };
+}
+function isLoopback(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+function normalizedOrigin(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback(url.hostname))) {
+      throw new Error("unsafe callback origin");
+    }
+    if (url.origin === "null") throw new Error("opaque callback origin");
+    return url.origin;
+  } catch {
+    throw new Error("MCP authorization returned an invalid callback origin.");
+  }
+}
+function validateMcpCallbackResult(result, expectedServerId) {
+  const serverId = String(result.server_id || "").trim();
+  const connectionId = String(result.connection_id || "").trim();
+  if (!serverId || serverId !== expectedServerId) {
+    throw new Error("MCP authorization completed for an unexpected server.");
+  }
+  if (!UUID_PATTERN.test(connectionId)) {
+    throw new Error("MCP authorization returned an invalid connection identity.");
+  }
+  return result;
+}
+function waitForMcpOauthComplete({
+  popup,
+  callbackOrigin,
+  popupNonce,
+  requireConnectionId = false,
+  serverId,
+  timeoutMs = 12e4
+}) {
+  if (!popup) return Promise.reject(new Error("Could not open the MCP authorization popup."));
+  const expectedOrigin = normalizedOrigin(callbackOrigin);
+  const expectedServerId = String(serverId || "").trim();
+  const expectedPopupNonce = String(popupNonce || "").trim();
+  if (!expectedServerId) return Promise.reject(new Error("MCP authorization is missing its server identity."));
+  if (!expectedPopupNonce) return Promise.reject(new Error("MCP authorization is missing its popup binding."));
+  const returnFocusTo = typeof document !== "undefined" ? document.activeElement : null;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      window.clearTimeout(timeout);
+      window.clearInterval(closeTimer);
+      window.removeEventListener("message", onMessage);
+      returnFocusTo?.focus?.();
+      if (result instanceof Error) reject(result);
+      else resolve(result);
+    };
+    const onMessage = (event) => {
+      if (event.source !== popup || event.origin !== expectedOrigin) return;
+      const data = event.data;
+      if (data?.type !== "agents24.mcp.callback" || data.server_id !== expectedServerId || data.popup_nonce !== expectedPopupNonce) return;
+      const code = String(data.code || "").trim();
+      if (!code || code.length > 2048) return;
+      const connectionId = String(data.connection_id || "").trim();
+      if ((requireConnectionId || connectionId) && !UUID_PATTERN.test(connectionId)) return;
+      finish({
+        code,
+        ...connectionId ? { connectionId } : {},
+        popupNonce: expectedPopupNonce,
+        serverId: expectedServerId
+      });
+    };
+    const timeout = window.setTimeout(
+      () => finish(new Error("MCP authorization timed out.")),
+      Math.max(1, timeoutMs)
+    );
+    const closeTimer = window.setInterval(() => {
+      if (popup.closed) finish(new Error("MCP authorization window was closed before connecting."));
+    }, 500);
+    window.addEventListener("message", onMessage);
+  });
+}
+
+// src/runtime/input-contract.ts
+var SUPPORTED_INPUT_MIME_TYPES = {
+  files: ["application/pdf", "text/plain", "text/markdown", "text/csv", "application/json"],
+  images: ["image/png", "image/jpeg", "image/webp"],
+  audio: ["audio/wav", "audio/mpeg", "audio/webm", "audio/mp4"]
+};
+function workflowInputRule(inputs, key) {
+  const input = inputs?.find((candidate) => candidate.key === key);
+  return {
+    enabled: input?.enabled !== false,
+    required: input?.required === true
+  };
+}
+function validateWorkflowInputSubmission(inputs, text, attachmentMimeTypes) {
+  const present = { files: false, images: false, audio: false };
+  if (text.trim() && !workflowInputRule(inputs, "text").enabled) {
+    return "This workflow does not accept text input.";
+  }
+  for (const rawMimeType of attachmentMimeTypes) {
+    const mimeType = canonicalInputMimeType(rawMimeType);
+    const modality = mimeType.startsWith("image/") ? "images" : mimeType.startsWith("audio/") ? "audio" : "files";
+    const supported = SUPPORTED_INPUT_MIME_TYPES[modality].includes(mimeType);
+    if (!supported || !workflowInputRule(inputs, modality).enabled) {
+      return `The attachment type ${mimeType || "unknown"} is not accepted.`;
+    }
+    present[modality] = true;
+  }
+  if (workflowInputRule(inputs, "text").required && !text.trim()) return "Text input is required.";
+  for (const modality of ["files", "images", "audio"]) {
+    if (workflowInputRule(inputs, modality).required && !present[modality]) {
+      return `${modality[0].toUpperCase()}${modality.slice(1)} input is required.`;
+    }
+  }
+  return null;
+}
+function canonicalInputMimeType(value) {
+  const normalized = value.split(";", 1)[0]?.trim().toLowerCase() || "";
+  if (normalized === "image/jpg") return "image/jpeg";
+  if (["audio/x-wav"].includes(normalized)) return "audio/wav";
+  if (["audio/x-m4a", "audio/m4a"].includes(normalized)) return "audio/mp4";
+  return normalized;
+}
+function uploadByteSize(data) {
+  if (data instanceof Uint8Array || data instanceof ArrayBuffer) return data.byteLength;
+  return data.size;
+}
+function inputMimeTypes(contract) {
+  if (!contract) return [];
+  return [
+    ...contract.modalities.files.allowed_mime_types,
+    ...contract.modalities.images.allowed_mime_types,
+    ...contract.modalities.audio.allowed_mime_types
+  ];
+}
+function validateAgentChatSubmission(contract, text, files) {
+  const { modalities, limits } = contract;
+  const normalizedText = text.trim();
+  if (normalizedText && !modalities.text.enabled) return "This agent does not accept text input.";
+  if (modalities.text.required && !normalizedText) return "Text input is required.";
+  if (files.length > limits.max_attachments_per_turn) {
+    return `You can attach up to ${limits.max_attachments_per_turn} items per message.`;
+  }
+  let totalBytes = 0;
+  const present = { files: false, images: false, audio: false };
+  for (const file of files) {
+    const mediaType = canonicalInputMimeType(file.mediaType);
+    const modality = mediaType.startsWith("image/") ? "images" : mediaType.startsWith("audio/") ? "audio" : "files";
+    const rule = modalities[modality];
+    if (!rule.enabled || !rule.allowed_mime_types.includes(mediaType)) {
+      return `The attachment type ${mediaType || "unknown"} is not accepted.`;
+    }
+    const byteSize = uploadByteSize(file.data);
+    if (byteSize > limits.max_file_bytes) return "An attachment exceeds the per-file size limit.";
+    totalBytes += byteSize;
+    present[modality] = true;
+  }
+  if (totalBytes > limits.max_total_bytes) return "Attachments exceed the total size limit.";
+  for (const modality of ["files", "images", "audio"]) {
+    if (modalities[modality].required && !present[modality]) return `${modality[0].toUpperCase()}${modality.slice(1)} input is required.`;
+  }
+  return null;
+}
+
+// src/runtime/use-agent-chat-runtime.ts
+function agentChatRuntimeStateFromError(error) {
+  const typed = error;
+  if (typed?.kind === "authentication") return "expired";
+  if (typed?.kind === "authorization") return "denied";
+  if (typed?.kind === "quota" || typed?.kind === "rate_limit") return "quota";
+  if (typed?.kind === "network") return "offline";
+  return "failed";
+}
+function agentChatRuntimeErrorMessage(error) {
+  if (!error) return null;
+  return error instanceof Error ? error.message : String(error);
+}
+function modelsFromAgentChatBootstrap(bootstrap) {
+  const modelFeatures = bootstrap.features.models;
+  const selectable = bootstrap.capabilities.includes("models.select") && modelFeatures?.selectable === true;
+  if (!selectable) return { defaultModelId: null, models: [] };
+  const models = Array.isArray(modelFeatures.options) ? modelFeatures.options.flatMap((option) => typeof option?.id === "string" && option.id.trim() ? [{ id: option.id, label: typeof option.label === "string" && option.label.trim() ? option.label : option.id }] : []) : [];
+  const configuredDefault = models.some((model) => model.id === modelFeatures.default_id) ? modelFeatures.default_id : null;
+  return {
+    defaultModelId: configuredDefault,
+    models
+  };
+}
+function modelsFromEffectivePolicy(policy) {
+  const models = policy.model_selection.selectable ? policy.model_selection.options.map((option) => ({ id: option.id, label: option.label })) : [];
+  return {
+    defaultModelId: models.some((model) => model.id === policy.model_selection.default_id) ? policy.model_selection.default_id : null,
+    models
+  };
+}
+function hitlKey(part) {
+  return part.interruptId || part.id;
+}
+function useAgentChatRuntime(options) {
+  const {
+    activeThreadId,
+    agent: agentOverride,
+    client,
+    completeMcpAuthorization,
+    mcpRedirectUri,
+    modelId,
+    onActiveThreadIdChange,
+    onModelChange
+  } = options;
+  const controller = (0, import_react.useAgentChat)(
+    activeThreadId === void 0 ? { client } : { activeThreadId, client }
+  );
+  const attachments = (0, import_react.useAgentAttachments)();
+  const mcp = (0, import_react.useAgentMcp)();
+  const [bootstrap, setBootstrap] = React.useState(null);
+  const [effectivePolicy, setEffectivePolicy] = React.useState(null);
+  const [isBootstrapping, setIsBootstrapping] = React.useState(true);
+  const [bootstrapError, setBootstrapError] = React.useState(null);
+  const [localOperationError, setLocalOperationError] = React.useState(null);
+  const [selectedModelId, setSelectedModelId] = React.useState(modelId ?? null);
+  const [isSubmitting, setIsSubmitting] = React.useState(false);
+  const submitPromiseRef = React.useRef(null);
+  const [hitlStates, setHitlStates] = React.useState({});
+  const hitlStatesRef = React.useRef(hitlStates);
+  hitlStatesRef.current = hitlStates;
+  const mountedRef = React.useRef(true);
+  const clientRef = React.useRef(client);
+  clientRef.current = client;
+  const bootstrapPromiseRef = React.useRef(null);
+  React.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const previousControlledThreadRef = React.useRef(activeThreadId);
+  const controlledSyncTargetRef = React.useRef(null);
+  const previousControllerThreadRef = React.useRef(controller.activeThreadId);
+  const pendingThreadTransitionRef = React.useRef(null);
+  const lastReportedThreadRef = React.useRef(activeThreadId ?? controller.activeThreadId);
+  if (activeThreadId !== previousControlledThreadRef.current) {
+    previousControlledThreadRef.current = activeThreadId;
+    if (activeThreadId !== void 0) {
+      controlledSyncTargetRef.current = { value: activeThreadId };
+      lastReportedThreadRef.current = activeThreadId;
+    }
+  }
+  const reportActiveThread = React.useCallback((threadId, reason) => {
+    if (lastReportedThreadRef.current === threadId) return;
+    lastReportedThreadRef.current = threadId;
+    onActiveThreadIdChange?.({ threadId, reason });
+  }, [onActiveThreadIdChange]);
+  const retryBootstrap = React.useCallback(() => {
+    if (bootstrapPromiseRef.current?.client === client) return bootstrapPromiseRef.current.promise;
+    const requestClient = client;
+    const request = (async () => {
+      if (mountedRef.current) {
+        setIsBootstrapping(true);
+        setBootstrapError(null);
+        setBootstrap(null);
+        setEffectivePolicy(null);
+      }
+      try {
+        const result = await requestClient.bootstrap();
+        if (!mountedRef.current || clientRef.current !== requestClient) return;
+        setBootstrap(result);
+        const entitlement = await requestClient.resourcePolicies.getEffective();
+        if (!mountedRef.current || clientRef.current !== requestClient) return;
+        setEffectivePolicy(entitlement);
+        const availableModels = modelsFromEffectivePolicy(entitlement);
+        if (modelId === void 0) {
+          setSelectedModelId((current) => availableModels.models.some((item) => item.id === current) ? current : availableModels.defaultModelId);
+        }
+        await controller.refreshThreads().catch(() => void 0);
+      } catch (error) {
+        if (mountedRef.current && clientRef.current === requestClient) setBootstrapError(error);
+      } finally {
+        if (mountedRef.current && clientRef.current === requestClient) setIsBootstrapping(false);
+      }
+    })();
+    bootstrapPromiseRef.current = { client: requestClient, promise: request };
+    void request.finally(() => {
+      if (bootstrapPromiseRef.current?.promise === request) bootstrapPromiseRef.current = null;
+    });
+    return request;
+  }, [client, controller.refreshThreads, modelId]);
+  const refreshEffectivePolicy = React.useCallback(async () => {
+    const entitlement = await client.resourcePolicies.getEffective();
+    if (!mountedRef.current || clientRef.current !== client) return;
+    setEffectivePolicy(entitlement);
+    if (modelId === void 0) {
+      const available = modelsFromEffectivePolicy(entitlement);
+      setSelectedModelId((current) => available.models.some((item) => item.id === current) ? current : available.defaultModelId);
+    }
+  }, [client, modelId]);
+  React.useEffect(() => {
+    void retryBootstrap();
+  }, [retryBootstrap]);
+  React.useEffect(() => {
+    if (modelId !== void 0) setSelectedModelId(modelId);
+  }, [modelId]);
+  React.useEffect(() => {
+    hitlStatesRef.current = {};
+    setHitlStates({});
+  }, [client, controller.activeThreadId]);
+  React.useEffect(() => {
+    if (controlledSyncTargetRef.current?.value === null && controller.activeThreadId) {
+      controller.startNewThread();
+    }
+  }, [activeThreadId, controller.activeThreadId, controller.startNewThread]);
+  React.useEffect(() => {
+    const previous = previousControllerThreadRef.current;
+    const current = controller.activeThreadId;
+    previousControllerThreadRef.current = current;
+    const controlledTarget = controlledSyncTargetRef.current;
+    if (controlledTarget) {
+      if (current === controlledTarget.value) controlledSyncTargetRef.current = null;
+      return;
+    }
+    const pendingTransition = pendingThreadTransitionRef.current;
+    if (pendingTransition && current === pendingTransition.value) return;
+    if (previous === null && current !== null) reportActiveThread(current, "created");
+  }, [activeThreadId, controller.activeThreadId, reportActiveThread]);
+  const clearOperationError = React.useCallback(() => {
+    setLocalOperationError(null);
+    controller.clearOperationError();
+  }, [controller.clearOperationError]);
+  const submit = React.useCallback((input) => {
+    if (submitPromiseRef.current) return submitPromiseRef.current;
+    clearOperationError();
+    setIsSubmitting(true);
+    const request = (async () => {
+      try {
+        if (!bootstrap) throw new Error("The agent input contract is unavailable.");
+        const inputError = validateAgentChatSubmission(bootstrap.features.inputs, input.text, input.files || []);
+        if (inputError) throw new Error(inputError);
+        const uploaded = input.files?.length ? await attachments.uploadBatch({
+          uploads: input.files,
+          threadId: controller.activeThreadId || void 0
+        }) : [];
+        await controller.submit({
+          text: input.text,
+          attachmentIds: uploaded.flatMap((attachment) => attachment.id ? [attachment.id] : []),
+          attachments: uploaded,
+          requestedModelId: selectedModelId || void 0
+        });
+      } catch (error) {
+        setLocalOperationError(error);
+        const typed = error;
+        if (typed.kind === "quota" || typed.kind === "authorization") {
+          await refreshEffectivePolicy().catch(() => void 0);
+        }
+        throw error;
+      } finally {
+        setIsSubmitting(false);
+      }
+    })();
+    submitPromiseRef.current = request;
+    const clearRequest = () => {
+      if (submitPromiseRef.current === request) submitPromiseRef.current = null;
+    };
+    void request.then(clearRequest, clearRequest);
+    return request;
+  }, [attachments, bootstrap, clearOperationError, controller.activeThreadId, controller.submit, refreshEffectivePolicy, selectedModelId]);
+  const completeMcp = React.useCallback(async (part) => {
+    if (!mcpRedirectUri) throw new Error("mcpRedirectUri is required for MCP Connect.");
+    const serverId = String(part.presentation.server_id || "").trim();
+    if (!serverId) throw new Error("MCP authorization is missing its server identity.");
+    const runId = controller.activeRunId || controller.messages.find((message) => message.parts.includes(part))?.runId;
+    if (!runId) throw new Error("MCP authorization is missing its paused run.");
+    const popupNonce = browserChatCrypto().randomUUID();
+    const proof = await createMcpPkceProof();
+    const popup = window.open("about:blank", "agents24-mcp", "popup,width=560,height=720");
+    if (!popup) throw new Error("Allow popups to connect this MCP account.");
+    popup.document.title = "Connecting to MCP";
+    popup.document.body.textContent = "Opening secure connection\u2026";
+    try {
+      const started = await mcp.startAuthorization({
+        runId,
+        serverId,
+        interruptId: part.interruptId,
+        redirectUri: mcpRedirectUri,
+        popupNonce,
+        codeChallenge: proof.challenge
+      });
+      if (!started.callback_origin) throw new Error("MCP authorization did not return a callback origin.");
+      popup.location.replace(started.authorization_url);
+      const completion = await waitForMcpOauthComplete({
+        popup,
+        callbackOrigin: started.callback_origin,
+        popupNonce,
+        requireConnectionId: Boolean(completeMcpAuthorization),
+        serverId
+      });
+      if (completeMcpAuthorization) {
+        await completeMcpAuthorization({ completion, codeVerifier: proof.verifier, serverId });
+      } else {
+        const redeemed = await mcp.redeemCallback({ code: completion.code, codeVerifier: proof.verifier });
+        validateMcpCallbackResult(redeemed, serverId);
+      }
+    } finally {
+      popup.close();
+    }
+  }, [completeMcpAuthorization, controller.activeRunId, controller.messages, mcp, mcpRedirectUri]);
+  const onHitlAction = React.useCallback(async (part, response) => {
+    const action = response.action;
+    const key = hitlKey(part);
+    const current = hitlStatesRef.current[key];
+    if (current?.status === "connecting" || current?.status === "resuming") return;
+    clearOperationError();
+    const pending = {
+      action,
+      status: part.hitlKind === "mcp_auth" && action === "connect" ? "connecting" : "resuming"
+    };
+    hitlStatesRef.current = { ...hitlStatesRef.current, [key]: pending };
+    setHitlStates(hitlStatesRef.current);
+    try {
+      if (part.hitlKind === "mcp_auth" && action === "connect") await completeMcp(part);
+      await controller.resumeHitl(part, response);
+      setHitlStates((states) => {
+        const next = { ...states };
+        delete next[key];
+        hitlStatesRef.current = next;
+        return next;
+      });
+    } catch (error) {
+      setLocalOperationError(error);
+      const failedState = {
+        ...hitlStatesRef.current,
+        [key]: { action, error: agentChatRuntimeErrorMessage(error), status: "error" }
+      };
+      hitlStatesRef.current = failedState;
+      setHitlStates(failedState);
+      throw error;
+    }
+  }, [clearOperationError, completeMcp, controller.resumeHitl]);
+  const newThread = React.useCallback(() => {
+    clearOperationError();
+    pendingThreadTransitionRef.current = null;
+    reportActiveThread(null, "new");
+    controller.startNewThread();
+  }, [clearOperationError, controller.startNewThread, reportActiveThread]);
+  const openThread = React.useCallback(async (threadId) => {
+    clearOperationError();
+    pendingThreadTransitionRef.current = { reason: "opened", value: threadId };
+    try {
+      await controller.openThread(threadId);
+      reportActiveThread(threadId, "opened");
+    } catch (error) {
+      setLocalOperationError(error);
+      throw error;
+    } finally {
+      if (pendingThreadTransitionRef.current?.value === threadId) pendingThreadTransitionRef.current = null;
+    }
+  }, [clearOperationError, controller.openThread, reportActiveThread]);
+  const deleteThread = React.useCallback(async (threadId) => {
+    clearOperationError();
+    const wasActive = controller.activeThreadId === threadId;
+    if (wasActive) pendingThreadTransitionRef.current = { reason: "deleted", value: null };
+    try {
+      await controller.deleteThread(threadId);
+      if (wasActive) reportActiveThread(null, "deleted");
+    } catch (error) {
+      setLocalOperationError(error);
+      throw error;
+    } finally {
+      if (wasActive && pendingThreadTransitionRef.current?.reason === "deleted") {
+        pendingThreadTransitionRef.current = null;
+      }
+    }
+  }, [clearOperationError, controller.activeThreadId, controller.deleteThread, reportActiveThread]);
+  const changeModel = React.useCallback((nextModelId) => {
+    if (modelId === void 0) setSelectedModelId(nextModelId);
+    onModelChange?.(nextModelId);
+  }, [modelId, onModelChange]);
+  const modelOptions = effectivePolicy ? modelsFromEffectivePolicy(effectivePolicy).models : bootstrap ? modelsFromAgentChatBootstrap(bootstrap).models : [];
+  const fatalError = bootstrapError || controller.error;
+  const operationError = localOperationError || controller.operationError?.cause;
+  const state = isBootstrapping ? "loading" : fatalError ? agentChatRuntimeStateFromError(fatalError) : controller.runState === "streaming" ? "streaming" : controller.runState === "reconnecting" ? "reconnecting" : controller.runState === "paused" ? "paused" : controller.runState === "cancelling" ? "cancelling" : controller.runState === "cancelled" ? "cancelled" : "ready";
+  const connectionState = state === "offline" ? "offline" : state === "expired" ? "expired" : state === "reconnecting" ? "reconnecting" : isBootstrapping ? "connecting" : "connected";
+  return {
+    agent: agentOverride || { name: bootstrap?.deployment.name || "Agent" },
+    inputContract: bootstrap?.features.inputs || null,
+    allowFeedback: Boolean(bootstrap?.capabilities.includes("feedback.write")),
+    backgroundError: controller.backgroundError?.cause || null,
+    bootstrap,
+    capabilities: bootstrap?.capabilities || [],
+    changeModel,
+    clearOperationError,
+    connectionState,
+    contextWindow: controller.contextWindow,
+    contextCompression: controller.contextCompression,
+    controller,
+    deleteThread,
+    errorMessage: agentChatRuntimeErrorMessage(fatalError || operationError),
+    fatalError,
+    getHitlActionState: (part) => hitlStates[hitlKey(part)],
+    isBootstrapping,
+    isSubmitting: isSubmitting || controller.isSubmitting,
+    isUploading: attachments.isUploading,
+    modelId: selectedModelId,
+    models: modelOptions,
+    newThread,
+    onHitlAction,
+    openThread,
+    operationError,
+    retryBootstrap,
+    state,
+    submit
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SUPPORTED_INPUT_MIME_TYPES,
+  agentChatRuntimeErrorMessage,
+  agentChatRuntimeStateFromError,
+  canonicalInputMimeType,
+  inputMimeTypes,
+  modelsFromAgentChatBootstrap,
+  useAgentChatRuntime,
+  validateAgentChatSubmission,
+  validateWorkflowInputSubmission,
+  workflowInputRule
+});
+//# sourceMappingURL=index.cjs.map