tnega 0.3.0 → 0.4.1

package/dist/cli-runtime.js

@@ -9078,17 +9078,88 @@ function checkMonotonicSeq(events) {
   }
   return failures;
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || ancestors.has(value)) return false;
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+  ancestors.add(value);
+  const valid = (Array.isArray(value) ? Array.from(value) : Object.values(value)).every((member) => isJsonValue(member, ancestors));
+  ancestors.delete(value);
+  return valid;
+}
+function isStreamRecord(value) {
+  if (!isRecord(value) || !isNonNegativeInteger(value.time) || !isRecord(value.chunk)) return false;
+  const chunk = value.chunk;
+  if (chunk.type === "stream_error") {
+    return isRecord(chunk.error) && typeof chunk.error.message === "string" && (chunk.error.name === void 0 || typeof chunk.error.name === "string") && (chunk.error.stack === void 0 || typeof chunk.error.stack === "string");
+  }
+  if (typeof chunk.id !== "string") return false;
+  switch (chunk.type) {
+    case "message_start":
+      return chunk.model === void 0 || typeof chunk.model === "string";
+    case "message_delta":
+      return typeof chunk.delta === "string";
+    case "toolcall_start":
+    case "toolcall_end":
+      return isNonNegativeInteger(chunk.index) && typeof chunk.name === "string" && (chunk.type === "toolcall_start" || isJsonValue(chunk.arguments));
+    case "message_stop":
+      return chunk.finishReason === "stop" || chunk.finishReason === "tool_calls" || chunk.finishReason === "length" || chunk.finishReason === "max_turns" || chunk.finishReason === "max_steps" || chunk.finishReason === "error" || chunk.finishReason === "cancelled";
+    default:
+      return false;
+  }
+}
+function checkAssistantAttempts(events) {
+  const turns = /* @__PURE__ */ new Set();
+  const steps = /* @__PURE__ */ new Map();
+  const failures = [];
+  for (const event of events) {
+    if (event.type === "turn/start") turns.add(event.payload.turn);
+    if (event.type === "turn/end") {
+      turns.delete(event.payload.turn);
+      for (const [key, turn] of steps) {
+        if (turn === event.payload.turn) steps.delete(key);
+      }
+    }
+    if (event.type === "step/start" && turns.has(event.payload.turn)) {
+      steps.set(`${event.payload.turn}:${event.payload.step}`, event.payload.turn);
+    }
+    if (event.type === "step/end") steps.delete(`${event.payload.turn}:${event.payload.step}`);
+    if (event.type !== "assistant/attempt") continue;
+    const payload = event.payload;
+    if (!isRecord(payload) || !isNonNegativeInteger(payload.turn) || !isNonNegativeInteger(payload.step) || !turns.has(payload.turn) || !steps.has(`${payload.turn}:${payload.step}`)) {
+      failures.push({
+        name: "assistant/attempt-without-open-step",
+        detail: `assistant/attempt at seq ${event.seq} has no matching open turn and step`
+      });
+    }
+    if (!isRecord(payload) || !Array.isArray(payload.stream) || !payload.stream.every(isStreamRecord)) {
+      failures.push({
+        name: "assistant/attempt-invalid-stream",
+        detail: `assistant/attempt at seq ${event.seq} must contain an ordered array of normalized stream records`
+      });
+    }
+  }
+  return failures;
+}
 function checkSessionInvariants(events) {
   return [
     ...checkBalancedTurns(events),
     ...checkBalancedSteps(events),
     ...checkBalancedToolCalls(events),
-    ...checkMonotonicSeq(events)
+    ...checkMonotonicSeq(events),
+    ...checkAssistantAttempts(events)
   ];
 }
 
 // packages/session/src/index.ts
-var SESSION_FORMAT_VERSION = 7;
+var SESSION_FORMAT_VERSION = 10;
 var SessionFormatError = class extends Error {
   name = "SessionFormatError";
 };
