effect-agent 0.1.0-beta.144 → 0.1.0-beta.149

package/src/engine/internal/agent-runtime.ts

@@ -3248,8 +3248,8 @@ export const formatRunStatus = (view: RunStatusView): string => {
 /**
  * The run-status message is derived per request and appended only to the
  * OUTGOING prompt: official history and durable commits never carry it, so it
- * can never accumulate or replay. OpenAI receives it as trailing system guidance,
- * leaving the last user/tool result as the implicit cache-write boundary.
+ * can never accumulate or replay. Capable adapters receive trailing system guidance,
+ * leaving the preceding user/tool result available as a cache-write boundary.
  */
 const outgoingModelPrompt = (
   policy: AgentPolicy,
@@ -3257,13 +3257,13 @@ const outgoingModelPrompt = (
   prepared: Prompt.Prompt,
   turn: number,
   declaredToolCalls: number,
-): Effect.Effect<Prompt.Prompt, never, Model.ProviderName> =>
+  systemMessagesInHistory: boolean,
+): Effect.Effect<Prompt.Prompt> =>
   Effect.gen(function* () {
     if (policy.runStatus !== "appended") {
       return prepared;
     }
     const now = yield* Clock.currentTimeMillis;
-    const provider = yield* Model.ProviderName;
 
     const status = formatRunStatus({
       turn,
@@ -3280,7 +3280,7 @@ const outgoingModelPrompt = (
 
     return Prompt.fromMessages([
       ...prepared.content,
-      provider === "openai"
+      systemMessagesInHistory
         ? Prompt.systemMessage({ content: status })
         : Prompt.userMessage({ content: [Prompt.textPart({ text: status })] }),
     ]);
@@ -3880,6 +3880,8 @@ const estimateContextTokens = Effect.fn("AgentRuntime.estimateContextTokens")(fu
 const nextContextEstimate = Effect.fn("AgentRuntime.nextContextEstimate")(function* (
   context: RunContext,
   view: ReadonlyArray<Prompt.Message>,
+  systemMessagesInHistory: boolean,
+  staticInstructions: Prompt.RawInput | undefined,
 ) {
   const state = context.compaction;
 
@@ -3896,7 +3898,12 @@ const nextContextEstimate = Effect.fn("AgentRuntime.nextContextEstimate")(functi
   }
 
   return yield* estimateContextTokens(
-    prepareModelPrompt(Prompt.fromMessages(view), undefined).content,
+    prepareModelPrompt(
+      Prompt.fromMessages(view),
+      undefined,
+      systemMessagesInHistory,
+      staticInstructions,
+    ).content,
   );
 });
 
@@ -5551,6 +5558,25 @@ const makeTurn = <
       const withCallModel = <A, E, R>(operation: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
         modelServices === undefined ? operation : Effect.provide(operation, modelServices);
 
+      const provider = yield* withCallModel(Model.ProviderName);
+
+      // Older adapters do not expose this native capability. Keep their safe
+      // projection; only the established OpenAI and xAI transports default to it.
+      // Evaluate against this call's services so scoped model overrides are honored.
+      const callModel: LanguageModel.LanguageModel & {
+        readonly supportsSystemMessagesInHistory?: Effect.Effect<boolean> | undefined;
+      } = yield* withCallModel(LanguageModel.LanguageModel);
+
+      const systemMessagesInHistory =
+        callModel.supportsSystemMessagesInHistory === undefined
+          ? provider === "openai" || provider === "xai"
+          : yield* withCallModel(callModel.supportsSystemMessagesInHistory);
+
+      const staticInstructions =
+        typeof agent.definition.instructions === "function"
+          ? undefined
+          : agent.definition.instructions;
+
       const priorCompactionPrefix = context.preparedCompactionSource?.prefix;
 
       if (priorCompactionPrefix !== undefined && priorCompactionPrefix.length > 0) {
@@ -5690,9 +5716,14 @@ const makeTurn = <
 
       const canonicalDecoration = !admissionRequired
         ? Prompt.empty
-        : yield* outgoingModelPrompt(policy, context, Prompt.empty, turn, priorToolCalls).pipe(
-            withCallModel,
-          );
+        : yield* outgoingModelPrompt(
+            policy,
+            context,
+            Prompt.empty,
+            turn,
+            priorToolCalls,
+            systemMessagesInHistory,
+          ).pipe(withCallModel);
 
       const estimateToolSchemaTokens = Effect.suspend(() => {
         const choice = modelToolChoice();
@@ -5752,8 +5783,15 @@ const makeTurn = <
       // canonical indices still locate appended content and compaction coverage.
       const estimateSourceContext = (view: ReadonlyArray<Prompt.Message>) =>
         options.context === undefined && options.transientContext === undefined
-          ? nextContextEstimate(context, view)
-          : estimateCallTokens(prepareModelPrompt(Prompt.fromMessages(view), undefined).content);
+          ? nextContextEstimate(context, view, systemMessagesInHistory, staticInstructions)
+          : estimateCallTokens(
+              prepareModelPrompt(
+                Prompt.fromMessages(view),
+                undefined,
+                systemMessagesInHistory,
+                staticInstructions,
+              ).content,
+            );
 
       let prepared = buildCompactedView(modelContext.prompt.content, context.compaction);
       let sourceTokens: number | undefined;
@@ -6005,6 +6043,7 @@ const makeTurn = <
               transientContext,
               turn,
               priorToolCalls,
+              systemMessagesInHistory,
             ).pipe(withCallModel);
 
       const derivedPromptContentTokens = !admissionRequired
@@ -6186,9 +6225,12 @@ const makeTurn = <
             prepareModelPrompt(
               Prompt.fromMessages([...basis.content, ...transientContext.content]),
               outputContract._tag === "rendered" ? outputContract.part : undefined,
+              systemMessagesInHistory,
+              staticInstructions,
             ),
             turn,
             priorToolCalls,
+            systemMessagesInHistory,
           ).pipe(
             withCallModel,
             Effect.flatMap((providerPrompt) =>
@@ -6759,7 +6801,16 @@ const makeTurn = <
           const settleOrFollowUp = (history: Prompt.Prompt) =>
             Effect.gen(function* () {
               yield* advanceHistory(context, history, options);
-              const steering = yield* drainInputs(context, options);
+
+              // Do not consume durable receipts that this completed Turn cannot cover.
+              // Final-answer mode permits one grace Turn, but never a second finalization.
+              const turnsBlocked =
+                policy.onExhaustion === "fail" ? turn >= bounds.maxTurns : turn > bounds.maxTurns;
+
+              const steering =
+                turnsBlocked || context.finalizationUsed
+                  ? []
+                  : yield* drainInputs(context, options);
 
               const queued =
                 steering.length > 0
@@ -6771,9 +6822,6 @@ const makeTurn = <
                 // `maxTurns` (RUN-019): `turn > maxTurns` can only be
                 // `maxTurns + 1`, so a second grace is structurally
                 // impossible.
-                const turnsBlocked =
-                  policy.onExhaustion === "fail" ? turn >= bounds.maxTurns : turn > bounds.maxTurns;
-
                 if (turnsBlocked) {
                   return failRunEventStream(
                     AgentPolicyError.make({
@@ -7187,9 +7235,24 @@ const toolBatchContinuation = <
         }
       }
 
-      if (Option.isSome(selectedOutput)) {
+      // A completion Tool can admit steering while its handler runs. Only claim it
+      // when another ordinary Turn can cover it; otherwise keep it queued for a new Run.
+      const bounds = effectiveRunBounds(agent.definition.policy, options);
+
+      const canContinue =
+        turn < bounds.maxTurns &&
+        (completion?.required === true
+          ? toolCalls + context.programmaticToolCalls < bounds.maxToolCalls
+          : toolCalls + context.programmaticToolCalls <= bounds.maxToolCalls) &&
+        !context.tokenExhausted &&
+        !context.finalizationUsed &&
+        (yield* Clock.currentTimeMillis) < context.durationDeadlineMillis;
+
+      const steering =
+        Option.isSome(selectedOutput) && !canContinue ? [] : yield* drainInputs(context, options);
+
+      if (Option.isSome(selectedOutput) && steering.length === 0) {
         const output = selectedOutput.value;
-        const bounds = effectiveRunBounds(agent.definition.policy, options);
 
         const exhausted = context.tokenExhausted
           ? "tokens"
@@ -7225,7 +7288,6 @@ const toolBatchContinuation = <
           ),
         );
       }
-      const steering = yield* drainInputs(context, options);
       const nextPrompt = yield* appendInputs(context, history, steering, options);
 
       return nextTurn(nextPrompt, turn + 1, toolCalls);

package/src/engine/internal/output-contract.ts

@@ -147,22 +147,81 @@ export const outputSchemaContract = (definition: Agent.AnyDefinition): OutputCon
 const sameSystemMessage = Schema.toEquivalence(Prompt.SystemMessage);
 
 /**
- * Project system instructions and the output contract into one leading block.
- * Repeated Runs append instructions to canonical history; letting those copies
- * move the contract breaks the preceding user/tool prefix used by provider caches.
- * Keep the last occurrence of each equivalent system message, preserving the
- * precedence of distinct instructions and their native provider options.
+ * Keep supported system instructions in conversation order so changing late guidance
+ * cannot invalidate the preceding user/tool cache prefix. Omit an exact repeat
+ * only when no distinct system instruction intervened; returning to an earlier
+ * instruction after a different one must preserve the new directive's precedence.
+ * Anchor the immutable output contract after the initial system block.
+ * Restore leading static instructions for caller-supplied conversation-only history.
  *
  * This runs after preparation and compaction. Canonical messages, protected
  * instruction/input spans and compaction coverage retain their original positions.
- * Conversation order and message identities are unchanged. A single system block
- * also prevents Anthropic's last-system-group conversion from discarding earlier
- * application instructions or the output contract.
+ * Adapters without this capability retain the grouped-system projection: keep the
+ * last equivalent instruction with its native options, then the contract and
+ * conversation. This prevents older Anthropic adapters from discarding system groups.
  */
 export const prepareModelPrompt = (
   prompt: Prompt.Prompt,
   contract: Prompt.SystemMessage | undefined,
+  systemMessagesInHistory: boolean,
+  staticInstructions: Prompt.RawInput | undefined,
 ): Prompt.Prompt => {
+  if (systemMessagesInHistory) {
+    const content: Array<Prompt.Message> = [];
+    let lastSystem: Prompt.SystemMessage | undefined;
+    let ordered = prompt.content;
+
+    if (staticInstructions !== undefined) {
+      const firstConversation = prompt.content.findIndex((message) => message.role !== "system");
+
+      const leading = prompt.content.slice(
+        0,
+        firstConversation === -1 ? prompt.content.length : firstConversation,
+      );
+
+      const restored: Array<Prompt.Message> = [];
+
+      const instructions =
+        typeof staticInstructions === "string"
+          ? [Prompt.systemMessage({ content: staticInstructions })]
+          : Prompt.make(staticInstructions).content;
+
+      for (const message of instructions) {
+        if (message.role !== "system") break;
+        if (
+          leading.some(
+            (candidate) => candidate.role === "system" && sameSystemMessage(candidate, message),
+          )
+        )
+          break;
+
+        const original = prompt.content.find(
+          (candidate) => candidate.role === "system" && sameSystemMessage(candidate, message),
+        );
+
+        if (original === undefined) break;
+        restored.push(original);
+      }
+      if (restored.length > 0)
+        ordered = [...leading, ...restored, ...prompt.content.slice(leading.length)];
+    }
+
+    for (const message of ordered) {
+      if (message.role === "system") {
+        if (lastSystem !== undefined && sameSystemMessage(lastSystem, message)) continue;
+        lastSystem = message;
+      }
+      content.push(message);
+    }
+    if (contract !== undefined) {
+      const firstConversation = content.findIndex((message) => message.role !== "system");
+
+      content.splice(firstConversation === -1 ? content.length : firstConversation, 0, contract);
+    }
+
+    return Prompt.fromMessages(content);
+  }
+
   const systems: Array<Prompt.SystemMessage> = [];
   const conversation: Array<Prompt.Message> = [];
   const seen = new Map<string, Array<Prompt.SystemMessage>>();