effect-agent 0.1.0-beta.143 → 0.1.0-beta.148

package/src/durable/internal/worker-host.ts

@@ -128,6 +128,7 @@ import {
   WorkerHostConfig,
   WorkerPolicyResolver,
   type WorkerPolicyTarget,
+  type WorkerStartAdmission,
 } from "../WorkerHost.ts";
 import {
   definitionDigestsEqual,
@@ -263,6 +264,20 @@ export class WorkerInputControl extends Context.Service<
   }
 >()("@effect-agent/thread/internal/WorkerInputControl") {}
 
+const CurrentStartPreparation = Context.Reference<WorkerStartAdmission | undefined>(
+  "@effect-agent/thread/internal/CurrentStartPreparation",
+  { defaultValue: () => undefined },
+);
+
+const CurrentStartDelivery = Context.Reference<
+  | {
+      readonly authorization: WorkerStartAdmission;
+      readonly admission: WorkerAdmission;
+      readonly inputDigest: Digest;
+    }
+  | undefined
+>("@effect-agent/thread/internal/CurrentStartDelivery", { defaultValue: () => undefined });
+
 /** No in-memory ownership: every mutation is reserved in source canonical history with CAS. */
 export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
   options: WorkerRuntimeOptions,
@@ -290,9 +305,40 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
   const withCrypto = <A, E>(effect: Effect.Effect<A, E, Crypto.Crypto>) =>
     Effect.provideService(effect, Crypto.Crypto, deps.crypto);
 