@@ -9260,7 +9331,7 @@ function transcriptEvents(events) {
   const structure = events.filter((event) => !inSkeleton.has(event.id)).filter((event) => event.type !== "compaction/start" && event.type !== "compaction/end").filter((event) => event.type !== "checkpoint").filter((event) => !(event.type === "tool/call" && declaredCalls.has(event.payload.id)));
   const ordered = [...skeleton];
   for (const event of structure) {
-    let index = ordered.length;
+    let index = 0;
     for (let cursor = ordered.length - 1; cursor >= 0; cursor -= 1) {
       if (ordered[cursor].seq <= event.seq) {
         index = cursor + 1;
@@ -9357,6 +9428,7 @@ function estimateEventTokens(event) {
       return Math.ceil(raw.length / 4);
     }
     case "plan":
+    case "assistant/attempt":
       return 0;
     case "checkpoint":
       return estimateMessageTokens(event.payload.messages);
@@ -9491,9 +9563,15 @@ function estimateContextUsage(messages, limit = DEFAULT_CONTEXT_LIMIT) {
   };
 }
 var SessionLog = class {
-  constructor(file, _broadcast) {
+  constructor(file, _broadcast, publicationContext) {
     this.file = file;
     this._broadcast = _broadcast;
+    if (!this._broadcast && publicationContext) {
+      this._broadcast = (type, payload) => {
+        if (type === "event") publicationContext.emit("session/event", payload);
+        else publicationContext.emit("session/flush", payload);
+      };
+    }
   }
   file;
   _broadcast;
@@ -9662,7 +9740,7 @@ var SessionLog = class {
           selected.push(clone(event));
           continue;
         }
-        if (event.type === "meta" || event.type === "llm/retry" || event.type === "llm/retry-started" || event.type.startsWith("turn/") || event.type.startsWith("step/")) {
+        if (event.type === "meta" || event.type === "llm/retry" || event.type === "llm/retry-started" || event.type === "assistant/attempt" || event.type.startsWith("turn/") || event.type.startsWith("step/")) {
           continue;
         }
         if (event.type === "checkpoint") {
@@ -10012,7 +10090,7 @@ function copyMessages(messages) {
       copy.tool_calls = message3.tool_calls.map((call) => ({
         id: call.id,
         name: call.name,
-        arguments: call.arguments
+        arguments: structuredClone(call.arguments)
       }));
     }
     return copy;
@@ -10043,6 +10121,75 @@ function copyCompletion(completion) {
   }
   return copy;
 }
+function canonicalMessages(messages) {
+  return JSON.stringify(messages.map((message3) => ({
+    role: message3.role,
+    content: message3.content,
+    ...message3.name ? { name: message3.name } : {},
+    ...message3.tool_call_id ? { tool_call_id: message3.tool_call_id } : {},
+    ...message3.tool_calls?.length ? { tool_calls: message3.tool_calls } : {},
+    ...message3.toolOk !== void 0 ? { toolOk: message3.toolOk } : {},
+    ...message3.toolError ? {
+      toolError: { name: message3.toolError.name, message: message3.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((message3) => message3.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 = randomUUID2();
+  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 record3 = value;
@@ -10063,6 +10210,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") {
@@ -10107,6 +10261,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 = randomUUID2();
+  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 record3 = { time: Date.now(), chunk: structuredClone(chunk) };
+    const index = this.records.length;
+    this.records.push(record3);
+    return { type: "assistant/stream", frame: {
+      type: "chunk",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      index,
+      ...structuredClone(record3)
+    } };
+  }
+  async settle(message3) {
+    if (this.ended) throw new AgentError("assistant attempt is already settled");
+    const eventType = message3 ? "assistant/message" : "assistant/attempt";
+    let event;
+    try {
+      event = message3 ? await this.session.append("assistant/message", { ...message3, 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;
@@ -10115,9 +10341,24 @@ var AgentService = class {
   }
   ctx;
   config;
+  async *settleAttempt(attempt, message3) {
+    try {
+      yield await attempt.settle(message3);
+    } 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;
@@ -10131,7 +10372,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]();
@@ -10141,7 +10382,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);
@@ -10149,26 +10390,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((message3) => message3.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;
@@ -10187,20 +10434,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,
@@ -10212,93 +10461,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(
@@ -10307,14 +10548,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
@@ -10339,16 +10580,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,
@@ -10369,18 +10624,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 = {
@@ -10422,7 +10689,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,
@@ -10433,19 +10700,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;
@@ -10455,7 +10722,8 @@ var AgentService = class {
         }
         if (toolCalls.length) finishReason = "tool_calls";
         index += 1;
-        messages = nextMessages;
+        messages = [...nextMessages, ...nextStepMessages];
+        claimedMessages = nextStepMessages.filter((message3) => message3.role === "user");
       }
     } catch (error2) {
       turnError = error2;
@@ -10541,23 +10809,22 @@ var AgentService = class {
     });
     return compactMessages.map((message3) => copyMessages([message3])[0]);
   }
-  async _persistStepInput(session2, request, input) {
-    const system = input.find((message3) => message3.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((message3) => !isUserOrSystemMessage(message3));
+    let ownerIndex = 0;
+    for (const message3 of input) {
+      if (isUserOrSystemMessage(message3)) continue;
+      const actual = canonicalMessages([message3]);
+      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;
@@ -10587,19 +10854,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 message3 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 message3 of tail) {
         if (message3.role === "user") {
           await session2.append("user/message", {
             content: message3.content,
@@ -10612,45 +10883,37 @@ var AgentService = class {
           });
         }
       }
-    };
-    if (surface.length === 0) {
-      await appendDurable(requested);
       return;
     }
-    const durableUsers = surface.filter((message3) => message3.role === "user").length;
-    let seenUsers = 0;
-    const newTail = [];
-    for (const message3 of requested) {
-      if (message3.role === "user") seenUsers += 1;
-      if (seenUsers <= durableUsers) continue;
-      newTail.push(message3);
-    }
-    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((message3) => message3.role !== "system").map((message3) => ({
-      role: message3.role,
-      content: message3.content,
-      ...message3.tool_call_id ? { tool_call_id: message3.tool_call_id } : {},
-      ...message3.name ? { name: message3.name } : {},
-      ...message3.tool_calls?.length ? { tool_calls: message3.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: stringify2(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 systemPrompt3 = assembled || this.inbox.injected().get("agentSystem");
     const systemMessage = typeof systemPrompt3 === "string" && systemPrompt3 ? [{ role: "system", content: systemPrompt3 }] : [];
     if (input.messages?.length) {
@@ -10675,7 +10938,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 ? stringify2(result.output) : `error: ${result.error?.message ?? "unknown"}` : "error: missing tool result";
@@ -10705,7 +10968,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;
   }
@@ -10888,67 +11152,77 @@ var DurableInbox = class _DurableInbox {
   _session;
   _nextTurn = [];
   _nextStep = [];
+  _operationTail = Promise.resolve();
   get size() {
     return this._nextTurn.length + this._nextStep.length;
   }
   async insert(input, target = "next-turn") {
-    const message3 = {
-      id: randomUUID3(),
-      ...input.text !== void 0 ? { text: input.text } : {},
-      ...input.content !== void 0 ? { content: input.content } : {}
-    };
-    const list = target === "next-step" ? this._nextStep : this._nextTurn;
-    list.push(message3);
-    await this._session.append("agent/inbox/spliced", {
-      target,
-      index: list.length - 1,
-      inserted: [{
-        id: message3.id,
-        content: contentOf(message3),
-        ...payloadOf(message3) !== void 0 ? { payload: payloadOf(message3) } : {}
-      }]
+    return this._run(async () => {
+      const message3 = {
+        id: randomUUID3(),
+        ...input.text !== void 0 ? { text: input.text } : {},
+        ...input.content !== void 0 ? { content: input.content } : {}
+      };
+      const list = target === "next-step" ? this._nextStep : this._nextTurn;
+      const index = list.length;
+      await this._session.append("agent/inbox/spliced", {
+        target,
+        index,
+        inserted: [{
+          id: message3.id,
+          content: contentOf(message3),
+          ...payloadOf(message3) !== void 0 ? { payload: payloadOf(message3) } : {}
+        }]
+      });
+      list.push(message3);
+      return message3;
     });
-    return message3;
   }
   async steer(input) {
-    const message3 = {
-      id: randomUUID3(),
-      ...input.text !== void 0 ? { text: input.text } : {},
-      ...input.content !== void 0 ? { content: input.content } : {}
-    };
-    this._nextStep.unshift(message3);
-    await this._session.append("agent/inbox/spliced", {
-      target: "next-step",
-      index: 0,
-      inserted: [{
-        id: message3.id,
-        content: contentOf(message3),
-        ...payloadOf(message3) !== void 0 ? { payload: payloadOf(message3) } : {},
-        mode: "steer"
-      }]
-    });
-    return message3;
-  }
-  async claim() {
-    const steered = this._nextStep.shift();
-    if (steered) {
+    return this._run(async () => {
+      const message3 = {
+        id: randomUUID3(),
+        ...input.text !== void 0 ? { text: input.text } : {},
+        ...input.content !== void 0 ? { content: input.content } : {}
+      };
       await this._session.append("agent/inbox/spliced", {
         target: "next-step",
-        index: 0,
-        deleteCount: 1
+        index: this._nextStep.length,
+        inserted: [{
+          id: message3.id,
+          content: contentOf(message3),
+          ...payloadOf(message3) !== void 0 ? { payload: payloadOf(message3) } : {},
+          mode: "steer"
+        }]
       });
-      return steered;
-    }
-    const next = this._nextTurn.shift();
-    if (next) {
-      await this._session.append("agent/inbox/spliced", {
-        target: "next-turn",
-        index: 0,
-        deleteCount: 1
-      });
-      return next;
-    }
-    return void 0;
+      this._nextStep.push(message3);
+      return message3;
+    });
+  }
+  async claim() {
+    return this._run(async () => {
+      const steered = this._nextStep[0];
+      if (steered) {
+        await this._session.append("agent/inbox/spliced", {
+          target: "next-step",
+          index: 0,
+          deleteCount: 1
+        });
+        this._nextStep.shift();
+        return steered;
+      }
+      const next = this._nextTurn[0];
+      if (next) {
+        await this._session.append("agent/inbox/spliced", {
+          target: "next-turn",
+          index: 0,
+          deleteCount: 1
+        });
+        this._nextTurn.shift();
+        return next;
+      }
+      return void 0;
+    });
   }
   /**
    * Claim the complete proposed step batch: every pending next-step input plus
@@ -10956,105 +11230,108 @@ var DurableInbox = class _DurableInbox {
    * nothing is pending.
    */
   async claimBatch() {
-    const claimed = [];
-    if (this._nextStep.length) {
-      const removed = this._nextStep.splice(0);
-      claimed.push(...removed);
+    return this._run(async () => {
+      const claimed = [...this._nextStep];
+      const nextTurn = this._nextTurn[0];
+      if (nextTurn) claimed.push(nextTurn);
+      if (!claimed.length) return [];
+      const deleteCounts = { nextStep: this._nextStep.length, nextTurn: nextTurn ? 1 : 0 };
+      await this._session.append("agent/inbox/spliced", { target: "all", deleteCounts });
+      this._nextStep.splice(0, deleteCounts.nextStep);
+      this._nextTurn.splice(0, deleteCounts.nextTurn);
+      return claimed;
+    });
+  }
+  /** Claim every input waiting for the next step, without consuming a turn. */
+  async claimNextStep() {
+    return this._run(async () => {
+      if (!this._nextStep.length) return [];
+      const claimed = [...this._nextStep];
       await this._session.append("agent/inbox/spliced", {
         target: "next-step",
         index: 0,
-        deleteCount: removed.length
-      });
-    }
-    const nextTurn = this._nextTurn.shift();
-    if (nextTurn) {
-      claimed.push(nextTurn);
-      await this._session.append("agent/inbox/spliced", {
-        target: "next-turn",
-        index: 0,
-        deleteCount: 1
+        deleteCount: claimed.length
       });
-    }
-    return claimed;
+      this._nextStep.splice(0, claimed.length);
+      return claimed;
+    });
   }
   async clear() {
-    if (this._nextTurn.length) {
-      this._nextTurn = [];
+    return this._run(async () => {
+      if (!this._nextTurn.length && !this._nextStep.length) return;
       await this._session.append("agent/inbox/spliced", {
-        target: "next-turn",
-        index: 0,
-        deleteCount: Number.POSITIVE_INFINITY
+        target: "all"
       });
-    }
-    if (this._nextStep.length) {
+      this._nextTurn = [];
       this._nextStep = [];
-      await this._session.append("agent/inbox/spliced", {
-        target: "next-step",
-        index: 0,
-        deleteCount: Number.POSITIVE_INFINITY
-      });
-    }
+    });
   }
   /** Insert a message at an explicit target/index boundary. */
   async insertAt(input, target, index, mode = "followup") {
-    const message3 = {
-      id: randomUUID3(),
-      ...input.text !== void 0 ? { text: input.text } : {},
-      ...input.content !== void 0 ? { content: input.content } : {}
-    };
-    const list = target === "next-step" ? this._nextStep : this._nextTurn;
-    const safeIndex = Math.max(0, Math.min(index, list.length));
-    list.splice(safeIndex, 0, message3);
-    await this._session.append("agent/inbox/spliced", {
-      target,
-      index: safeIndex,
-      inserted: [{
-        id: message3.id,
-        content: contentOf(message3),
-        ...payloadOf(message3) !== void 0 ? { payload: payloadOf(message3) } : {},
-        mode
-      }]
+    return this._run(async () => {
+      const message3 = {
+        id: randomUUID3(),
+        ...input.text !== void 0 ? { text: input.text } : {},
+        ...input.content !== void 0 ? { content: input.content } : {}
+      };
+      const list = target === "next-step" ? this._nextStep : this._nextTurn;
+      const safeIndex = Math.max(0, Math.min(index, list.length));
+      await this._session.append("agent/inbox/spliced", {
+        target,
+        index: safeIndex,
+        inserted: [{
+          id: message3.id,
+          content: contentOf(message3),
+          ...payloadOf(message3) !== void 0 ? { payload: payloadOf(message3) } : {},
+          mode
+        }]
+      });
+      list.splice(safeIndex, 0, message3);
+      return message3;
     });
-    return message3;
   }
   /**
    * Replace one pending message by id. The old message is emitted as
    * discarded and the new one as inserted, matching the DSH inbox contract.
    */
   async replace(messageId, input) {
-    const entry = this._find(messageId);
-    if (!entry) return void 0;
-    const replacement = {
-      id: randomUUID3(),
-      ...input.text !== void 0 ? { text: input.text } : {},
-      ...input.content !== void 0 ? { content: input.content } : {}
-    };
-    const target = entry.target;
-    const index = entry.index;
-    entry.list.splice(index, 1, replacement);
-    await this._session.append("agent/inbox/spliced", {
-      target,
-      index,
-      deleteCount: 1,
-      inserted: [{
-        id: replacement.id,
-        content: contentOf(replacement),
-        ...payloadOf(replacement) !== void 0 ? { payload: payloadOf(replacement) } : {}
-      }]
+    return this._run(async () => {
+      const entry = this._find(messageId);
+      if (!entry) return void 0;
+      const replacement = {
+        id: randomUUID3(),
+        ...input.text !== void 0 ? { text: input.text } : {},
+        ...input.content !== void 0 ? { content: input.content } : {}
+      };
+      const target = entry.target;
+      const index = entry.index;
+      await this._session.append("agent/inbox/spliced", {
+        target,
+        index,
+        deleteCount: 1,
+        inserted: [{
+          id: replacement.id,
+          content: contentOf(replacement),
+          ...payloadOf(replacement) !== void 0 ? { payload: payloadOf(replacement) } : {}
+        }]
+      });
+      entry.list.splice(index, 1, replacement);
+      return replacement;
     });
-    return replacement;
   }
   /** Remove one pending message by id. */
   async remove(messageId) {
-    const entry = this._find(messageId);
-    if (!entry) return void 0;
-    entry.list.splice(entry.index, 1);
-    await this._session.append("agent/inbox/spliced", {
-      target: entry.target,
-      index: entry.index,
-      deleteCount: 1
+    return this._run(async () => {
+      const entry = this._find(messageId);
+      if (!entry) return void 0;
+      await this._session.append("agent/inbox/spliced", {
+        target: entry.target,
+        index: entry.index,
+        deleteCount: 1
+      });
+      entry.list.splice(entry.index, 1);
+      return entry.message;
     });
-    return entry.message;
   }
   /** Return the first pending message by id across both queues. */
   get(messageId) {
@@ -11066,6 +11343,12 @@ var DurableInbox = class _DurableInbox {
       nextStep: [...this._nextStep]
     };
   }
+  /** Keep the entire read → append → apply transition ordered, including claims. */
+  _run(operation) {
+    const result = this._operationTail.then(operation);
+    this._operationTail = result.then(() => void 0, () => void 0);
+    return result;
+  }
   _find(messageId) {
     for (const target of ["next-step", "next-turn"]) {
       const list = target === "next-step" ? this._nextStep : this._nextTurn;
@@ -11083,6 +11366,11 @@ var DurableInbox = class _DurableInbox {
     for (const event of events) {
       if (event.type !== "agent/inbox/spliced") continue;
       const payload = event.payload;
+      if (payload.target === "all") {
+        this._nextTurn.splice(0, payload.deleteCounts?.nextTurn ?? this._nextTurn.length);
+        this._nextStep.splice(0, payload.deleteCounts?.nextStep ?? this._nextStep.length);
+        continue;
+      }
       const list = payload.target === "next-step" ? this._nextStep : this._nextTurn;
       const count = payload.deleteCount ?? 0;
       if (count === Number.POSITIVE_INFINITY) {
@@ -11112,8 +11400,29 @@ var DurableInbox = class _DurableInbox {
 };
 
 // packages/agent/src/live.ts
+function createAgentRuntimeContext(agentCtx) {
+  const runtimeCtx = agentCtx.extend();
+  Object.defineProperty(runtimeCtx, Context.filter, {
+    value: (target) => {
+      const targetScope = target[symbols.isolate].agentScope;
+      let ancestor = agentCtx;
+      while (true) {
+        if (targetScope === ancestor[symbols.isolate].agentScope) return true;
+        if (ancestor.fiber.parent.fiber === ancestor.fiber) return false;
+        ancestor = ancestor.fiber.parent;
+      }
+    }
+  });
+  const events = agentCtx.events;
+  for (const method of ["emit", "parallel", "serial", "bail", "waterfall", "waterfallAsync"]) {
+    Object.defineProperty(runtimeCtx, method, {
+      value: (...args) => events[method](runtimeCtx, ...args)
+    });
+  }
+  return runtimeCtx;
+}
 var LiveAgentImpl = class {
-  constructor(_ctx, _agentCtx, _service, id, inbox, session2, durable, meta2, manualStreaming = false) {
+  constructor(_ctx, _agentCtx, _service, id, inbox, session2, durable, meta2, manualStreaming = false, wakeReserved = false) {
     this._ctx = _ctx;
     this._agentCtx = _agentCtx;
     this._service = _service;
@@ -11123,6 +11432,7 @@ var LiveAgentImpl = class {
     this.meta = meta2;
     this._durable = durable;
     this._manualStreaming = manualStreaming;
+    this._wakeReserved = wakeReserved;
   }
   _ctx;
   _agentCtx;
@@ -11144,8 +11454,9 @@ var LiveAgentImpl = class {
   _setupDisposers = [];
   _scopeClosed = false;
   _durable;
-  _agentSystem;
   _manualStreaming = false;
+  _wakeReserved = false;
+  _loop;
   get agentType() {
     return this.meta.agentType;
   }
@@ -11172,13 +11483,41 @@ var LiveAgentImpl = class {
     return this._ctx;
   }
   followup(input) {
-    this._send(input, "followup");
+    return this._send(input, "followup");
+  }
+  setLoop(loop) {
+    this._loop = loop;
+  }
+  async _closeCustomTurn(turn, run) {
+    const events = await this.session.read();
+    if (events.some((event) => event.type === "turn/end" && event.payload.turn === turn)) return;
+    const reason = run.finishReason === "length" ? { kind: "max-tokens" } : run.finishReason === "max_steps" ? { kind: "max-steps" } : run.finishReason === "max_turns" ? { kind: "max-turns" } : run.finishReason === "cancelled" ? { kind: "interrupted" } : run.finishReason === "error" ? { kind: "interrupted" } : { kind: "completed" };
+    await this.session.append("turn/end", {
+      turn,
+      finishReason: run.finishReason,
+      reason,
+      ...run.output ? { output: run.output } : {},
+      ...run.steps.length ? { steps: run.steps.length } : {}
+    });
+  }
+  async _closeFailedCustomTurn(turn, error2) {
+    const events = await this.session.read();
+    if (events.some((event) => event.type === "turn/end" && event.payload.turn === turn)) return;
+    const failure = error2 instanceof Error ? { name: error2.name, message: error2.message, ...error2.stack ? { stack: error2.stack } : {} } : { name: "Error", message: String(error2) };
+    await this.session.append("turn/end", {
+      turn,
+      finishReason: "error",
+      reason: { kind: "error", error: failure },
+      interrupted: true,
+      error: failure
+    });
   }
   /** Replace one pending inbox message by durable message id. */
   replaceMessage(messageId, input) {
-    this._mutatePending(async () => {
+    return this._mutatePending(async () => {
       const previous = this._durable.get(messageId);
-      if (!previous) return;
+      const target = this._findTarget(messageId);
+      if (!previous || !target) return;
       const replacement = await this._durable.replace(messageId, {
         text: input.text ?? "",
         ...input.messages !== void 0 || input.context !== void 0 ? { content: input.messages ?? input.context } : {}
@@ -11189,18 +11528,19 @@ var LiveAgentImpl = class {
         agent: this,
         message: previous
       });
-      this._ctx.emit("agent/inbox/inserted", {
+      const event = {
         id: this.id,
         agent: this,
-        target: this._findTarget(messageId) ?? "next-turn",
+        target,
         input: replacement,
         inboxSeq: this._durable.size
-      });
+      };
+      this._ctx.emit("agent/inbox/inserted", event);
     });
   }
   /** Remove one pending inbox message by durable message id. */
   removeMessage(messageId) {
-    this._mutatePending(async () => {
+    return this._mutatePending(async () => {
       const removed = await this._durable.remove(messageId);
       if (!removed) return;
       this._ctx.emit("agent/inbox/discarded", {
@@ -11211,48 +11551,54 @@ var LiveAgentImpl = class {
     });
   }
   steer(input) {
-    this._send(input, "steer");
+    return this._send(input, "steer");
   }
-  inject(key, value) {
-    if (key === "agentSystem" && typeof value === "string") {
-      this._agentSystem = value;
-    }
+  inject(input) {
+    return this._send(input, "inject");
   }
   send(input, options = {}) {
-    this._send(input, options.mode === "steer" ? "steer" : "followup");
+    return this._send(input, options.mode === "steer" ? "steer" : "followup");
   }
   _send(input, target) {
-    if (this._disposed) throw new Error(`agent disposed: ${this.id}`);
     const text = input.text ?? "";
     const content = input.messages ?? input.context;
-    const task = this._writeTail.then(async () => {
-      const message3 = target === "steer" ? await this._durable.steer({ text, ...content !== void 0 ? { content } : {} }) : await this._durable.insert({ text, ...content !== void 0 ? { content } : {} });
-      this._ctx.emit("agent/inbox/inserted", {
+    const steeredAfterAbort = target === "steer" && this._controller?.signal.aborted === true;
+    return this._mutatePending(async () => {
+      const message3 = target === "followup" ? await this._durable.insert({ text, ...content !== void 0 ? { content } : {} }) : target === "steer" ? steeredAfterAbort ? await this._durable.insert({ text, ...content !== void 0 ? { content } : {} }) : await this._durable.steer({ text, ...content !== void 0 ? { content } : {} }) : await this._durable.insert({ text, ...content !== void 0 ? { content } : {} }, "next-step");
+      if (target !== "inject") this._wakeReserved = true;
+      const event = {
         id: this.id,
+        agent: this,
         target,
         input: message3,
         inboxSeq: this._durable.size
-      });
-    }).catch((error2) => {
-      this._ctx.emit("agent/error", { id: this.id, error: error2 });
-    });
-    this._writeTail = task;
-    this._pendingWrite = task;
-    task.finally(() => {
-      if (this._pendingWrite === task) this._pendingWrite = void 0;
-      queueMicrotask(() => this._wake());
-    });
+      };
+      this._ctx.emit("agent/inbox/inserted", event);
+    }, target !== "inject");
   }
-  _mutatePending(task) {
-    if (this._disposed) throw new Error(`agent disposed: ${this.id}`);
-    const chained = this._writeTail.then(task).catch((error2) => {
-      this._ctx.emit("agent/error", { id: this.id, error: error2 });
-    });
-    this._writeTail = chained;
-    this._pendingWrite = chained;
-    chained.finally(() => {
-      if (this._pendingWrite === chained) this._pendingWrite = void 0;
+  _mutatePending(task, wakes = false, allowDisposed = false) {
+    if (this._disposed && !allowDisposed) {
+      return Promise.reject(new Error(`agent disposed: ${this.id}`));
+    }
+    const result = this._writeTail.then(task);
+    const recovered = result.catch((error2) => {
+      try {
+        this._ctx.emit("agent/error", { id: this.id, error: error2 });
+      } catch {
+      }
     });
+    this._writeTail = recovered;
+    this._pendingWrite = recovered;
+    void result.then(
+      () => {
+        if (this._pendingWrite === recovered) this._pendingWrite = void 0;
+        if (wakes) queueMicrotask(() => this._wake());
+      },
+      () => {
+        if (this._pendingWrite === recovered) this._pendingWrite = void 0;
+      }
+    );
+    return result;
   }
   _findTarget(messageId) {
     const snapshot = this._durable.snapshot();
@@ -11262,27 +11608,21 @@ var LiveAgentImpl = class {
   }
   cancel(cause, options = {}) {
     if (!options.keepInbox) {
-      const task = this._writeTail.then(async () => {
+      void this._mutatePending(async () => {
         const before = this._durable.snapshot();
+        await this._durable.clear();
         for (const message3 of [...before.nextStep, ...before.nextTurn]) {
           this._ctx.emit("agent/inbox/discarded", { id: this.id, message: message3 });
         }
-        await this._durable.clear();
-      }).catch((error2) => {
-        this._ctx.emit("agent/error", { id: this.id, error: error2 });
-      });
-      this._writeTail = task;
-      this._pendingWrite = task;
-      task.finally(() => {
-        if (this._pendingWrite === task) this._pendingWrite = void 0;
-      });
+        this._wakeReserved = false;
+      }, false, true);
     }
     this._controller?.abort(cause);
     this._maintenance?.controller.abort(cause);
   }
   async whenIdle() {
-    while (this._pendingWrite) await this._pendingWrite;
     while (true) {
+      while (this._pendingWrite) await this._pendingWrite;
       const maintenance = this._maintenance;
       if (maintenance) {
         await maintenance.promise.catch(() => void 0);
@@ -11293,7 +11633,7 @@ var LiveAgentImpl = class {
         await drain.catch(() => void 0);
         continue;
       }
-      if (!this._durable.size) break;
+      if (!this._hasQueuedWork()) break;
       await new Promise((resolve12) => setTimeout(resolve12, 0));
     }
   }
@@ -11335,6 +11675,7 @@ var LiveAgentImpl = class {
       this._pendingWrite = void 0;
       await writeTail.catch(() => void 0);
     }
+    await this.session.close();
     this._setStatus("idle");
   }
   /** Publish the agent lifecycle session-start notification once. */
@@ -11364,13 +11705,23 @@ var LiveAgentImpl = class {
     if (this._disposed || this._manualStreaming || this._drainPromise || this._busy || this._maintenanceBusy) return;
     const task = this._drainAll();
     this._drainPromise = task;
-    task.finally(() => {
-      if (this._drainPromise === task) this._drainPromise = void 0;
-    });
+    void task.then(
+      () => {
+        if (this._drainPromise === task) this._drainPromise = void 0;
+        if (this._hasQueuedWork()) queueMicrotask(() => this._wake());
+      },
+      (error2) => {
+        if (this._drainPromise === task) this._drainPromise = void 0;
+        try {
+          this._ctx.emit("agent/error", { id: this.id, agent: this, error: error2 });
+        } catch {
+        }
+      }
+    );
   }
   async _drainAll() {
     await this._writeTail.catch(() => void 0);
-    if (this._durable.size) {
+    if (this._hasQueuedWork()) {
       for await (const _ of this._streamTurns()) void _;
     }
   }
@@ -11386,10 +11737,13 @@ var LiveAgentImpl = class {
     this._setStatus("running");
     try {
       while (!this._disposed) {
-        const batch = await this._durable.claimBatch();
-        if (!batch.length) break;
-        const input = await this._inputForBatch(batch);
+        const snapshot = this._durable.snapshot();
+        if (!snapshot.nextTurn.length && !this._wakeReserved) break;
         const turn = await this._nextTurnNumber();
+        await this.session.append("turn/start", { turn, reason: "user" });
+        const batch = await this._durable.claimBatch();
+        this._wakeReserved = false;
+        const input = batch.length ? await this._inputForBatch(batch, true) : { text: "" };
         for (const message3 of batch) {
           this._ctx.emit("agent/inbox/claimed", {
             id: this.id,
@@ -11406,11 +11760,21 @@ var LiveAgentImpl = class {
         else signal?.addEventListener("abort", forward, { once: true });
         try {
           if (this._manualStreaming) {
-            yield* this._service.runStream(input, { signal: controller.signal });
+            if (this._loop) {
+              const run = await this._loop(input, { signal: controller.signal, turn });
+              await this._closeCustomTurn(turn, run);
+              yield { type: "run/end", run };
+            } else {
+              yield* this._service.runStream(input, { signal: controller.signal, turn });
+            }
           } else {
-            await this._service.run(input, { signal: controller.signal });
+            if (this._loop) {
+              const run = await this._loop(input, { signal: controller.signal, turn });
+              await this._closeCustomTurn(turn, run);
+            } else await this._service.run(input, { signal: controller.signal, turn });
           }
         } catch (error2) {
+          if (this._loop) await this._closeFailedCustomTurn(turn, error2);
           if (!controller.signal.aborted) {
             const step = await this._failedStep();
             this._ctx.emit("agent/error", {
@@ -11428,26 +11792,37 @@ var LiveAgentImpl = class {
       }
     } finally {
       this._busy = false;
+      if (!this._durable.size) this._wakeReserved = false;
       this._setStatus("idle");
     }
   }
-  async _inputForBatch(batch) {
-    const history = await this.session.deriveMessages();
-    const structured = batch.filter((message3) => message3.content !== void 0);
-    const plain = batch.filter((message3) => message3.content === void 0);
-    const plainMessages = plain.filter((message3) => message3.text !== void 0).map((message3) => ({ role: "user", content: message3.text ?? "" }));
-    if (structured.length) {
-      return {
-        messages: [
-          ...history,
-          ...structured.flatMap((message3) => Array.isArray(message3.content) ? message3.content : [{ role: "user", content: String(message3.content ?? "") }])
-        ]
-      };
-    }
-    if (history.length || batch.length > 1) {
-      return { messages: [...history, ...plainMessages] };
+  _hasQueuedWork() {
+    const snapshot = this._durable.snapshot();
+    return snapshot.nextTurn.length > 0 || this._wakeReserved && snapshot.nextStep.length > 0;
+  }
+  async _inputForBatch(batch, includeHistory) {
+    const history = includeHistory ? await this.session.deriveMessages() : [];
+    const messages = batch.flatMap((message3) => message3.content !== void 0 ? Array.isArray(message3.content) ? message3.content : [{ role: "user", content: String(message3.content ?? "") }] : message3.text !== void 0 ? [{ role: "user", content: message3.text }] : []);
+    if (history.length || messages.length > 1) return { messages: [...history, ...messages] };
+    return { text: messages[0]?.content ?? "" };
+  }
+  async claimNextStepInputs() {
+    await this._writeTail;
+    const batch = await this._durable.claimNextStep();
+    this._wakeReserved = false;
+    if (batch.length) {
+      const turn = await this._nextTurnNumber() - 1;
+      for (const message3 of batch) {
+        this._ctx.emit("agent/inbox/claimed", {
+          id: this.id,
+          agent: this,
+          message: message3,
+          input: { text: message3.text ?? "" },
+          turn
+        });
+      }
     }
-    return { text: plainMessages[0]?.content ?? "" };
+    return batch.length ? [await this._inputForBatch(batch, false)] : [];
   }
   _setStatus(status) {
     const previous = this._status;
@@ -11543,112 +11918,156 @@ async function buildHandle(ctx, options, resume = false) {
   }
   const agentId = fileMeta?.agentId ?? requestedId;
   if (!agentId) throw new AgentError("agent requires a stable identity");
-  const log = new SessionLog(
-    options.file,
-    (type, payload) => {
-      if (type === "event") ctx.emit("session/event", payload);
-      else ctx.emit("session/flush", payload);
-    }
-  );
-  await log.init();
-  const fileEvents = await log.read();
-  const durableMeta = readDurableAgentMeta(fileEvents);
-  if (durableMeta) {
-    if (durableMeta.agentId !== agentId) {
-      throw new AgentError(
-        `agent id mismatch: session belongs to ${durableMeta.agentId}, requested ${agentId}`
-      );
-    }
-    if (options.agentType && durableMeta.agentType !== options.agentType) {
-      throw new AgentError(
-        `agent type mismatch: session is ${durableMeta.agentType ?? "untyped"}, requested ${options.agentType}`
-      );
-    }
-    if (options.mode && durableMeta.mode !== options.mode) {
-      throw new AgentError(
-        `agent mode mismatch: session is ${durableMeta.mode ?? "unset"}, requested ${options.mode}`
-      );
-    }
-  }
-  const boundMeta = {
-    ...fileMeta,
-    ...durableMeta ?? {},
-    ...options.title ? { title: options.title } : {},
-    ...options.owner ? { owner: options.owner } : {},
-    ...options.parentSessionId ? { parentSessionId: options.parentSessionId } : {},
-    ...options.forkedAtMessageId ? { forkedAtMessageId: options.forkedAtMessageId } : {},
-    agentId
-  };
-  const resolvedAgentType = options.agentType ?? durableMeta?.agentType;
-  if (resolvedAgentType) boundMeta.agentType = resolvedAgentType;
-  const resolvedMode = options.mode ?? durableMeta?.mode;
-  if (resolvedMode) boundMeta.mode = resolvedMode;
-  if (!durableMeta) {
-    await log.append("meta", {
-      kind: "agent",
-      agentId,
-      ...boundMeta.agentType ? { agentType: boundMeta.agentType } : {},
-      ...boundMeta.mode ? { mode: boundMeta.mode } : {},
-      ...boundMeta.title ? { title: boundMeta.title } : {},
-      ...boundMeta.owner ? { owner: boundMeta.owner } : {},
-      ...boundMeta.parentSessionId ? { parentSessionId: boundMeta.parentSessionId } : {},
-      ...boundMeta.forkedAtMessageId ? { forkedAtMessageId: boundMeta.forkedAtMessageId } : {},
-      ...boundMeta.createdAt !== void 0 ? { createdAt: boundMeta.createdAt } : {}
-    });
-  }
-  const durable = resume ? await DurableInbox.restore(log) : new DurableInbox(log);
-  const injected = new AgentInbox();
-  const inboxView = {
-    get size() {
-      return durable.size;
-    },
-    snapshot: () => durable.snapshot()
-  };
-  const service = new AgentService(ctx, {
-    session: log,
-    inbox: injected,
-    ...options.llm ? { llm: options.llm } : {},
-    ...options.maxTurns !== void 0 ? { maxTurns: options.maxTurns } : {},
-    ...options.maxSteps !== void 0 ? { maxSteps: options.maxSteps } : {},
-    ...options.contextBudget ? { contextBudget: options.contextBudget } : {},
-    ...options.hooks ? { hooks: options.hooks } : {}
-  });
-  if (options.system) injected.inject("agentSystem", options.system);
+  let agentCtx;
   const agentScope = await ctx.inject([], (scopeCtx) => {
-    scopeCtx.isolate("agentScope").provide("agentScope", scopeCtx);
+    agentCtx = scopeCtx.isolate("agentScope").isolate("llm").isolate("tools").isolate("systemPrompt");
+    agentCtx.provide("agentScope", agentCtx);
   });
   await agentScope;
-  const agentCtx = agentScope.ctx;
-  const agent2 = new LiveAgentImpl(
-    ctx,
-    agentCtx,
-    service,
-    agentId,
-    inboxView,
-    log,
-    durable,
-    boundMeta,
-    options.manualStreaming === true
-  );
-  agent2.trackSetupDispose(() => agentScope.dispose());
-  if (options.system) agent2.inject("agentSystem", options.system);
-  let setupResult;
+  const runtimeCtx = createAgentRuntimeContext(agentCtx);
+  const log = new SessionLog(options.file, void 0, runtimeCtx);
   try {
-    setupResult = await options.setup?.(agentCtx);
-    setupResult?.commit();
+    await log.init();
+    const fileEvents = await log.read();
+    const durableMeta = readDurableAgentMeta(fileEvents);
+    if (durableMeta) {
+      if (durableMeta.agentId !== agentId) {
+        throw new AgentError(
+          `agent id mismatch: session belongs to ${durableMeta.agentId}, requested ${agentId}`
+        );
+      }
+      if (options.agentType && durableMeta.agentType !== options.agentType) {
+        throw new AgentError(
+          `agent type mismatch: session is ${durableMeta.agentType ?? "untyped"}, requested ${options.agentType}`
+        );
+      }
+      if (options.mode && durableMeta.mode !== options.mode) {
+        throw new AgentError(
+          `agent mode mismatch: session is ${durableMeta.mode ?? "unset"}, requested ${options.mode}`
+        );
+      }
+    }
+    const boundMeta = {
+      ...fileMeta,
+      ...durableMeta ?? {},
+      ...options.title ? { title: options.title } : {},
+      ...options.owner ? { owner: options.owner } : {},
+      ...options.parentSessionId ? { parentSessionId: options.parentSessionId } : {},
+      ...options.forkedAtMessageId ? { forkedAtMessageId: options.forkedAtMessageId } : {},
+      agentId
+    };
+    const resolvedAgentType = options.agentType ?? durableMeta?.agentType;
+    if (resolvedAgentType) boundMeta.agentType = resolvedAgentType;
+    const resolvedMode = options.mode ?? durableMeta?.mode;
+    if (resolvedMode) boundMeta.mode = resolvedMode;
+    if (!durableMeta) {
+      await log.append("meta", {
+        kind: "agent",
+        agentId,
+        ...boundMeta.agentType ? { agentType: boundMeta.agentType } : {},
+        ...boundMeta.mode ? { mode: boundMeta.mode } : {},
+        ...boundMeta.title ? { title: boundMeta.title } : {},
+        ...boundMeta.owner ? { owner: boundMeta.owner } : {},
+        ...boundMeta.parentSessionId ? { parentSessionId: boundMeta.parentSessionId } : {},
+        ...boundMeta.forkedAtMessageId ? { forkedAtMessageId: boundMeta.forkedAtMessageId } : {},
+        ...boundMeta.createdAt !== void 0 ? { createdAt: boundMeta.createdAt } : {}
+      });
+    }
+    const durable = resume ? await DurableInbox.restore(log) : new DurableInbox(log);
+    const restoredWakeReservation = resume && hasRestoredWakeReservation(fileEvents);
+    const injected = new AgentInbox();
+    const inboxView = {
+      get size() {
+        return durable.size;
+      },
+      snapshot: () => durable.snapshot()
+    };
+    let claimNextStep = async () => [];
+    const service = new AgentService(runtimeCtx, {
+      session: log,
+      inbox: injected,
+      ...options.llm ? { llm: options.llm } : {},
+      ...options.maxTurns !== void 0 ? { maxTurns: options.maxTurns } : {},
+      ...options.maxSteps !== void 0 ? { maxSteps: options.maxSteps } : {},
+      ...options.contextBudget ? { contextBudget: options.contextBudget } : {},
+      ...options.hooks ? { hooks: options.hooks } : {},
+      claimNextStep: () => claimNextStep()
+    });
+    if (options.system) injected.inject("agentSystem", options.system);
+    const agent2 = new LiveAgentImpl(
+      runtimeCtx,
+      agentCtx,
+      service,
+      agentId,
+      inboxView,
+      log,
+      durable,
+      boundMeta,
+      options.manualStreaming === true,
+      restoredWakeReservation
+    );
+    claimNextStep = () => agent2.claimNextStepInputs();
+    agent2.trackSetupDispose(() => agentScope.dispose());
+    let setupResult;
+    try {
+      setupResult = await options.setup?.(agentCtx);
+      for (const name2 of ["llm", "systemPrompt"]) {
+        if (agentCtx.reflect.get(name2, false) !== void 0) continue;
+        const inherited = ctx.reflect.get(name2, false);
+        if (inherited !== void 0) agentCtx.provide(name2, inherited);
+      }
+      const loop = agentCtx.reflect.get("agentLoop", false);
+      agent2.setLoop(loop);
+      setupResult?.commit();
+    } catch (error2) {
+      await agent2.dispose().catch(() => void 0);
+      await log.close().catch(() => void 0);
+      throw error2;
+    }
+    await agent2.publishSessionStart(resume ? "resume" : "startup");
+    for (const input of options.initial ?? []) {
+      if (!resume) await durable.insert({ text: input.text ?? "" });
+    }
+    if (resume && (durable.snapshot().nextTurn.length || restoredWakeReservation) && options.manualStreaming !== true) {
+      setTimeout(() => agent2.wakeNow(), 0);
+    }
+    return { agent: agent2, dispose: () => agent2.dispose() };
   } catch (error2) {
-    await agent2.dispose().catch(() => void 0);
-    await log.close().catch(() => void 0);
+    await Promise.resolve().then(() => agentScope.dispose()).catch(() => void 0);
     throw error2;
   }
-  await agent2.publishSessionStart(resume ? "resume" : "startup");
-  for (const input of options.initial ?? []) {
-    if (!resume) await durable.insert({ text: input.text ?? "" });
-  }
-  if (resume && durable.size && options.manualStreaming !== true) {
-    setTimeout(() => agent2.wakeNow(), 0);
+}
+function hasRestoredWakeReservation(events) {
+  const nextTurn = [];
+  const nextStep = [];
+  for (const event of events) {
+    if (event.type !== "agent/inbox/spliced") continue;
+    const payload = event.payload;
+    if (payload.target === "all") {
+      nextTurn.splice(0, payload.deleteCounts?.nextTurn ?? nextTurn.length);
+      nextStep.splice(0, payload.deleteCounts?.nextStep ?? nextStep.length);
+      continue;
+    }
+    const list = payload.target === "next-step" ? nextStep : nextTurn;
+    const count = payload.deleteCount ?? 0;
+    if (count === Number.POSITIVE_INFINITY) {
+      list.length = 0;
+    } else if (count > 0 && payload.index !== void 0) {
+      list.splice(payload.index, count);
+    }
+    let insertedOffset = 0;
+    for (const inserted of payload.inserted ?? []) {
+      const entry = { wakes: payload.target === "next-step" && inserted.mode === "steer" };
+      if (inserted.mode === "steer") {
+        list.unshift(entry);
+      } else {
+        const index = payload.index === void 0 ? list.length : Math.min(list.length, payload.index + insertedOffset);
+        list.splice(index, 0, entry);
+        insertedOffset += 1;
+      }
+    }
   }
-  return { agent: agent2, dispose: () => agent2.dispose() };
+  return nextStep.some((entry) => entry.wakes);
 }
 async function readAgentMeta(file) {
   const lines = await import("node:fs/promises").then((fs2) => fs2.readFile(file, "utf8")).catch((error2) => {
@@ -12098,7 +12517,9 @@ function anthropicMessagesAdapter(config2 = {}) {
         }
         let sawEvent = false;
         try {
-          for await (const event of parseAnthropicStream(response.body)) {
+          const contentType2 = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+          const events = contentType2 === "application/json" ? parseJSONCompletionStream(response) : parseAnthropicStream(response.body);
+          for await (const event of events) {
             sawEvent = true;
             yield event;
           }
@@ -12139,7 +12560,7 @@ function buildRequest(messages, tools2, config2, signal, stream = false) {
       headers: {
         "content-type": "application/json",
         "anthropic-version": ANTHROPIC_VERSION,
-        ...config2.apiKey ? { "x-api-key": config2.apiKey } : {}
+        ...config2.apiKey ? { [config2.apiKeyHeader ?? "x-api-key"]: config2.apiKey } : {}
       },
       body: JSON.stringify(body),
       ...signal ? { signal } : {}
@@ -12431,6 +12852,26 @@ async function* parseAnthropicStream(body) {
 function toIndex(block) {
   return typeof block.index === "number" ? block.index : 0;
 }
+async function* parseJSONCompletionStream(response) {
+  const payload = await parseJson(response);
+  const completion = parseCompletion(payload);
+  const record3 = payload;
+  const id = typeof record3?.id === "string" && record3.id ? record3.id : randomUUID5();
+  const model = typeof record3?.model === "string" && record3.model ? record3.model : void 0;
+  yield { type: "message_start", id, ...model ? { model } : {} };
+  if (completion.content) yield { type: "message_delta", id, delta: completion.content };
+  for (const [index, call] of (completion.toolCalls ?? []).entries()) {
+    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 toStreamError(error2, timeoutMs) {
   if (isAbortLike(error2)) {
     return new OpenAICompatibleError(
@@ -12519,7 +12960,9 @@ function openaiCompatAdapter(config2 = {}) {
         }
         let sawEvent = false;
         try {
-          for await (const event of parseOpenAIStream(response.body)) {
+          const contentType2 = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+          const events = contentType2 === "application/json" ? parseJSONCompletionStream2(response) : parseOpenAIStream(response.body);
+          for await (const event of events) {
             sawEvent = true;
             yield event;
           }
@@ -12711,6 +13154,26 @@ async function* parseOpenAIStream(body) {
   }
   yield* finalizeStreamEvents(messageId, content, calls, finishReason);
 }
+async function* parseJSONCompletionStream2(response) {
+  const payload = await parseJson(response);
+  const completion = parseCompletion2(payload);
+  const record3 = payload;
+  const id = typeof record3?.id === "string" && record3.id ? record3.id : randomUUID6();
+  const model = typeof record3?.model === "string" && record3.model ? record3.model : void 0;
+  yield { type: "message_start", id, ...model ? { model } : {} };
+  if (completion.content) yield { type: "message_delta", id, delta: completion.content };
+  for (const [index, call] of (completion.toolCalls ?? []).entries()) {
+    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 processStreamChunk(payload, state, progress, calls) {
   const record3 = payload;
   const events = [];
@@ -30049,7 +30512,7 @@ async function updateSystemConfig(patch, file = systemConfigPath()) {
 }
 function effectiveLlmConfig(config2, env = process.env) {
   const envConfig = resolveLlmEnv(env);
-  const apiKey = envConfig.apiKey ?? config2.apiKey;
+  const apiKey = effectiveApiKey(config2, env);
   const baseUrl = envConfig.baseUrl ?? config2.baseUrl ?? DEFAULT_OPENCODE_GO_BASE_URL;
   const model = envConfig.model ?? config2.model ?? DEFAULT_MODEL;
   const result = {
@@ -30058,15 +30521,18 @@ function effectiveLlmConfig(config2, env = process.env) {
     model
   };
   if (config2.protocol) result.protocol = config2.protocol;
+  if (config2.apiKeyHeader) result.apiKeyHeader = config2.apiKeyHeader;
   if (config2.temperature !== void 0) result.temperature = config2.temperature;
   return result;
 }
 function effectiveApiKey(config2, env = process.env) {
+  if (env.TNEGA_API_KEY) return env.TNEGA_API_KEY;
+  if (config2.protocol && config2.apiKey) return config2.apiKey;
   return resolveLlmEnv(env).apiKey ?? config2.apiKey;
 }
 function resolveLlmEnv(env = process.env) {
   const config2 = {};
-  const apiKey = env.OPENCODE_GO_API_KEY || env.OPENAI_API_KEY || env.DEEPSEEK_API_KEY;
+  const apiKey = env.TNEGA_API_KEY || env.OPENCODE_GO_API_KEY || env.OPENAI_API_KEY || env.DEEPSEEK_API_KEY;
   if (apiKey) config2.apiKey = apiKey;
   if (env.OPENCODE_GO_BASE_URL) config2.baseUrl = env.OPENCODE_GO_BASE_URL;
   if (env.OPENCODE_GO_MODEL) config2.model = env.OPENCODE_GO_MODEL;
@@ -30082,6 +30548,9 @@ function normalizeConfig2(value) {
   if (record3.protocol === "anthropic" || record3.protocol === "openai") {
     config2.protocol = record3.protocol;
   }
+  if (record3.apiKeyHeader === "x-api-key" || record3.apiKeyHeader === "api-key") {
+    config2.apiKeyHeader = record3.apiKeyHeader;
+  }
   if (typeof record3.temperature === "number" && Number.isFinite(record3.temperature)) {
     config2.temperature = record3.temperature;
   }
@@ -31141,10 +31610,10 @@ async function runCommand3(options) {
   if (candidate.coding) {
     const systemConfig = await readSystemConfig();
     const envConfig = resolveLlmEnv(process.env);
-    const apiKey = envConfig.apiKey ?? systemConfig.apiKey;
+    const apiKey = effectiveApiKey(systemConfig);
     if (!apiKey) {
       throw new CliError(
-        "missing LLM API key for coding eval; set OPENCODE_GO_API_KEY (or OPENAI_API_KEY / DEEPSEEK_API_KEY) or configure it in the tnega config file"
+        "missing LLM API key for coding eval; set TNEGA_API_KEY (or OPENCODE_GO_API_KEY / OPENAI_API_KEY / DEEPSEEK_API_KEY) or configure it in the tnega config file"
       );
     }
     const model = options.model ?? envConfig.model ?? systemConfig.model ?? candidate.coding.model;
@@ -31154,6 +31623,7 @@ async function runCommand3(options) {
       ...model ? { model } : {},
       ...baseUrl ? { baseUrl } : {},
       ...systemConfig.protocol ? { protocol: systemConfig.protocol } : {},
+      ...systemConfig.apiKeyHeader ? { apiKeyHeader: systemConfig.apiKeyHeader } : {},
       ...options.maxTokens !== void 0 ? { maxTokens: options.maxTokens } : {},
       ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
       ...systemConfig.temperature !== void 0 && options.temperature === void 0 ? { temperature: systemConfig.temperature } : {},
@@ -31221,10 +31691,10 @@ async function runAgentCommand(options) {
   const profileOptions = profile?.options ?? {};
   const systemConfig = await readSystemConfig(configFile);
   const envConfig = resolveLlmEnv(process.env);
-  const apiKey = envConfig.apiKey ?? systemConfig.apiKey;
+  const apiKey = effectiveApiKey(systemConfig);
   if (!apiKey) {
     throw new CliError(
-      "missing LLM API key; set OPENCODE_GO_API_KEY (or OPENAI_API_KEY / DEEPSEEK_API_KEY) or configure it in the tnega config file"
+      "missing LLM API key; set TNEGA_API_KEY (or OPENCODE_GO_API_KEY / OPENAI_API_KEY / DEEPSEEK_API_KEY) or configure it in the tnega config file"
     );
   }
   const model = options.model ?? profileOptions.model ?? envConfig.model ?? systemConfig.model;
@@ -31235,6 +31705,7 @@ async function runAgentCommand(options) {
     ...typeof model === "string" && model ? { model } : {},
     ...baseUrl ? { baseUrl } : {},
     ...protocolFrom(profileOptions) ?? systemConfig.protocol ? { protocol: protocolFrom(profileOptions) ?? systemConfig.protocol } : {},
+    ...systemConfig.apiKeyHeader ? { apiKeyHeader: systemConfig.apiKeyHeader } : {},
     ...options.maxTokens !== void 0 ? { maxTokens: options.maxTokens } : {},
     ...options.maxTokens === void 0 && typeof profileOptions.maxTokens === "number" ? { maxTokens: profileOptions.maxTokens } : {},
     ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
@@ -31365,10 +31836,10 @@ async function runEvolveCommand(options) {
   const configFile = options.configFile ?? systemConfigPath();
   const systemConfig = await readSystemConfig(configFile);
   const envConfig = resolveLlmEnv(process.env);
-  const apiKey = envConfig.apiKey ?? systemConfig.apiKey;
+  const apiKey = effectiveApiKey(systemConfig);
   if (!apiKey) {
     throw new CliError(
-      "missing LLM API key; set OPENCODE_GO_API_KEY (or OPENAI_API_KEY / DEEPSEEK_API_KEY) or configure it in the tnega config file"
+      "missing LLM API key; set TNEGA_API_KEY (or OPENCODE_GO_API_KEY / OPENAI_API_KEY / DEEPSEEK_API_KEY) or configure it in the tnega config file"
     );
   }
   const model = options.model ?? envConfig.model ?? systemConfig.model;
@@ -31378,6 +31849,7 @@ async function runEvolveCommand(options) {
     ...model ? { model } : {},
     ...baseUrl ? { baseUrl } : {},
     ...systemConfig.protocol ? { protocol: systemConfig.protocol } : {},
+    ...systemConfig.apiKeyHeader ? { apiKeyHeader: systemConfig.apiKeyHeader } : {},
     ...options.maxTokens !== void 0 ? { maxTokens: options.maxTokens } : {},
     ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
     ...systemConfig.temperature !== void 0 && options.temperature === void 0 ? { temperature: systemConfig.temperature } : {},
@@ -32744,6 +33216,7 @@ function adapterFromConfig(effective, apiKey) {
     model: effective.model
   };
   if (effective.protocol) options.protocol = effective.protocol;
+  if (effective.apiKeyHeader) options.apiKeyHeader = effective.apiKeyHeader;
   if (effective.temperature !== void 0) options.temperature = effective.temperature;
   return createLlmAdapter(options);
 }
@@ -33380,6 +33853,7 @@ export {
   bootAgentRuntimeFromFile,
   compareCommand,
   createAgentRuntime,
+  effectiveApiKey,
   ensureProfileDir,
   formatAgentRun,
   formatBenchmarkImport,