From ebb2d475690bc349b3af1264228ffeefb816f3f6 Mon Sep 17 00:00:00 2001 From: Aiden Cline Date: Tue, 17 Nov 2026 00:47:47 -0600 Subject: [PATCH 1/6] feat(core): send mid-conversation tool changes in place --- packages/client/src/effect/api/api.ts | 29 ++ .../client/src/promise/generated/types.ts | 53 +++- packages/client/src/solid/data.ts | 7 +- packages/client/test/solid-data.test.ts | 44 ++++ packages/core/src/config/plugin/provider.ts | 4 +- packages/core/src/model-resolver.ts | 10 +- packages/core/src/models-dev.ts | 16 +- packages/core/src/session/compaction.ts | 1 + packages/core/src/session/generate.ts | 1 + packages/core/src/session/message-updater.ts | 11 + packages/core/src/session/model-request.ts | 67 +++-- packages/core/src/session/projector.ts | 1 + packages/core/src/session/runner/llm.ts | 7 + .../core/src/session/runner/to-llm-message.ts | 2 + packages/core/src/session/tool-changes.ts | 116 ++++++++ packages/core/src/session/transfer.ts | 15 +- packages/core/test/model-resolver.test.ts | 3 +- packages/core/test/models.test.ts | 71 +++++ packages/core/test/session-runner.test.ts | 247 +++++++++++++++++- .../core/test/session-tool-changes.test.ts | 146 +++++++++++ packages/schema/src/model-compatibility.ts | 8 +- packages/schema/src/session-event.ts | 18 +- packages/schema/src/session-message.ts | 7 +- packages/schema/src/tool.ts | 19 ++ packages/schema/test/event-manifest.test.ts | 4 + 25 files changed, 859 insertions(+), 48 deletions(-) create mode 100644 packages/core/src/session/tool-changes.ts create mode 100644 packages/core/test/session-tool-changes.test.ts diff --git a/packages/client/src/effect/api/api.ts b/packages/client/src/effect/api/api.ts index 54d8d8c5edc0..92258337568c 100644 --- a/packages/client/src/effect/api/api.ts +++ b/packages/client/src/effect/api/api.ts @@ -1434,6 +1434,35 @@ export type ExperimentalSessionLogOutput = readonly content: ReadonlyArray } } + | { + readonly id: Event.ID + readonly created: number + readonly metadata?: { readonly [x: string]: unknown } | undefined + readonly type: "session.tools.updated" + readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version } + readonly location?: + | { readonly directory: AbsolutePath; readonly workspaceID?: Workspace.ID | undefined } + | undefined + readonly data: { + readonly sessionID: Session.ID + readonly add: ReadonlyArray<{ + readonly name: string + readonly description: string + readonly inputSchema: { readonly [x: string]: unknown } + readonly outputSchema?: { readonly [x: string]: unknown } | undefined + readonly freeform?: + | ( + | { readonly type: "text" } + | { readonly type: "regex"; readonly pattern: string } + | { readonly type: "lark"; readonly grammar: string } + ) + | undefined + readonly native?: { readonly [x: string]: unknown } | undefined + }> + readonly remove: ReadonlyArray + readonly model?: Model.Ref | undefined + } + } ) | EventLog.Synced export type ExperimentalSessionLogOperation = ( diff --git a/packages/client/src/promise/generated/types.ts b/packages/client/src/promise/generated/types.ts index a6a62e36cc2a..c38b2b1f306e 100644 --- a/packages/client/src/promise/generated/types.ts +++ b/packages/client/src/promise/generated/types.ts @@ -99,6 +99,8 @@ export type SessionInboxSyntheticPayload = { text: string; description?: string; export type SessionInboxCompactionPayload = {} +export type ToolFreeform = { type: "text" } | { type: "regex"; pattern: string } | { type: "lark"; grammar: string } + export type ShellID = string export type SessionMessageNative = { [x: string]: JsonValue } @@ -186,6 +188,8 @@ export type ModelMaxTokensField = "max_completion_tokens" | "max_tokens" export type ModelCacheFormat = "anthropic" | "alibaba" +export type ModelToolUpdate = "add" | "remove" | "replace" + export type ModelMediaInput = "assets" | "state" | "root" export type ToolFreeformFormat = "text" | "regex" | "lark" @@ -441,15 +445,6 @@ export type SessionMessageSynthetic = { type: "synthetic" } -export type SessionMessageSystem = { - id: SessionMessageID - metadata?: { [x: string]: JsonValue } - time: { created: number } - type: "system" - text: string - description?: string -} - export type SessionMessageCompactionRunning = { type: "compaction" id: SessionMessageID @@ -525,6 +520,24 @@ export type SessionInboxCompaction = { delivery: SessionInboxDelivery } +export type ToolDefinition = { + name: string + description: string + inputSchema: { [x: string]: JsonValue } + outputSchema?: { [x: string]: JsonValue } + freeform?: ToolFreeform + native?: { [x: string]: JsonValue } +} + +export type ToolDefinition1 = { + name: string + description: string + inputSchema: { [x: string]: any } + outputSchema?: { [x: string]: any } + freeform?: ToolFreeform + native?: { [x: string]: any } +} + export type SessionMessageShell = { id: SessionMessageID metadata?: { [x: string]: JsonValue } @@ -706,6 +719,7 @@ export type ModelCompatibility = { cacheFormat?: ModelCacheFormat supportsThinkingBlockBinding?: boolean supportsEffortUpdates?: boolean + supportsToolUpdates?: Array mediaInput?: ModelMediaInput } @@ -1171,6 +1185,16 @@ export type SessionInboxUserPayload1 = { metadata?: { [x: string]: any } } +export type SessionMessageSystem = { + id: SessionMessageID + metadata?: { [x: string]: JsonValue } + time: { created: number } + type: "system" + text: string + description?: string + tools?: { add: Array; remove: Array; model?: ModelRef } +} + export type SessionMessageToolStateCompleted = { status: "completed" input: { [x: string]: JsonValue } @@ -1699,6 +1723,16 @@ export type SessionUsageRecorded = { data: { sessionID: SessionID; source: "title" | "compaction" | "generate"; cost: MoneyUSD; tokens: TokenUsageInfo } } +export type SessionToolsUpdated = { + id: EventID + created: number + metadata?: { [x: string]: any } + type: "session.tools.updated" + durable: { aggregateID: string; seq: EventSeq; version: 1 } + location?: LocationRef + data: { sessionID: SessionID; add: Array; remove: Array; model?: ModelRef } +} + export type LocationShutdown = { id: EventID created: number @@ -2928,6 +2962,7 @@ export type SessionEventDurable = | SessionRevertCommitted | SessionUsageRecorded | SessionMessageContentUpdated + | SessionToolsUpdated export type V2Event = | LocationShutdown diff --git a/packages/client/src/solid/data.ts b/packages/client/src/solid/data.ts index 8b6d247dc965..650082ad14e5 100644 --- a/packages/client/src/solid/data.ts +++ b/packages/client/src/solid/data.ts @@ -210,6 +210,9 @@ function omitMessageFileData(message: SessionMessageInfo): SessionMessageInfo { } } +// Tool changes are model context the server keeps with the history; transcripts don't show them. +const transcript = (message: SessionMessageInfo) => message.type !== "system" || message.tools === undefined + function formRequestOptions(sessionID: string, ref?: LocationRef) { if (sessionID !== "global" || !ref) return undefined return { @@ -1888,7 +1891,7 @@ export function createData(config: CreateDataInput) { }) .catch(evictMissing) if ((deletedAt.get(sessionID) ?? 0) > started) return - const fetched = response.data.toReversed().map(stored) + const fetched = response.data.filter(transcript).toReversed().map(stored) // Same protection as the pending sync: a re-fetch racing an // admission must not wipe its local transcript row. const ids = new Set(fetched.map((item) => item.id)) @@ -1963,7 +1966,7 @@ export function createData(config: CreateDataInput) { { signal }, ) if (signal?.aborted) return - fetched.push(...response.data.map(stored)) + fetched.push(...response.data.filter(transcript).map(stored)) next = response.cursor.next ?? undefined if (!options?.all) break } while (next) diff --git a/packages/client/test/solid-data.test.ts b/packages/client/test/solid-data.test.ts index b040e634d595..7235a00f8ec0 100644 --- a/packages/client/test/solid-data.test.ts +++ b/packages/client/test/solid-data.test.ts @@ -52,6 +52,50 @@ test("uses the configured initial window and retains normal cursor page sizes", } }) +test("leaves recorded tool changes out of the transcript", async () => { + const tools = (id: string, created: number) => ({ + id, + type: "system", + text: "", + tools: { add: [{ name: "lookup", description: "Look up", inputSchema: {} }], remove: [] }, + time: { created }, + }) + const api = OpenCode.make({ + baseUrl: "http://opencode.local", + fetch: async (input, init) => { + const url = new URL((input instanceof Request ? input : new Request(input, init)).url) + const cursor = url.searchParams.get("cursor") + return Response.json( + cursor + ? { data: [tools("msg_1", 1)], cursor: {} } + : { + data: [ + { id: "msg_4", type: "system", text: "Instructions changed", time: { created: 4 } }, + tools("msg_3", 3), + { id: "msg_2", type: "user", text: "History", time: { created: 2 } }, + ], + cursor: { next: "older" }, + }, + ) + }, + }) + const setup = createRoot((dispose) => ({ + data: createData({ + api: () => api, + directory: "/project", + event: { on: () => () => {}, listen: () => () => {} }, + }), + dispose, + })) + try { + await setup.data.session.message.sync("ses_refresh") + await setup.data.session.message.loadMore("ses_refresh") + expect(setup.data.session.message.list("ses_refresh").map((message) => message.id)).toEqual(["msg_2", "msg_4"]) + } finally { + setup.dispose() + } +}) + test("counts every subagent page in a root session's cost", async () => { const child = (index: number): SessionInfo => ({ ...session(0), diff --git a/packages/core/src/config/plugin/provider.ts b/packages/core/src/config/plugin/provider.ts index e6c68668b15c..ee9b2cf0e2f9 100644 --- a/packages/core/src/config/plugin/provider.ts +++ b/packages/core/src/config/plugin/provider.ts @@ -7,6 +7,7 @@ import { Document, type Entry } from "@opencode/schema/config" import { ConfigProvider } from "@opencode/schema/config/provider" import { Money } from "@opencode/schema/money" import { Effect } from "effect" +import { castDraft } from "immer" import { Config } from "../../config.js" import { Model } from "../../model.js" import { Provider } from "../../provider.js" @@ -225,7 +226,8 @@ function overlay( if (config.name) model.name = config.name if (config.modelID !== undefined) model.modelID = config.modelID if (config.releaseDate !== undefined) model.time = { released: Date.parse(config.releaseDate) } - if (config.compatibility !== undefined) model.compatibility = { ...model.compatibility, ...config.compatibility } + if (config.compatibility !== undefined) + model.compatibility = castDraft({ ...model.compatibility, ...config.compatibility }) if (config.package !== undefined) model.package = config.package if (config.settings !== undefined) model.settings = Provider.mergeOverlay(model.settings, config.settings) if (config.headers !== undefined) model.headers = Provider.mergeHeaders(model.headers, config.headers) diff --git a/packages/core/src/model-resolver.ts b/packages/core/src/model-resolver.ts index ae4307a23d03..d0e5d0f7309e 100644 --- a/packages/core/src/model-resolver.ts +++ b/packages/core/src/model-resolver.ts @@ -274,7 +274,12 @@ const resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(funct }) // Config `compatibility` keys the AI package reads as model capabilities. -const CAPABILITY_KEYS = ["supportsPromptCacheKey", "streamUsage", "supportsEffortUpdates"] as const +const CAPABILITY_KEYS = [ + "supportsPromptCacheKey", + "streamUsage", + "supportsEffortUpdates", + "supportsToolUpdates", +] as const const capabilities = (base: LanguageModel["capabilities"], compatibility: Compatibility) => ({ ...base, @@ -283,6 +288,9 @@ const capabilities = (base: LanguageModel["capabilities"], compatibility: Compat ...("supportsEffortUpdates" in compatibility ? { reasoning: { ...base?.reasoning, updates: compatibility.supportsEffortUpdates } } : {}), + ...("supportsToolUpdates" in compatibility + ? { tools: { ...base?.tools, updates: compatibility.supportsToolUpdates } } + : {}), }) /** Settings and package loading shared by every model type: credentials, variables, canonical provider, overlays. */ diff --git a/packages/core/src/models-dev.ts b/packages/core/src/models-dev.ts index 3b1e6ba6caa2..5b456315ee2a 100644 --- a/packages/core/src/models-dev.ts +++ b/packages/core/src/models-dev.ts @@ -1,7 +1,7 @@ import { Cause, Context, Duration, Effect, Layer, Option, Result, Schedule, Schema, Semaphore } from "effect" import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http" import { ConfigProvider } from "@opencode/schema/config/provider" -import { MaxTokensField, MediaInput } from "@opencode/schema/model-compatibility" +import { MaxTokensField, MediaInput, ToolUpdate } from "@opencode/schema/model-compatibility" import { ModelsDev } from "@opencode/schema/models-dev" import { Money } from "@opencode/schema/money" import { FreeformFormat } from "@opencode/schema/tool" @@ -72,8 +72,14 @@ const SourceApi = Schema.Struct({ base_url: Schema.optional(Schema.String), capabilities: Schema.optional( Schema.Struct({ - // Format names this version doesn't know are skipped when the route is built. - tools: Schema.optional(Schema.Struct({ freeform: Schema.optional(Schema.Array(Schema.String)) })), + // Format and update names this version doesn't know are skipped when the route is built. + tools: Schema.optional( + Schema.Struct({ + freeform: Schema.optional(Schema.Array(Schema.String)), + // Older catalogs published a boolean here, which counts as no updates. + updates: Schema.optional(Schema.Unknown), + }), + ), }), ), sdk: Schema.optional( @@ -144,6 +150,7 @@ const decodeContext = Schema.decodeUnknownOption(ContextCondition) const decodeMaxTokensField = Schema.decodeUnknownOption(MaxTokensField) const decodeMediaInput = Schema.decodeUnknownOption(MediaInput) const knownFreeformFormat = Schema.is(FreeformFormat) +const knownToolUpdate = Schema.is(ToolUpdate) const decodeStatus = Schema.decodeUnknownOption(Schema.Literals(["alpha", "beta", "deprecated"])) export type Snapshot = { @@ -274,7 +281,10 @@ function route(providerID: Provider.ID, model: SourceModel, unknown: Set if (!packageName) return undefined const maxTokensField = Option.getOrUndefined(decodeMaxTokensField(api.compatibility?.max_tokens_field)) const mediaInput = Option.getOrUndefined(decodeMediaInput(api.compatibility?.media_input)) + const updates = api.capabilities?.tools?.updates + const toolUpdates = Array.isArray(updates) ? updates.filter(knownToolUpdate) : [] const compatibility = { + ...(toolUpdates.length > 0 ? { supportsToolUpdates: toolUpdates } : {}), ...(api.compatibility?.reasoning_field ? { reasoningField: api.compatibility.reasoning_field } : {}), ...(maxTokensField ? { maxTokensField } : {}), ...(mediaInput ? { mediaInput } : {}), diff --git a/packages/core/src/session/compaction.ts b/packages/core/src/session/compaction.ts index 62ff2dfd84f7..d73a2cf03cfb 100644 --- a/packages/core/src/session/compaction.ts +++ b/packages/core/src/session/compaction.ts @@ -852,6 +852,7 @@ export const layer = Layer.effect( agent: context.agent.id, model: context.model, tools: context.tools, + toolEpoch: base.toolEpoch, system: base.system, messages: base.messages, webSocket, diff --git a/packages/core/src/session/generate.ts b/packages/core/src/session/generate.ts index a9ab0fd35573..8b61481db5df 100644 --- a/packages/core/src/session/generate.ts +++ b/packages/core/src/session/generate.ts @@ -58,6 +58,7 @@ export const generate = Effect.fn("SessionGenerate.generate")(function* (input: agent: selection.agent.id, model, tools: selection.tools, + toolEpoch: transcript.toolEpoch, system: transcript.system, messages: [ ...transcript.messages, diff --git a/packages/core/src/session/message-updater.ts b/packages/core/src/session/message-updater.ts index 1e89db3af822..a0339535c0b7 100644 --- a/packages/core/src/session/message-updater.ts +++ b/packages/core/src/session/message-updater.ts @@ -164,6 +164,17 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) { }), ) }, + "session.tools.updated": (event) => + adapter.appendMessage( + SessionMessage.System.make({ + id: SessionMessage.ID.fromEvent(event.id), + type: "system", + text: "", + tools: { add: event.data.add, remove: event.data.remove, model: event.data.model }, + metadata: event.metadata, + time: { created }, + }), + ), "session.synthetic": (event) => { return adapter.appendMessage( SessionMessage.Synthetic.make({ diff --git a/packages/core/src/session/model-request.ts b/packages/core/src/session/model-request.ts index aea3440a0273..f4fe51f159c0 100644 --- a/packages/core/src/session/model-request.ts +++ b/packages/core/src/session/model-request.ts @@ -13,6 +13,7 @@ import { type MediaPart, Message, SystemPart, + ToolDefinition, ToolMessage, type ToolResultPart, UserMessage, @@ -44,6 +45,7 @@ import { SessionModelTransport } from "./model-transport.js" import { SessionRunnerModel } from "./runner/model.js" import { SessionSchema } from "./schema.js" import { SessionSystemPrompt } from "./system-prompt.js" +import { SessionToolChanges } from "./tool-changes.js" import { toLLMMessages } from "./runner/to-llm-message.js" import type { SessionMessage } from "./message.js" @@ -72,7 +74,9 @@ export interface Prepared { readonly request: LLMRequest readonly options: StreamOptions readonly retry: (event: PluginHooks.Domains["session"]["retry"]) => Effect.Effect - /** Runs a tool call against the tools this request advertised. */ + /** A change to the offered tools the durable runner records before sending this request. */ + readonly toolChange?: SessionToolChanges.Plan["record"] + /** Runs a tool call against the tools offered now, which may differ from the request's top-level `tools`. */ readonly executeTool: ( input: Parameters[0], ) => Effect.Effect @@ -83,6 +87,8 @@ export interface Input { readonly agent: Agent.ID readonly model: SessionRunnerModel.Resolved readonly tools?: Tool.Snapshot + /** The tool epoch the history continues, from `baseTranscript`. */ + readonly toolEpoch?: SessionToolChanges.Epoch readonly system: Array readonly messages: Array readonly toolChoice?: LLM.LLMRequestInput["toolChoice"] @@ -111,8 +117,10 @@ export const baseTranscript = (input: { readonly messages: ReadonlyArray }) => { const providerMetadataKey = input.model.model.route.providerMetadataKey ?? input.model.model.provider + const toolEpoch = SessionToolChanges.epoch(input.messages, input.model) return { providerMetadataKey, + toolEpoch, system: [ SystemPart.make( input.agent.system @@ -125,14 +133,14 @@ export const baseTranscript = (input: { }, ].filter((part) => part.text.length > 0), // Hooks read each stored message's metadata on the messages built from it; `prepare` strips it before the request. - messages: input.messages.flatMap((message) => - toLLMMessages([message], input.model.ref, providerMetadataKey).map( + messages: input.messages.flatMap((message, index): Array => { + const tools = SessionToolChanges.replay(message, index, toolEpoch) + if (tools) return [tools] + return toLLMMessages([message], input.model.ref, providerMetadataKey).map( (item): SessionRequestMessage => - message.metadata === undefined || item.id !== message.id - ? item - : { ...item, metadata: message.metadata }, - ), - ), + message.metadata === undefined || item.id !== message.id ? item : { ...item, metadata: message.metadata }, + ) + }), } } @@ -318,6 +326,30 @@ export const layer = Layer.effect( const entries = Object.entries(shaped.options) const generation = Object.fromEntries(entries.filter(([k]) => GENERATION_KEYS.has(k))) as GenerationOptionsFields const providerOptions = Object.fromEntries(entries.filter(([k]) => !GENERATION_KEYS.has(k))) + const toolPlan = SessionToolChanges.plan({ + model, + epoch: input.toolEpoch, + offered: Array.from(hooked, ([name, t]) => + ToolDefinition.make({ + ...t, + name, + freeform: t.freeform && model.capabilities.freeform?.includes(t.freeform.type) ? t.freeform : undefined, + }), + ), + }) + // Stored metadata is stripped so it never reaches the provider. + const messages = boundImages( + unsupportedParts( + shaped.messages.map((message) => { + const { metadata, ...rest } = message + return metadata === undefined ? message : Message.make(rest) + }), + model.capabilities, + model.model.provider, + ), + ) + // A change sits where the history ends, which is where it replays once recorded, before any assistant prefill. + const at = messages.findLastIndex((message) => message.role !== "assistant") + 1 const affinity = SessionAffinity.get(session) const base = ai.request({ model: model.model, @@ -336,22 +368,8 @@ export const layer = Layer.effect( promptCacheKey: /^ses_[0-9a-f]{64}$/.test(affinity) ? affinity.slice(4) : affinity, cache: model.cache?.ttl === undefined ? undefined : { ttl: model.cache.ttl }, system: shaped.system, - // Strip the stored metadata hooks could read, so it never reaches the provider. - messages: boundImages( - unsupportedParts( - shaped.messages.map((message) => { - const { metadata, ...rest } = message - return metadata === undefined ? message : Message.make(rest) - }), - model.capabilities, - model.model.provider, - ), - ), - tools: Array.from(hooked, ([name, t]) => ({ - ...t, - name, - freeform: t.freeform && model.capabilities.freeform?.includes(t.freeform.type) ? t.freeform : undefined, - })), + messages: toolPlan.marker ? [...messages.slice(0, at), toolPlan.marker, ...messages.slice(at)] : messages, + tools: toolPlan.tools, toolChoice: input.toolChoice, ...generation, providerOptions: Object.keys(providerOptions).length === 0 ? undefined : providerOptions, @@ -436,6 +454,7 @@ export const layer = Layer.effect( event: shaped, request, options: { ...(http ? { http } : {}), ...(webSocket ? { webSocket } : {}) }, + toolChange: toolPlan.record, retry: (event: Parameters[0]) => hooks.trigger("session", "retry", event).pipe(Effect.asVoid), // Permission.assert and the question tool throw declines as defects so tools cannot diff --git a/packages/core/src/session/projector.ts b/packages/core/src/session/projector.ts index a66839ca9e49..c558411673e2 100644 --- a/packages/core/src/session/projector.ts +++ b/packages/core/src/session/projector.ts @@ -1075,6 +1075,7 @@ const layer = Layer.effectDiscard( }), ) yield* bus.project(SessionEvent.Synthetic, (event) => run(db, event)) + yield* bus.project(SessionEvent.ToolsUpdated, (event) => run(db, event)) yield* bus.project(SessionEvent.Skill.Activated, (event) => run(db, event)) yield* bus.project(SessionEvent.Shell.Started, (event) => run(db, event)) yield* bus.project(SessionEvent.Shell.Ended, (event) => run(db, event)) diff --git a/packages/core/src/session/runner/llm.ts b/packages/core/src/session/runner/llm.ts index 77ecc97d971f..5e047723993d 100644 --- a/packages/core/src/session/runner/llm.ts +++ b/packages/core/src/session/runner/llm.ts @@ -272,6 +272,7 @@ const layer = Layer.effect( agent: loaded.agent.id, model: loaded.model, tools: loaded.tools, + toolEpoch: transcript.toolEpoch, system: transcript.system, messages: stepLimitReached ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)] @@ -282,6 +283,12 @@ const layer = Layer.effect( inputTokens: estimate, }) .pipe( + // Recorded before the request is sent, so later steps replay the change where this one sent it. + Effect.tap((prepared) => + prepared.toolChange + ? bus.publish(SessionEvent.ToolsUpdated, { sessionID, ...prepared.toolChange }) + : Effect.void, + ), // The hook event holds every message from before images are bounded, screenshots included, and is a separate // copy once a plugin hook has rewritten it. The step and its tool callbacks live as long as the slowest tool, // so they keep only what they use. diff --git a/packages/core/src/session/runner/to-llm-message.ts b/packages/core/src/session/runner/to-llm-message.ts index b45fb8e71bf4..f776b554bf51 100644 --- a/packages/core/src/session/runner/to-llm-message.ts +++ b/packages/core/src/session/runner/to-llm-message.ts @@ -276,6 +276,8 @@ function toLLMMessage(message: SessionMessage.Info, model: Model.Ref, providerMe case "skill": return [Message.make({ id: message.id, role: "user", content: message.text })] case "system": + // Tool changes replay through `SessionToolChanges`, which knows the epoch they belong to. + if (message.tools) return [] return [Message.system(message.text)] case "shell": // Background shell results enter context once, through their completion inbox item. diff --git a/packages/core/src/session/tool-changes.ts b/packages/core/src/session/tool-changes.ts new file mode 100644 index 000000000000..ab7a8d3af117 --- /dev/null +++ b/packages/core/src/session/tool-changes.ts @@ -0,0 +1,116 @@ +export * as SessionToolChanges from "./tool-changes.js" + +import { type LanguageModel, Message, type SystemMessage, ToolDefinition } from "@opencode/ai/effect" +import type { Model } from "@opencode/schema/model" +import type { Tool } from "@opencode/schema/tool" +import { canonicalJson } from "../util/canonical-json.js" +import type { SessionMessage } from "./message.js" + +// Changing a request's top-level tools invalidates the provider's prompt cache. On models that take tool changes in +// place, each epoch declares the tools it started with at the top of every request, and the history replays each +// later change where it was recorded. Both are hidden system messages, so the epoch follows the history: a compaction +// leaves its baseline behind (provider checkpoints don't keep tools added later), a revert or fork keeps only the +// changes before its point, and a baseline shaped for another provider or model ends it. Variants share the epoch. + +export interface Epoch { + /** The baseline's index in the history; changes before it belong to an earlier epoch. */ + readonly start: number + /** Declared at the top of every request in the epoch. */ + readonly baseline: ReadonlyArray + /** The tools after the latest recorded change. */ + readonly current: ReadonlyArray +} + +/** What a request declares, and the change a durable step records before sending it. */ +export interface Plan { + readonly tools: ReadonlyArray + /** Appended after the history: the change from the epoch's current tools to the offered ones. */ + readonly marker?: SystemMessage + readonly record?: Tool.Changes & { readonly model?: Model.Ref } +} + +/** Whether the model takes some tool change in place on its route. Other models never record or replay changes. */ +export const tracked = (model: LanguageModel) => { + const kinds = model.route.toolUpdates?.kinds ?? [] + return (model.capabilities?.tools?.updates ?? []).some((kind) => kinds.includes(kind)) +} + +/** The epoch the history continues on `model`, or undefined when the next step starts one. */ +export const epoch = ( + messages: ReadonlyArray, + model: { readonly ref: Model.Ref; readonly model: LanguageModel }, +): Epoch | undefined => { + if (!tracked(model.model)) return undefined + const start = messages.findLastIndex((message) => message.type === "system" && message.tools?.model !== undefined) + const baseline = changes(messages[start]) + if (baseline?.model?.providerID !== model.ref.providerID || baseline.model.id !== model.ref.id) return undefined + return { + start, + baseline: baseline.add, + current: messages.slice(start + 1).reduce((tools, message) => fold(tools, changes(message)), baseline.add), + } +} + +/** The marker a recorded change replays as. Changes outside the epoch replay as nothing. */ +export const replay = (message: SessionMessage.Info, index: number, epoch: Epoch | undefined) => { + const recorded = changes(message) + if (recorded === undefined || epoch === undefined || index <= epoch.start) return undefined + // Without the message ID, so it matches the marker the recording step sent. + return Message.make(Message.tools({ add: recorded.add.map(ToolDefinition.make), remove: recorded.remove })) +} + +/** Compares the offered tools with the epoch's and decides what the request declares. */ +export const plan = (input: { + readonly model: { readonly ref: Model.Ref; readonly model: LanguageModel } + readonly epoch: Epoch | undefined + readonly offered: ReadonlyArray +}): Plan => { + if (!tracked(input.model.model)) return { tools: input.offered } + const offered = input.offered.map(definition) + if (input.epoch === undefined) + return { + tools: input.offered, + record: { + add: offered, + remove: [], + model: { providerID: input.model.ref.providerID, id: input.model.ref.id }, + }, + } + const current = new Map(input.epoch.current.map((tool) => [tool.name, key(tool)])) + const names = new Set(offered.map((tool) => tool.name)) + const change = { + add: offered.filter((tool) => current.get(tool.name) !== key(tool)), + remove: input.epoch.current.flatMap((tool) => (names.has(tool.name) ? [] : [tool.name])), + } + const tools = input.epoch.baseline.map(ToolDefinition.make) + if (change.add.length === 0 && change.remove.length === 0) return { tools } + return { + tools, + marker: Message.make(Message.tools({ add: change.add.map(ToolDefinition.make), remove: change.remove })), + record: change, + } +} + +const changes = (message: SessionMessage.Info | undefined) => (message?.type === "system" ? message.tools : undefined) + +/** Removals first, then additions replace a same-named tool in place or append, as the AI package folds them. */ +const fold = (tools: ReadonlyArray, change: Tool.Changes | undefined) => { + if (change === undefined) return tools + const added = new Map(change.add.map((tool) => [tool.name, tool])) + const kept = tools.filter((tool) => !change.remove.includes(tool.name)).map((tool) => added.get(tool.name) ?? tool) + const names = new Set(kept.map((tool) => tool.name)) + return [...kept, ...change.add.filter((tool) => !names.has(tool.name))] +} + +/** What the provider sees of a tool. */ +const definition = (tool: ToolDefinition): Tool.Definition => ({ + name: tool.name, + description: tool.description, + inputSchema: tool.inputSchema, + ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }), + ...(tool.freeform === undefined ? {} : { freeform: tool.freeform }), + ...(tool.native === undefined ? {} : { native: tool.native }), +}) + +// Key order inside a schema can differ between equal tools, so they compare by canonical JSON. +const key = (tool: Tool.Definition) => canonicalJson(JSON.parse(JSON.stringify(tool))) diff --git a/packages/core/src/session/transfer.ts b/packages/core/src/session/transfer.ts index e944238a3519..f5606770b6a6 100644 --- a/packages/core/src/session/transfer.ts +++ b/packages/core/src/session/transfer.ts @@ -288,7 +288,20 @@ function sanitizeMessage(message: SessionMessage.Info): SessionMessage.Info { ? undefined : redact("synthetic-description", message.id, message.description), } - if (message.type === "system") return { ...message, metadata: meta, text: redact("system", message.id, message.text) } + if (message.type === "system") + return { + ...message, + metadata: meta, + text: redact("system", message.id, message.text), + tools: message.tools && { + ...message.tools, + add: message.tools.add.map((tool, index) => ({ + name: tool.name, + description: redact("tool-description", `${message.id}:${index}`, tool.description), + inputSchema: { redacted: `tool-schema:${message.id}:${index}` }, + })), + }, + } if (message.type === "skill") return { ...message, metadata: meta, text: redact("skill", message.id, message.text) } if (message.type === "shell") return { diff --git a/packages/core/test/model-resolver.test.ts b/packages/core/test/model-resolver.test.ts index b6672e2e20c9..59cc1d0466e3 100644 --- a/packages/core/test/model-resolver.test.ts +++ b/packages/core/test/model-resolver.test.ts @@ -1,4 +1,5 @@ import { describe, expect } from "bun:test" +import { castDraft } from "immer" import { ai, LanguageModel, Message } from "@opencode/ai/effect" import { OpenAIChat } from "@opencode/ai/protocols" import { compileRequest } from "@opencode/ai/testing" @@ -35,7 +36,7 @@ function model(packageName: string | undefined, options: RequestOptions = {}) { providerID: options.providerID ?? Provider.ID.make("test-provider"), canonical: options.canonical, name: "Test model", - compatibility: options.compatibility, + compatibility: castDraft(options.compatibility), package: packageName, settings: options.settings ?? {}, headers: options.headers ?? { "x-test": "header" }, diff --git a/packages/core/test/models.test.ts b/packages/core/test/models.test.ts index 2746756b78ef..b9401011eb1d 100644 --- a/packages/core/test/models.test.ts +++ b/packages/core/test/models.test.ts @@ -9,6 +9,7 @@ import { Bus } from "@opencode/core/bus" import { KV } from "@opencode/core/kv" import { Location } from "@opencode/core/location" import { Model } from "@opencode/core/model" +import { ModelResolver } from "@opencode/core/model-resolver" import { bodyDigest, ModelsDev } from "@opencode/core/models-dev" import { Provider } from "@opencode/core/provider" import { AbsolutePath } from "@opencode/core/schema" @@ -348,6 +349,76 @@ describe("ModelsDev Service", () => { }), ) + it.live("reads the tool changes the selected API takes in place and gives them to the runtime model", () => + Effect.gen(function* () { + const cache = makeCache() + const messages = (capabilities?: object) => ({ + messages: { + base_url: "https://claude.acme.test/v1", + sdk: { aisdk: "@ai-sdk/anthropic", opencodeai: "@opencode/ai/providers/anthropic" }, + ...(capabilities ? { capabilities } : {}), + }, + }) + writeCache(cache, { + acme: { + ...fixture.acme, + models: { + "claude-all": sourceModel("claude-all", { + api: messages({ tools: { updates: ["add", "future-change", "remove", "replace"] } }), + }), + "claude-none": sourceModel("claude-none", { api: messages({ tools: { updates: [] } }) }), + "claude-boolean": sourceModel("claude-boolean", { api: messages({ tools: { updates: true } }) }), + "claude-plain": sourceModel("claude-plain", { api: messages() }), + "acme-responses": sourceModel("acme-responses", { + api: { + responses: { + base_url: "https://api.acme.test/v1", + sdk: { aisdk: "@ai-sdk/openai", opencodeai: "@opencode/ai/providers/openai/responses" }, + }, + "chat-completions": { + base_url: "https://other.acme.test/v1", + sdk: { aisdk: "@ai-sdk/openai" }, + capabilities: { tools: { updates: ["add"] } }, + }, + }, + }), + }, + }, + }) + const state = yield* Ref.make(initialState) + const [acme] = yield* provided( + state, + cache, + ModelsDev.Service.use((service) => service.get()), + ) + const find = (id: string) => { + const model = acme?.models.find((item) => item.id === id) + if (!model) throw new Error(`Missing model ${id}`) + return model + } + expect(find("claude-all").compatibility).toEqual({ supportsToolUpdates: ["add", "remove", "replace"] }) + expect(find("claude-none").compatibility).toBeUndefined() + expect(find("claude-plain").compatibility).toBeUndefined() + expect(find("claude-boolean").compatibility).toBeUndefined() + // Only the API the model resolves to counts. + expect(find("acme-responses").compatibility).toBeUndefined() + + const updates = (id: string) => + ModelResolver.fromCatalogModel({ ...find(id), package: "@opencode/ai/providers/anthropic" }).pipe( + Effect.map((model) => model.capabilities?.tools?.updates), + ) + expect(yield* updates("claude-all")).toEqual(["add", "remove", "replace"]) + expect(yield* updates("claude-plain")).toBeUndefined() + // Config compatibility overrides the catalog, as it does for other capabilities. + const overridden = yield* ModelResolver.fromCatalogModel({ + ...find("claude-all"), + package: "@opencode/ai/providers/anthropic", + compatibility: { supportsToolUpdates: [] }, + }) + expect(overridden.capabilities?.tools?.updates).toEqual([]) + }), + ) + it.live("keeps non-chat models with their type, maps MIME modalities, and skips malformed models", () => Effect.gen(function* () { const cache = makeCache() diff --git a/packages/core/test/session-runner.test.ts b/packages/core/test/session-runner.test.ts index ebddaab97d59..04f41004b2b3 100644 --- a/packages/core/test/session-runner.test.ts +++ b/packages/core/test/session-runner.test.ts @@ -2084,9 +2084,7 @@ describe("SessionRunnerLLM", () => { expect(userTexts(last)).toEqual(["First", "Fourth"]) expect(last.system.map((part) => part.text).join("\n")).not.toContain("Entered mode") // Clients still see every message; only the model context hides the stale update. - expect((yield* s.messages).filter((message) => message.type === "system")).toMatchObject([ - { text: "Entered mode" }, - ]) + expect((yield* s.messages).filter((message) => message.type === "system")).toMatchObject([{ text: "Entered mode" }]) }) scenario("uses the selected model family prompt when the agent does not override it", function* (s) { @@ -2564,6 +2562,249 @@ describe("SessionRunnerLLM", () => { ).toEqual(["Replacement context"]) }) + describe("tool changes", () => { + // Anthropic sends system messages mid-conversation only to models that accept them. + const trackedModel = (id = "claude-opus-5-5") => + LanguageModel.make({ + id, + provider: "fake", + route: AnthropicMessages.route, + capabilities: { tools: { updates: ["add", "remove", "replace"] } }, + }) + const markers = (request: LLMRequest | undefined) => + (request?.messages ?? []).flatMap((message) => + message.role === "system" && message.tools ? [message.tools] : [], + ) + const toolNames = (request: LLMRequest | undefined) => request?.tools.map((tool) => tool.name) + const names = (tools: { + readonly add: ReadonlyArray<{ readonly name: string }> + readonly remove: ReadonlyArray + }) => ({ + add: tools.add.map((tool) => tool.name), + remove: tools.remove, + }) + const toolEvents = Effect.gen(function* () { + const { db } = yield* Database.Service + return (yield* db + .select({ data: EventTable.data }) + .from(EventTable) + .where(and(eq(EventTable.aggregate_id, sessionID), eq(EventTable.type, "session.tools.updated.1"))) + .orderBy(asc(EventTable.seq)) + .all() + .pipe(Effect.orDie)).map( + (row) => + row.data as { + readonly add: ReadonlyArray<{ readonly name: string }> + readonly remove: ReadonlyArray + readonly model?: { readonly providerID: string; readonly id: string } + }, + ) + }) + const tool = (name: string, description: string, run?: () => void): ToolInfo => ({ + name, + description, + input: Schema.Struct({}), + output: Schema.Struct({ value: Schema.String }), + execute: () => Effect.sync(() => run?.()).pipe(Effect.as({ output: { value: name } })), + }) + // Offers `lookup` for the first step, then swaps it for `fresh`, as when an MCP server reconnects with new tools. + const swapTools = (s: Scenario, executions: string[] = []) => + Effect.gen(function* () { + const registry = yield* Tool.Service + const scope = yield* Scope.make() + yield* transformTools( + registry, + { lookup: tool("lookup", "Look something up", () => executions.push("lookup")) }, + { codemode: false }, + ).pipe(Scope.provide(scope)) + yield* s.runPrompt("First") + yield* Scope.close(scope, Exit.void) + yield* transformTools( + registry, + { fresh: tool("fresh", "A tool that connected later", () => executions.push("fresh")) }, + { codemode: false }, + ) + }) + const starting = ["defect", "echo", "lookup", "storefail"] + const current = ["defect", "echo", "fresh", "storefail"] + + scenario("sends the same tools as before on models without tool updates", function* (s) { + yield* swapTools(s) + yield* s.runPrompt("Second") + + expect(s.requests.map(toolNames)).toEqual([starting, current]) + expect(s.requests.map(markers)).toEqual([[], []]) + expect(yield* toolEvents).toEqual([]) + expect((yield* s.messages).filter((message) => message.type === "system")).toEqual([]) + }) + + scenario("keeps the starting tools and sends a later change in place", function* (s) { + s.currentModel = trackedModel() + yield* swapTools(s) + yield* s.runPrompt("Second") + yield* s.runPrompt("Third") + + expect(s.requests.map(toolNames)).toEqual([starting, starting, starting]) + expect(markers(s.requests[0])).toEqual([]) + expect(markers(s.requests[1]).map(names)).toEqual([{ add: ["fresh"], remove: ["lookup"] }]) + expect(s.requests[1]?.messages.at(-1)?.role).toBe("system") + // The recorded change replays where it was sent, so the next request extends the same prefix. + const sent = s.requests[1]!.messages + expect(s.requests[2]?.messages.slice(0, sent.length)).toEqual([...sent]) + expect(markers(s.requests[2])).toEqual(markers(s.requests[1])) + expect(s.requests[2]?.system).toEqual(s.requests[0]?.system) + const [first, second, third] = yield* Effect.forEach(s.requests, (request) => compileRequest(request)) + expect(second?.body).toMatchObject({ + tools: starting.map((name) => ({ name })), + messages: expect.arrayContaining([ + { + role: "system", + content: [ + expect.objectContaining({ type: "tool_addition" }), + expect.objectContaining({ type: "tool_removal" }), + ], + }, + ]), + }) + expect((third?.body as { tools: unknown }).tools).toEqual((first?.body as { tools: unknown }).tools) + + const events = yield* toolEvents + expect(events.map((event) => [names(event), event.model])).toEqual([ + // The request log leaves out the Code Mode tool; the recorded baseline keeps it. + [ + { add: [...starting, "execute"], remove: [] }, + { providerID: "fake", id: "claude-opus-5-5" }, + ], + [{ add: ["fresh"], remove: ["lookup"] }, undefined], + ]) + // The changes are hidden history: their messages hold no text, and replaying the events restores them. + const recorded = (yield* s.messages).filter((message) => message.type === "system") + expect(recorded.map((message) => message.type === "system" && message.text)).toEqual(["", ""]) + yield* replaySessionProjection(sessionID) + expect((yield* s.messages).filter((message) => message.type === "system")).toEqual(recorded) + }) + + scenario("runs an added tool and refuses a removed one", function* (s) { + s.currentModel = trackedModel() + const executions: string[] = [] + yield* swapTools(s, executions) + yield* s.admit("Second") + yield* s.llm.push( + TestLLM.toolCall("call-lookup", "lookup", {}), + TestLLM.toolCall("call-fresh", "fresh", {}), + TestLLM.text("Done", "text-done"), + ) + yield* s.resume + + expect(executions).toEqual(["fresh"]) + const calls = (yield* s.context).flatMap((message) => + message.type === "assistant" ? message.content.filter((part) => part.type === "tool") : [], + ) + expect(calls.map((call) => [call.name, call.state.status])).toEqual([ + ["lookup", "error"], + ["fresh", "completed"], + ]) + }) + + scenario("declares the current tools again after a compaction", function* (s) { + s.currentModel = trackedModel() + yield* swapTools(s) + yield* s.runPrompt("Second") + yield* s.llm.push(TestLLM.text("## Objective\n- summary", "tools-summary")) + yield* s.session.compact({ sessionID }) + yield* s.resume + yield* s.runPrompt("Third") + + // The summary request continues the epoch it summarizes. + expect(toolNames(s.requests[2])).toEqual(starting) + expect(markers(s.requests[2]).map(names)).toEqual([{ add: ["fresh"], remove: ["lookup"] }]) + // Provider checkpoints don't keep tools added mid-conversation, so the next request starts over from them. + expect(toolNames(s.requests[3])).toEqual(current) + expect(markers(s.requests[3])).toEqual([]) + expect((yield* toolEvents).map((event) => event.model !== undefined)).toEqual([true, false, true]) + }) + + scenario("starts over for another model but not for a variant", function* (s) { + s.currentModel = trackedModel() + yield* swapTools(s) + yield* s.runPrompt("Second") + yield* s.bus.publish(SessionEvent.ModelSelected, { + sessionID, + model: { + id: ID.make("claude-opus-5-5"), + providerID: Provider.ID.make("fake"), + variant: Model.VariantID.make("high"), + }, + }) + yield* s.runPrompt("Third") + s.currentModel = trackedModel("claude-sonnet-5-5") + yield* s.runPrompt("Fourth") + s.currentModel = trackedModel() + yield* s.runPrompt("Fifth") + + expect(s.requests.slice(0, 3).map(toolNames)).toEqual([starting, starting, starting]) + expect(markers(s.requests[2])).toEqual(markers(s.requests[1])) + expect(toolNames(s.requests[3])).toEqual(current) + expect(markers(s.requests[3])).toEqual([]) + // Coming back starts another epoch: the latest one was shaped for the other model. + expect(toolNames(s.requests[4])).toEqual(current) + expect(markers(s.requests[4])).toEqual([]) + expect((yield* toolEvents).map((event) => event.model?.id)).toEqual([ + "claude-opus-5-5", + undefined, + "claude-sonnet-5-5", + "claude-opus-5-5", + ]) + }) + + scenario("drops the changes for a model without tool updates and resumes them after", function* (s) { + s.currentModel = trackedModel() + yield* swapTools(s) + yield* s.runPrompt("Second") + s.currentModel = model + yield* s.runPrompt("Third") + s.currentModel = trackedModel() + yield* s.runPrompt("Fourth") + + expect(toolNames(s.requests[2])).toEqual(current) + expect(markers(s.requests[2])).toEqual([]) + expect(toolNames(s.requests[3])).toEqual(starting) + expect(markers(s.requests[3]).map(names)).toEqual([{ add: ["fresh"], remove: ["lookup"] }]) + expect(yield* toolEvents).toHaveLength(2) + }) + + scenario("replays only the changes a revert keeps", function* (s) { + s.currentModel = trackedModel() + yield* swapTools(s) + const second = yield* s.runPrompt("Second") + yield* s.bus.publish(SessionEvent.RevertEvent.Committed, { sessionID, to: second.id }) + yield* s.runPrompt("Again") + const first = (yield* s.session.messages({ sessionID, order: "asc" })).find((message) => message.type === "user")! + yield* s.bus.publish(SessionEvent.RevertEvent.Committed, { sessionID, to: first.id }) + yield* s.runPrompt("Over") + + // The reverted change is gone, so the same change is recorded again over the kept baseline. + expect(toolNames(s.requests[2])).toEqual(starting) + expect(markers(s.requests[2]).map(names)).toEqual([{ add: ["fresh"], remove: ["lookup"] }]) + // Reverting past the baseline starts over from the tools offered then. + expect(toolNames(s.requests[3])).toEqual(current) + expect(markers(s.requests[3])).toEqual([]) + expect((yield* toolEvents).map((event) => event.model !== undefined)).toEqual([true, false, false, true]) + }) + + scenario("carries the parent's tool changes into a fork", function* (s) { + s.currentModel = trackedModel() + yield* swapTools(s) + yield* s.runPrompt("Second") + const forked = yield* s.session.fork({ sessionID }) + yield* s.session.prompt({ sessionID: forked.id, text: "Forked", resume: false }) + yield* s.session.resume(forked.id) + + expect(toolNames(s.requests.at(-1))).toEqual(starting) + expect(markers(s.requests.at(-1))).toEqual(markers(s.requests[1])) + }) + }) + for (const order of ["before", "between", "after"] as const) { scenario(`prioritizes manual compaction admitted ${order} two steers at the safe boundary`, function* (s) { s.currentModel = recoveryModel diff --git a/packages/core/test/session-tool-changes.test.ts b/packages/core/test/session-tool-changes.test.ts new file mode 100644 index 000000000000..7092eacdd59f --- /dev/null +++ b/packages/core/test/session-tool-changes.test.ts @@ -0,0 +1,146 @@ +import { describe, expect, test } from "bun:test" +import { LanguageModel, ToolDefinition } from "@opencode/ai/effect" +import { AnthropicMessages } from "@opencode/ai/protocols" +import { OpenAIChat } from "@opencode/ai/protocols/openai-chat" +import { DateTime } from "effect" +import { Model } from "@opencode/core/model" +import { Provider } from "@opencode/core/provider" +import { SessionMessage } from "@opencode/core/session/message" +import { SessionToolChanges } from "@opencode/core/session/tool-changes" +import type { Tool } from "@opencode/schema/tool" + +const ref = Model.Ref.make({ providerID: Provider.ID.make("anthropic"), id: Model.ID.make("claude") }) +const tracked = { + ref, + model: LanguageModel.make({ + id: "claude", + provider: "anthropic", + route: AnthropicMessages.route, + capabilities: { tools: { updates: ["add", "remove", "replace"] } }, + }), +} +const untracked = { ref, model: LanguageModel.make({ id: "claude", provider: "anthropic", route: OpenAIChat.route }) } + +const tool = (name: string, description = `The ${name} tool`, properties: Record = {}) => + ToolDefinition.make({ name, description, inputSchema: { type: "object", properties } }) +const stored = (tool: ToolDefinition): Tool.Definition => ({ + name: tool.name, + description: tool.description, + inputSchema: tool.inputSchema, +}) + +let seq = 0 +const marker = (tools: SessionMessage.System["tools"]) => + SessionMessage.System.make({ + id: SessionMessage.ID.make(`msg_tools_${seq++}`), + type: "system", + text: "", + tools, + time: { created: DateTime.makeUnsafe(0) }, + }) +const user = (text: string) => + SessionMessage.User.make({ + id: SessionMessage.ID.make(`msg_user_${seq++}`), + type: "user", + text, + time: { created: DateTime.makeUnsafe(0) }, + }) +const baseline = (tools: ReadonlyArray, model: Model.Ref = ref) => + marker({ add: tools.map(stored), remove: [], model: { providerID: model.providerID, id: model.id } }) + +const changeFrom = (history: ReadonlyArray, offered: ReadonlyArray) => + SessionToolChanges.plan({ model: tracked, epoch: SessionToolChanges.epoch(history, tracked), offered }).record + +describe("SessionToolChanges", () => { + const [read, edit, write] = [tool("read"), tool("edit"), tool("write")] + const history = [baseline([read, edit]), user("Go")] + + test("starts an epoch from the offered tools, without the variant", () => { + const plan = SessionToolChanges.plan({ + model: { ...tracked, ref: Model.Ref.make({ ...ref, variant: Model.VariantID.make("high") }) }, + epoch: undefined, + offered: [read, edit], + }) + expect(plan.tools).toEqual([read, edit]) + expect(plan.marker).toBeUndefined() + expect(plan.record).toEqual({ add: [stored(read), stored(edit)], remove: [], model: ref }) + }) + + test("records nothing when the tools are unchanged, even reordered", () => { + expect(changeFrom(history, [read, edit])).toBeUndefined() + expect(changeFrom(history, [edit, read])).toBeUndefined() + expect(changeFrom(history, [read, tool("edit", "The edit tool", {})])).toBeUndefined() + }) + + test("diffs additions, removals and redefinitions by name", () => { + expect(changeFrom(history, [read, edit, write])).toEqual({ add: [stored(write)], remove: [] }) + expect(changeFrom(history, [read])).toEqual({ add: [], remove: ["edit"] }) + const edit2 = tool("edit", "Edit, version 2", { path: { type: "string" } }) + expect(changeFrom(history, [read, edit2])).toEqual({ add: [stored(edit2)], remove: [] }) + }) + + test("compares against the folded changes, so a removed tool added again is an addition", () => { + const removed = [...history, marker({ add: [], remove: ["edit"] })] + const epoch = SessionToolChanges.epoch(removed, tracked) + expect(epoch?.baseline).toEqual([stored(read), stored(edit)]) + expect(epoch?.current).toEqual([stored(read)]) + expect(changeFrom(removed, [read])).toBeUndefined() + expect(changeFrom(removed, [read, edit])).toEqual({ add: [stored(edit)], remove: [] }) + }) + + test("declares the baseline and appends the change as a marker", () => { + const plan = SessionToolChanges.plan({ + model: tracked, + epoch: SessionToolChanges.epoch(history, tracked), + offered: [read, write], + }) + expect(plan.tools.map((item) => item.name)).toEqual(["read", "edit"]) + expect(plan.marker?.tools).toEqual({ add: [write], remove: ["edit"] }) + }) + + test("replays changes after the latest baseline only", () => { + const messages = [ + baseline([read]), + marker({ add: [stored(edit)], remove: [] }), + user("Compacted"), + baseline([read, edit]), + user("Go"), + marker({ add: [stored(write)], remove: ["read"] }), + ] + const epoch = SessionToolChanges.epoch(messages, tracked) + expect(epoch?.start).toBe(3) + expect(epoch?.current).toEqual([stored(edit), stored(write)]) + const replayed = messages.map((message, index) => SessionToolChanges.replay(message, index, epoch)) + expect(replayed.map((message) => message?.tools)).toEqual([ + undefined, + undefined, + undefined, + undefined, + undefined, + { add: [write], remove: ["read"] }, + ]) + // The same history replays the same marker every time. + expect(SessionToolChanges.replay(messages[5]!, 5, epoch)).toEqual(replayed[5]) + }) + + test("ends the epoch when the latest baseline is for another model", () => { + const other = Model.Ref.make({ providerID: Provider.ID.make("anthropic"), id: Model.ID.make("other") }) + expect(SessionToolChanges.epoch([baseline([read], other), user("Go")], tracked)).toBeUndefined() + expect(SessionToolChanges.epoch([baseline([read]), user("Go"), baseline([read], other)], tracked)).toBeUndefined() + }) + + test("leaves models without tool updates alone", () => { + expect(SessionToolChanges.tracked(untracked.model)).toBe(false) + expect(SessionToolChanges.epoch(history, untracked)).toBeUndefined() + const plan = SessionToolChanges.plan({ model: untracked, epoch: undefined, offered: [edit, read] }) + expect(plan).toEqual({ tools: [edit, read] }) + // A capability the route can't encode doesn't count either. + const chat = LanguageModel.make({ + id: "claude", + provider: "anthropic", + route: OpenAIChat.route, + capabilities: { tools: { updates: ["add"] } }, + }) + expect(SessionToolChanges.tracked(chat)).toBe(false) + }) +}) diff --git a/packages/schema/src/model-compatibility.ts b/packages/schema/src/model-compatibility.ts index 93990c96a099..5ee17074787d 100644 --- a/packages/schema/src/model-compatibility.ts +++ b/packages/schema/src/model-compatibility.ts @@ -22,6 +22,10 @@ export type MediaInput = typeof MediaInput.Type export const CacheFormat = Schema.Literals(["anthropic", "alibaba"]).annotate({ identifier: "Model.CacheFormat" }) export type CacheFormat = typeof CacheFormat.Type +/** A tool change a model accepts in place, from models.dev `capabilities.tools.updates`. */ +export const ToolUpdate = Schema.Literals(["add", "remove", "replace"]).annotate({ identifier: "Model.ToolUpdate" }) +export type ToolUpdate = typeof ToolUpdate.Type + export interface Compatibility extends Schema.Schema.Type {} export const Compatibility = Schema.Struct({ /** OpenAI Chat: assistant-message field that carries reasoning. Unset uses the streamed field, else `reasoning_content`. */ @@ -44,6 +48,8 @@ export const Compatibility = Schema.Struct({ supportsThinkingBlockBinding: Schema.Boolean.pipe(optional), /** Anthropic Messages and OpenAI Responses: supports per-message effort updates. Overrides model-ID detection. */ supportsEffortUpdates: Schema.Boolean.pipe(optional), + /** Anthropic Messages and OpenAI Responses: tool changes the model accepts mid-conversation without resending its tools. Empty sends every change as a new tool list. */ + supportsToolUpdates: Schema.Array(ToolUpdate).pipe(optional), /** System One: where the decision host reads media. Unset keeps the route default. */ mediaInput: MediaInput.pipe(optional), }).annotate({ identifier: "Model.Compatibility" }) @@ -51,5 +57,5 @@ export const Compatibility = Schema.Struct({ // Provider defaults inherited by its models. Model-version features stay model-only. export interface ProviderCompatibility extends Schema.Schema.Type {} export const ProviderCompatibility = Schema.Struct( - Struct.omit(Compatibility.fields, ["supportsThinkingBlockBinding", "supportsEffortUpdates"]), + Struct.omit(Compatibility.fields, ["supportsThinkingBlockBinding", "supportsEffortUpdates", "supportsToolUpdates"]), ).annotate({ identifier: "Provider.Compatibility" }) diff --git a/packages/schema/src/session-event.ts b/packages/schema/src/session-event.ts index ee3a2393f757..daa80d3f00da 100644 --- a/packages/schema/src/session-event.ts +++ b/packages/schema/src/session-event.ts @@ -4,7 +4,7 @@ import { Schema } from "effect" import { optional } from "./schema.js" import { Event } from "./event.js" import { FinishReason } from "./llm.js" -import { Content } from "./tool.js" +import { Changes, Content } from "./tool.js" import { Model } from "./model.js" import { NonNegativeInt, PositiveInt, RelativePath } from "./schema.js" import { SessionID } from "./session-id.js" @@ -169,6 +169,21 @@ export const UsageRecorded = Event.durable({ }) export type UsageRecorded = typeof UsageRecorded.Type +/** + * The tools offered to the model changed before a step. With `model`, `add` is the whole set offered to that model + * from here on, which later changes build on. Recorded only for models that take tool changes in place. + */ +export const ToolsUpdated = Event.durable({ + type: "session.tools.updated", + ...options, + schema: { + ...Base, + ...Changes.fields, + model: Model.Ref.pipe(optional), + }, +}) +export type ToolsUpdated = typeof ToolsUpdated.Type + export const UsageUpdated = Event.ephemeral({ type: "session.usage.updated", schema: { @@ -722,6 +737,7 @@ export const DurableDefinitions = Event.inventory( ...Definitions.filter((definition) => definition.durability === "durable"), UsageRecorded, MessageContentUpdated, + ToolsUpdated, ) export const EphemeralDefinitions = Event.inventory( ...Definitions.filter((definition) => definition.durability === "ephemeral"), diff --git a/packages/schema/src/session-message.ts b/packages/schema/src/session-message.ts index 5c1755c45ec1..29cd634948b8 100644 --- a/packages/schema/src/session-message.ts +++ b/packages/schema/src/session-message.ts @@ -2,7 +2,7 @@ export * as SessionMessage from "./session-message.js" import { Schema } from "effect" import { optional } from "./schema.js" -import { Content } from "./tool.js" +import { Content, Tool } from "./tool.js" import { Location } from "./location.js" import { Model } from "./model.js" import { Project } from "./project.js" @@ -106,6 +106,11 @@ export const System = Schema.Struct({ text: Schema.String, /** A short human-readable summary for transcript display. */ description: Schema.String.pipe(optional), + /** + * A change to the tools the model is offered, recorded where it happened; `text` is empty. With `model`, `add` is + * the whole set offered to that model from here on. Model context only, not shown in transcripts. + */ + tools: Schema.Struct({ ...Tool.Changes.fields, model: Model.Ref.pipe(optional) }).pipe(optional), }).annotate({ identifier: "Session.Message.System" }) export interface Skill extends Schema.Schema.Type {} diff --git a/packages/schema/src/tool.ts b/packages/schema/src/tool.ts index c2f9f017d29e..01725c739fe4 100644 --- a/packages/schema/src/tool.ts +++ b/packages/schema/src/tool.ts @@ -5,6 +5,7 @@ import type { StandardSchemaV1 } from "@standard-schema/spec" import type { Agent } from "./agent.js" import type { Session } from "./session.js" import type { SessionMessage } from "./session-message.js" +import { optional } from "./schema.js" export type Metadata = Readonly> @@ -20,6 +21,24 @@ export const FreeformFormat = Schema.Literals(Freeform.members.map((member) => m identifier: "Tool.FreeformFormat", }) +/** A tool as a model request declares it. */ +export const Definition = Schema.Struct({ + name: Schema.String, + description: Schema.String, + inputSchema: Schema.Record(Schema.String, Schema.Unknown), + outputSchema: Schema.Record(Schema.String, Schema.Unknown).pipe(optional), + freeform: Freeform.pipe(optional), + native: Schema.Record(Schema.String, Schema.Unknown).pipe(optional), +}).annotate({ identifier: "Tool.Definition" }) +export interface Definition extends Schema.Schema.Type {} + +/** A change to the tools a model is offered: tools added or redefined in full, and names withdrawn. */ +export const Changes = Schema.Struct({ + add: Schema.Array(Definition), + remove: Schema.Array(Schema.String), +}).annotate({ identifier: "Tool.Changes" }) +export interface Changes extends Schema.Schema.Type {} + export const CallID = Schema.String.pipe(Schema.brand("Tool.CallID")) export type CallID = typeof CallID.Type diff --git a/packages/schema/test/event-manifest.test.ts b/packages/schema/test/event-manifest.test.ts index c766ea8b3d4f..b399ff38e4db 100644 --- a/packages/schema/test/event-manifest.test.ts +++ b/packages/schema/test/event-manifest.test.ts @@ -127,6 +127,7 @@ describe("public event manifest", () => { "session.unarchived.1", "session.message.content.updated.1", "session.usage.recorded.1", + "session.tools.updated.1", "session.forked.2", "session.inbox.delivered.1", "session.inbox.enqueued.1", @@ -169,7 +170,10 @@ describe("public event manifest", () => { ...SessionEvent.Definitions.filter((definition) => definition.durability === "durable"), SessionEvent.UsageRecorded, SessionEvent.MessageContentUpdated, + SessionEvent.ToolsUpdated, ]) + expect(EventManifest.Durable.get("session.tools.updated.1")).toBe(SessionEvent.ToolsUpdated) + expect(EventManifest.ServerDefinitions).not.toContain(SessionEvent.ToolsUpdated) expect(SessionEvent.UsageRecorded.durability).toBe("durable") expect(EventManifest.Durable.get("session.usage.recorded.1")).toBe(SessionEvent.UsageRecorded) expect(SessionEvent.Definitions).not.toContain(SessionEvent.UsageRecorded) From 3c2dc1fe4b4ee60ec5ebe2d229fab120bd515b28 Mon Sep 17 00:00:00 2001 From: Aiden Cline Date: Tue, 17 Nov 2026 01:00:28 -0600 Subject: [PATCH 2/6] chore(protocol): regenerate OpenAPI document --- packages/protocol/openapi.json | 167 +++++++++++++++++++++++++++++++++ 1 file changed, 167 insertions(+) diff --git a/packages/protocol/openapi.json b/packages/protocol/openapi.json index 1e241a9bfa20..77d87b88e204 100644 --- a/packages/protocol/openapi.json +++ b/packages/protocol/openapi.json @@ -21463,6 +21463,12 @@ "supportsEffortUpdates": { "type": "boolean" }, + "supportsToolUpdates": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Model.ToolUpdate" + } + }, "mediaInput": { "$ref": "#/components/schemas/Model.MediaInput" } @@ -21678,6 +21684,10 @@ } ] }, + "Model.ToolUpdate": { + "type": "string", + "enum": ["add", "remove", "replace"] + }, "Model.Type": { "anyOf": [ { @@ -23448,6 +23458,9 @@ }, { "$ref": "#/components/schemas/session.message.content.updated" + }, + { + "$ref": "#/components/schemas/session.tools.updated" } ] }, @@ -24633,6 +24646,28 @@ }, "description": { "type": "string" + }, + "tools": { + "type": "object", + "properties": { + "add": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Tool.Definition" + } + }, + "remove": { + "type": "array", + "items": { + "type": "string" + } + }, + "model": { + "$ref": "#/components/schemas/Model.Ref" + } + }, + "required": ["add", "remove"], + "additionalProperties": false } }, "required": ["id", "time", "type", "text"], @@ -25535,6 +25570,31 @@ } ] }, + "Tool.Definition": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "description": { + "type": "string" + }, + "inputSchema": { + "type": "object" + }, + "outputSchema": { + "type": "object" + }, + "freeform": { + "$ref": "#/components/schemas/Tool.Freeform" + }, + "native": { + "type": "object" + } + }, + "required": ["name", "description", "inputSchema"], + "additionalProperties": false + }, "Tool.FileContent": { "type": "object", "properties": { @@ -25562,6 +25622,49 @@ "required": ["type", "uri", "mime"], "additionalProperties": false }, + "Tool.Freeform": { + "anyOf": [ + { + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": ["text"] + } + }, + "required": ["type"], + "additionalProperties": false + }, + { + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": ["regex"] + }, + "pattern": { + "type": "string" + } + }, + "required": ["type", "pattern"], + "additionalProperties": false + }, + { + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": ["lark"] + }, + "grammar": { + "type": "string" + } + }, + "required": ["type", "grammar"], + "additionalProperties": false + } + ] + }, "Tool.FreeformFormat": { "type": "string", "enum": ["text", "regex", "lark"] @@ -30669,6 +30772,70 @@ "required": ["id", "created", "type", "durable", "data"], "additionalProperties": false }, + "session.tools.updated": { + "type": "object", + "properties": { + "id": { + "$ref": "#/components/schemas/Event.ID" + }, + "created": { + "type": "number" + }, + "metadata": { + "type": "object" + }, + "type": { + "type": "string", + "enum": ["session.tools.updated"] + }, + "durable": { + "type": "object", + "properties": { + "aggregateID": { + "type": "string" + }, + "seq": { + "$ref": "#/components/schemas/Event.Seq" + }, + "version": { + "$ref": "#/components/schemas/Event.VersionEncoded_c77c5abcb68d" + } + }, + "required": ["aggregateID", "seq", "version"], + "additionalProperties": false + }, + "location": { + "$ref": "#/components/schemas/Location.Ref" + }, + "data": { + "type": "object", + "properties": { + "sessionID": { + "$ref": "#/components/schemas/Session.ID" + }, + "add": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Tool.Definition" + } + }, + "remove": { + "type": "array", + "items": { + "type": "string" + } + }, + "model": { + "$ref": "#/components/schemas/Model.Ref" + } + }, + "required": ["sessionID", "add", "remove"], + "additionalProperties": false + } + }, + "required": ["id", "created", "type", "durable", "data"], + "additionalProperties": false + }, "session.unarchived": { "type": "object", "properties": { From cef8caa03249c1838f351da9be5654556cb49f2a Mon Sep 17 00:00:00 2001 From: Aiden Cline Date: Tue, 17 Nov 2026 11:27:06 -0600 Subject: [PATCH 3/6] refactor(core): simplify how tool changes are stored and hidden --- packages/client/src/solid/data.ts | 7 +--- packages/client/test/solid-data.test.ts | 44 --------------------- packages/core/src/config/plugin/provider.ts | 11 ++++-- packages/core/src/session/store.ts | 10 ++++- packages/core/src/session/tool-changes.ts | 10 +++-- packages/core/src/session/transfer.ts | 4 +- packages/core/test/session-runner.test.ts | 8 ++-- packages/core/test/session-store.test.ts | 31 +++++++++++++++ 8 files changed, 65 insertions(+), 60 deletions(-) diff --git a/packages/client/src/solid/data.ts b/packages/client/src/solid/data.ts index 650082ad14e5..8b6d247dc965 100644 --- a/packages/client/src/solid/data.ts +++ b/packages/client/src/solid/data.ts @@ -210,9 +210,6 @@ function omitMessageFileData(message: SessionMessageInfo): SessionMessageInfo { } } -// Tool changes are model context the server keeps with the history; transcripts don't show them. -const transcript = (message: SessionMessageInfo) => message.type !== "system" || message.tools === undefined - function formRequestOptions(sessionID: string, ref?: LocationRef) { if (sessionID !== "global" || !ref) return undefined return { @@ -1891,7 +1888,7 @@ export function createData(config: CreateDataInput) { }) .catch(evictMissing) if ((deletedAt.get(sessionID) ?? 0) > started) return - const fetched = response.data.filter(transcript).toReversed().map(stored) + const fetched = response.data.toReversed().map(stored) // Same protection as the pending sync: a re-fetch racing an // admission must not wipe its local transcript row. const ids = new Set(fetched.map((item) => item.id)) @@ -1966,7 +1963,7 @@ export function createData(config: CreateDataInput) { { signal }, ) if (signal?.aborted) return - fetched.push(...response.data.filter(transcript).map(stored)) + fetched.push(...response.data.map(stored)) next = response.cursor.next ?? undefined if (!options?.all) break } while (next) diff --git a/packages/client/test/solid-data.test.ts b/packages/client/test/solid-data.test.ts index 7235a00f8ec0..b040e634d595 100644 --- a/packages/client/test/solid-data.test.ts +++ b/packages/client/test/solid-data.test.ts @@ -52,50 +52,6 @@ test("uses the configured initial window and retains normal cursor page sizes", } }) -test("leaves recorded tool changes out of the transcript", async () => { - const tools = (id: string, created: number) => ({ - id, - type: "system", - text: "", - tools: { add: [{ name: "lookup", description: "Look up", inputSchema: {} }], remove: [] }, - time: { created }, - }) - const api = OpenCode.make({ - baseUrl: "http://opencode.local", - fetch: async (input, init) => { - const url = new URL((input instanceof Request ? input : new Request(input, init)).url) - const cursor = url.searchParams.get("cursor") - return Response.json( - cursor - ? { data: [tools("msg_1", 1)], cursor: {} } - : { - data: [ - { id: "msg_4", type: "system", text: "Instructions changed", time: { created: 4 } }, - tools("msg_3", 3), - { id: "msg_2", type: "user", text: "History", time: { created: 2 } }, - ], - cursor: { next: "older" }, - }, - ) - }, - }) - const setup = createRoot((dispose) => ({ - data: createData({ - api: () => api, - directory: "/project", - event: { on: () => () => {}, listen: () => () => {} }, - }), - dispose, - })) - try { - await setup.data.session.message.sync("ses_refresh") - await setup.data.session.message.loadMore("ses_refresh") - expect(setup.data.session.message.list("ses_refresh").map((message) => message.id)).toEqual(["msg_2", "msg_4"]) - } finally { - setup.dispose() - } -}) - test("counts every subagent page in a root session's cost", async () => { const child = (index: number): SessionInfo => ({ ...session(0), diff --git a/packages/core/src/config/plugin/provider.ts b/packages/core/src/config/plugin/provider.ts index ee9b2cf0e2f9..c4c552b4ae88 100644 --- a/packages/core/src/config/plugin/provider.ts +++ b/packages/core/src/config/plugin/provider.ts @@ -7,7 +7,6 @@ import { Document, type Entry } from "@opencode/schema/config" import { ConfigProvider } from "@opencode/schema/config/provider" import { Money } from "@opencode/schema/money" import { Effect } from "effect" -import { castDraft } from "immer" import { Config } from "../../config.js" import { Model } from "../../model.js" import { Provider } from "../../provider.js" @@ -226,8 +225,14 @@ function overlay( if (config.name) model.name = config.name if (config.modelID !== undefined) model.modelID = config.modelID if (config.releaseDate !== undefined) model.time = { released: Date.parse(config.releaseDate) } - if (config.compatibility !== undefined) - model.compatibility = castDraft({ ...model.compatibility, ...config.compatibility }) + if (config.compatibility !== undefined) { + const { supportsToolUpdates, ...compatibility } = config.compatibility + model.compatibility = { + ...model.compatibility, + ...compatibility, + ...(supportsToolUpdates === undefined ? {} : { supportsToolUpdates: [...supportsToolUpdates] }), + } + } if (config.package !== undefined) model.package = config.package if (config.settings !== undefined) model.settings = Provider.mergeOverlay(model.settings, config.settings) if (config.headers !== undefined) model.headers = Provider.mergeHeaders(model.headers, config.headers) diff --git a/packages/core/src/session/store.ts b/packages/core/src/session/store.ts index 4eb1ee2e8382..79ca479788e7 100644 --- a/packages/core/src/session/store.ts +++ b/packages/core/src/session/store.ts @@ -1,6 +1,6 @@ export * as SessionStore from "./store.js" -import { and, asc, desc, eq, gt, isNotNull, isNull, lt, notInArray, or, sql, type SQL } from "drizzle-orm" +import { and, asc, desc, eq, gt, isNotNull, isNull, lt, ne, notInArray, or, sql, type SQL } from "drizzle-orm" import { Context, Effect, Layer, Schema } from "effect" import { Project } from "@opencode/schema/project" import { Workspace } from "@opencode/schema/workspace" @@ -45,6 +45,8 @@ export type MessagesInput = { limit?: number order?: "asc" | "desc" type?: SessionMessage.Type + /** Include the hidden system messages that record tool changes. Only session export needs them. */ + toolChanges?: boolean cursor?: { id: SessionMessage.ID direction: "previous" | "next" @@ -134,6 +136,12 @@ const layer = Layer.effect( eq(SessionMessageTable.session_id, input.sessionID), boundary, input.type === undefined ? undefined : eq(SessionMessageTable.type, input.type), + input.toolChanges + ? undefined + : or( + ne(SessionMessageTable.type, "system"), + sql`json_extract(${SessionMessageTable.data}, '$.tools') IS NULL`, + ), ), ) .orderBy(order === "asc" ? asc(SessionMessageTable.seq) : desc(SessionMessageTable.seq)) diff --git a/packages/core/src/session/tool-changes.ts b/packages/core/src/session/tool-changes.ts index ab7a8d3af117..76215c1420ee 100644 --- a/packages/core/src/session/tool-changes.ts +++ b/packages/core/src/session/tool-changes.ts @@ -55,8 +55,7 @@ export const epoch = ( export const replay = (message: SessionMessage.Info, index: number, epoch: Epoch | undefined) => { const recorded = changes(message) if (recorded === undefined || epoch === undefined || index <= epoch.start) return undefined - // Without the message ID, so it matches the marker the recording step sent. - return Message.make(Message.tools({ add: recorded.add.map(ToolDefinition.make), remove: recorded.remove })) + return marker(recorded) } /** Compares the offered tools with the epoch's and decides what the request declares. */ @@ -86,11 +85,16 @@ export const plan = (input: { if (change.add.length === 0 && change.remove.length === 0) return { tools } return { tools, - marker: Message.make(Message.tools({ add: change.add.map(ToolDefinition.make), remove: change.remove })), + marker: marker(change), record: change, } } +// The one place a change becomes a request message, so the step that records it and every later replay send the +// same bytes. No message ID, since the recording step has none yet. +const marker = (change: Tool.Changes) => + Message.make(Message.tools({ add: change.add.map(ToolDefinition.make), remove: change.remove })) + const changes = (message: SessionMessage.Info | undefined) => (message?.type === "system" ? message.tools : undefined) /** Removals first, then additions replace a same-named tool in place or append, as the AI package folds them. */ diff --git a/packages/core/src/session/transfer.ts b/packages/core/src/session/transfer.ts index f5606770b6a6..0c6742a10dfd 100644 --- a/packages/core/src/session/transfer.ts +++ b/packages/core/src/session/transfer.ts @@ -61,7 +61,9 @@ const layer = Layer.effect( export: Effect.fn("SessionTransfer.export")(function* (input) { const data = { info: yield* sessions.get(input.sessionID), - messages: (yield* sessions.messages({ sessionID: input.sessionID, order: "asc" })).filter(isSettled), + messages: (yield* sessions.messages({ sessionID: input.sessionID, order: "asc", toolChanges: true })).filter( + isSettled, + ), } return input.sanitize ? sanitize(data) : data }), diff --git a/packages/core/test/session-runner.test.ts b/packages/core/test/session-runner.test.ts index 04f41004b2b3..b9e404c4606c 100644 --- a/packages/core/test/session-runner.test.ts +++ b/packages/core/test/session-runner.test.ts @@ -2677,11 +2677,13 @@ describe("SessionRunnerLLM", () => { ], [{ add: ["fresh"], remove: ["lookup"] }, undefined], ]) - // The changes are hidden history: their messages hold no text, and replaying the events restores them. - const recorded = (yield* s.messages).filter((message) => message.type === "system") + // The changes are hidden history: the model context holds them with no text, the message listing leaves them + // out, and replaying the events restores them. + const recorded = (yield* s.context).filter((message) => message.type === "system") expect(recorded.map((message) => message.type === "system" && message.text)).toEqual(["", ""]) + expect((yield* s.messages).filter((message) => message.type === "system")).toEqual([]) yield* replaySessionProjection(sessionID) - expect((yield* s.messages).filter((message) => message.type === "system")).toEqual(recorded) + expect((yield* s.context).filter((message) => message.type === "system")).toEqual(recorded) }) scenario("runs an added tool and refuses a removed one", function* (s) { diff --git a/packages/core/test/session-store.test.ts b/packages/core/test/session-store.test.ts index a69b0851e0b6..e8f40afb74f9 100644 --- a/packages/core/test/session-store.test.ts +++ b/packages/core/test/session-store.test.ts @@ -280,6 +280,37 @@ describe("SessionStore", () => { }), ) + it.effect("leaves recorded tool changes out of the message listing unless asked for them", () => + Effect.gen(function* () { + const sessionID = Session.ID.make("ses_tool_changes") + const bus = yield* seedSessions([{ id: sessionID, updated: 0 }]) + const store = yield* SessionStore.Service + yield* bus.publish(SessionEvent.Synthetic, { sessionID, text: "before" }, { id: Event.ID.make("evt_before") }) + yield* bus.publish( + SessionEvent.ToolsUpdated, + { sessionID, add: [{ name: "read", description: "Read a file.", inputSchema: {} }], remove: [] }, + { id: Event.ID.make("evt_tools") }, + ) + yield* bus.publish(SessionEvent.Synthetic, { sessionID, text: "after" }, { id: Event.ID.make("evt_after") }) + + expect((yield* store.messages({ sessionID, order: "asc" })).map((message) => String(message.id))).toEqual([ + "msg_before", + "msg_after", + ]) + expect( + (yield* store.messages({ + sessionID, + order: "asc", + limit: 1, + cursor: { id: SessionMessage.ID.make("msg_before"), direction: "next" }, + })).map((message) => String(message.id)), + ).toEqual(["msg_after"]) + expect( + (yield* store.messages({ sessionID, order: "asc", toolChanges: true })).map((message) => String(message.id)), + ).toEqual(["msg_before", "msg_tools", "msg_after"]) + }), + ) + it.effect("hydrates and settles assistant messages across session_part rows and legacy inline content rows", () => Effect.gen(function* () { const sessionID = Session.ID.make("ses_dual_read") From 704a23662d1feb8cf376953c833778d83ee41bbb Mon Sep 17 00:00:00 2001 From: Aiden Cline Date: Tue, 17 Nov 2026 12:08:45 -0600 Subject: [PATCH 4/6] fix(core): only treat changes the provider sees as tool changes --- packages/client/src/effect/api/api.ts | 1 - packages/client/src/promise/generated/types.ts | 2 -- packages/core/src/session/tool-changes.ts | 3 +-- packages/core/test/session-tool-changes.test.ts | 5 +++++ packages/protocol/openapi.json | 3 --- packages/schema/src/tool.ts | 1 - 6 files changed, 6 insertions(+), 9 deletions(-) diff --git a/packages/client/src/effect/api/api.ts b/packages/client/src/effect/api/api.ts index 92258337568c..5f0c5a99e08e 100644 --- a/packages/client/src/effect/api/api.ts +++ b/packages/client/src/effect/api/api.ts @@ -1449,7 +1449,6 @@ export type ExperimentalSessionLogOutput = readonly name: string readonly description: string readonly inputSchema: { readonly [x: string]: unknown } - readonly outputSchema?: { readonly [x: string]: unknown } | undefined readonly freeform?: | ( | { readonly type: "text" } diff --git a/packages/client/src/promise/generated/types.ts b/packages/client/src/promise/generated/types.ts index c38b2b1f306e..acd2170b6148 100644 --- a/packages/client/src/promise/generated/types.ts +++ b/packages/client/src/promise/generated/types.ts @@ -524,7 +524,6 @@ export type ToolDefinition = { name: string description: string inputSchema: { [x: string]: JsonValue } - outputSchema?: { [x: string]: JsonValue } freeform?: ToolFreeform native?: { [x: string]: JsonValue } } @@ -533,7 +532,6 @@ export type ToolDefinition1 = { name: string description: string inputSchema: { [x: string]: any } - outputSchema?: { [x: string]: any } freeform?: ToolFreeform native?: { [x: string]: any } } diff --git a/packages/core/src/session/tool-changes.ts b/packages/core/src/session/tool-changes.ts index 76215c1420ee..52efda7fef9f 100644 --- a/packages/core/src/session/tool-changes.ts +++ b/packages/core/src/session/tool-changes.ts @@ -106,12 +106,11 @@ const fold = (tools: ReadonlyArray, change: Tool.Changes | unde return [...kept, ...change.add.filter((tool) => !names.has(tool.name))] } -/** What the provider sees of a tool. */ +// What the provider sees of a tool. An output schema is never sent, so changing one isn't a tool change. const definition = (tool: ToolDefinition): Tool.Definition => ({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema, - ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }), ...(tool.freeform === undefined ? {} : { freeform: tool.freeform }), ...(tool.native === undefined ? {} : { native: tool.native }), }) diff --git a/packages/core/test/session-tool-changes.test.ts b/packages/core/test/session-tool-changes.test.ts index 7092eacdd59f..a83c553873fb 100644 --- a/packages/core/test/session-tool-changes.test.ts +++ b/packages/core/test/session-tool-changes.test.ts @@ -72,6 +72,11 @@ describe("SessionToolChanges", () => { expect(changeFrom(history, [read, tool("edit", "The edit tool", {})])).toBeUndefined() }) + test("ignores a changed output schema, which is never sent", () => { + const withOutput = ToolDefinition.make({ ...edit, outputSchema: { type: "object", properties: { ok: {} } } }) + expect(changeFrom(history, [read, withOutput])).toBeUndefined() + }) + test("diffs additions, removals and redefinitions by name", () => { expect(changeFrom(history, [read, edit, write])).toEqual({ add: [stored(write)], remove: [] }) expect(changeFrom(history, [read])).toEqual({ add: [], remove: ["edit"] }) diff --git a/packages/protocol/openapi.json b/packages/protocol/openapi.json index 77d87b88e204..1fa973fbaf34 100644 --- a/packages/protocol/openapi.json +++ b/packages/protocol/openapi.json @@ -25582,9 +25582,6 @@ "inputSchema": { "type": "object" }, - "outputSchema": { - "type": "object" - }, "freeform": { "$ref": "#/components/schemas/Tool.Freeform" }, diff --git a/packages/schema/src/tool.ts b/packages/schema/src/tool.ts index 01725c739fe4..9a3cfa0ff66a 100644 --- a/packages/schema/src/tool.ts +++ b/packages/schema/src/tool.ts @@ -26,7 +26,6 @@ export const Definition = Schema.Struct({ name: Schema.String, description: Schema.String, inputSchema: Schema.Record(Schema.String, Schema.Unknown), - outputSchema: Schema.Record(Schema.String, Schema.Unknown).pipe(optional), freeform: Freeform.pipe(optional), native: Schema.Record(Schema.String, Schema.Unknown).pipe(optional), }).annotate({ identifier: "Tool.Definition" }) From 4e291495c256bf32a32e458651564dcb1e766941 Mon Sep 17 00:00:00 2001 From: Aiden Cline Date: Tue, 17 Nov 2026 12:11:40 -0600 Subject: [PATCH 5/6] fix(core): place a tool change after a step a crash cut short --- packages/core/src/session/model-request.ts | 9 ++++--- packages/core/src/session/runner/llm.ts | 5 ++-- packages/core/test/session-runner.test.ts | 28 ++++++++++++++++++++++ 3 files changed, 36 insertions(+), 6 deletions(-) diff --git a/packages/core/src/session/model-request.ts b/packages/core/src/session/model-request.ts index f4fe51f159c0..936a59e0f6d6 100644 --- a/packages/core/src/session/model-request.ts +++ b/packages/core/src/session/model-request.ts @@ -91,6 +91,8 @@ export interface Input { readonly toolEpoch?: SessionToolChanges.Epoch readonly system: Array readonly messages: Array + /** An assistant message appended after the history to steer the reply. Hooks see it last; a tool change goes before it. */ + readonly prefill?: Message readonly toolChoice?: LLM.LLMRequestInput["toolChoice"] /** Only the durable runner may use a stateful WebSocket. */ readonly webSocket?: "session" @@ -304,7 +306,7 @@ export const layer = Layer.effect( sessionID: session.id, model: model.ref, system: input.system, - messages: input.messages, + messages: input.prefill ? [...input.messages, input.prefill] : input.messages, options: kind === "primary" ? { maxTokens: outputLimit(model.limit, input.inputTokens, WINDOW_HEADROOM) } @@ -348,8 +350,9 @@ export const layer = Layer.effect( model.model.provider, ), ) - // A change sits where the history ends, which is where it replays once recorded, before any assistant prefill. - const at = messages.findLastIndex((message) => message.role !== "assistant") + 1 + // A change sits where the history ends, which is where it replays once recorded. A trailing assistant message is + // history too (a step a crash cut short), so only the prefill goes after the change. + const at = input.prefill && messages.at(-1)?.role === "assistant" ? messages.length - 1 : messages.length const affinity = SessionAffinity.get(session) const base = ai.request({ model: model.model, diff --git a/packages/core/src/session/runner/llm.ts b/packages/core/src/session/runner/llm.ts index 5e047723993d..6b52ce1310c7 100644 --- a/packages/core/src/session/runner/llm.ts +++ b/packages/core/src/session/runner/llm.ts @@ -274,9 +274,8 @@ const layer = Layer.effect( tools: loaded.tools, toolEpoch: transcript.toolEpoch, system: transcript.system, - messages: stepLimitReached - ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)] - : transcript.messages, + messages: transcript.messages, + prefill: stepLimitReached ? Message.assistant(MAX_STEPS_PROMPT) : undefined, // Keep tool definitions on the final Step to preserve the provider's cached prefix. toolChoice: stepLimitReached ? "none" : undefined, webSocket: "session", diff --git a/packages/core/test/session-runner.test.ts b/packages/core/test/session-runner.test.ts index b9e404c4606c..20d52011fbca 100644 --- a/packages/core/test/session-runner.test.ts +++ b/packages/core/test/session-runner.test.ts @@ -2686,6 +2686,34 @@ describe("SessionRunnerLLM", () => { expect((yield* s.context).filter((message) => message.type === "system")).toEqual(recorded) }) + scenario("places a change after a step a crash cut short, where it replays", function* (s) { + s.currentModel = trackedModel() + yield* swapTools(s) + // A prior process died while streaming the next step: the input was promoted and partial text was stored. + yield* s.admit("Second") + yield* SessionInbox.promote(s.db, s.bus, sessionID, "steer") + const assistantMessageID = SessionMessage.ID.create() + yield* s.bus.publish(SessionEvent.Step.Started, { + sessionID, + assistantMessageID, + agent: Agent.ID.make("build"), + model: { id: ID.make("claude-opus-5-5"), providerID: Provider.ID.make("fake") }, + started: 0, + }) + yield* s.bus.publish(SessionEvent.Text.Started, { sessionID, assistantMessageID, ordinal: 0 }) + yield* s.bus.publish(SessionEvent.Text.Ended, { sessionID, assistantMessageID, ordinal: 0, text: "partial" }) + yield* s.llm.push(TestLLM.text("Done", "text-resumed")) + yield* s.resume + yield* s.runPrompt("Third") + + const [, resumed, next] = s.requests + // The change goes after the cut-short step in both requests, so the next one extends the one before it. + expect(resumed?.messages.at(-1)).toMatchObject({ role: "system", tools: expect.anything() }) + expect(next?.messages.slice(0, resumed?.messages.length)).toEqual([...(resumed?.messages ?? [])]) + expect(markers(next).map(names)).toEqual([{ add: ["fresh"], remove: ["lookup"] }]) + expect(toolNames(next)).toEqual(toolNames(s.requests[0])) + }) + scenario("runs an added tool and refuses a removed one", function* (s) { s.currentModel = trackedModel() const executions: string[] = [] From 79ca495f45d2c554e298d3324be949649f432322 Mon Sep 17 00:00:00 2001 From: Aiden Cline Date: Tue, 17 Nov 2026 17:52:12 -0600 Subject: [PATCH 6/6] fix(core): leave recorded tool changes out of sanitized exports --- packages/core/src/session/transfer.ts | 14 ++++------ packages/core/test/session-create.test.ts | 34 +++++++++++++++++++++++ 2 files changed, 39 insertions(+), 9 deletions(-) diff --git a/packages/core/src/session/transfer.ts b/packages/core/src/session/transfer.ts index 0c6742a10dfd..7b4b385fcfed 100644 --- a/packages/core/src/session/transfer.ts +++ b/packages/core/src/session/transfer.ts @@ -242,7 +242,11 @@ function sanitize(data: Data): Data { } : undefined, }, - messages: data.messages.map(sanitizeMessage), + // Recorded tool changes are left out: redacted definitions would be sent to the provider as real tools, and + // without them the next step records a fresh baseline. + messages: data.messages + .filter((message) => message.type !== "system" || message.tools === undefined) + .map(sanitizeMessage), } } @@ -295,14 +299,6 @@ function sanitizeMessage(message: SessionMessage.Info): SessionMessage.Info { ...message, metadata: meta, text: redact("system", message.id, message.text), - tools: message.tools && { - ...message.tools, - add: message.tools.add.map((tool, index) => ({ - name: tool.name, - description: redact("tool-description", `${message.id}:${index}`, tool.description), - inputSchema: { redacted: `tool-schema:${message.id}:${index}` }, - })), - }, } if (message.type === "skill") return { ...message, metadata: meta, text: redact("skill", message.id, message.text) } if (message.type === "shell") diff --git a/packages/core/test/session-create.test.ts b/packages/core/test/session-create.test.ts index 1701d99de655..5ea45a842182 100644 --- a/packages/core/test/session-create.test.ts +++ b/packages/core/test/session-create.test.ts @@ -1467,6 +1467,40 @@ describe("SessionTransfer", () => { }), ) + it.effect("exports recorded tool changes, and a sanitized export leaves them out", () => + Effect.gen(function* () { + const session = yield* Session.Service + const transfer = yield* SessionTransfer.Service + const template = yield* session.create({ location, title: "Transfer source" }) + const sessionID = Session.ID.create() + const userID = SessionMessage.ID.create() + const toolsID = SessionMessage.ID.create() + const model = Model.Ref.make({ id: Model.ID.make("model"), providerID: Provider.ID.make("provider") }) + + yield* transfer.import({ + data: { + info: { ...template, id: sessionID }, + messages: [ + { + id: toolsID, + type: "system", + text: "", + tools: { add: [{ name: "read", description: "Read a file.", inputSchema: {} }], remove: [], model }, + time: { created: DateTime.makeUnsafe(1) }, + }, + { id: userID, type: "user", text: "Hi", time: { created: DateTime.makeUnsafe(2) } }, + ], + }, + location, + }) + + expect((yield* transfer.export({ sessionID })).messages.map((message) => message.id)).toEqual([toolsID, userID]) + expect((yield* transfer.export({ sessionID, sanitize: true })).messages.map((message) => message.id)).toEqual([ + userID, + ]) + }), + ) + it.effect("imports projected messages and reserves their aggregate sequence", () => Effect.gen(function* () { const session = yield* Session.Service