@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-IXPTECSC.js

@@ -0,0 +1,403 @@
+"use client";
+import {
+  capabilityOn,
+  draftFromRequest
+} from "./chunk-AWKES45Y.js";
+import {
+  buildTools
+} from "./chunk-ZPW5NFYD.js";
+import {
+  sessionMcpPermissionGroups
+} from "./chunk-H2ALCTWC.js";
+
+// src/app/lib/session-create.tsx
+import {
+  CAPABILITY_DESCRIPTORS,
+  DEFAULT_FIRST_PARTY_MCP_TOOLS,
+  FIRST_PARTY_MCP_TOOL_CAPABILITIES,
+  isDerivedAgentToolOwner,
+  mergeResourceRefs,
+  Permission,
+  stableJson
+} from "@opengeni/contracts";
+function rememberedProjectCompute(history, channelId, defaultSandboxBackend) {
+  const project = history.projects.find((candidate) => candidate.channelId === channelId);
+  if (!project) return null;
+  if (!project.targetSandboxId) {
+    return defaultSandboxBackend === "selfhosted" ? { kind: "machine", sandboxId: null, folder: { kind: "root" } } : { kind: "sandbox", backend: "" };
+  }
+  const machine = project.machines.find(
+    (candidate) => candidate.sandboxId === project.targetSandboxId
+  );
+  return {
+    kind: "machine",
+    sandboxId: project.targetSandboxId,
+    folder: machine?.workingDir ? { kind: "path", path: machine.workingDir } : { kind: "root" }
+  };
+}
+function rememberedMachineFolder(history, channelId, sandboxId) {
+  const machine = history.projects.find((project) => project.channelId === channelId)?.machines.find((candidate) => candidate.sandboxId === sandboxId);
+  return machine?.workingDir ? { kind: "path", path: machine.workingDir } : { kind: "root" };
+}
+function workspaceDefaultRigOptionLabel(workspaceDefaultRigId, rigs) {
+  if (!workspaceDefaultRigId) return "None";
+  const rig = rigs.find((candidate) => candidate.id === workspaceDefaultRigId);
+  return rig ? `Workspace default: ${rig.name}` : "Workspace default";
+}
+function emptySessionDraft(defaultFirstPartyMcpTools = DEFAULT_FIRST_PARTY_MCP_TOOLS, defaultSandboxBackend) {
+  return {
+    visibility: "workspace",
+    compute: defaultSandboxBackend === "selfhosted" ? { kind: "machine", sandboxId: null, folder: { kind: "root" } } : { kind: "sandbox", backend: "" },
+    rigId: "",
+    goalText: "",
+    goalSuccessCriteria: "",
+    goalMaxAutoContinuations: "",
+    customMcpPermissions: false,
+    mcpPermissions: new Set(sessionMcpPermissionGroups().flatMap((group) => group.permissions)),
+    firstPartyMcpTools: new Set(defaultFirstPartyMcpTools)
+  };
+}
+function explicitFirstPartyTools(draft, defaultFirstPartyMcpTools) {
+  const selected = [...draft.firstPartyMcpTools];
+  if (selected.length === defaultFirstPartyMcpTools.length && defaultFirstPartyMcpTools.every((tool) => draft.firstPartyMcpTools.has(tool))) {
+    return {};
+  }
+  if (draft.agentCapabilities === void 0) return { firstPartyMcpTools: selected };
+  const values = draftFromRequest(draft.agentCapabilities).values;
+  return {
+    firstPartyMcpTools: selected.filter((tool) => {
+      const owner = FIRST_PARTY_MCP_TOOL_CAPABILITIES[tool];
+      return isDerivedAgentToolOwner(owner) || capabilityOn(values, owner);
+    })
+  };
+}
+function fitToolPolicyToAgentCapabilities(policy, capabilities) {
+  if (capabilities === void 0) return policy;
+  const values = draftFromRequest(capabilities).values;
+  if (!values.workspaceConnectors) {
+    const { excludedMcpServerIds: _excluded, ...rest } = policy;
+    return { ...rest, tools: [], toolsProvided: false };
+  }
+  return {
+    ...policy,
+    tools: policy.tools.filter(
+      (tool) => !(tool.id === "files" && !values.workspaceFiles) && !(tool.id === "docs" && !values.knowledge)
+    )
+  };
+}
+function isSessionDraftComputeReady(draft) {
+  return draft.compute.kind !== "machine" || draft.compute.sandboxId !== null;
+}
+function newSessionCreateVisibility(personalWorkspace, selectedVisibility, canCreatePrivate) {
+  return personalWorkspace ? canCreatePrivate ? "private" : "workspace" : selectedVisibility;
+}
+function classifyCreateSessionFailure(error) {
+  return {
+    error: error instanceof Error ? error : new Error(String(error)),
+    outcomeUnknown: typeof error === "object" && error !== null && error.outcomeUnknown === true
+  };
+}
+function retainCreateSessionAttemptAfterFailure(input) {
+  if (input.current?.idempotencyKey !== input.attempted.idempotencyKey) {
+    return input.current;
+  }
+  return input.outcomeUnknown ? input.current : null;
+}
+function buildCreateSessionRequest(input) {
+  const baseResources = input.omitWorkspaceResources ? [] : input.currentResources;
+  const resources = mergeResourceRefs(
+    [],
+    [...baseResources, ...input.submission.resources ?? []],
+    { rejectConflicts: true }
+  );
+  const selectedToolIds = [
+    ...new Set(
+      buildTools(
+        [],
+        input.selectedTools.map((tool) => tool.id)
+      ).map((tool) => tool.id)
+    )
+  ].sort();
+  const defaultToolIds = input.workspaceDefaultMcpServerIds ? [...new Set(input.workspaceDefaultMcpServerIds)].sort() : null;
+  const draftPolicy = input.newSessionDraftToolPolicy;
+  const exclusionOnlyCustomize = draftPolicy?.toolsProvided === true && draftPolicy.tools.length === 0 && draftPolicy.excludedMcpServerIds !== void 0;
+  const tools = draftPolicy ? draftPolicy.toolsProvided && !exclusionOnlyCustomize ? [...draftPolicy.tools] : void 0 : input.workspaceMcpCatalogReady === true && defaultToolIds && selectedToolIds.join("\0") === [...new Set(buildTools([], defaultToolIds).map((tool) => tool.id))].sort().join("\0") ? void 0 : [...input.selectedTools];
+  return {
+    ...input.startMode === "realtime" ? { startMode: "realtime" } : { initialMessage: input.submission.text },
+    visibility: input.visibility ?? "workspace",
+    instructions: input.instructions || void 0,
+    ...input.installedSkillIds?.length ? { installedSkillIds: input.installedSkillIds } : {},
+    ...input.bot ? {
+      keepLive: true,
+      profile: {
+        title: input.bot.name,
+        ...input.bot.description ? { description: input.bot.description } : {},
+        ...input.bot.avatar ? { avatar: input.bot.avatar } : {}
+      }
+    } : {},
+    resources,
+    ...tools === void 0 ? {} : { tools },
+    ...input.newSessionDraftToolPolicy?.excludedMcpServerIds !== void 0 ? { excludedMcpServerIds: input.newSessionDraftToolPolicy.excludedMcpServerIds } : {},
+    model: input.submission.model ?? input.defaultModel,
+    reasoningEffort: input.submission.reasoningEffort ?? input.defaultReasoningEffort,
+    latencyMode: input.submission.latencyMode ?? input.defaultLatencyMode,
+    clientEventId: input.clientEventId,
+    idempotencyKey: input.idempotencyKey,
+    ...input.submission.sandboxBackend ? { sandboxBackend: input.submission.sandboxBackend } : {},
+    ...input.submission.rigId ? { rigId: input.submission.rigId } : {},
+    ...input.submission.goal ? { goal: input.submission.goal } : {},
+    ...input.submission.firstPartyMcpPermissions ? { firstPartyMcpPermissions: input.submission.firstPartyMcpPermissions } : {},
+    ...input.submission.firstPartyMcpTools ? { firstPartyMcpTools: input.submission.firstPartyMcpTools } : {},
+    ...input.submission.personalResourceAttachment ? {
+      personalResourceAttachment: input.submission.personalResourceAttachment
+    } : {},
+    ...input.submission.connectionAccounts ? { connectionAccounts: input.submission.connectionAccounts } : {},
+    ...input.submission.agent ? { agent: input.submission.agent } : {},
+    ...input.targetSandboxId ? { targetSandboxId: input.targetSandboxId } : {},
+    ...input.workingDir ? { workingDir: input.workingDir } : {},
+    ...input.channelId ? { channelId: input.channelId } : {},
+    ...input.agentLearning && Object.keys(input.agentLearning).length ? { agentLearning: input.agentLearning } : {},
+    ...typeof input.usageLimitMicros === "number" ? { usageLimitMicros: input.usageLimitMicros } : {},
+    ...input.expectedNewSessionDraftRevision !== void 0 ? {
+      expectedNewSessionDraftRevision: input.expectedNewSessionDraftRevision
+    } : {}
+  };
+}
+function prepareCreateSessionAttempt(input) {
+  const {
+    clientEventId: _clientEventId,
+    idempotencyKey: _idempotencyKey,
+    expectedNewSessionDraftRevision: _expectedNewSessionDraftRevision,
+    ...logicalRequest
+  } = input.request;
+  const signature = stableJson(logicalRequest);
+  const idempotencyKey = input.pending?.client === input.client && input.pending.workspaceId === input.workspaceId && input.pending.signature === signature ? input.pending.idempotencyKey : input.freshIdempotencyKey;
+  const clientEventId = idempotencyKey === input.pending?.idempotencyKey ? input.pending.eventId : input.request.clientEventId ?? idempotencyKey;
+  return {
+    pending: {
+      client: input.client,
+      workspaceId: input.workspaceId,
+      signature,
+      idempotencyKey,
+      eventId: clientEventId
+    },
+    request: { ...input.request, idempotencyKey, clientEventId }
+  };
+}
+function submissionFromSessionDraft(draft, defaultFirstPartyMcpTools = DEFAULT_FIRST_PARTY_MCP_TOOLS, personalResourceAttachment) {
+  const goal = goalFromDraft(draft);
+  const mcp = draft.customMcpPermissions ? { firstPartyMcpPermissions: [...draft.mcpPermissions] } : {};
+  const visibleTools = explicitFirstPartyTools(draft, defaultFirstPartyMcpTools);
+  if (draft.compute.kind === "machine") {
+    return {
+      // No sandboxBackend (forced `selfhosted` server-side); the machine's own
+      // env and git auth apply (D2). Secrets arrive per command by reference.
+      extras: {
+        ...personalResourceAttachment ? { personalResourceAttachment } : {},
+        ...goal ? { goal } : {},
+        ...mcp,
+        ...visibleTools,
+        ...agentExtras(draft)
+      },
+      options: {
+        targetSandboxId: draft.compute.sandboxId,
+        workingDir: workingDirFromFolder(draft.compute.folder),
+        visibility: draft.visibility
+      },
+      omitWorkspaceResources: true
+    };
+  }
+  return {
+    extras: {
+      ...draft.compute.backend ? { sandboxBackend: draft.compute.backend } : {},
+      ...draft.rigId ? { rigId: draft.rigId } : {},
+      ...personalResourceAttachment ? { personalResourceAttachment } : {},
+      ...goal ? { goal } : {},
+      ...mcp,
+      ...visibleTools,
+      ...agentExtras(draft)
+    },
+    options: {
+      targetSandboxId: null,
+      workingDir: null,
+      visibility: draft.visibility
+    },
+    omitWorkspaceResources: false
+  };
+}
+function newSessionDraftOptionsFromSessionDraft(draft, defaultFirstPartyMcpTools = DEFAULT_FIRST_PARTY_MCP_TOOLS, effectiveVisibility = draft.visibility) {
+  const goal = goalFromDraft(draft);
+  const permissions = draft.customMcpPermissions ? {
+    firstPartyMcpPermissions: [...draft.mcpPermissions].map(
+      (permission) => Permission.parse(permission)
+    )
+  } : {};
+  const visibleTools = explicitFirstPartyTools(draft, defaultFirstPartyMcpTools);
+  if (draft.compute.kind === "machine") {
+    const workingDir = workingDirFromFolder(draft.compute.folder);
+    return {
+      visibility: effectiveVisibility,
+      ...draft.agentLearning ? { agentLearning: draft.agentLearning } : {},
+      ...draft.compute.sandboxId ? { targetSandboxId: draft.compute.sandboxId } : {},
+      ...workingDir ? { workingDir } : {},
+      ...goal ? { goal } : {},
+      ...permissions,
+      ...visibleTools,
+      ...agentExtras(draft)
+    };
+  }
+  return {
+    visibility: effectiveVisibility,
+    ...draft.agentLearning ? { agentLearning: draft.agentLearning } : {},
+    ...draft.compute.backend ? { sandboxBackend: draft.compute.backend } : {},
+    ...draft.rigId ? { rigId: draft.rigId } : {},
+    ...goal ? { goal } : {},
+    ...permissions,
+    ...visibleTools,
+    ...agentExtras(draft)
+  };
+}
+function agentExtras(draft) {
+  const vaultPolicy = draft.vaultPolicy?.mode === "selected" ? draft.vaultPolicy : void 0;
+  if (draft.agentCapabilities === void 0 && draft.agentInstructions === void 0 && vaultPolicy === void 0) {
+    return {};
+  }
+  return {
+    agent: {
+      ...draft.agentCapabilities !== void 0 ? { capabilities: draft.agentCapabilities } : {},
+      ...draft.agentInstructions !== void 0 ? { instructions: draft.agentInstructions } : {},
+      ...vaultPolicy !== void 0 ? { vaultPolicy } : {}
+    }
+  };
+}
+function sessionDraftFromNewSessionDraftOptions(options, defaultFirstPartyMcpTools = DEFAULT_FIRST_PARTY_MCP_TOOLS, defaultSandboxBackend) {
+  const base = emptySessionDraft(defaultFirstPartyMcpTools, defaultSandboxBackend);
+  const machine = Boolean(
+    options.targetSandboxId || options.workingDir || options.sandboxBackend === "selfhosted" || defaultSandboxBackend === "selfhosted"
+  );
+  return {
+    ...base,
+    visibility: options.visibility ?? "workspace",
+    ...options.agentLearning ? { agentLearning: options.agentLearning } : {},
+    compute: machine ? {
+      kind: "machine",
+      sandboxId: options.targetSandboxId ?? null,
+      folder: options.workingDir ? { kind: "path", path: options.workingDir } : { kind: "root" }
+    } : {
+      kind: "sandbox",
+      // Preserve an explicit managed choice when the workspace defaults to a machine.
+      backend: options.sandboxBackend && options.sandboxBackend !== "selfhosted" ? options.sandboxBackend : ""
+    },
+    rigId: options.rigId ?? "",
+    goalText: options.goal?.text ?? "",
+    goalSuccessCriteria: options.goal?.successCriteria ?? "",
+    goalMaxAutoContinuations: options.goal?.maxAutoContinuations === void 0 ? "" : String(options.goal.maxAutoContinuations),
+    customMcpPermissions: options.firstPartyMcpPermissions !== void 0,
+    mcpPermissions: options.firstPartyMcpPermissions === void 0 ? base.mcpPermissions : new Set(options.firstPartyMcpPermissions),
+    firstPartyMcpTools: options.firstPartyMcpTools === void 0 ? base.firstPartyMcpTools : new Set(options.firstPartyMcpTools),
+    ...options.agent?.capabilities !== void 0 ? { agentCapabilities: options.agent.capabilities } : {},
+    ...options.agent?.instructions !== void 0 ? { agentInstructions: options.agent.instructions } : {},
+    ...options.agent?.vaultPolicy?.mode === "selected" ? { vaultPolicy: options.agent.vaultPolicy } : {}
+  };
+}
+function workingDirFromFolder(folder) {
+  return folder.kind === "path" ? folder.path.trim() || null : null;
+}
+function goalFromDraft(draft) {
+  if (!draft.goalText.trim()) {
+    return null;
+  }
+  const maxAutoContinuations = nonNegativeInteger(draft.goalMaxAutoContinuations);
+  return {
+    text: draft.goalText.trim(),
+    ...draft.goalSuccessCriteria.trim() ? { successCriteria: draft.goalSuccessCriteria.trim() } : {},
+    ...maxAutoContinuations !== null ? { maxAutoContinuations } : {}
+  };
+}
+function nonNegativeInteger(value) {
+  const parsed = Number(value);
+  return value.trim() && Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+var MANAGED_BACKEND_LABELS = {
+  docker: "Docker",
+  modal: "Modal",
+  local: "Local",
+  none: "None (no sandbox)",
+  daytona: "Daytona",
+  runloop: "Runloop",
+  e2b: "E2B",
+  blaxel: "Blaxel",
+  cloudflare: "Cloudflare",
+  vercel: "Vercel",
+  opensandbox: "OpenSandbox",
+  compute: "Opengeni compute"
+};
+function backendLabel(backend) {
+  return MANAGED_BACKEND_LABELS[backend] ?? backend.slice(0, 1).toUpperCase() + backend.slice(1);
+}
+function descriptorChips(descriptor) {
+  const chips = [];
+  if (descriptor.capabilities.DesktopStream.available) {
+    chips.push("Desktop");
+  }
+  if (descriptor.capabilities.Recording.available) {
+    chips.push("Recording");
+  }
+  const hardLifetimeMs = descriptor.lifetime.hardLifetimeMs;
+  if (hardLifetimeMs) {
+    chips.push(formatLifetime(hardLifetimeMs));
+  }
+  if (chips.length === 0 && descriptor.tier !== "none") {
+    chips.push(descriptor.tier.slice(0, 1).toUpperCase() + descriptor.tier.slice(1));
+  }
+  return chips;
+}
+function formatLifetime(ms) {
+  const hours = ms / (60 * 60 * 1e3);
+  return Number.isInteger(hours) ? `${hours}h` : `${Math.round(hours)}h`;
+}
+function managedBackendOptions() {
+  const managed = Object.entries(CAPABILITY_DESCRIPTORS).filter(([backend]) => backend !== "selfhosted").map(([backend, descriptor]) => ({
+    value: backend,
+    label: backendLabel(backend),
+    chips: descriptorChips(descriptor)
+  }));
+  return [{ value: "", label: "Deployment default", chips: [] }, ...managed];
+}
+function selfhostedCapabilityChips(machine) {
+  const descriptor = CAPABILITY_DESCRIPTORS.selfhosted;
+  const chips = [];
+  if (descriptor.capabilities.FileSystem.available) {
+    chips.push("FileSystem");
+  }
+  if (descriptor.capabilities.Terminal.available) {
+    chips.push("Terminal");
+  }
+  if (descriptor.capabilities.Git.available) {
+    chips.push("Git");
+  }
+  if (machine?.hasDisplay) {
+    chips.push("Desktop");
+  }
+  return chips;
+}
+
+export {
+  rememberedProjectCompute,
+  rememberedMachineFolder,
+  workspaceDefaultRigOptionLabel,
+  emptySessionDraft,
+  fitToolPolicyToAgentCapabilities,
+  isSessionDraftComputeReady,
+  newSessionCreateVisibility,
+  classifyCreateSessionFailure,
+  retainCreateSessionAttemptAfterFailure,
+  buildCreateSessionRequest,
+  prepareCreateSessionAttempt,
+  submissionFromSessionDraft,
+  newSessionDraftOptionsFromSessionDraft,
+  sessionDraftFromNewSessionDraftOptions,
+  managedBackendOptions,
+  selfhostedCapabilityChips
+};
+//# sourceMappingURL=chunk-IXPTECSC.js.map

package/dist/chunk-J255A3N5.js

@@ -0,0 +1,71 @@
+"use client";
+import {
+  LoadingPanel
+} from "./chunk-VGYXW3VG.js";
+import {
+  Link
+} from "./chunk-BXBDYNRP.js";
+import {
+  useAppHost
+} from "./chunk-ENFLCAR3.js";
+
+// src/app/lib/app-surfaces.tsx
+import { lazy, Suspense, useEffect } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function lazySurface(load) {
+  let pending = null;
+  const loadOnce = () => pending ??= load();
+  const component = lazy(loadOnce);
+  component.preload = () => {
+    void loadOnce().catch(() => {
+      pending = null;
+    });
+  };
+  return component;
+}
+function useAppSurface(name) {
+  return useAppHost().surfaces?.[name];
+}
+function usePreloadAppSurface(name, when) {
+  const surface = useAppSurface(name);
+  useEffect(() => {
+    if (when) surface?.preload?.();
+  }, [surface, when]);
+}
+function PdfPreviewSurface(props) {
+  const Registered = useAppSurface("pdfPreview");
+  if (Registered) return /* @__PURE__ */ jsx(Registered, { ...props });
+  return /* @__PURE__ */ jsx("a", { className: "text-sm underline", href: props.url, target: "_blank", rel: "noreferrer", children: props.title });
+}
+function EditableArtifactSurface(props) {
+  const Registered = useAppSurface("editableArtifact");
+  if (Registered) {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(LoadingPanel, { label: "Opening artifact" }), children: /* @__PURE__ */ jsx(Registered, { ...props }) });
+  }
+  return /* @__PURE__ */ jsx("section", { className: "grid flex-1 place-items-center px-4 text-center", children: /* @__PURE__ */ jsxs("div", { className: "grid max-w-sm justify-items-center gap-3 text-sm text-fg-muted", children: [
+    /* @__PURE__ */ jsx("p", { children: "This artifact opens in the Opengeni web app." }),
+    /* @__PURE__ */ jsx(
+      Link,
+      {
+        to: "/workspaces/$workspaceId/artifacts/editable/$artifactId",
+        params: { workspaceId: props.workspaceId, artifactId: props.artifactId },
+        className: "font-medium text-fg underline underline-offset-2",
+        children: "Open artifact"
+      }
+    )
+  ] }) });
+}
+function CodexSubscriptionsSurface(props) {
+  const Registered = useAppSurface("codexSubscriptions");
+  if (Registered) return /* @__PURE__ */ jsx(Registered, { ...props });
+  return null;
+}
+
+export {
+  lazySurface,
+  usePreloadAppSurface,
+  PdfPreviewSurface,
+  EditableArtifactSurface,
+  CodexSubscriptionsSurface
+};
+//# sourceMappingURL=chunk-J255A3N5.js.map

