refactor(core): route title and compaction through shared model requests

.changeset/unify-request-envelope.md

@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Title generation and compaction summaries now build their model requests through the shared session request boundary, gaining unsupported-media filtering and image bounds while explicitly opting out of session context hooks: plugins that shape the agent conversation do not observe title or compaction requests. Title requests gain the fork-aware session prompt cache key, and compaction summaries in forked sessions reuse the fork root's prompt cache key instead of the fork's own.

packages/core/src/session/compaction.ts

@@ -1,6 +1,6 @@
 export * as SessionCompaction from "./compaction.js"
 
-import { LLM, LLMClient, AIError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
+import { LLMClient, AIError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
 import type { StreamOptions } from "@opencode-ai/ai/route"
 import { SessionError } from "@opencode-ai/schema/session-error"
 import { Context, Effect, Layer, Stream } from "effect"
@@ -9,17 +9,12 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { llmClient } from "../effect/app-node-platform.js"
 import { SessionEvent } from "./event.js"
 import type { SessionMessage } from "./message.js"
-import { SessionModelHeaders } from "./model-headers.js"
-import { SessionModelHook } from "./model-hook.js"
-import { SessionModelHttp } from "./model-http.js"
-import { SessionPromptCacheKey } from "./prompt-cache-key.js"
-import { App } from "../app.js"
+import { SessionModelRequest } from "./model-request.js"
 import { SessionRunnerModel } from "./runner/model.js"
 import { SessionSchema } from "./schema.js"
 import { toSessionError } from "./to-session-error.js"
 import { Token } from "../util/token.js"
 import { SessionUsage } from "./usage.js"
-import { PluginHooks } from "../plugin/hooks.js"
 import { Agent } from "../agent.js"
 import { State } from "../state.js"
 
@@ -70,13 +65,12 @@ export type Draft = {
 }
 
 type Dependencies = {
-  readonly app: App.Info
   readonly bus: Bus.Interface
   readonly llm: {
     readonly stream: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<LLMEvent, AIError>
   }
   readonly models: SessionRunnerModel.Interface
-  readonly hooks: PluginHooks.Interface
+  readonly modelRequests: SessionModelRequest.Interface
 }
 
 export type AutoInput = {
@@ -85,15 +79,15 @@ export type AutoInput = {
   readonly resolved: SessionRunnerModel.Resolved
 }
 
+type RequiredInput = Pick<AutoInput, "messages" | "resolved">
+
 export type ManualInput = {
   readonly session: SessionSchema.Info
   readonly messages: readonly SessionMessage.Info[]
   readonly inputID: SessionMessage.ID
   readonly started?: boolean
 }
 
-type RequiredInput = Pick<AutoInput, "messages" | "resolved">
-
 type Plan = {
   readonly session: SessionSchema.Info
   readonly resolved: SessionRunnerModel.Resolved
@@ -266,65 +260,51 @@ const make = (dependencies: Dependencies) => {
           })
         : Effect.void,
     )
-    const request = yield* SessionModelHook.apply(
-      dependencies.hooks,
-      { sessionID: plan.session.id, agent: Agent.ID.make("compaction"), model: plan.resolved.ref },
-      LLM.request({
-        model: plan.resolved.model,
-        promptCacheKey: SessionPromptCacheKey.make(plan.session.id),
-        http: { headers: SessionModelHeaders.make(plan.session, dependencies.app) },
-        messages: [Message.user(plan.prompt)],
-        tools: [],
-      }),
-    )
-    yield* dependencies.llm
-      .stream(request, {
-        http: SessionModelHttp.middleware(dependencies.hooks, {
-          sessionID: plan.session.id,
-          agent: Agent.ID.make("compaction"),
-          model: plan.resolved.ref,
-        }),
-      })
-      .pipe(
-        Stream.runForEach((event) => {
-          if (LLMEvent.is.providerError(event))
-            failure = {
-              type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
-              message: event.message,
-            }
-          if (LLMEvent.is.textDelta(event)) {
-            chunks.push(event.text)
-            return dependencies.bus.publish(SessionEvent.Compaction.Delta, {
-              sessionID: plan.session.id,
-              text: event.text,
-            })
-          }
-          if (LLMEvent.is.stepFinish(event)) {
-            const step = SessionUsage.record(event.usage, plan.resolved.cost)
-            usage = usage ? SessionUsage.add(usage, step) : step
+    const prepared = yield* dependencies.modelRequests.prepare({
+      scope: { session: plan.session, agentID: Agent.ID.make("compaction"), model: plan.resolved },
+      transcript: { system: [], messages: [Message.user(plan.prompt)] },
+      contextHooks: false,
+    })
+    yield* dependencies.llm.stream(prepared.request, prepared.options).pipe(
+      Stream.runForEach((event) => {
+        if (LLMEvent.is.providerError(event))
+          failure = {
+            type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
+            message: event.message,
           }
-          return Effect.void
+        if (LLMEvent.is.textDelta(event)) {
+          chunks.push(event.text)
+          return dependencies.bus.publish(SessionEvent.Compaction.Delta, {
+            sessionID: plan.session.id,
+            text: event.text,
+          })
+        }
+        if (LLMEvent.is.stepFinish(event)) {
+          const step = SessionUsage.record(event.usage, plan.resolved.cost)
+          usage = usage ? SessionUsage.add(usage, step) : step
+        }
+        return Effect.void
+      }),
+      Effect.catchTag("AI.Error", (error) =>
+        Effect.sync(() => {
+          failure = toSessionError(error)
         }),
-        Effect.catchTag("AI.Error", (error) =>
-          Effect.sync(() => {
-            failure = toSessionError(error)
-          }),
-        ),
-        Effect.onInterrupt(() =>
-          recordUsage.pipe(
-            Effect.andThen(
-              plan.reason === "auto"
-                ? failed({
-                    sessionID: plan.session.id,
-                    reason: plan.reason,
-                    error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
-                    inputID: plan.inputID,
-                  }).pipe(Effect.asVoid)
-                : Effect.void,
-            ),
+      ),
+      Effect.onInterrupt(() =>
+        recordUsage.pipe(
+          Effect.andThen(
+            plan.reason === "auto"
+              ? failed({
+                  sessionID: plan.session.id,
+                  reason: plan.reason,
+                  error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
+                  inputID: plan.inputID,
+                }).pipe(Effect.asVoid)
+              : Effect.void,
           ),
         ),
-      )
+      ),
+    )
     yield* recordUsage
     const summary = chunks.join("")
     if (failure || !summary.trim()) {
@@ -425,14 +405,13 @@ export const layer = Layer.effect(
     const bus = yield* Bus.Service
     const llm = yield* LLMClient.Service
     const models = yield* SessionRunnerModel.Service
-    const app = yield* App.Metadata
-    const hooks = yield* PluginHooks.Service
-    return make({ bus, llm, models, app, hooks })
+    const modelRequests = yield* SessionModelRequest.Service
+    return make({ bus, llm, models, modelRequests })
   }),
 )
 
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Bus.node, llmClient, SessionRunnerModel.node, App.node, PluginHooks.node],
+  deps: [Bus.node, llmClient, SessionRunnerModel.node, SessionModelRequest.node],
 })

packages/core/src/session/model-request.ts

@@ -61,13 +61,20 @@ interface PrepareInput {
     readonly session: SessionSchema.Info
     readonly agentID: Agent.ID
     readonly model: SessionRunnerModel.Resolved
-    readonly tools: Tool.Snapshot
+    /** Omitted for requests that carry no tools (title, compaction). */
+    readonly tools?: Tool.Snapshot
   }
   readonly transcript: {
     readonly system: Array<SystemPart>
     readonly messages: Array<Message>
   }
   readonly toolChoice?: LLM.RequestInput["toolChoice"]
+  /**
+   * Session context hooks shape the agent conversation. Requests that are not
+   * part of the conversation (title, compaction) opt out: their transcripts
+   * pass through unchanged.
+   */
+  readonly contextHooks?: false
   /** Stateful Session WebSocket channels require an explicit durable-runner opt-in. */
   readonly webSocket?: "session"
 }
@@ -209,7 +216,10 @@ export const layer = Layer.effect(
       const session = input.scope.session
       const resolved = input.scope.model
       const model = resolved.model
-      const tools = input.scope.tools
+      const tools = input.scope.tools ?? {
+        definitions: [],
+        execute: () => new Tool.Error({ message: "Tools are not available for this request" }),
+      }
       const registry = new Map(tools.definitions.map((tool) => [tool.name, tool]))
       // The definition objects we hand to hooks, mapped back to their tools. Hooks rename a
       // tool by moving its definition to a new key; recognizing the object recovers the tool.
@@ -219,14 +229,18 @@ export const layer = Layer.effect(
         ),
       )
       // Hooks mutate this record in place: edit descriptions and schemas, rename, or remove.
-      const context = yield* hooks.trigger("session", "context", {
-        sessionID: session.id,
-        agent: input.scope.agentID,
-        model: resolved.ref,
-        system: input.transcript.system,
-        messages: input.transcript.messages,
-        tools: Object.fromEntries(Array.from(given, ([definition, tool]) => [tool.name, definition])),
-      })
+      const definitions = Object.fromEntries(Array.from(given, ([definition, tool]) => [tool.name, definition]))
+      const context =
+        input.contextHooks === false
+          ? { system: input.transcript.system, messages: input.transcript.messages, tools: definitions }
+          : yield* hooks.trigger("session", "context", {
+              sessionID: session.id,
+              agent: input.scope.agentID,
+              model: resolved.ref,
+              system: input.transcript.system,
+              messages: input.transcript.messages,
+              tools: definitions,
+            })
       // Match each surviving entry back to its tool, by recognizing a moved definition or
       // by key. Identity wins so a definition moved onto another tool's name still executes
       // the tool it describes. Entries matching neither were invented by a hook and dropped.

packages/core/src/session/runner/llm.ts

@@ -315,7 +315,6 @@ const layer = Layer.effect(
       const loaded = yield* context.load(selected)
       const { session, agent } = loaded
       const resolved = loaded.model
-      const model = resolved.model
       // Make room: history must fit the context window before the call. A pending manual
       // compaction owns this instead; the runner executes it between steps.
       const compactionInput = { session, messages: loaded.messages, resolved }

packages/core/src/session/title.ts

@@ -1,21 +1,17 @@
 export * as SessionTitle from "./title.js"
 
-import { LLM, LLMClient, AIError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
+import { LLMClient, AIError, LLMEvent, Message, SystemPart, type LLMRequest } from "@opencode-ai/ai"
 import type { StreamOptions } from "@opencode-ai/ai/route"
 import { Context, DateTime, Effect, Layer, Stream } from "effect"
 import { Agent } from "../agent.js"
 import { Database } from "../database/database.js"
 import { Bus } from "../bus.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { isExactRootFallback } from "@opencode-ai/util/session-title-fallback"
-import { App } from "../app.js"
 import { llmClient } from "../effect/app-node-platform.js"
-import { PluginHooks } from "../plugin/hooks.js"
 import { SessionEvent } from "./event.js"
 import { SessionHistory } from "./history.js"
-import { SessionModelHeaders } from "./model-headers.js"
-import { SessionModelHook } from "./model-hook.js"
-import { SessionModelHttp } from "./model-http.js"
+import { SessionModelRequest } from "./model-request.js"
 import { SessionRunnerModel } from "./runner/model.js"
 import { SessionSchema } from "./schema.js"
 import { SessionUsage } from "./usage.js"
@@ -25,15 +21,14 @@ const MAX_LENGTH = 100
 const titleChanged = Symbol("Session title changed")
 
 type Dependencies = {
-  readonly app: App.Info
   readonly bus: Bus.Interface
   readonly llm: {
     readonly stream: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<LLMEvent, AIError>
   }
   readonly agents: Agent.Interface
   readonly models: SessionRunnerModel.Interface
+  readonly modelRequests: SessionModelRequest.Interface
   readonly store: SessionStore.Interface
-  readonly hooks: PluginHooks.Interface
 }
 
 export interface Interface {
@@ -81,39 +76,28 @@ const make = (dependencies: Dependencies) => {
           })
         : Effect.void,
     )
-    const request = yield* SessionModelHook.apply(
-      dependencies.hooks,
-      { sessionID: session.id, agent: agent.id, model: resolved.ref },
-      LLM.request({
-        model: resolved.model,
-        http: { headers: SessionModelHeaders.make(session, dependencies.app) },
-        system: agent.system,
+    const prepared = yield* dependencies.modelRequests.prepare({
+      scope: { session, agentID: agent.id, model: resolved },
+      transcript: {
+        system: agent.system ? [SystemPart.make(agent.system)] : [],
         messages: [Message.user(firstUser.text)],
-        tools: [],
+      },
+      contextHooks: false,
+    })
+    const streamed = yield* dependencies.llm.stream(prepared.request, prepared.options).pipe(
+      Stream.runForEach((event) => {
+        if (LLMEvent.is.providerError(event)) failed = true
+        if (LLMEvent.is.textDelta(event)) chunks.push(event.text)
+        if (LLMEvent.is.stepFinish(event)) {
+          const step = SessionUsage.record(event.usage, resolved.cost)
+          usage = usage ? SessionUsage.add(usage, step) : step
+        }
+        return Effect.void
       }),
+      Effect.as(true),
+      Effect.catchTag("AI.Error", () => Effect.succeed(false)),
+      Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)),
     )
-    const streamed = yield* dependencies.llm
-      .stream(request, {
-        http: SessionModelHttp.middleware(dependencies.hooks, {
-          sessionID: session.id,
-          agent: agent.id,
-          model: resolved.ref,
-        }),
-      })
-      .pipe(
-        Stream.runForEach((event) => {
-          if (LLMEvent.is.providerError(event)) failed = true
-          if (LLMEvent.is.textDelta(event)) chunks.push(event.text)
-          if (LLMEvent.is.stepFinish(event)) {
-            const step = SessionUsage.record(event.usage, resolved.cost)
-            usage = usage ? SessionUsage.add(usage, step) : step
-          }
-          return Effect.void
-        }),
-        Effect.as(true),
-        Effect.catchTag("AI.Error", () => Effect.succeed(false)),
-        Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)),
-      )
     yield* recordUsage
     if (!streamed || failed) return
     const title = chunks
@@ -146,11 +130,10 @@ export const layer = Layer.effect(
     const llm = yield* LLMClient.Service
     const agents = yield* Agent.Service
     const models = yield* SessionRunnerModel.Service
+    const modelRequests = yield* SessionModelRequest.Service
     const store = yield* SessionStore.Service
     const database = yield* Database.Service
-    const app = yield* App.Metadata
-    const hooks = yield* PluginHooks.Service
-    const title = make({ bus, llm, agents, models, store, app, hooks })
+    const title = make({ bus, llm, agents, models, modelRequests, store })
     return Service.of({
       generateForFirstPrompt: (sessionID) => title.generateForFirstPrompt(database.db, sessionID),
     })
@@ -165,9 +148,8 @@ export const node = makeLocationNode({
     llmClient,
     Agent.node,
     SessionRunnerModel.node,
+    SessionModelRequest.node,
     SessionStore.node,
     Database.node,
-    App.node,
-    PluginHooks.node,
   ],
 })