@@ -1244,6 +1244,8 @@ const compacted = Effect.gen(function* () {
 })
 ```
 
+From the Promise API, `await ai.llm.compact(request)` takes the same request and options (plus `signal`) and returns the same result.
+
 `replacement` replaces the complete input window. Do not append it to the original transcript or extract only the encrypted item: the provider may retain additional messages in its output. Retained user and assistant messages remain ordinary messages with typed text, media, or reasoning parts, in their original order. Provider-specific message IDs, status, and phase use `providerMetadata`, not a raw output array hidden in an assistant message. Unsupported returned item types fail explicitly.
 
 The selected model carries explicit-compaction capability through request construction and updates. Calls using unsupported routes fail type checking. When the model is selected dynamically, narrow the request with `LLMClient.canCompact(request)` before calling `LLMClient.compact`; a model or route switch does not inherit the old capability. Runtime validation still rejects unsupported calls from untyped consumers. Capability describes the route's API, not whether every model or custom deployment supports the operation.
 
@@ -5,8 +5,22 @@ import type { AwaitOptions, Event, Generation, Snapshot } from "./generation.js"
 import { Image, type ImageModel, type ImageRequest, type ImageRequestInput } from "./image.js"
 import { LLM } from "./effect.js"
 import { Media } from "./media.js"
+import {
+  LLMClient,
+  type CheckpointRequest,
+  type CompactionRequest,
+  type EndpointCompactOptions,
+  type TriggerCompactOptions,
+} from "./route/client.js"
 import { RequestExecutor } from "./route/executor.js"
-import { AIError, InvalidRequestError, LanguageModel, type LLMRequest } from "./schema/index.js"
+import {
+  AIError,
+  InvalidRequestError,
+  LanguageModel,
+  type CompactionCheckpointResponse,
+  type CompactionResponse,
+  type LLMRequest,
+} from "./schema/index.js"
 import type {
   GenerateObjectDynamicOptions,
   GenerateObjectOptions,
@@ -113,6 +127,21 @@ export const make = <R = never>(options: Options<R> = {}) => {
     return run("schema" in input ? LLM.generateObject(input) : LLM.generateObject(input), options)
   }
 
+  function compact(
+    request: CheckpointRequest,
+    options: TriggerCompactOptions & RunOptions,
+  ): Promise<CompactionCheckpointResponse>
+  function compact(request: CompactionRequest, options?: EndpointCompactOptions & RunOptions): Promise<CompactionResponse>
+  // The overloads pair each request type with its mechanism; `LLMClient.compact` checks the route's capability at runtime.
+  function compact(
+    request: CheckpointRequest | CompactionRequest,
+    options?: (TriggerCompactOptions | EndpointCompactOptions) & RunOptions,
+  ) {
+    return options?.mechanism === "trigger"
+      ? run(LLMClient.compact(request as CheckpointRequest, options), options)
+      : run(LLMClient.compact(request as CompactionRequest, options), options)
+  }
+
   const handle = <Response>(generation: Generation<Response>): GenerationHandle<Response> => ({
     ...generation.snapshot,
     token: generation.token,
@@ -172,6 +201,8 @@ export const make = <R = never>(options: Options<R> = {}) => {
         iterate(LLM.loop(input), options),
       /** Decode the model's output against `schema` (or `jsonSchema`, unvalidated) like `LLM.generateObject`. */
       generateObject,
+      /** Compact a Responses request like `LLMClient.compact`: a replacement window, or a checkpoint with `mechanism: "trigger"`. */
+      compact,
     },
     image: {
       request: Image.request,
 
@@ -458,6 +458,54 @@ describe("AI promise client", () => {
     await ai.dispose()
   })
 
+  test("compacts through the endpoint and the trigger, and rejects unsupported routes with AIError", async () => {
+    const checkpoint = { type: "compaction", id: "cmp_1", encrypted_content: "opaque" }
+    const paths: Array<string> = []
+    const ai = AI.make({
+      layer: RequestExecutor.layer.pipe(
+        Layer.provide(
+          handlerLayer((input) =>
+            Effect.gen(function* () {
+              const path = new URL((yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)).url).pathname
+              paths.push(path)
+              if (path === "/v1/responses/compact")
+                return json(input, {
+                  object: "response.compaction",
+                  output: [checkpoint],
+                  usage: { input_tokens: 100, output_tokens: 10, total_tokens: 110 },
+                })
+              expect(JSON.parse(input.text).input.at(-1)).toEqual({ type: "compaction_trigger" })
+              return input.respond(
+                sseEvents({ type: "response.completed", response: { id: "resp_1", output: [checkpoint] } }),
+                { headers: { "content-type": "text/event-stream" } },
+              )
+            }),
+          ),
+        ),
+      ),
+    })
+    const request = ai.llm.request({ model: openai.responses("gpt-5"), prompt: "Hello" })
+
+    const compacted = await ai.llm.compact(request)
+    expect(compacted.replacement.flatMap((message) => message.content.map((part) => part.type))).toEqual([
+      "compaction",
+    ])
+    expect(compacted.usage?.totalTokens).toBe(110)
+
+    const triggered = await ai.llm.compact(request, { mechanism: "trigger" })
+    expect(triggered.checkpoint).toMatchObject({ id: "cmp_1", encrypted: "opaque" })
+    expect(triggered.responseID).toBe("resp_1")
+    expect(paths).toEqual(["/v1/responses/compact", "/v1/responses"])
+
+    const unsupported = await ai.llm
+      // @ts-expect-error Untyped callers on routes without a compact endpoint must reject with AIError.
+      .compact(ai.llm.request({ model: openai.chat("gpt-4o-mini"), prompt: "Hello" }))
+      .catch((error: unknown) => error)
+    expect(unsupported instanceof AIError && unsupported.reason._tag).toBe("UnsupportedOperation")
+    expect(paths).toHaveLength(2)
+    await ai.dispose()
+  })
+
   test("the default client is created lazily and can be disposed", async () => {
     expect(typeof AI.ai.llm.generate).toBe("function")
     expect(typeof AI.ai.image.generate).toBe("function")
 
@@ -16,6 +16,7 @@ import {
   OpenAICompatibleResponses,
   XAI,
 } from "../../src/providers.js"
+import { ai } from "../../src/index.js"
 import type { WebSocketChannelExecutor } from "../../src/route.js"
 import type { RoutePatch } from "../../src/route/client.js"
 import type { OpenAIResponsesBody } from "../../src/protocols/openai-responses.js"
@@ -127,3 +128,19 @@ if (LLMClient.canCompact(dynamic)) {
 }
 // @ts-expect-error A dynamic model override cannot preserve trigger support.
 LLMClient.compact(LLMRequest.update(request, patch), { mechanism: "trigger" })
+
+void ai.llm.compact(request).then((result) => result satisfies CompactionResponse)
+void ai.llm.compact(request, { mechanism: "trigger", webSocket, signal: AbortSignal.timeout(1) }).then((result) => {
+  result satisfies CompactionCheckpointResponse
+  // @ts-expect-error A trigger does not return replacement history.
+  result.replacement
+})
+// @ts-expect-error Endpoint compaction does not accept a WebSocket executor.
+void ai.llm.compact(request, { webSocket })
+// @ts-expect-error Azure must not inherit OpenAI's trigger operation.
+void ai.llm.compact(LLM.request({ model: azure }), { mechanism: "trigger" })
+// @ts-expect-error OpenAI Chat does not expose explicit compaction.
+void ai.llm.compact(unsupported.openai)
+// @ts-expect-error Dynamic models must be narrowed.
+void ai.llm.compact(dynamic)
+if (LLMClient.canCompact(dynamic, { mechanism: "trigger" })) void ai.llm.compact(dynamic, { mechanism: "trigger" })