package/dist/chunk-J5F5HPPW.js

@@ -0,0 +1,141 @@
+"use client";
+import {
+  currentSessionMachineAccess,
+  recheckSessionAdmission,
+  runSavedMessageOnMachine,
+  savedMessageApprovedMachines,
+  savedMessageMachineChoices,
+  sessionAdmissionApprovedElsewhere,
+  sessionAdmissionNeedsDifferentMachine,
+  sessionAdmissionReason,
+  sessionWaitingWorkExplainsBlock
+} from "./chunk-JWKGPA6Q.js";
+import {
+  useMachines
+} from "./chunk-2M3J7ZWQ.js";
+import {
+  useEmbeddedSession
+} from "./chunk-TVQCDDSZ.js";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/hooks/use-session-start.ts
+import { useCallback, useMemo } from "react";
+var BLOCKED_MACHINE_POLL_MS = 15e3;
+function useSessionStart({
+  session,
+  onSessionChanged,
+  machinesClient,
+  machinesEnabled = true,
+  ...override
+}) {
+  const t = useOpenGeniText();
+  const { client, workspaceId } = useEmbeddedSession(override);
+  const reason = sessionAdmissionReason(session);
+  const machines = machinesClient ?? (typeof client.listMachines === "function" ? client : void 0);
+  const fleet = useMachines({
+    client,
+    workspaceId,
+    ...machines ? { machinesClient: machines } : {},
+    sessionId: session.id,
+    enabled: machinesEnabled && machines !== void 0 && session.activeSandboxId != null,
+    pollIntervalMs: reason ? BLOCKED_MACHINE_POLL_MS : void 0
+  });
+  const machineAccess = currentSessionMachineAccess(
+    fleet.sessionMachineAccess,
+    session.activeSandboxId
+  );
+  const attach = fleet.attach;
+  const refreshMachines = fleet.refresh;
+  const chooseMachine = useCallback(
+    async (machine) => {
+      if (!await attach(machine.sandboxId)) return t("sessionAdmission.machineChangeFailed");
+      await onSessionChanged();
+      return null;
+    },
+    [attach, onSessionChanged, t]
+  );
+  const control = session.effectiveControl;
+  const sessionId = session.id;
+  const recheck = useCallback(
+    () => recheckSessionAdmission({
+      control,
+      refreshOnly: false,
+      resume: (fence) => client.resumeSession(workspaceId, sessionId, {
+        clientEventId: globalThis.crypto.randomUUID(),
+        expectedControlEtag: fence.controlEtag
+      }),
+      refresh: [onSessionChanged, refreshMachines]
+    }),
+    [client, control, onSessionChanged, refreshMachines, sessionId, workspaceId]
+  );
+  const continueClient = client;
+  const canContinue = typeof continueClient.continueSessionWaitingWork === "function";
+  const blocked = reason !== null;
+  const continueWaitingWork = useCallback(async () => {
+    await continueClient.continueSessionWaitingWork(workspaceId, sessionId);
+    if (blocked && control.state !== "paused")
+      await recheckSessionAdmission({
+        control,
+        refreshOnly: false,
+        resume: (fence) => client.resumeSession(workspaceId, sessionId, {
+          clientEventId: globalThis.crypto.randomUUID(),
+          expectedControlEtag: fence.controlEtag
+        }),
+        refresh: [onSessionChanged]
+      });
+    else await onSessionChanged();
+    await refreshMachines();
+  }, [
+    blocked,
+    client,
+    continueClient,
+    control,
+    onSessionChanged,
+    refreshMachines,
+    sessionId,
+    workspaceId
+  ]);
+  const machineChoices = useMemo(
+    () => savedMessageMachineChoices(fleet.machines),
+    [fleet.machines]
+  );
+  const approvedMachines = useMemo(
+    () => savedMessageApprovedMachines(machineAccess, fleet.machines),
+    [machineAccess, fleet.machines]
+  );
+  const runOnApprovedMachine = useCallback(
+    (sandboxId) => runSavedMessageOnMachine({
+      sandboxId,
+      attach,
+      recheck,
+      failedMove: t("sessionAdmission.machineChangeFailed")
+    }),
+    [attach, recheck, t]
+  );
+  return {
+    reason,
+    machineAccess,
+    needsDifferentMachine: sessionAdmissionNeedsDifferentMachine(reason, machineAccess),
+    approvedElsewhere: sessionAdmissionApprovedElsewhere(reason, machineAccess),
+    approvedMachines,
+    runOnApprovedMachine: fleet.canAttach ? runOnApprovedMachine : void 0,
+    machines: fleet.machines,
+    moveToMachine: fleet.canAttach ? attach : void 0,
+    // Others' waiting updates keep the composer's machine notice beside them:
+    // it is where they choose a machine or ask the owner.
+    warnBeforeSending: machineAccess !== null && !machineAccess.isOwner && (reason === null || (machineAccess.waitingWork?.length ?? 0) > 0 && !sessionAdmissionNeedsDifferentMachine(reason, machineAccess) && sessionWaitingWorkExplainsBlock(reason)),
+    machineChoices,
+    canChooseMachine: fleet.canAttach,
+    chooseMachine,
+    machineChoiceError: fleet.mutationError?.message ?? null,
+    recheck,
+    continueWaitingWork: canContinue ? continueWaitingWork : void 0
+  };
+}
+
+export {
+  useSessionStart
+};
+//# sourceMappingURL=chunk-J5F5HPPW.js.map