tnega 0.3.0 → 0.4.1

package/dist/evolve.js

@@ -7879,7 +7879,7 @@ function copyMessages(messages) {
       copy.tool_calls = message2.tool_calls.map((call) => ({
         id: call.id,
         name: call.name,
-        arguments: call.arguments
+        arguments: structuredClone(call.arguments)
       }));
     }
     return copy;
@@ -7910,6 +7910,75 @@ function copyCompletion(completion) {
   }
   return copy;
 }
+function canonicalMessages(messages) {
+  return JSON.stringify(messages.map((message2) => ({
+    role: message2.role,
+    content: message2.content,
+    ...message2.name ? { name: message2.name } : {},
+    ...message2.tool_call_id ? { tool_call_id: message2.tool_call_id } : {},
+    ...message2.tool_calls?.length ? { tool_calls: message2.tool_calls } : {},
+    ...message2.toolOk !== void 0 ? { toolOk: message2.toolOk } : {},
+    ...message2.toolError ? {
+      toolError: { name: message2.toolError.name, message: message2.toolError.message }
+    } : {}
+  })));
+}
+function freezeRequestData(data) {
+  const visited = /* @__PURE__ */ new Set();
+  const freeze = (value) => {
+    if (typeof value !== "object" || value === null || visited.has(value)) return;
+    visited.add(value);
+    for (const child of Object.values(value)) freeze(child);
+    Object.freeze(value);
+  };
+  freeze(data);
+}
+function lockStreamRequest(request) {
+  freezeRequestData(request.messages);
+  request.tools = Object.freeze(request.tools.map((tool) => {
+    const schema = structuredClone(tool.schema);
+    freezeRequestData(schema);
+    return Object.freeze({ ...tool, schema });
+  }));
+  Object.freeze(request.options);
+  Object.freeze(request);
+}
+function requestHeaderFor(request, input) {
+  const system = input.find((message2) => message2.role === "system")?.content;
+  const tools2 = request.tools.map((tool) => ({
+    name: tool.schema.name,
+    description: tool.schema.description,
+    ...tool.schema.parameters ? { parameters: tool.schema.parameters } : {}
+  }));
+  const config2 = {
+    ...request.options.provider ? { provider: request.options.provider } : {},
+    ...request.options.model ? { model: request.options.model } : {},
+    ...request.options.temperature !== void 0 ? { temperature: request.options.temperature } : {}
+  };
+  return {
+    ...Object.keys(config2).length ? { config: config2 } : {},
+    ...system !== void 0 ? { system } : {},
+    ...tools2.length ? { tools: tools2 } : {}
+  };
+}
+async function* completeAsStream(llm, messages, tools2, options) {
+  const id = randomUUID();
+  yield { type: "message_start", id };
+  const completion = await llm.complete(messages, tools2, options);
+  if (completion.content) yield { type: "message_delta", id, delta: completion.content };
+  for (let index = 0; index < (completion.toolCalls?.length ?? 0); index += 1) {
+    const call = completion.toolCalls[index];
+    yield { type: "toolcall_start", id: call.id, index, name: call.name };
+    yield {
+      type: "toolcall_end",
+      id: call.id,
+      index,
+      name: call.name,
+      arguments: call.arguments
+    };
+  }
+  yield { type: "message_stop", id, finishReason: completion.finishReason };
+}
 function isCancelCause(value) {
   if (typeof value !== "object" || value === null) return false;
   const record2 = value;
@@ -7930,6 +7999,13 @@ function cancelCauseFromSignal(signal) {
   if (isCancelCause(reason)) return reason;
   return { type: "abort" };
 }
+function abortedToolError(signal) {
+  const cause = cancelCauseFromSignal(signal);
+  return {
+    name: "AbortError",
+    message: `tool call aborted: ${cause?.type ?? "abort"}`
+  };
+}
 function toTurnEndReason(fields) {
   const { cancelled, turnError, finishReason, cancelCause } = fields;
   if (cancelled || finishReason === "cancelled") {
@@ -7974,6 +8050,78 @@ async function cancellableDelay(ms, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
+var AssistantStreamAttempt = class {
+  constructor(session2, turn, step, nextRevision) {
+    this.session = session2;
+    this.turn = turn;
+    this.step = step;
+    this.nextRevision = nextRevision;
+  }
+  session;
+  turn;
+  step;
+  nextRevision;
+  attemptId = randomUUID();
+  records = [];
+  ended = false;
+  start() {
+    return { type: "assistant/stream", frame: {
+      type: "start",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      turn: this.turn,
+      step: this.step
+    } };
+  }
+  push(chunk) {
+    if (this.ended) throw new AgentError("assistant attempt is already settled");
+    const record2 = { time: Date.now(), chunk: structuredClone(chunk) };
+    const index = this.records.length;
+    this.records.push(record2);
+    return { type: "assistant/stream", frame: {
+      type: "chunk",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      index,
+      ...structuredClone(record2)
+    } };
+  }
+  async settle(message2) {
+    if (this.ended) throw new AgentError("assistant attempt is already settled");
+    const eventType = message2 ? "assistant/message" : "assistant/attempt";
+    let event;
+    try {
+      event = message2 ? await this.session.append("assistant/message", { ...message2, stream: this.records }) : await this.session.append("assistant/attempt", { turn: this.turn, step: this.step, stream: this.records });
+    } catch (cause) {
+      this.ended = true;
+      const frame = { type: "assistant/stream", frame: {
+        type: "end",
+        attemptId: this.attemptId,
+        revision: this.nextRevision(),
+        index: this.records.length,
+        outcome: { kind: "abandoned" }
+      } };
+      throw new AttemptSettlementError(cause, frame);
+    }
+    this.ended = true;
+    return { type: "assistant/stream", frame: {
+      type: "end",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      index: this.records.length,
+      outcome: { kind: "committed", eventType, seq: event.seq }
+    } };
+  }
+};
+var AttemptSettlementError = class extends Error {
+  constructor(cause, frame) {
+    super("assistant attempt settlement failed");
+    this.cause = cause;
+    this.frame = frame;
+  }
+  cause;
+  frame;
+};
 var AgentService = class {
   constructor(ctx, config2 = {}) {
     this.ctx = ctx;
@@ -7982,9 +8130,24 @@ var AgentService = class {
   }
   ctx;
   config;
+  async *settleAttempt(attempt, message2) {
+    try {
+      yield await attempt.settle(message2);
+    } catch (error2) {
+      if (error2 instanceof AttemptSettlementError) {
+        yield error2.frame;
+        throw error2.cause;
+      }
+      throw error2;
+    }
+  }
   inbox;
   _seriesStarted = false;
   _persistedRequest = false;
+  _streamRevision = 0;
+  _attempt(session2, turn, step) {
+    return new AssistantStreamAttempt(session2, turn, step, () => ++this._streamRevision);
+  }
   /** Call when a request begins an explicit new model-message series. */
   startSeries() {
     this._seriesStarted = true;
@@ -7998,7 +8161,7 @@ var AgentService = class {
     return this._persistedRequest;
   }
   async run(input, options = {}) {
-    return consumeAgentStream(this._stream(input, options, false));
+    return consumeAgentStream(this._stream(input, options));
   }
   async *runStream(input, options = {}) {
     const iterator = this._stream(input, options)[Symbol.asyncIterator]();
@@ -8008,7 +8171,7 @@ var AgentService = class {
       yield next.value;
     }
   }
-  async *_stream(input, options = {}, useStream = true) {
+  async *_stream(input, options = {}) {
     const claimed = input ?? this.inbox.claim();
     if (!claimed) throw new AgentError("no agent input available");
     await this.config.hooks?.beforeRun?.(claimed, options);
@@ -8016,26 +8179,32 @@ var AgentService = class {
     const tools2 = this._tools();
     const llm = this._llm();
     if (!llm) throw new AgentError("no LLM adapter available");
+    const streamAdapter = llm.stream;
+    const persistChunks = streamAdapter !== void 0;
     const maxTurns = options.maxTurns ?? this.config.maxTurns ?? 64;
     const maxSteps = options.maxSteps ?? this.config.maxSteps ?? 64;
     const contextBudget = options.contextBudget ?? this.config.contextBudget;
     const injected = this.inbox.injected();
     this.ctx.emit("agent/start", { input: claimed, options, injected });
     let messages = await this._initialMessages(claimed);
+    let claimedMessages = messages.filter((message2) => message2.role === "user");
     const steps = [];
     let output = "";
     let finishReason = "stop";
+    let lengthReached = false;
     this.ctx.emit("agent/turn-start", {
       input: claimed,
       messages: copyMessages(messages),
       injected
     });
-    const turn = await session2.nextTurn();
-    await session2.append("turn/start", {
-      turn,
-      input: claimed.text ?? claimed,
-      reason: "user"
-    });
+    const turn = options.turn ?? await session2.nextTurn();
+    if (options.turn === void 0) {
+      await session2.append("turn/start", {
+        turn,
+        input: claimed.text ?? claimed,
+        reason: "user"
+      });
+    }
     let index = 0;
     let finalTurnGranted = false;
     let currentStepIndex;
@@ -8054,20 +8223,22 @@ var AgentService = class {
           messages = await this._enforceContextBudget(session2, contextBudget, messages);
         }
         const stepInput = copyMessages(messages);
-        const preStep = this.ctx.waterfall("agent/pre-step", {
+        const preStep = await this.ctx.waterfallAsync("agent/pre-step", {
           index,
           turn,
           step: index,
           messages: stepInput,
+          claimedMessages: copyMessages(claimedMessages),
           ...options.signal ? { signal: options.signal } : {}
         }, (payload) => payload);
-        if (!preStep || !Array.isArray(preStep.messages) || !preStep.messages.length) {
+        if (!preStep || preStep.admission === "reject" || !Array.isArray(preStep.messages) || !preStep.messages.length) {
           break;
         }
         if (preStep.startsRequestSeries) this._seriesStarted = true;
         await session2.append("step/start", { turn, step: index });
         currentStepIndex = index;
         const requestedInput = copyMessages(preStep.messages);
+        const admittedHistory = await session2.deriveMessages();
         this.ctx.emit("agent/step", {
           index,
           turn,
@@ -8079,93 +8250,85 @@ var AgentService = class {
           maxSteps: maxSteps - steps.length
         };
         if (options.signal) completeOptions.signal = options.signal;
-        const request = this.ctx.waterfall("agent/request", {
-          index,
-          messages: requestedInput,
-          tools: availableTools,
-          options: completeOptions
-        }, (payload) => payload);
-        if (!request || !request.options || !request.tools) {
-          throw new AgentError("agent/request must return a request payload");
-        }
         let llmMessages = copyMessages(requestedInput);
         let completion;
-        const streamMethod = useStream ? llm.stream : void 0;
+        let activeAttempt;
         let attempt = 0;
-        let persistedStepInput = false;
         while (true) {
           if (options.signal?.aborted) {
             finishReason = "cancelled";
             break;
           }
           const streamEvents = [];
+          activeAttempt = this._attempt(session2, turn, index);
+          yield activeAttempt.start();
+          const streamRequest = {
+            index,
+            messages: copyMessages(requestedInput),
+            tools: [...availableTools],
+            options: { ...completeOptions }
+          };
           try {
-            if (streamMethod) {
-              const streamRequest = {
-                index,
-                messages: llmMessages,
-                tools: request.tools,
-                options: request.options
-              };
-              const stream = await this.ctx.waterfallAsync(
-                "llm/stream",
-                streamRequest,
-                async (payload) => {
-                  if (!streamMethod) {
-                    throw new AgentError("llm.stream is required for streaming runs");
-                  }
-                  return streamMethod(payload.messages, payload.tools, payload.options);
-                }
-              );
-              if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
-                throw new AgentError("llm/stream must return an async iterable stream");
-              }
+            const request = await this.ctx.waterfallAsync("agent/request", {
+              index,
+              messages: copyMessages(requestedInput),
+              tools: streamRequest.tools,
+              options: streamRequest.options
+            }, (payload) => payload);
+            if (!request || !request.options || !request.tools) {
+              throw new AgentError("agent/request must return a request payload");
+            }
+            streamRequest.tools = request.tools;
+            streamRequest.options = request.options;
+            let preparation;
+            const prepareRequest = () => preparation ??= (async () => {
+              lockStreamRequest(streamRequest);
               llmMessages = copyMessages(streamRequest.messages);
-              if (!persistedStepInput) {
-                await this._persistStepInput(session2, request, llmMessages);
-                if (this.config.assertReplayable) {
-                  await this._assertReplayable(session2, llmMessages);
-                }
-                persistedStepInput = true;
-              }
-              let chunkIndex = 0;
-              for await (const event of stream) {
-                streamEvents.push(event);
-                if (event.type === "message_delta") {
-                  await session2.append("assistant/chunk", {
-                    id: event.id,
-                    content: event.delta,
-                    index: chunkIndex
-                  });
-                  chunkIndex += 1;
-                }
-                yield event;
-              }
-              completion = completionFromStreamEvents(streamEvents);
-            } else {
-              if (!persistedStepInput) {
-                await this._persistStepInput(session2, request, llmMessages);
-                if (this.config.assertReplayable) {
-                  await this._assertReplayable(session2, llmMessages);
-                }
-                persistedStepInput = true;
+              await this._persistStepInput(session2, streamRequest, llmMessages, admittedHistory);
+              await this._assertReplayable(session2, streamRequest, llmMessages);
+            })();
+            const stream = await this.ctx.waterfallAsync(
+              "llm/stream",
+              streamRequest,
+              (payload) => (async function* () {
+                await prepareRequest();
+                yield* streamAdapter ? streamAdapter.call(llm, payload.messages, payload.tools, payload.options) : completeAsStream(llm, payload.messages, payload.tools, payload.options);
+              })()
+            );
+            if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
+              throw new AgentError("llm/stream must return an async iterable stream");
+            }
+            await prepareRequest();
+            let chunkIndex = 0;
+            for await (const event of stream) {
+              streamEvents.push(structuredClone(event));
+              yield activeAttempt.push(event);
+              if (persistChunks && event.type === "message_delta") {
+                await session2.append("assistant/chunk", {
+                  id: event.id,
+                  content: event.delta,
+                  index: chunkIndex
+                });
+                chunkIndex += 1;
               }
-              completion = await llm.complete(llmMessages, request.tools, request.options);
+              yield event;
+            }
+            completion = completionFromStreamEvents(streamEvents);
+            if (completion.finishReason === "error" || completion.finishReason === "cancelled") {
+              const terminalReason = completion.finishReason;
+              completion = void 0;
+              throw new AgentError(`LLM stream finished with ${terminalReason}`);
             }
             break;
           } catch (error2) {
-            const content = partialStreamContent(streamEvents);
-            if (content) {
-              await session2.append("assistant/message", {
-                content,
-                interrupted: true
-              });
-              llmMessages = await session2.deriveMessages();
-            }
+            yield activeAttempt.push({ type: "stream_error", error: toToolError(error2) });
             if (options.signal?.aborted) {
+              const content = partialStreamContent(streamEvents);
+              yield* this.settleAttempt(activeAttempt, content ? { content, interrupted: true } : void 0);
               finishReason = "cancelled";
               break;
             }
+            yield* this.settleAttempt(activeAttempt);
             attempt += 1;
             const failure = toToolError(error2);
             const decision = await this.ctx.waterfallAsync(
@@ -8174,14 +8337,14 @@ var AgentService = class {
                 index,
                 turn,
                 step: index,
-                messages: copyMessages(llmMessages),
-                tools: request.tools,
-                options: request.options,
+                messages: copyMessages(streamRequest.messages),
+                tools: [...streamRequest.tools],
+                options: { ...streamRequest.options },
                 attempt,
                 error: error2,
                 failure,
-                ...request.options.provider ? { provider: request.options.provider } : {},
-                ...request.options.model ? { model: request.options.model } : {},
+                ...streamRequest.options.provider ? { provider: streamRequest.options.provider } : {},
+                ...streamRequest.options.model ? { model: streamRequest.options.model } : {},
                 ...options.signal ? { signal: options.signal } : {}
               },
               () => void 0
@@ -8206,16 +8369,30 @@ var AgentService = class {
             await session2.append("llm/retry-started", { retryId, retry: attempt });
           }
         }
-        if (options.signal?.aborted) break;
-        if (!completion) throw new AgentError("LLM adapter did not produce a completion");
+        if (!completion || !activeAttempt) {
+          if (options.signal?.aborted) {
+            finishReason = "cancelled";
+            break;
+          }
+          throw new AgentError("LLM adapter did not produce a completion");
+        }
         const toolCalls = completion.toolCalls ?? [];
-        if (finalTurnGranted && toolCalls.length) {
+        if (completion.finishReason === "length") lengthReached = true;
+        if (options.signal?.aborted && toolCalls.length === 0) {
+          yield activeAttempt.push({ type: "stream_error", error: { name: "AbortError", message: "stream aborted" } });
+          yield* this.settleAttempt(activeAttempt);
+          finishReason = "cancelled";
+          break;
+        }
+        if (finalTurnGranted && toolCalls.length && !options.signal?.aborted) {
+          yield activeAttempt.push({ type: "stream_error", error: { name: "AgentError", message: "maximum turns reached" } });
+          yield* this.settleAttempt(activeAttempt);
           finishReason = "max_turns";
           break;
         }
         const toolResults = [];
         if (toolCalls.length) {
-          await session2.append("assistant/message", {
+          yield* this.settleAttempt(activeAttempt, {
             content: completion.content ?? "",
             toolCalls: toolCalls.map((call) => ({
               id: call.id,
@@ -8236,18 +8413,30 @@ var AgentService = class {
           if (options.signal) toolOptions.signal = options.signal;
           const startedAt = Date.now();
           let result;
-          try {
-            result = await tools2.execute(call.name, call.arguments, toolOptions);
-          } catch (error2) {
+          if (options.signal?.aborted) {
             result = {
               ok: false,
               name: call.name,
               callId: call.id,
               input: call.arguments,
-              error: toToolError(error2),
+              error: abortedToolError(options.signal),
               startedAt,
               durationMs: Date.now() - startedAt
             };
+          } else {
+            try {
+              result = await tools2.execute(call.name, call.arguments, toolOptions);
+            } catch (error2) {
+              result = {
+                ok: false,
+                name: call.name,
+                callId: call.id,
+                input: call.arguments,
+                error: toToolError(error2),
+                startedAt,
+                durationMs: Date.now() - startedAt
+              };
+            }
           }
           toolResults.push(result);
           const toolResultPayload = {
@@ -8289,7 +8478,7 @@ var AgentService = class {
           output = completion.content;
         }
         if (!toolCalls.length) {
-          await session2.append("assistant/message", { content: completion.content ?? "" });
+          yield* this.settleAttempt(activeAttempt, { content: completion.content ?? "" });
         }
         await session2.append("step/end", {
           turn,
@@ -8300,19 +8489,19 @@ var AgentService = class {
         currentStepIndex = void 0;
         const nextMessages = this._extendMessages(llmMessages, completion, toolResults);
         const concludesTurn = toolResults.some((result) => result.concludesTurn === true);
-        if (concludesTurn) {
-          finishReason = "stop";
-          break;
-        }
-        if (toolCalls.length === 0) {
-          finishReason = completion.finishReason === "length" ? "length" : completion.finishReason === "error" ? "error" : "stop";
+        let nextStepMessages = await this._claimNextStepMessages();
+        if ((toolCalls.length === 0 || concludesTurn) && nextStepMessages.length === 0) {
+          finishReason = lengthReached ? "length" : completion.finishReason === "error" ? "error" : "stop";
           const keepGoing = await this.ctx.serial("agent/turn-stopping", {
             index,
             turn,
             steps: copySteps(steps),
             finishReason
           });
-          if (!keepGoing) break;
+          if (!keepGoing) {
+            nextStepMessages = await this._claimNextStepMessages();
+            if (nextStepMessages.length === 0) break;
+          }
         }
         if (index + 1 >= maxTurns && !finalTurnGranted) {
           finalTurnGranted = true;
@@ -8322,7 +8511,8 @@ var AgentService = class {
         }
         if (toolCalls.length) finishReason = "tool_calls";
         index += 1;
-        messages = nextMessages;
+        messages = [...nextMessages, ...nextStepMessages];
+        claimedMessages = nextStepMessages.filter((message2) => message2.role === "user");
       }
     } catch (error2) {
       turnError = error2;
@@ -8408,23 +8598,22 @@ var AgentService = class {
     });
     return compactMessages.map((message2) => copyMessages([message2])[0]);
   }
-  async _persistStepInput(session2, request, input) {
-    const system = input.find((message2) => message2.role === "system")?.content;
-    const tools2 = request.tools.map((tool) => ({
-      name: tool.schema.name,
-      description: tool.schema.description,
-      ...tool.schema.parameters ? { parameters: tool.schema.parameters } : {}
-    }));
-    const config2 = {
-      ...request.options.provider ? { provider: request.options.provider } : {},
-      ...request.options.model ? { model: request.options.model } : {},
-      ...request.options.temperature !== void 0 ? { temperature: request.options.temperature } : {}
-    };
-    const nextHeader = {
-      ...Object.keys(config2).length ? { config: config2 } : {},
-      ...system !== void 0 ? { system } : {},
-      ...tools2.length ? { tools: tools2 } : {}
-    };
+  async _persistStepInput(session2, request, input, admittedHistory) {
+    const surface = await session2.deriveMessages();
+    const owned = admittedHistory.filter((message2) => !isUserOrSystemMessage(message2));
+    let ownerIndex = 0;
+    for (const message2 of input) {
+      if (isUserOrSystemMessage(message2)) continue;
+      const actual = canonicalMessages([message2]);
+      while (ownerIndex < owned.length && canonicalMessages([owned[ownerIndex]]) !== actual) {
+        ownerIndex += 1;
+      }
+      if (ownerIndex === owned.length) {
+        throw new AgentError("request is not reconstructable from session log: unowned or reordered assistant/tool message");
+      }
+      ownerIndex += 1;
+    }
+    const nextHeader = requestHeaderFor(request, input);
     const previousHeader = session2.requestHeader();
     const isFirstRequest = !this._persistedRequest;
     const isResume = isFirstRequest && previousHeader !== void 0;
@@ -8454,19 +8643,23 @@ var AgentService = class {
       ...request.options.provider ? { provider: request.options.provider } : {},
       ...request.options.model ? { model: request.options.model } : {}
     };
+    if (request.options.contextWindow !== void 0) {
+      nextContext.contextWindow = request.options.contextWindow;
+    }
     const llmService = this.ctx.reflect.get("llm", false);
     const routeCapacity = llmService?.routeCapacity?.();
-    if (routeCapacity?.contextWindow !== void 0) {
+    if (nextContext.contextWindow === void 0 && routeCapacity?.contextWindow !== void 0) {
       nextContext.contextWindow = routeCapacity.contextWindow;
     }
     const previousContext = session2.requestContext();
     if (previousContext?.provider !== nextContext.provider || previousContext?.model !== nextContext.model || previousContext?.contextWindow !== nextContext.contextWindow || previousContext === void 0) {
       await session2.append("request/context", nextContext);
     }
-    const requested = input.filter(isUserOrSystemMessage);
-    const surface = await session2.deriveMessages();
-    const appendDurable = async (messages) => {
-      for (const message2 of messages) {
+    const isSurfacePrefix = (messages) => canonicalMessages(messages.slice(0, surface.length)) === canonicalMessages(surface);
+    const requested = surface.length > 0 && input[0]?.role === "system" && input[0].content === nextHeader.system && isSurfacePrefix(input.slice(1)) ? input.slice(1) : input;
+    const tail = requested.slice(surface.length);
+    if (isSurfacePrefix(requested) && tail.every(isUserOrSystemMessage)) {
+      for (const message2 of tail) {
         if (message2.role === "user") {
           await session2.append("user/message", {
             content: message2.content,
@@ -8479,45 +8672,37 @@ var AgentService = class {
           });
         }
       }
-    };
-    if (surface.length === 0) {
-      await appendDurable(requested);
       return;
     }
-    const durableUsers = surface.filter((message2) => message2.role === "user").length;
-    let seenUsers = 0;
-    const newTail = [];
-    for (const message2 of requested) {
-      if (message2.role === "user") seenUsers += 1;
-      if (seenUsers <= durableUsers) continue;
-      newTail.push(message2);
-    }
-    await appendDurable(newTail);
+    const nodes = await session2.surfaceEvents();
+    await session2.append("checkpoint", {
+      messages: copyMessages(requested),
+      surfaceOp: { op: "replace", start: nodes[0].seq, end: nodes.at(-1).seq }
+    });
   }
-  async _assertReplayable(session2, input) {
+  async _assertReplayable(session2, request, input) {
     const reconstructed = await session2.deriveMessages();
-    const canonical = (messages) => messages.filter((message2) => message2.role !== "system").map((message2) => ({
-      role: message2.role,
-      content: message2.content,
-      ...message2.tool_call_id ? { tool_call_id: message2.tool_call_id } : {},
-      ...message2.name ? { name: message2.name } : {},
-      ...message2.tool_calls?.length ? { tool_calls: message2.tool_calls.map((call) => ({
-        id: call.id,
-        name: call.name,
-        args: JSON.stringify(call.arguments ?? {})
-      })) } : {}
-    }));
-    const actual = canonical(input);
-    const replay = canonical(reconstructed);
-    if (JSON.stringify(actual) !== JSON.stringify(replay)) {
+    const actual = canonicalMessages(input);
+    const replay = canonicalMessages(reconstructed);
+    const header = session2.requestHeader();
+    const headerOwnsPrefix = input[0]?.role === "system" && input[0].content === header?.system && canonicalMessages(input.slice(1)) === replay;
+    if (actual !== replay && !headerOwnsPrefix) {
       throw new AgentError(
-        `request is not reconstructable from session log: actual=${JSON.stringify(actual)} replay=${JSON.stringify(replay)}`
+        `request is not reconstructable from session log: actual=${actual} replay=${replay}`
       );
     }
+    const expected = requestHeaderFor(request, input);
+    if (header?.system !== expected.system || JSON.stringify(header?.tools ?? []) !== JSON.stringify(expected.tools ?? []) || JSON.stringify(header?.config ?? {}) !== JSON.stringify(expected.config ?? {})) {
+      throw new AgentError("request envelope is not reconstructable from session log");
+    }
+  }
+  async _claimNextStepMessages() {
+    const inputs = await this.config.claimNextStep?.() ?? [];
+    return inputs.flatMap((input) => input.messages?.length ? copyMessages(input.messages) : input.text ? [{ role: "user", content: input.text }] : input.context !== void 0 ? [{ role: "user", content: stringify(input.context) }] : []);
   }
   async _initialMessages(input) {
     const promptService = this.ctx.reflect.get("systemPrompt", false);
-    const assembled = promptService ? (await promptService.assemble()).text.trim() : void 0;
+    const assembled = promptService ? (await promptService.assemble({}, this.ctx)).text.trim() : void 0;
     const systemPrompt = assembled || this.inbox.injected().get("agentSystem");
     const systemMessage = typeof systemPrompt === "string" && systemPrompt ? [{ role: "system", content: systemPrompt }] : [];
     if (input.messages?.length) {
@@ -8542,7 +8727,7 @@ var AgentService = class {
         arguments: call.arguments
       }));
     }
-    next.push(assistant);
+    if (assistant.content || toolCalls.length) next.push(assistant);
     for (const call of toolCalls) {
       const result = toolResults.find((candidate) => candidate.callId === call.id);
       const content = result ? result.ok ? stringify(result.output) : `error: ${result.error?.message ?? "unknown"}` : "error: missing tool result";
@@ -8572,7 +8757,8 @@ var AgentService = class {
     return session2;
   }
   _tools() {
-    const tools2 = this.ctx.tools;
+    const scoped = this.ctx.reflect.get("tools", false);
+    const tools2 = scoped ?? this.ctx.tools;
     if (!tools2) throw new AgentError("tools service is required");
     return tools2;
   }
@@ -8665,178 +8851,6 @@ var agent = {
   }
 };
 
-// packages/evolve/src/llm.ts
-var LlmProposalError = class extends Error {
-  name = "LlmProposalError";
-};
-function withSystemPrompt(adapter, system) {
-  return {
-    async complete(messages, tools2, options) {
-      const hasSystem = messages.some((message2) => message2.role === "system");
-      const next = !system || hasSystem ? messages : [{ role: "system", content: system }, ...messages];
-      return adapter.complete(next, tools2, options);
-    }
-  };
-}
-function llmCandidate(options) {
-  const config2 = {};
-  if (options.system !== void 0) config2.system = options.system;
-  if (options.maxTurns !== void 0) config2.maxTurns = options.maxTurns;
-  if (options.maxSteps !== void 0) config2.maxSteps = options.maxSteps;
-  const plugin = {
-    name: options.name,
-    apply: async (ctx, rawConfig) => {
-      const candidateConfig = readConfig(rawConfig);
-      const fiber = await ctx.plugin(agent, {
-        llm: withSystemPrompt(options.adapter, candidateConfig.system ?? ""),
-        ...candidateConfig.maxTurns !== void 0 ? { maxTurns: candidateConfig.maxTurns } : {},
-        ...candidateConfig.maxSteps !== void 0 ? { maxSteps: candidateConfig.maxSteps } : {}
-      });
-      return () => fiber.dispose();
-    }
-  };
-  return {
-    name: options.name,
-    plugin,
-    ...options.version ? { version: options.version } : {},
-    config: config2,
-    ...options.mutation ? { mutation: options.mutation } : {},
-    ...options.rationale ? { rationale: options.rationale } : {},
-    ...options.model ? { model: options.model } : {}
-  };
-}
-function createLlmProposeRule(options) {
-  const parse3 = options.parse ?? parseLlmProposal;
-  return {
-    id: options.ruleId ?? "llm-propose",
-    description: "use an LLM to propose a system prompt mutation",
-    async apply(context) {
-      const completion = await options.adapter.complete(
-        [{ role: "user", content: buildProposalPrompt(context) }],
-        [],
-        {}
-      );
-      const content = completion.content;
-      if (!content) {
-        throw new LlmProposalError("LLM proposal returned no content");
-      }
-      const proposal = await parse3(content);
-      return llmCandidate({
-        name: proposal.name,
-        system: proposal.system,
-        adapter: options.adapter,
-        ...options.maxTurns !== void 0 ? { maxTurns: options.maxTurns } : {},
-        ...options.maxSteps !== void 0 ? { maxSteps: options.maxSteps } : {},
-        ...options.model ? { model: options.model } : {},
-        mutation: {
-          type: "system-prompt",
-          description: proposal.mutationDescription,
-          patch: { system: proposal.system }
-        },
-        rationale: proposal.rationale
-      });
-    }
-  };
-}
-function parseLlmProposal(content) {
-  const json = extractJson(content);
-  let parsed;
-  try {
-    parsed = JSON.parse(json);
-  } catch (error2) {
-    throw new LlmProposalError(`LLM proposal is not valid JSON: ${message(error2)}`);
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new LlmProposalError("LLM proposal must be a JSON object");
-  }
-  const record2 = parsed;
-  const name2 = record2.name;
-  const system = record2.system;
-  const rationale = record2.rationale;
-  const mutationDescription = record2.mutationDescription;
-  if (typeof name2 !== "string" || !name2.trim()) {
-    throw new LlmProposalError("LLM proposal missing string field: name");
-  }
-  if (typeof system !== "string" || !system.trim()) {
-    throw new LlmProposalError("LLM proposal missing string field: system");
-  }
-  if (typeof rationale !== "string" || !rationale.trim()) {
-    throw new LlmProposalError("LLM proposal missing string field: rationale");
-  }
-  if (typeof mutationDescription !== "string" || !mutationDescription.trim()) {
-    throw new LlmProposalError("LLM proposal missing string field: mutationDescription");
-  }
-  return {
-    name: name2.trim(),
-    system: system.trim(),
-    rationale: rationale.trim(),
-    mutationDescription: mutationDescription.trim()
-  };
-}
-function readConfig(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  const record2 = value;
-  const config2 = {};
-  if (typeof record2.system === "string") config2.system = record2.system;
-  if (typeof record2.maxTurns === "number") config2.maxTurns = record2.maxTurns;
-  if (typeof record2.maxSteps === "number") config2.maxSteps = record2.maxSteps;
-  return config2;
-}
-function buildProposalPrompt(context) {
-  const diagnosis = context.diagnosis;
-  const lines = [
-    "\u4F60\u662F tnega \u7684\u81EA\u8FDB\u5316\u5F15\u64CE\u3002\u6839\u636E\u4E00\u6B21\u8BC4\u6D4B\u7684\u8BCA\u65AD\u7ED3\u679C\uFF0C\u751F\u6210\u4E00\u4E2A\u6539\u8FDB\u540E\u7684 Agent \u7CFB\u7EDF\u63D0\u793A\u8BCD\u5019\u9009\u3002",
-    "\u53EA\u8F93\u51FA\u4E00\u4E2A JSON \u5BF9\u8C61\uFF0C\u4E0D\u8981 Markdown \u4EE3\u7801\u5757\uFF0C\u4E0D\u8981\u989D\u5916\u89E3\u91CA\u3002JSON \u5B57\u6BB5\uFF1A",
-    '{"name":"\u5019\u9009\u540D","system":"\u65B0\u7684\u7CFB\u7EDF\u63D0\u793A\u8BCD","rationale":"\u4FEE\u6539\u7406\u7531","mutationDescription":"\u5177\u4F53\u6539\u52A8\u8BF4\u660E"}',
-    "",
-    `\u8FED\u4EE3\uFF1A${context.iteration}`
-  ];
-  if (context.baseline) {
-    const run = context.baseline;
-    lines.push(
-      `baseline: ${run.candidate.name} score=${run.summary.score.toFixed(3)} passed=${run.summary.passed}/${run.summary.total}`
-    );
-  }
-  if (diagnosis.failingTasks.length) {
-    lines.push("\u5931\u8D25\u4EFB\u52A1\uFF1A");
-    for (const taskId of diagnosis.failingTasks) {
-      const modes = diagnosis.failureModes.filter((mode) => mode.taskId === taskId);
-      const reasons = modes.map((mode) => {
-        const reason = mode.reason ? `(${mode.reason})` : "";
-        return `${mode.strategy}=${mode.status}${reason}`;
-      }).join(", ");
-      lines.push(`- ${taskId}: ${reasons}`);
-    }
-  } else if (context.baseline) {
-    lines.push("\u5F53\u524D baseline \u5168\u90E8\u901A\u8FC7\uFF0C\u8BF7\u4FDD\u6301\u6B63\u786E\u884C\u4E3A\uFF0C\u5E76\u5C1D\u8BD5\u8BA9\u8F93\u51FA\u66F4\u7A33\u5B9A\u3002");
-  }
-  if (context.history.length) {
-    lines.push("\u5DF2\u6709\u5019\u9009\uFF08\u907F\u514D\u91CD\u590D\uFF09\uFF1A");
-    for (const node2 of context.history.slice(-5)) {
-      lines.push(`- ${node2.candidate.name}: ${node2.candidate.rationale ?? ""}`);
-    }
-  }
-  lines.push("\u7EA6\u675F\uFF1Asystem \u5FC5\u987B\u662F\u7B80\u6D01\u53EF\u6267\u884C\u7684\u4E2D\u6587\u6216\u82F1\u6587\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF1B\u4E0D\u8981\u5305\u542B JSON \u4E4B\u5916\u7684\u8F93\u51FA\u3002");
-  return lines.join("\n");
-}
-function extractJson(content) {
-  const fenced = content.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  if (fenced?.[1]) return fenced[1];
-  const start = content.indexOf("{");
-  const end = content.lastIndexOf("}");
-  if (start < 0 || end < start) {
-    throw new LlmProposalError("LLM proposal did not contain a JSON object");
-  }
-  return content.slice(start, end + 1);
-}
-function message(error2) {
-  if (error2 instanceof Error) return error2.message;
-  return String(error2);
-}
-
-// packages/evolve/src/log.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-
 // packages/core/src/utils.ts
 var DisposableList = class {
   sn = 0;
@@ -10112,6 +10126,178 @@ var Service = class _Service {
   }
 };
 
+// packages/evolve/src/llm.ts
+var LlmProposalError = class extends Error {
+  name = "LlmProposalError";
+};
+function withSystemPrompt(adapter, system) {
+  return {
+    async complete(messages, tools2, options) {
+      const hasSystem = messages.some((message2) => message2.role === "system");
+      const next = !system || hasSystem ? messages : [{ role: "system", content: system }, ...messages];
+      return adapter.complete(next, tools2, options);
+    }
+  };
+}
+function llmCandidate(options) {
+  const config2 = {};
+  if (options.system !== void 0) config2.system = options.system;
+  if (options.maxTurns !== void 0) config2.maxTurns = options.maxTurns;
+  if (options.maxSteps !== void 0) config2.maxSteps = options.maxSteps;
+  const plugin = {
+    name: options.name,
+    apply: async (ctx, rawConfig) => {
+      const candidateConfig = readConfig(rawConfig);
+      const fiber = await ctx.plugin(agent, {
+        llm: withSystemPrompt(options.adapter, candidateConfig.system ?? ""),
+        ...candidateConfig.maxTurns !== void 0 ? { maxTurns: candidateConfig.maxTurns } : {},
+        ...candidateConfig.maxSteps !== void 0 ? { maxSteps: candidateConfig.maxSteps } : {}
+      });
+      return () => fiber.dispose();
+    }
+  };
+  return {
+    name: options.name,
+    plugin,
+    ...options.version ? { version: options.version } : {},
+    config: config2,
+    ...options.mutation ? { mutation: options.mutation } : {},
+    ...options.rationale ? { rationale: options.rationale } : {},
+    ...options.model ? { model: options.model } : {}
+  };
+}
+function createLlmProposeRule(options) {
+  const parse3 = options.parse ?? parseLlmProposal;
+  return {
+    id: options.ruleId ?? "llm-propose",
+    description: "use an LLM to propose a system prompt mutation",
+    async apply(context) {
+      const completion = await options.adapter.complete(
+        [{ role: "user", content: buildProposalPrompt(context) }],
+        [],
+        {}
+      );
+      const content = completion.content;
+      if (!content) {
+        throw new LlmProposalError("LLM proposal returned no content");
+      }
+      const proposal = await parse3(content);
+      return llmCandidate({
+        name: proposal.name,
+        system: proposal.system,
+        adapter: options.adapter,
+        ...options.maxTurns !== void 0 ? { maxTurns: options.maxTurns } : {},
+        ...options.maxSteps !== void 0 ? { maxSteps: options.maxSteps } : {},
+        ...options.model ? { model: options.model } : {},
+        mutation: {
+          type: "system-prompt",
+          description: proposal.mutationDescription,
+          patch: { system: proposal.system }
+        },
+        rationale: proposal.rationale
+      });
+    }
+  };
+}
+function parseLlmProposal(content) {
+  const json = extractJson(content);
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (error2) {
+    throw new LlmProposalError(`LLM proposal is not valid JSON: ${message(error2)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new LlmProposalError("LLM proposal must be a JSON object");
+  }
+  const record2 = parsed;
+  const name2 = record2.name;
+  const system = record2.system;
+  const rationale = record2.rationale;
+  const mutationDescription = record2.mutationDescription;
+  if (typeof name2 !== "string" || !name2.trim()) {
+    throw new LlmProposalError("LLM proposal missing string field: name");
+  }
+  if (typeof system !== "string" || !system.trim()) {
+    throw new LlmProposalError("LLM proposal missing string field: system");
+  }
+  if (typeof rationale !== "string" || !rationale.trim()) {
+    throw new LlmProposalError("LLM proposal missing string field: rationale");
+  }
+  if (typeof mutationDescription !== "string" || !mutationDescription.trim()) {
+    throw new LlmProposalError("LLM proposal missing string field: mutationDescription");
+  }
+  return {
+    name: name2.trim(),
+    system: system.trim(),
+    rationale: rationale.trim(),
+    mutationDescription: mutationDescription.trim()
+  };
+}
+function readConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const record2 = value;
+  const config2 = {};
+  if (typeof record2.system === "string") config2.system = record2.system;
+  if (typeof record2.maxTurns === "number") config2.maxTurns = record2.maxTurns;
+  if (typeof record2.maxSteps === "number") config2.maxSteps = record2.maxSteps;
+  return config2;
+}
+function buildProposalPrompt(context) {
+  const diagnosis = context.diagnosis;
+  const lines = [
+    "\u4F60\u662F tnega \u7684\u81EA\u8FDB\u5316\u5F15\u64CE\u3002\u6839\u636E\u4E00\u6B21\u8BC4\u6D4B\u7684\u8BCA\u65AD\u7ED3\u679C\uFF0C\u751F\u6210\u4E00\u4E2A\u6539\u8FDB\u540E\u7684 Agent \u7CFB\u7EDF\u63D0\u793A\u8BCD\u5019\u9009\u3002",
+    "\u53EA\u8F93\u51FA\u4E00\u4E2A JSON \u5BF9\u8C61\uFF0C\u4E0D\u8981 Markdown \u4EE3\u7801\u5757\uFF0C\u4E0D\u8981\u989D\u5916\u89E3\u91CA\u3002JSON \u5B57\u6BB5\uFF1A",
+    '{"name":"\u5019\u9009\u540D","system":"\u65B0\u7684\u7CFB\u7EDF\u63D0\u793A\u8BCD","rationale":"\u4FEE\u6539\u7406\u7531","mutationDescription":"\u5177\u4F53\u6539\u52A8\u8BF4\u660E"}',
+    "",
+    `\u8FED\u4EE3\uFF1A${context.iteration}`
+  ];
+  if (context.baseline) {
+    const run = context.baseline;
+    lines.push(
+      `baseline: ${run.candidate.name} score=${run.summary.score.toFixed(3)} passed=${run.summary.passed}/${run.summary.total}`
+    );
+  }
+  if (diagnosis.failingTasks.length) {
+    lines.push("\u5931\u8D25\u4EFB\u52A1\uFF1A");
+    for (const taskId of diagnosis.failingTasks) {
+      const modes = diagnosis.failureModes.filter((mode) => mode.taskId === taskId);
+      const reasons = modes.map((mode) => {
+        const reason = mode.reason ? `(${mode.reason})` : "";
+        return `${mode.strategy}=${mode.status}${reason}`;
+      }).join(", ");
+      lines.push(`- ${taskId}: ${reasons}`);
+    }
+  } else if (context.baseline) {
+    lines.push("\u5F53\u524D baseline \u5168\u90E8\u901A\u8FC7\uFF0C\u8BF7\u4FDD\u6301\u6B63\u786E\u884C\u4E3A\uFF0C\u5E76\u5C1D\u8BD5\u8BA9\u8F93\u51FA\u66F4\u7A33\u5B9A\u3002");
+  }
+  if (context.history.length) {
+    lines.push("\u5DF2\u6709\u5019\u9009\uFF08\u907F\u514D\u91CD\u590D\uFF09\uFF1A");
+    for (const node2 of context.history.slice(-5)) {
+      lines.push(`- ${node2.candidate.name}: ${node2.candidate.rationale ?? ""}`);
+    }
+  }
+  lines.push("\u7EA6\u675F\uFF1Asystem \u5FC5\u987B\u662F\u7B80\u6D01\u53EF\u6267\u884C\u7684\u4E2D\u6587\u6216\u82F1\u6587\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF1B\u4E0D\u8981\u5305\u542B JSON \u4E4B\u5916\u7684\u8F93\u51FA\u3002");
+  return lines.join("\n");
+}
+function extractJson(content) {
+  const fenced = content.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]) return fenced[1];
+  const start = content.indexOf("{");
+  const end = content.lastIndexOf("}");
+  if (start < 0 || end < start) {
+    throw new LlmProposalError("LLM proposal did not contain a JSON object");
+  }
+  return content.slice(start, end + 1);
+}
+function message(error2) {
+  if (error2 instanceof Error) return error2.message;
+  return String(error2);
+}
+
+// packages/evolve/src/log.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
 // packages/tools/src/calc.ts
 var CONSTANTS = {
   e: Math.E,