@manta-eu/react 0.12.0 → 0.13.0

package/src/routes/rules/components/CreateRuleChatModal.tsx

@@ -30,16 +30,20 @@ const createRuleChatFormSchema = z.object({
 
 type CreateRuleChatFormValues = z.infer<typeof createRuleChatFormSchema>;
 
+export type CreateRuleChatSubject = { name: string; context: string };
+
 export type CreateRuleChatModalProps = {
   open: boolean;
   onOpenChange: (open: boolean) => void;
-  onStartFromBlankRule: () => void;
+  onStartFromBlankRule?: () => void;
+  subject?: CreateRuleChatSubject;
+  onDraftStarted?: () => void;
   model: OperatorAllowedModel;
   ruleSuggestions?: string[];
 };
 
 export function CreateRuleChatModal(props: CreateRuleChatModalProps) {
-  const { open, onOpenChange, onStartFromBlankRule, model, ruleSuggestions } = props;
+  const { open, onOpenChange, onStartFromBlankRule, subject, onDraftStarted, model, ruleSuggestions } = props;
   const { startContextConversation } = useChatManagerConnection();
   const { open: openChat } = useChatPanel();
   const formId = useId();
@@ -53,11 +57,12 @@ export function CreateRuleChatModal(props: CreateRuleChatModalProps) {
     try {
       const conversation = await startContextConversation(
         { kind: ChatContextKind.RuleCreate, draftIri: generateRuleDraftIri() },
-        createUserMessage({ text: values.intent, model }),
+        createUserMessage({ text: subject ? `${values.intent}\n\n${subject.context}` : values.intent, model }),
       );
       if (!conversation) return;
 
-      openChat();
+      if (onDraftStarted) onDraftStarted();
+      else openChat();
       form.reset();
       onOpenChange(false);
     } catch (err) {
@@ -78,14 +83,18 @@ export function CreateRuleChatModal(props: CreateRuleChatModalProps) {
         }}
       >
         <DialogHeader>
-          <DialogTitle text="Create a rule" />
+          <DialogTitle text={subject ? `Write a rule for ${subject.name}` : "Create a rule"} />
           <DialogDescription>Describe it in your words — Manta drafts the rule for your review.</DialogDescription>
         </DialogHeader>
 
         <DialogBody className="space-y-4">
           <form id={formId} onSubmit={form.handleSubmit(handleDraft)}>
             <Textarea
-              placeholder="e.g. Pause underperforming ads when their CTR stays below the account average for a week…"
+              placeholder={
+                subject
+                  ? `e.g. When a company ${subject.name} memory says…, then…`
+                  : "e.g. Pause underperforming ads when their CTR stays below the account average for a week…"
+              }
               className="min-h-32 border rounded border-default-border bg-base-background"
               autoFocus
               {...form.register("intent")}
@@ -98,26 +107,41 @@ export function CreateRuleChatModal(props: CreateRuleChatModalProps) {
           </form>
 
           {isPresent(ruleSuggestions) && (
-            <div className="flex flex-col gap-1">
-              {ruleSuggestions.map((suggestion, index) => (
-                <button
-                  key={`${suggestion}-${index}`}
-                  type="button"
-                  onClick={() => form.setValue("intent", suggestion, { shouldValidate: true, shouldDirty: true })}
-                  className="flex w-full cursor-pointer items-center gap-3 rounded-md-v4 px-3 py-2.5 text-left transition-colors hover:bg-muted"
-                  title={suggestion}
-                >
-                  <span className="typography-small text-default-foreground">{suggestion}</span>
-                </button>
-              ))}
-            </div>
+            <section className="flex flex-col gap-1.5" aria-labelledby={`${formId}-suggestions`}>
+              <h3 id={`${formId}-suggestions`} className="typography-small text-muted-foreground">
+                Suggestions
+              </h3>
+              <ul className="flex flex-col">
+                {ruleSuggestions.map((suggestion, index) => (
+                  <li key={`${suggestion}-${index}`}>
+                    <button
+                      type="button"
+                      onClick={() => form.setValue("intent", suggestion, { shouldValidate: true, shouldDirty: true })}
+                      className="flex w-full cursor-pointer items-start gap-2.5 rounded-md-v4 px-3 py-2 text-left transition-colors hover:bg-muted focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-active-border/50"
+                      title={suggestion}
+                    >
+                      <span aria-hidden className="mt-[0.45rem] size-1.5 shrink-0 rounded-full bg-muted-foreground" />
+                      <span className="typography-small text-default-foreground">{suggestion}</span>
+                    </button>
+                  </li>
+                ))}
+              </ul>
+            </section>
           )}
         </DialogBody>
 
         <DialogFooter>
-          <Button type="button" variant="secondary" icon={FileCode2} className="mr-auto" onClick={onStartFromBlankRule}>
-            Start from blank rule
-          </Button>
+          {onStartFromBlankRule && (
+            <Button
+              type="button"
+              variant="secondary"
+              icon={FileCode2}
+              className="mr-auto"
+              onClick={onStartFromBlankRule}
+            >
+              Start from blank rule
+            </Button>
+          )}
           <Button type="button" variant="ghost" disabled={!form.formState.isDirty} onClick={() => form.reset()}>
             Clear
           </Button>

package/src/routes/rules/components/RuleValueControls.tsx

@@ -1,50 +1,18 @@
 import { isPresent } from "@manta-eu/lib/present";
 import type { Awaitable } from "@manta-eu/lib/types";
 import { RotateCcw, Save, SlidersHorizontal } from "lucide-react";
-import { identity } from "ramda";
 import { useEffect, useId, useMemo, useState } from "react";
-import { buildUpdatedRuleText, dateTimeValueForInput, dateTimeValueFromInput } from "./rule-value-edit";
+import { buildUpdatedRuleText } from "./rule-value-edit";
+import { ruleValueInputDescriptors } from "./rule-value-input";
 import { Button } from "#components/button/index";
 import { Input } from "#components/input/index";
 import {
   type EditableRuleValue,
-  type EditableRuleValueKind,
   narrativeSegmentsAroundEdit,
   RuleNarrativeSegments,
   type RuleSetupModel,
 } from "#ldo-ui";
 
-type RuleValueInputDescriptor = {
-  type: "date" | "datetime-local" | "number";
-  step?: string;
-  inputMode?: "decimal";
-  helperText?: string;
-  toInputValue: (value: string) => string;
-  fromInputValue: (value: string) => string;
-};
-
-const inputDescriptorByKind: Record<EditableRuleValueKind, RuleValueInputDescriptor> = {
-  number: {
-    type: "number",
-    step: "any",
-    inputMode: "decimal",
-    toInputValue: identity,
-    fromInputValue: identity,
-  },
-  date: {
-    type: "date",
-    toInputValue: identity,
-    fromInputValue: identity,
-  },
-  dateTime: {
-    type: "datetime-local",
-    step: "1",
-    helperText: "UTC timezone",
-    toInputValue: dateTimeValueForInput,
-    fromInputValue: dateTimeValueFromInput,
-  },
-};
-
 export type RuleValueControlsProps = {
   model: RuleSetupModel;
   onStageChange: (newRuleText: string) => Awaitable<boolean>;
@@ -110,7 +78,7 @@ export function RuleValueControls(props: RuleValueControlsProps) {
         {model.editableValues.map(({ edit: editableValue, segments }) => {
           const value = values[editableValue.id] ?? editableValue.value;
           const inputId = `${idPrefix}-${editableValue.id}`;
-          const inputDescriptor = inputDescriptorByKind[editableValue.kind];
+          const inputDescriptor = ruleValueInputDescriptors[editableValue.kind];
           const inputValue = inputDescriptor.toInputValue(value);
           const contextSegments = narrativeSegmentsAroundEdit(segments, editableValue.id);
 

package/src/routes/rules/components/rule-value-input.ts

@@ -0,0 +1,34 @@
+import { identity } from "ramda";
+import { dateTimeValueForInput, dateTimeValueFromInput } from "./rule-value-edit";
+import type { EditableRuleValueKind } from "#ldo-ui";
+
+export type RuleValueInputDescriptor = {
+  type: "date" | "datetime-local" | "number";
+  step?: string;
+  inputMode?: "decimal";
+  helperText?: string;
+  toInputValue: (value: string) => string;
+  fromInputValue: (value: string) => string;
+};
+
+export const ruleValueInputDescriptors: Record<EditableRuleValueKind, RuleValueInputDescriptor> = {
+  number: {
+    type: "number",
+    step: "any",
+    inputMode: "decimal",
+    toInputValue: identity,
+    fromInputValue: identity,
+  },
+  date: {
+    type: "date",
+    toInputValue: identity,
+    fromInputValue: identity,
+  },
+  dateTime: {
+    type: "datetime-local",
+    step: "1",
+    helperText: "UTC timezone",
+    toInputValue: dateTimeValueForInput,
+    fromInputValue: dateTimeValueFromInput,
+  },
+};

package/src/routes/rules/components/rules.utils.ts

@@ -1,6 +1,12 @@
 import type { GQLRule } from "@manta-eu/client";
 import { humanizeEntityName } from "@manta-eu/client/shared/agent-mode";
-import { formatEntityName } from "@manta-eu/client/shared/rdf-namespaces";
+import {
+  compactUri,
+  expandPrefix,
+  formatEntityName,
+  iriLocalName,
+  isValidFullIri,
+} from "@manta-eu/client/shared/rdf-namespaces";
 import { isPresent } from "@manta-eu/lib/present";
 import type { Awaitable } from "@manta-eu/lib/types";
 import { ascend, descend, sortWith } from "ramda";
@@ -39,15 +45,31 @@ export function sortRulesForDisplay(rules: readonly GQLRule[]): GQLRule[] {
 }
 
 export function getRuleDisplayName(ruleIri: string): string {
-  const localName = formatEntityName(ruleIri);
+  const localName = isValidFullIri(compactUri(ruleIri)) ? iriLocalName(ruleIri) : formatEntityName(ruleIri);
   const nameWithoutRulePrefix = localName.replace(/^Rule_/, "").replace(/^Rule(?=[A-Z0-9])/, "");
   return humanizeEntityName(nameWithoutRulePrefix) || localName;
 }
 
+const iriSchemePattern = /^[a-z][a-z\d+.-]*:/i;
+
+// The local name inside the realm's vocabulary and the whole IRI anywhere else, whatever its scheme. A local name that
+// would itself read as an IRI is routed whole too, so every route reads back to the rule it came from.
 export function getRuleRouteName(ruleIri: string): string {
-  return formatEntityName(ruleIri);
+  const compacted = compactUri(ruleIri);
+  const localName = compacted.startsWith(":") ? compacted.slice(1) : null;
+  if (localName === null) return ruleIri;
+  return iriSchemePattern.test(localName) ? expandPrefix(compacted) : localName;
+}
+
+// Takes the route param as the router gives it, already decoded; decoding again would change an IRI holding an escape.
+export function ruleIriFromRouteName(routeName: string): string {
+  return iriSchemePattern.test(routeName) ? routeName : expandPrefix(`:${routeName}`);
 }
 
+/**
+ * @deprecated Use `ruleIriFromRouteName` on the route param as the router gives it, already decoded, instead;
+ * removed in 1.0.
+ */
 export function decodeRuleRouteName(ruleName: string): string {
   try {
     return decodeURIComponent(ruleName);

package/src/routes/rules/pages.ts

@@ -1,6 +1,10 @@
 // The rule screens the application mounts. The route entry itself stays in `agents`, because the
 // Datalog editor it reaches carries the CodeMirror stack this package does not depend on.
-export { CreateRuleChatModal, type CreateRuleChatModalProps } from "./components/CreateRuleChatModal";
+export {
+  CreateRuleChatModal,
+  type CreateRuleChatModalProps,
+  type CreateRuleChatSubject,
+} from "./components/CreateRuleChatModal";
 export { RuleDetailsPage, type RuleDetailsPageProps } from "./components/RuleDetailsPage";
 export {
   RulesOverviewHeaderActions,

package/src/shared/graph-derived-queries.ts

@@ -12,7 +12,10 @@ import {
   useGetActionPlansSummaryQuery,
   useManualActionProgressQuery,
   useMemoriesQuery,
+  useMemorySchemaRuleCountsQuery,
   useMemorySchemasQuery,
+  useMemorySchemaTemplatesQuery,
+  useMemorySchemaUsageQuery,
   useNodePropertiesQuery,
   useNodeRelationshipsQuery,
   useRulesQuery,
@@ -39,7 +42,10 @@ export const graphDerivedQueries: QueryWithGetKey[] = [
   useGetActionPlansSummaryQuery,
   useManualActionProgressQuery,
   useMemoriesQuery,
+  useMemorySchemaRuleCountsQuery,
   useMemorySchemasQuery,
+  useMemorySchemaTemplatesQuery,
+  useMemorySchemaUsageQuery,
   useNodePropertiesQuery,
   useNodeRelationshipsQuery,
   useRulesQuery,

package/src/themes/manta-dark.css

@@ -68,3 +68,7 @@
   --font-weight-semibold: 620;
   --font-weight-bold: 700;
 }
+
+[data-theme="manta-dark"] :is(input[type="date"], input[type="datetime-local"], input[type="time"]) {
+  color-scheme: dark;
+}

package/src/worker/index.ts

@@ -0,0 +1,175 @@
+import { originAllowsRequest } from "@manta-eu/auth/request-origin";
+import { safeReturnTo } from "@manta-eu/auth/sealed-cookies";
+import { operationRootFields } from "@manta-eu/client/operations";
+import {
+  authErrorParam,
+  chatManagerBasePath,
+  mantaGQLPath,
+  switchDatastoreRoutePath,
+} from "@manta-eu/client/shared/constants";
+import { isValidDatastoreId } from "@manta-eu/client/shared/datastore-id";
+import {
+  datastoreScopedRoutePattern,
+  imageRoutePath,
+  redirectRoutePath,
+  sparqlRoutePath,
+  uploadedFileRoutePath,
+  uploadPartRoutePath,
+} from "@manta-eu/client/shared/datastore-path";
+import { signedOutLoginStatus } from "@manta-eu/client/shared/login-status";
+import { isPresent } from "@manta-eu/lib/present";
+import { Hono, type Context } from "hono";
+import {
+  crossOriginBlockedMessage,
+  graphqlAllowed,
+  graphqlBlockedMessage,
+  graphqlShapeMessage,
+  isJsonGraphQLRequest,
+  methodAllowed,
+  methodBlockedMessage,
+  namedOperations,
+  type GraphQLAllowlist,
+  type ProxyRoute,
+} from "./policy";
+import { proxyToAgents, type ProxyArgs } from "./proxy";
+import { clearSessionSetCookies, isSignedIn, readSession, type SessionCookies } from "./session";
+
+export type { GraphQLAllowlist, ProxyRoute } from "./policy";
+
+export type AppWorkerEnv = {
+  MANTA_AGENTS_URL?: string;
+  MANTA_SESSION_SECRET?: string;
+  AGENTS?: { fetch: typeof fetch };
+  ASSETS?: { fetch: typeof fetch };
+};
+
+export type AppWorkerOptions = {
+  cookiePrefix?: string;
+  graphqlOperations?: GraphQLAllowlist;
+  proxyRoutes?: readonly ProxyRoute[];
+};
+
+const scoped = (path: string) => [path, datastoreScopedRoutePattern(path)];
+
+const sdkProxyRoutes: readonly ProxyRoute[] = [
+  { path: mantaGQLPath, methods: ["POST"], graphql: true },
+  ...scoped(sparqlRoutePath).map((path) => ({ path, methods: ["GET", "POST"] })),
+  { path: datastoreScopedRoutePattern(redirectRoutePath), methods: ["GET"] },
+  ...scoped(imageRoutePath).map((path) => ({ path, methods: ["GET"] })),
+  { path: switchDatastoreRoutePath, methods: ["POST"] },
+  ...scoped(uploadedFileRoutePath).map((path) => ({ path, methods: ["GET"] })),
+  ...scoped(uploadPartRoutePath).map((path) => ({ path, methods: ["PUT"] })),
+  { path: `/${chatManagerBasePath}/*`, methods: ["GET", "POST"], websocket: true },
+];
+
+const unreachableMessage = "Manta could not be reached, so signing in is not possible right now.";
+
+export function createAppWorker<E extends AppWorkerEnv>(options: AppWorkerOptions = {}) {
+  const { cookiePrefix = "manta_session", graphqlOperations = {}, proxyRoutes = [] } = options;
+
+  const allowlist = { ...operationRootFields, ...graphqlOperations };
+  const app = new Hono<{ Bindings: E }>();
+
+  type AppContext = Context<{ Bindings: E }>;
+
+  const sessionCookiesOf = (c: AppContext): SessionCookies => ({
+    prefix: cookiePrefix,
+    secret: c.env.MANTA_SESSION_SECRET ?? "",
+  });
+
+  app.use("*", async (c, next) => {
+    if (!isPresent(c.env.MANTA_AGENTS_URL) || (c.env.MANTA_SESSION_SECRET ?? "").length < 32) {
+      return c.json({ error: "Set MANTA_AGENTS_URL, and MANTA_SESSION_SECRET to at least 32 characters." }, 500);
+    }
+
+    return next();
+  });
+
+  const proxy = (c: AppContext, extra: Pick<ProxyArgs, "body" | "clearSession" | "session"> = {}) =>
+    proxyToAgents({
+      request: c.req.raw,
+      agentsUrl: c.env.MANTA_AGENTS_URL ?? "",
+      agents: c.env.AGENTS,
+      cookies: sessionCookiesOf(c),
+      ...extra,
+    });
+
+  const signInStep = async (c: AppContext) => {
+    try {
+      return await proxy(c);
+    } catch {
+      const target = new URL("/", c.req.url);
+      target.searchParams.set(authErrorParam, unreachableMessage);
+
+      return c.redirect(target.toString());
+    }
+  };
+
+  app.get("/login", signInStep);
+  app.get("/auth/callback", signInStep);
+
+  app.on(["GET", "POST"], "/logout", async (c) => {
+    if (!originAllowsRequest(c.req.raw)) return c.json({ error: crossOriginBlockedMessage }, 403);
+
+    const response = await proxy(c, { clearSession: true }).catch(() => undefined);
+
+    if (isPresent(response) && response.status < 500) return response;
+
+    const url = new URL(c.req.url);
+    const location = safeReturnTo({ raw: url.searchParams.get("redirect"), fallback: "/", appUrl: url });
+
+    for (const cookie of clearSessionSetCookies(sessionCookiesOf(c), c.req.raw)) {
+      c.header("set-cookie", cookie, { append: true });
+    }
+
+    c.header("cache-control", "no-store");
+
+    return c.redirect(location);
+  });
+
+  app.get("/api/login", async (c) => {
+    if (!originAllowsRequest(c.req.raw)) return c.json({ error: crossOriginBlockedMessage }, 403);
+
+    const session = await readSession(sessionCookiesOf(c), c.req.raw);
+
+    if (!isSignedIn(session)) return c.json(signedOutLoginStatus);
+
+    const response = await proxy(c, { session }).catch(() => undefined);
+
+    return response ?? c.json({ error: unreachableMessage }, 503);
+  });
+
+  for (const route of [...sdkProxyRoutes, ...proxyRoutes]) {
+    app.all(route.path, async (c) => {
+      const { raw } = c.req;
+
+      if (!originAllowsRequest(raw)) return c.json({ error: crossOriginBlockedMessage }, 403);
+      if (!methodAllowed(route, raw)) return c.json({ error: methodBlockedMessage }, 405);
+
+      const datastoreId = c.req.param("datastoreId");
+
+      if (isPresent(datastoreId) && !isValidDatastoreId(datastoreId)) {
+        return c.json({ error: "Unknown datastore." }, 404);
+      }
+
+      const session = await readSession(sessionCookiesOf(c), raw);
+
+      if (!isSignedIn(session)) return c.json({ error: "Not signed in." }, 401);
+      if (!route.graphql) return proxy(c, { session });
+      if (!isJsonGraphQLRequest(raw)) return c.json({ errors: [{ message: graphqlShapeMessage }] }, 415);
+
+      const body = await raw.text();
+      const operations = namedOperations(body);
+
+      if (graphqlAllowed(operations, allowlist)) return proxy(c, { body, session });
+
+      console.warn("Refused GraphQL operations", JSON.stringify(operations ?? "unparsable"));
+
+      return c.json({ errors: [{ message: graphqlBlockedMessage }] }, 403);
+    });
+  }
+
+  app.notFound((c) => c.env.ASSETS?.fetch(c.req.raw) ?? c.text("Not found", 404));
+
+  return app;
+}

package/src/worker/policy.ts

@@ -0,0 +1,62 @@
+import { isWebSocket } from "@manta-eu/auth/request-origin";
+import { isPresent } from "@manta-eu/lib/present";
+import { operationRootFieldsOf, type OperationRootFields } from "@manta-eu/client/shared/operation-root-fields";
+import { parse } from "graphql";
+
+export type GraphQLAllowlist = Record<string, readonly string[]>;
+
+type NamedOperation = OperationRootFields & { name: string };
+
+export type ProxyRoute = {
+  path: string;
+  methods: readonly string[];
+  websocket?: true;
+  graphql?: true;
+};
+
+export const crossOriginBlockedMessage = "Cross-origin requests to this app's proxy are blocked.";
+export const methodBlockedMessage = "This proxy does not allow that method on this path.";
+export const graphqlShapeMessage = "This proxy only forwards GraphQL as a JSON body, with nothing in the query string.";
+export const graphqlBlockedMessage = "This proxy only forwards the SDK's GraphQL operations and the app's own.";
+
+const maxGraphQLTokens = 5_000;
+const maxGraphQLQueryLength = 100_000;
+
+export function isJsonGraphQLRequest(request: Request): boolean {
+  const mediaType = request.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+
+  return mediaType === "application/json" && !isPresent(new URL(request.url).search);
+}
+
+export function methodAllowed(route: ProxyRoute, request: Request): boolean {
+  return isWebSocket(request) ? route.websocket === true : route.methods.includes(request.method);
+}
+
+export function namedOperations(bodyText: string): NamedOperation[] | undefined {
+  try {
+    const body: unknown = JSON.parse(bodyText);
+
+    if (typeof body !== "object" || body === null || !("query" in body) || typeof body.query !== "string")
+      return undefined;
+
+    if (body.query.length > maxGraphQLQueryLength) return undefined;
+
+    const operations = operationRootFieldsOf(parse(body.query, { maxTokens: maxGraphQLTokens }));
+
+    return operations.every((operation): operation is NamedOperation => isPresent(operation.name))
+      ? operations
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function graphqlAllowed(operations: NamedOperation[] | undefined, allowlist: GraphQLAllowlist): boolean {
+  if (!isPresent(operations)) return false;
+
+  return operations.every(({ name, fields }) => {
+    const allowed = Object.hasOwn(allowlist, name) ? allowlist[name] : undefined;
+
+    return isPresent(allowed) && fields.every((field) => allowed.includes(field));
+  });
+}

package/src/worker/proxy.ts

@@ -0,0 +1,101 @@
+import { isWebSocket } from "@manta-eu/auth/request-origin";
+import { forwardedOriginHeader } from "@manta-eu/client/shared/constants";
+import { isPresent } from "@manta-eu/lib/present";
+import { equals } from "ramda";
+import {
+  captureUpstreamCookies,
+  clearSessionSetCookies,
+  readSession,
+  sessionSetCookies,
+  upstreamCookieHeader,
+  type SessionCookies,
+  type SessionState,
+} from "./session";
+
+export type ProxyArgs = {
+  request: Request;
+  agentsUrl: string;
+  agents?: { fetch: typeof fetch };
+  cookies: SessionCookies;
+  session?: SessionState;
+  body?: string;
+  clearSession?: boolean;
+};
+
+type UpstreamRequestArgs = Pick<ProxyArgs, "request" | "agentsUrl" | "session" | "body">;
+
+type CookiesToWriteArgs = Pick<ProxyArgs, "cookies" | "request"> & {
+  previous: SessionState;
+  after: SessionState;
+  clear: boolean;
+};
+
+function upstreamRequest(args: UpstreamRequestArgs) {
+  const { request, agentsUrl, session, body } = args;
+
+  const incoming = new URL(request.url);
+  const url = new URL(`${agentsUrl.replace(/\/+$/, "")}${incoming.pathname}${incoming.search}`);
+  const headers = new Headers(request.headers);
+
+  for (const name of ["host", "cookie", "authorization", "referer", "sec-fetch-site"]) headers.delete(name);
+
+  headers.set("origin", url.origin);
+  headers.set(forwardedOriginHeader, incoming.origin);
+
+  if (isPresent(session)) headers.set("cookie", upstreamCookieHeader(session));
+
+  const sendsBody = !isWebSocket(request) && request.method !== "GET" && request.method !== "HEAD";
+  const init: RequestInit & { duplex?: "half" } = {
+    method: request.method,
+    headers,
+    redirect: "manual",
+    ...(sendsBody && { body: body ?? request.body, duplex: "half" as const }),
+  };
+
+  return { url, init };
+}
+
+function withAppCookies(response: Response, written: string[]): Response {
+  const upgraded = (response as Response & { webSocket?: unknown }).webSocket;
+
+  if (!isPresent(written) && !isPresent(response.headers.getSetCookie())) return response;
+
+  const headers = new Headers(response.headers);
+
+  headers.delete("set-cookie");
+
+  for (const cookie of written) headers.append("set-cookie", cookie);
+
+  if (response.status === 101 || isPresent(upgraded)) {
+    return new Response(null, { status: response.status, headers, webSocket: upgraded } as ResponseInit);
+  }
+
+  headers.delete("content-encoding");
+  headers.delete("content-length");
+
+  return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+}
+
+async function cookiesToWrite(args: CookiesToWriteArgs) {
+  const { cookies, request, previous, after, clear } = args;
+
+  if (!clear && equals(previous, after)) return [];
+
+  return clear || !isPresent(after.upstreamCookies)
+    ? clearSessionSetCookies(cookies, request)
+    : sessionSetCookies({ cookies, state: after, request });
+}
+
+export async function proxyToAgents(args: ProxyArgs): Promise<Response> {
+  const { request, agentsUrl, agents, cookies, session, body, clearSession = false } = args;
+
+  const before = session ?? (await readSession(cookies, request));
+  const { url, init } = upstreamRequest({ request, agentsUrl, session: before, body });
+
+  const response = await (agents?.fetch ?? fetch)(url, init);
+
+  const previous = before ?? { upstreamCookies: {} };
+  const after = captureUpstreamCookies({ state: previous, response });
+
+  return withAppCookies(response, await cookiesToWrite({ cookies, request, previous, after, clear: clearSession }));
+}