+  const currentStart = Effect.fnUntraced(function* (
+    admission: WorkerStartAdmission | undefined,
+    sourceThreadId: ThreadId,
+    sourceSubmissionId: SubmissionId | undefined,
+    principal: Principal,
+    targetAgentId: AgentId,
+    continuationOf: WorkerContinuation | undefined,
+  ) {
+    if (
+      admission === undefined ||
+      admission.sourceThreadId !== sourceThreadId ||
+      admission.sourceSubmissionId !== sourceSubmissionId ||
+      (admission.principal !== principal && admission.requestedPrincipal !== principal) ||
+      admission.targetAgentId !== targetAgentId ||
+      !Schema.toEquivalence(Schema.UndefinedOr(WorkerContinuation))(
+        admission.continuationOf,
+        continuationOf,
+      )
+    )
+      return undefined;
+
+    const tail = yield* deps.store
+      .inspectTail(ThreadTailRequest.make({ threadId: sourceThreadId }))
+      .pipe(Effect.mapError(storageFailure("start")));
+
+    return tail.tailSequence === admission.tailSequence && tail.tailDigest === admission.tailDigest
+      ? admission
+      : undefined;
+  });
+
   const authorizeBudget = Effect.fn("WorkerHost.authorizeBudget")(function* (
     origin: WorkerOrigin,
     principal: Principal,
+    admission?: WorkerStartAdmission,
   ) {
     yield* verifyContinuation(origin);
     if (origin.budgetScope !== "worker-run") return;
@@ -300,6 +346,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     if (origin.depth !== 1) return yield* failure("start", "denied");
 
     yield* deps.budgetAuthorizer.authorize({
+      ...(admission === undefined ? {} : { admission }),
       source: origin.source,
       principal,
       worker: origin.worker,
@@ -1049,6 +1096,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     input: PersistedJson,
     principal: Principal,
     retainedFrameworkInput: boolean,
+    authorization?: WorkerStartAdmission,
   ): Effect.fn.Return<void, WorkerError> {
     const origin = admission.origin;
 
@@ -1133,6 +1181,11 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
           ? {
               ...targetRequest,
               _tag: "InitialInput",
+              ...(authorization === undefined ||
+              authorization.tailSequence !== current.tailSequence ||
+              authorization.tailDigest !== current.tailDigest
+                ? {}
+                : { admission: authorization }),
               ...(origin.continuationOf === undefined
                 ? {}
                 : { continuationOf: origin.continuationOf }),
@@ -1351,7 +1404,24 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     }
 
     yield* verifyContinuation(admission.origin);
+    const delivery = yield* CurrentStartDelivery;
+
+    const authorization =
+      delivery !== undefined &&
+      sameAdmission(delivery.admission, admission) &&
+      delivery.inputDigest === inputDigest
+        ? yield* currentStart(
+            delivery.authorization,
+            admission.origin.source.threadId,
+            admission.sourceSubmissionId,
+            options.principal,
+            agentId,
+            admission.origin.continuationOf,
+          )
+        : undefined;
+
     yield* deps.authorizer.authorize({
+      ...(authorization === undefined ? {} : { admission: authorization }),
       sourceThreadId: admission.origin.source.threadId,
       ...(admission.sourceSubmissionId === undefined
         ? {}
@@ -1364,7 +1434,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         ? {}
         : { continuationOf: admission.origin.continuationOf }),
     });
-    yield* authorizeBudget(admission.origin, options.principal);
+    yield* authorizeBudget(admission.origin, options.principal, authorization);
     if (
       admission.origin.worker.threadId !== options.threadId ||
       admission.origin.worker.targetAgentId !== agentId ||
@@ -1378,7 +1448,14 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
     if (retainedFrameworkInput && admission.reportKind !== "update")
       yield* validateCompletion(options.messageAdmission, options, agentId, inputDigest);
-    yield* reservation(admission, inputDigest, input, options.principal, retainedFrameworkInput);
+    yield* reservation(
+      admission,
+      inputDigest,
+      input,
+      options.principal,
+      retainedFrameworkInput,
+      authorization,
+    );
 
     return admission;
   });
@@ -1866,13 +1943,17 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     principal: Principal,
     sourceSubmissionId?: SubmissionId,
   ): SubagentHost["Service"] => {
+    const requestedPrincipal = principal;
+
     const authorize = (
       operation: WorkerError["operation"],
       access: "context" | "read" | "send" | "control",
       worker?: WorkerRef,
       continuationOf?: WorkerContinuation,
+      admission?: WorkerStartAdmission,
     ) =>
       deps.authorizer.authorize({
+        ...(admission === undefined ? {} : { admission }),
         sourceThreadId: context.source.threadId,
         ...(sourceSubmissionId === undefined ? {} : { sourceSubmissionId }),
         principal,
@@ -1894,6 +1975,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       target: Agent.AnyDefinition,
       encodedInput: unknown,
       continuationOf?: WorkerContinuation,
+      authorization?: WorkerStartAdmission,
     ) {
       const resolved = yield* binding(target, "start");
 
@@ -1908,8 +1990,18 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
       const source = yield* sourceAuthority(context.source.threadId, sourceSubmissionId);
 
+      const admission = yield* currentStart(
+        authorization,
+        context.source.threadId,
+        sourceSubmissionId,
+        principal,
+        target.id,
+        continuationOf,
+      );
+
       const policy = yield* resolveTargetPolicy({
         _tag: "InitialInput",
+        ...(admission === undefined ? {} : { admission }),
         ...(continuationOf === undefined ? {} : { continuationOf }),
         definition: resolved.definition,
         definitions: resolved.digests,
@@ -2064,6 +2156,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       encodedParameters: unknown,
       principal: Principal,
       operation: "start" | "followUp",
+      authorization?: WorkerStartAdmission,
     ) {
       if (Option.isNone(deps.deliveries)) return yield* failure(operation, "unavailable");
       const deliveries = deps.deliveries.value;
@@ -2146,17 +2239,25 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         Effect.provideService(MessageDeliveryStore, deliveries),
         Effect.provideService(PreparedInputAdmission, {
           submit: (prepared) =>
-            deps
-              .submit(prepared)
-              .pipe(
-                Effect.mapError((error) =>
-                  error._tag === "AdmissionConflict" || error._tag === "AgentInputError"
-                    ? ScheduledInputRefused.make({ code: error._tag, cause: error })
-                    : error._tag === "AdmissionPolicyError" && error.reason === "refused"
-                      ? ScheduledInputRefused.make({ code: error.code, cause: error })
-                      : ScheduledInputRetryable.make({ reason: "storage", cause: error }),
-                ),
+            deps.submit(prepared).pipe(
+              Effect.provideService(
+                CurrentStartDelivery,
+                authorization !== undefined &&
+                  prepared.workerAdmission !== undefined &&
+                  prepared.admissionKey === messageId &&
+                  prepared.inputDigest === inputDigest &&
+                  sameOrigin(prepared.workerAdmission.origin, origin)
+                  ? { authorization, admission: prepared.workerAdmission, inputDigest }
+                  : undefined,
               ),
+              Effect.mapError((error) =>
+                error._tag === "AdmissionConflict" || error._tag === "AgentInputError"
+                  ? ScheduledInputRefused.make({ code: error._tag, cause: error })
+                  : error._tag === "AdmissionPolicyError" && error.reason === "refused"
+                    ? ScheduledInputRefused.make({ code: error.code, cause: error })
+                    : ScheduledInputRetryable.make({ reason: "storage", cause: error }),
+              ),
+            ),
           submissionStatus: (receipt) =>
             deps
               .status(receipt)
@@ -2393,10 +2494,23 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
                 request.continuationOf.delegationId,
               );
 
-        yield* authorize("start", "send", undefined, previous?.evidence);
+        const admission = yield* currentStart(
+          yield* CurrentStartPreparation,
+          context.source.threadId,
+          sourceSubmissionId,
+          principal,
+          request.target.id,
+          previous?.evidence,
+        );
+
+        yield* authorize("start", "send", undefined, previous?.evidence, admission);
 
-        return (yield* preparedTarget(request.target, request.encodedInput, previous?.evidence))
-          .policy;
+        return (yield* preparedTarget(
+          request.target,
+          request.encodedInput,
+          previous?.evidence,
+          admission,
+        )).policy;
       }),
       start: Effect.fn("WorkerHost.start")(function* <E = never, R = never>(
         command: StartWorkerRequest | DeferredStartWorkerRequest<E, R>,
@@ -2411,8 +2525,26 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
                 command.delegationId,
               );
 
+        // Bind the decision to the tail before authorization. If it changes while the
+        // authorizer reads current state, currentStart rejects reuse of this decision.
+        const tail = yield* deps.store
+          .inspectTail(ThreadTailRequest.make({ threadId: context.source.threadId }))
+          .pipe(Effect.mapError(storageFailure("start")));
+
         const principal = yield* authorize("start", "send", undefined, previous?.evidence);
 
+        const startAdmission: WorkerStartAdmission = {
+          sourceThreadId: context.source.threadId,
+          ...(sourceSubmissionId === undefined ? {} : { sourceSubmissionId }),
+          requestedPrincipal,
+          principal,
+          targetAgentId: command.target.id,
+          ...(previous === undefined ? {} : { continuationOf: previous.evidence }),
+          access: "send",
+          tailSequence: tail.tailSequence,
+          tailDigest: tail.tailDigest,
+        };
+
         if (context.depth !== 0 && sourceSubmissionId === undefined)
           return yield* failure("start", "denied");
 
@@ -2507,7 +2639,14 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
         return yield* Effect.gen(function* () {
           const request =
-            "prepare" in command ? { ...(yield* command.prepare), ...command } : command;
+            "prepare" in command
+              ? {
+                  ...(yield* command.prepare.pipe(
+                    Effect.provideService(CurrentStartPreparation, startAdmission),
+                  )),
+                  ...command,
+                }
+              : command;
 
           const currentPrevious =
             command.continuationOf === undefined
@@ -2535,6 +2674,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
             request.target,
             request.encodedInput,
             currentPrevious?.evidence,
+            startAdmission,
           );
 
           const resolved = prepared.resolved;
@@ -2596,7 +2736,18 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
             "start",
           );
 
-          yield* authorizeBudget(origin, principal);
+          yield* authorizeBudget(
+            origin,
+            principal,
+            yield* currentStart(
+              startAdmission,
+              context.source.threadId,
+              sourceSubmissionId,
+              principal,
+              request.target.id,
+              currentPrevious?.evidence,
+            ),
+          );
 
           const targetPolicy = Option.isSome(prepared.policy)
             ? prepared.policy.value
@@ -2623,6 +2774,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
             request.encodedParameters,
             principal,
             "start",
+            startAdmission,
           );
 
           return { worker: origin.worker, delivery };

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>>();