@economic/agents 3.0.0 → 3.0.1

package/dist/index.d.mts

@@ -341,6 +341,61 @@ type Tool<Context extends Record<string, unknown> = Record<string, unknown>, INP
   executeTask?: ExecuteTask<Context, INPUT, NoInfer<OUTPUT> & TaskValue>;
 };
 export declare function tool<Context extends Record<string, unknown> = Record<string, unknown>, INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any>(definition: Tool<Context, INPUT, OUTPUT>): Tool<Context, INPUT, OUTPUT>;
+/** Tool execution options plus the additional context supplied by native Think actions. */
+type ActionContext<Context extends Record<string, unknown> = Record<string, unknown>> = ToolExecutionOptions<Context> & ActionContext$1 & {
+  /** The action's resolved domain key, or its tool-call fallback when none was declared. */
+  idempotencyKey: string;
+};
+type Action<Context extends Record<string, unknown> = Record<string, unknown>, Input = any, Output = any> = Omit<ActionConfig<FlexibleSchema<Input>, Output>, "approval" | "execute" | "idempotencyKey" | "inputSchema" | "permissions"> & {
+  description: string;
+  inputSchema: FlexibleSchema<Input>;
+  approval?: ActionApprovalPolicy<Input>;
+  idempotencyKey?: ActionIdempotencyKey<Input>;
+  permissions?: ActionPermissionSpec<Input>;
+  authorize?: (ctx?: Context) => boolean;
+  onUnauthorized?: UnauthorizedPolicy<Context>;
+  execute(input: Input, ctx: ActionContext<Context>): Promise<Output> | Output;
+};
+type RegisteredAction<Context extends Record<string, unknown> = Record<string, unknown>, InputSchema extends FlexibleSchema = FlexibleSchema, Output = unknown> = Action$1<InputSchema, Output> & {
+  authorize?: (ctx?: Context) => boolean;
+  onUnauthorized?: UnauthorizedPolicy<Context>;
+};
+/** A native Think action with the SDK's standard authorization policy. */
+export declare function action<Context extends Record<string, unknown> = Record<string, unknown>, Input = any, Output = any>(definition: Action<Context, Input, Output>): RegisteredAction<Context, FlexibleSchema<Input>, Output>;
+interface SkillDefinition<Context extends Record<string, unknown>> {
+  name: string;
+  description: string;
+  instructions: string;
+  tools?: Record<string, Tool<Context>>;
+  actions?: Record<string, RegisteredAction<Context, any, any>>;
+  authorize?: (ctx?: Context) => boolean;
+  onUnauthorized?: UnauthorizedPolicy<Context>;
+}
+/**
+ * When the skill is active:
+ * - `"auto"`: once the model starts it, when it's relevant. The default.
+ * - `"always"`: on every turn, without being started.
+ * - `"manual"`: once the user starts it with its `command`. It's hidden from
+ *   the model, which can't start it itself.
+ */
+type SkillActivation = "auto" | "always" | "manual";
+type Skill<Context extends Record<string, unknown> = Record<string, unknown>> = SkillDefinition<Context> & ({
+  activation?: "auto" | "always";
+  /** Lets the user start the skill from chat with `/command`. */
+  command?: string;
+} | {
+  activation: "manual";
+  command: string;
+});
+interface SkillSource<Context extends Record<string, unknown> = Record<string, unknown>> extends SkillSource$1 {
+  command?: string;
+  activation?: SkillActivation;
+  tools?: Record<string, Tool<Context>>;
+  actions?: Record<string, RegisteredAction<Context, any, any>>;
+  authorize?: (ctx?: Context | undefined) => boolean;
+  onUnauthorized?: UnauthorizedPolicy<Context>;
+}
+export declare function skill<Context extends Record<string, unknown> = Record<string, unknown>>(definition: Skill<Context>): SkillSource<Context>;
 interface SpanIds {
   traceId: string;
   spanId: string;
@@ -463,6 +518,7 @@ declare class Tracing {
 type MessagePart = UIMessage["parts"][number];
 interface TurnInspection<RequestContext extends Record<string, unknown> = Record<string, unknown>, UserContext extends Record<string, unknown> = Record<string, unknown>> {
   messages?: ModelMessage[];
+  continuation?: boolean;
   requestContext?: RequestContext;
   userContext?: UserContext;
 }
@@ -479,6 +535,8 @@ type CurrentTurnState<RequestContext extends Record<string, unknown>, UserContex
   context?: ToolContext<RequestContext, UserContext>;
   inputTools: ToolSet;
   preparedTools: ToolSet;
+  activeSkillNames: Set<string>;
+  skillSourcesByName?: Promise<Map<string, SkillSource>>;
   unavailableSkillIds: Set<string>;
   skillsSystemBlock: string;
   visibleSkillNames: string[];
@@ -655,7 +713,7 @@ export declare abstract class Agent<RequestContext extends Record<string, unknow
   workspaceTools: boolean;
   sendReasoning: boolean;
   getSkillScriptRunner(): skills.SkillScriptRunner | null;
-  protected pruneTurnMessages(messages: ModelMessage[]): ModelMessage[];
+  protected pruneTurnMessages(messages: ModelMessage[], continuation?: boolean): ModelMessage[];
   private _prepareTools;
   private _renderSkillsSystemBlock;
   /**
@@ -666,7 +724,6 @@ export declare abstract class Agent<RequestContext extends Record<string, unknow
   private _filterSkillHelperTools;
   private _filterActivateSkillTool;
   private _skillSources?;
-  private _skillSourcesByName?;
   private _getUnauthorizedReason;
   private _getSkillSources;
   /** Each skill's source, by the skill's name. A source can hold several skills. */
@@ -703,12 +760,10 @@ export declare abstract class Agent<RequestContext extends Record<string, unknow
   private _withTurnContextFallback;
   /** The current turn's tool context, for every tool prepared for the turn. */
   private _toolsContext;
-  /**
-   * The skill the last `activate_skill` call started. A manual skill counts
-   * only when its command started it, not a call the model made itself.
-   */
-  private _activeSkillName;
-  private _getLastActivatedSkillName;
+  private _skillTurnStart;
+  private _activeSkillNamesForTurn;
+  private _activatedSkillNames;
+  private _getActivatedSkillNames;
   /**
    * The caller's identity, user context and credentials, kept until the
    * token expires so turns after hibernation, and scheduled turns, can still
@@ -796,61 +851,6 @@ type MessageFeedback = {
   created_at: number;
   updated_at: number;
 };
-/** Tool execution options plus the additional context supplied by native Think actions. */
-type ActionContext<Context extends Record<string, unknown> = Record<string, unknown>> = ToolExecutionOptions<Context> & ActionContext$1 & {
-  /** The action's resolved domain key, or its tool-call fallback when none was declared. */
-  idempotencyKey: string;
-};
-type Action<Context extends Record<string, unknown> = Record<string, unknown>, Input = any, Output = any> = Omit<ActionConfig<FlexibleSchema<Input>, Output>, "approval" | "execute" | "idempotencyKey" | "inputSchema" | "permissions"> & {
-  description: string;
-  inputSchema: FlexibleSchema<Input>;
-  approval?: ActionApprovalPolicy<Input>;
-  idempotencyKey?: ActionIdempotencyKey<Input>;
-  permissions?: ActionPermissionSpec<Input>;
-  authorize?: (ctx?: Context) => boolean;
-  onUnauthorized?: UnauthorizedPolicy<Context>;
-  execute(input: Input, ctx: ActionContext<Context>): Promise<Output> | Output;
-};
-type RegisteredAction<Context extends Record<string, unknown> = Record<string, unknown>, InputSchema extends FlexibleSchema = FlexibleSchema, Output = unknown> = Action$1<InputSchema, Output> & {
-  authorize?: (ctx?: Context) => boolean;
-  onUnauthorized?: UnauthorizedPolicy<Context>;
-};
-/** A native Think action with the SDK's standard authorization policy. */
-export declare function action<Context extends Record<string, unknown> = Record<string, unknown>, Input = any, Output = any>(definition: Action<Context, Input, Output>): RegisteredAction<Context, FlexibleSchema<Input>, Output>;
-interface SkillDefinition<Context extends Record<string, unknown>> {
-  name: string;
-  description: string;
-  instructions: string;
-  tools?: Record<string, Tool<Context>>;
-  actions?: Record<string, RegisteredAction<Context, any, any>>;
-  authorize?: (ctx?: Context) => boolean;
-  onUnauthorized?: UnauthorizedPolicy<Context>;
-}
-/**
- * When the skill is active:
- * - `"auto"`: once the model starts it, when it's relevant. The default.
- * - `"always"`: on every turn, without being started.
- * - `"manual"`: once the user starts it with its `command`. It's hidden from
- *   the model, which can't start it itself.
- */
-type SkillActivation = "auto" | "always" | "manual";
-type Skill<Context extends Record<string, unknown> = Record<string, unknown>> = SkillDefinition<Context> & ({
-  activation?: "auto" | "always";
-  /** Lets the user start the skill from chat with `/command`. */
-  command?: string;
-} | {
-  activation: "manual";
-  command: string;
-});
-interface SkillSource<Context extends Record<string, unknown> = Record<string, unknown>> extends SkillSource$1 {
-  command?: string;
-  activation?: SkillActivation;
-  tools?: Record<string, Tool<Context>>;
-  actions?: Record<string, RegisteredAction<Context, any, any>>;
-  authorize?: (ctx?: Context | undefined) => boolean;
-  onUnauthorized?: UnauthorizedPolicy<Context>;
-}
-export declare function skill<Context extends Record<string, unknown> = Record<string, unknown>>(definition: Skill<Context>): SkillSource<Context>;
 interface InvocableSkill {
   /** Slash command without the leading `/`. */
   command: string;

package/dist/index.mjs

@@ -2180,6 +2180,7 @@ var Agent = class Agent extends Think {
 	_turn = {
 		inputTools: {},
 		preparedTools: {},
+		activeSkillNames: /* @__PURE__ */ new Set(),
 		unavailableSkillIds: /* @__PURE__ */ new Set(),
 		skillsSystemBlock: "",
 		visibleSkillNames: [],
@@ -2206,14 +2207,15 @@ var Agent = class Agent extends Think {
 	*/
 	async beforeTurn(ctx) {
 		await this._inspection;
+		this._turn.skillSourcesByName = void 0;
 		this._turn.context = this.createToolContextForCurrentTurn(ctx.body);
 		const config = await this.getAgentConfig(this._turn.context);
 		if (config.inputSchema && !ctx.continuation) this._refuseUnexpectedInput(config.inputSchema);
 		this.tracing.turnStarted(ctx.messages, ctx.continuation);
 		this.registerInstanceActivity();
-		const activeSkillName = await this._activeSkillName(ctx.messages);
+		this._turn.activeSkillNames = await this._activeSkillNamesForTurn(ctx.messages, ctx.continuation);
 		this._turn.inputTools = ctx.tools;
-		const { tools, activeTools } = await this._prepareTools(ctx.tools, activeSkillName, true);
+		const { tools, activeTools } = await this._prepareTools(ctx.tools, this._turn.activeSkillNames, true);
 		const baseSystem = await this.context.refreshSystemPrompt();
 		this._turn.baseSystem = [baseSystem, this._turn.skillsSystemBlock].filter(Boolean).join("\n\n");
 		const turnTracing = await this.tracing.turn(this._turn.context ?? {}, this.messages);
@@ -2231,7 +2233,7 @@ var Agent = class Agent extends Think {
 			...config.outputSchema && { output: Output.object({ schema: config.outputSchema }) },
 			system: this._turn.baseSystem,
 			model: this.getModel(this._turn.context),
-			messages: this.pruneTurnMessages(ctx.messages),
+			messages: this.pruneTurnMessages(ctx.messages, ctx.continuation),
 			tools: this._withTurnContextFallback(this._withTaskToolExecution(tools)),
 			activeTools,
 			experimental_transform: buildSourcesTransform(),
@@ -2263,10 +2265,11 @@ var Agent = class Agent extends Think {
 	* @returns The step config.
 	*/
 	async beforeStep(ctx) {
-		const activeSkillName = await this._activeSkillName(ctx.steps);
+		const activatedSkillNames = await this._activatedSkillNames(ctx.steps);
 		const toolsContext = this._toolsContext();
-		if (!activeSkillName) return { toolsContext };
-		const { activeTools } = await this._prepareTools(this._turn.inputTools, activeSkillName);
+		if (activatedSkillNames.length === 0) return { toolsContext };
+		for (const name of activatedSkillNames) this._turn.activeSkillNames.add(name);
+		const { activeTools } = await this._prepareTools(this._turn.inputTools, this._turn.activeSkillNames);
 		return {
 			activeTools,
 			system: this._turn.baseSystem,
@@ -2280,6 +2283,10 @@ var Agent = class Agent extends Think {
 	async beforeToolCall(ctx) {
 		const toolCtx = this._turn.context ?? {};
 		const skill = await this._skillOfCall(ctx.toolName, ctx.input);
+		if (SKILL_TOOL_NAMES.has(ctx.toolName) && !skill) return {
+			action: "block",
+			reason: GENERIC_UNAVAILABLE_TOOL_GUIDANCE
+		};
 		if (skill?.authorize?.(toolCtx) === false) return {
 			action: "block",
 			reason: this._getUnauthorizedReason(skill.onUnauthorized, toolCtx) ?? "Say naturally that you don't have that capability, then stop. Do not mention tools, apologize, invent a reason or remedy, or offer further help."
@@ -2563,6 +2570,7 @@ var Agent = class Agent extends Think {
 			},
 			inputTools: {},
 			preparedTools: {},
+			activeSkillNames: /* @__PURE__ */ new Set(),
 			unavailableSkillIds: /* @__PURE__ */ new Set(),
 			skillsSystemBlock: "",
 			visibleSkillNames: [],
@@ -2583,7 +2591,8 @@ var Agent = class Agent extends Think {
 				...frameworkTools
 			};
 			this._turn.inputTools = inputTools;
-			const { tools, activeTools } = await this._prepareTools(inputTools, await this._activeSkillName(messages), true);
+			this._turn.activeSkillNames = await this._activeSkillNamesForTurn(messages, input.continuation);
+			const { tools, activeTools } = await this._prepareTools(inputTools, this._turn.activeSkillNames, true);
 			const baseSystem = await this.context.refreshSystemPrompt();
 			this._turn.baseSystem = [baseSystem, this._turn.skillsSystemBlock].filter(Boolean).join("\n\n");
 			const snapshotContext = this._turn.context;
@@ -2592,7 +2601,7 @@ var Agent = class Agent extends Think {
 				tools: withFallbackToolContext(this._withTaskToolExecution(tools), () => snapshotContext),
 				activeTools,
 				frameworkToolNames: Object.keys(frameworkTools),
-				messages: this.pruneTurnMessages(messages)
+				messages: this.pruneTurnMessages(messages, input.continuation)
 			};
 		} finally {
 			this._turn = previousTurn;
@@ -2610,19 +2619,21 @@ var Agent = class Agent extends Think {
 		if (!("LOADER" in this.env)) return null;
 		return skills.runner({ loader: this.env.LOADER });
 	}
-	pruneTurnMessages(messages) {
+	pruneTurnMessages(messages, continuation = false) {
+		const turnStart = this._skillTurnStart(messages, continuation);
+		const retainedSkillMessages = Math.max(5, messages.length - turnStart);
 		return pruneMessages({
 			messages,
 			toolCalls: [{
 				type: "before-last-2-messages",
 				tools: []
 			}, {
-				type: "before-last-5-messages",
+				type: `before-last-${retainedSkillMessages}-messages`,
 				tools: ["activate_skill"]
 			}]
 		});
 	}
-	async _prepareTools(inputTools, activeSkillName, updateSkillsSystemBlock = false) {
+	async _prepareTools(inputTools, activeSkillNames, updateSkillsSystemBlock = false) {
 		const ctx = this._turn.context;
 		const tools = {};
 		const activeTools = [];
@@ -2720,8 +2731,16 @@ var Agent = class Agent extends Think {
 			this._turn.authorizedSkillNames = /* @__PURE__ */ new Set([...catalog.authorizedSkillNames, ...await skillNames(manualSkillSources)]);
 		}
 		this._filterActivateSkillTool(tools, activeTools, this._turn.visibleSkillNames);
-		const activeSkill = skillSources.find((skill) => skill.id === activeSkillName);
-		if (activeSkill && skillAuthorization.get(activeSkill) !== false) {
+		const activeSources = /* @__PURE__ */ new Set();
+		if (activeSkillNames.size > 0) {
+			const sourcesByName = await this._getSkillSourcesByName();
+			for (const name of activeSkillNames) {
+				const source = sourcesByName.get(name);
+				if (source) activeSources.add(source);
+			}
+		}
+		for (const activeSkill of skillSources) {
+			if (!activeSources.has(activeSkill) || skillAuthorization.get(activeSkill) === false) continue;
 			const activeSkillTools = Object.entries(activeSkill.tools ?? {});
 			for (const [registrationName, definition] of Object.entries(activeSkill.actions ?? {})) {
 				const name = actionToolName(registrationName, definition);
@@ -2730,7 +2749,7 @@ var Agent = class Agent extends Think {
 			}
 			for (const [name, tool] of activeSkillTools) if (configureTool(name, tool, actionsByToolName.get(name) ?? tool)) activeTools.push(name);
 		}
-		if (!hasAlwaysActiveSkill) this._filterSkillHelperTools(activeTools, activeSkillName);
+		if (!hasAlwaysActiveSkill) this._filterSkillHelperTools(activeTools, activeSkillNames);
 		this._turn.preparedTools = tools;
 		return {
 			tools,
@@ -2777,8 +2796,8 @@ var Agent = class Agent extends Think {
 			provider: { get: async () => source.authorize?.(this._turn.context) !== false && !this._turn.unavailableSkillIds.has(source.id) ? (await source.load(name))?.body.trim() ?? "" : "" }
 		}))))).flat();
 	}
-	_filterSkillHelperTools(activeTools, activeSkillName) {
-		if (activeSkillName && this._turn.authorizedSkillNames.has(activeSkillName)) return;
+	_filterSkillHelperTools(activeTools, activeSkillNames) {
+		for (const name of activeSkillNames) if (this._turn.authorizedSkillNames.has(name)) return;
 		for (const name of SKILL_HELPER_TOOL_NAMES) {
 			const index = activeTools.indexOf(name);
 			if (index !== -1) activeTools.splice(index, 1);
@@ -2806,7 +2825,6 @@ var Agent = class Agent extends Think {
 		};
 	}
 	_skillSources;
-	_skillSourcesByName;
 	_getUnauthorizedReason(policy, ctx) {
 		return typeof policy === "function" ? policy(ctx) : policy;
 	}
@@ -2815,9 +2833,14 @@ var Agent = class Agent extends Think {
 	}
 	/** Each skill's source, by the skill's name. A source can hold several skills. */
 	_getSkillSourcesByName() {
-		return this._skillSourcesByName ??= this._getSkillSources().then(async (sources) => {
+		return this._turn.skillSourcesByName ??= this._getSkillSources().then(async (sources) => {
 			const byName = /* @__PURE__ */ new Map();
-			for (const source of sources) for (const descriptor of await source.list()) if (!byName.has(descriptor.name)) byName.set(descriptor.name, source);
+			for (const source of sources) try {
+				for (const descriptor of await source.list()) if (!byName.has(descriptor.name)) byName.set(descriptor.name, source);
+			} catch (error) {
+				console.warn(`[Agent] Failed to resolve skill source "${source.id}"`, error);
+				break;
+			}
 			return byName;
 		});
 	}
@@ -2864,36 +2887,63 @@ var Agent = class Agent extends Think {
 		const context = this._turn.context ?? {};
 		return Object.fromEntries(Object.keys(this._turn.preparedTools).map((name) => [name, context]));
 	}
-	/**
-	* The skill the last `activate_skill` call started. A manual skill counts
-	* only when its command started it, not a call the model made itself.
-	*/
-	async _activeSkillName(items) {
-		const manual = await skillNames((await this._getSkillSources()).filter((source) => source.activation === "manual"));
-		return this._getLastActivatedSkillName(items, new Set(manual));
-	}
-	_getLastActivatedSkillName(items = [], manualSkillNames) {
-		for (let index = items.length - 1; index >= 0; index--) {
-			const item = items[index];
-			if (!item || typeof item !== "object") continue;
-			const record = item;
-			const input = record.input;
-			if ((record.toolName === "activate_skill" || record.type === "tool-activate_skill") && input && typeof input === "object") {
-				const { name } = input;
-				if (typeof name === "string" && (!manualSkillNames.has(name) || String(record.toolCallId).startsWith("skill-command-"))) return name;
+	_skillTurnStart(messages, continuation) {
+		for (let index = messages.length - 1; index >= 0; index--) {
+			if (messages[index].role !== "user") continue;
+			if (continuation && index === messages.length - 1) {
+				if (this.messages.at(-1)?.role !== "user") continue;
 			}
-			for (const key of [
-				"toolResults",
-				"parts",
-				"content"
-			]) {
-				const nestedItems = record[key];
-				if (Array.isArray(nestedItems)) {
-					const skillName = this._getLastActivatedSkillName(nestedItems, manualSkillNames);
-					if (skillName) return skillName;
+			return index + 1;
+		}
+		return 0;
+	}
+	async _activeSkillNamesForTurn(messages, continuation = false) {
+		const turnStart = this._skillTurnStart(messages, continuation);
+		const previousSkills = await this._activatedSkillNames(messages.slice(0, turnStart));
+		const currentSkills = await this._activatedSkillNames(messages.slice(turnStart));
+		const previousSkill = previousSkills.at(-1);
+		return new Set(previousSkill ? [previousSkill, ...currentSkills] : currentSkills);
+	}
+	async _activatedSkillNames(items) {
+		const manual = await skillNames((await this._getSkillSources()).filter((source) => source.activation === "manual"));
+		return this._getActivatedSkillNames(items, new Set(manual));
+	}
+	_getActivatedSkillNames(items, manualSkillNames) {
+		const calls = /* @__PURE__ */ new Map();
+		const outputs = /* @__PURE__ */ new Map();
+		const collect = (entries) => {
+			for (const item of entries) {
+				if (!item || typeof item !== "object") continue;
+				const record = item;
+				const { type, toolCallId, input } = record;
+				const uiActivation = type === "tool-activate_skill";
+				if (typeof toolCallId === "string" && (uiActivation || record.toolName === "activate_skill")) {
+					if ((type === "tool-call" || uiActivation) && input && typeof input === "object") {
+						const { name } = input;
+						if (typeof name === "string" && !calls.has(toolCallId)) calls.set(toolCallId, name);
+					}
+					if (type === "tool-result" && !record.preliminary || uiActivation && record.state === "output-available") outputs.set(toolCallId, record.output);
+				}
+				for (const key of [
+					"content",
+					"parts",
+					"toolCalls",
+					"toolResults"
+				]) {
+					const nestedItems = record[key];
+					if (Array.isArray(nestedItems)) collect(nestedItems);
 				}
 			}
+		};
+		collect(items);
+		const names = [];
+		for (const [toolCallId, name] of calls) {
+			if (manualSkillNames.has(name) && !toolCallId.startsWith("skill-command-")) continue;
+			let output = outputs.get(toolCallId);
+			if (output && typeof output === "object" && "type" in output && output.type === "text") output = "value" in output ? output.value : void 0;
+			if (typeof output === "string" && output.startsWith(`<skill_content name="${name}"`)) names.push(name);
 		}
+		return names;
 	}
 	/**
 	* The caller's identity, user context and credentials, kept until the
@@ -3618,22 +3668,20 @@ var Assistant = class extends Agent$1 {
 };
 const COMPACTION_MAX_OUTPUT_TOKENS = 2e3;
 const COMPACTION_HEAD_MESSAGES = 2;
+const COMPACTION_TAIL_MESSAGES = 1;
 const COMPACTION_MESSAGE_CHARS = 2e4;
 const MODEL_COMPACTION_MESSAGE_ID = "compaction_model_context";
-/**
-* Summarizes everything between the first two messages and the newest one, so
-* a single large answer is compacted before the prompt that follows it.
-*/
+/** Summarizes older content while retaining the latest request and active skill exchanges. */
 const createCompactFn = (model) => async (messages) => {
-	const middle = messages.slice(COMPACTION_HEAD_MESSAGES, -1);
-	const previous = middle.find((message) => message.id === MODEL_COMPACTION_MESSAGE_ID);
-	const compacted = middle.filter((message) => message.id !== MODEL_COMPACTION_MESSAGE_ID);
-	const first = compacted[0];
-	const last = compacted.at(-1);
+	const { compacted } = partitionCompactionRange(messages, COMPACTION_HEAD_MESSAGES, messages.length - COMPACTION_TAIL_MESSAGES - 1);
+	const previous = compacted.find((message) => message.id === MODEL_COMPACTION_MESSAGE_ID);
+	const candidates = compacted.filter((message) => message.id !== MODEL_COMPACTION_MESSAGE_ID);
+	const first = candidates[0];
+	const last = candidates.at(-1);
 	if (!first || !last) return null;
 	const { text } = await generateText({
 		model,
-		prompt: summaryPrompt(compacted, previous),
+		prompt: summaryPrompt(candidates, previous),
 		maxOutputTokens: COMPACTION_MAX_OUTPUT_TOKENS
 	});
 	if (!text.trim()) return null;
@@ -3718,6 +3766,40 @@ function migrateSessionCompaction(sql) {
 	sql`DELETE FROM cf_agents_session_compactions WHERE session_id = ''`;
 	return true;
 }
+function partitionCompactionRange(messages, from, to) {
+	const turnStart = messages.findLastIndex((message) => message.role === "user");
+	const retained = [];
+	const compacted = [];
+	for (let index = from; index <= to; index++) {
+		const message = messages[index];
+		if (index === turnStart) {
+			retained.push(message);
+			continue;
+		}
+		const retainedParts = [];
+		const compactedParts = [];
+		for (const part of message.parts) if (part.type === "step-start") retainedParts.push(part);
+		else if (index > turnStart && message.role === "assistant" && retainTurnToolPart(part)) retainedParts.push(part);
+		else compactedParts.push(part);
+		if (retainedParts.some((part) => part.type !== "step-start")) retained.push({
+			...message,
+			parts: retainedParts
+		});
+		if (compactedParts.length > 0) compacted.push({
+			...message,
+			parts: compactedParts
+		});
+	}
+	return {
+		retained,
+		compacted
+	};
+}
+function retainTurnToolPart(part) {
+	if (!isToolUIPart(part)) return false;
+	if (getToolName(part) === "activate_skill" || part.approval) return true;
+	return part.state === "input-streaming" || part.state === "input-available" || part.state === "output-available" && part.preliminary === true;
+}
 function applyModelCompaction(messages, state) {
 	const fromIndex = messages.findIndex((message) => message.id === state.fromMessageId);
 	const toIndex = messages.findIndex((message) => message.id === state.toMessageId);
@@ -3732,6 +3814,7 @@ function applyModelCompaction(messages, state) {
 				text: state.summary
 			}]
 		},
+		...partitionCompactionRange(messages, fromIndex, toIndex).retained,
 		...messages.slice(toIndex + 1)
 	];
 }
@@ -3756,10 +3839,23 @@ async function prepareModelHistory(messages, existingState, compact, systemPromp
 		state,
 		stateChanged
 	};
+	let fromIndex = messages.findIndex((message) => message.id === result.fromMessageId);
+	let toIndex = messages.findIndex((message) => message.id === result.toMessageId);
+	if (fromIndex === -1 || toIndex < fromIndex) return {
+		messages: projected,
+		state,
+		stateChanged
+	};
+	if (state) {
+		const previousStart = messages.findIndex((message) => message.id === state.fromMessageId);
+		const previousEnd = messages.findIndex((message) => message.id === state.toMessageId);
+		fromIndex = Math.min(previousStart, fromIndex);
+		toIndex = Math.max(previousEnd, toIndex);
+	}
 	const nextState = {
 		summary: result.summary,
-		fromMessageId: state?.fromMessageId ?? result.fromMessageId,
-		toMessageId: result.toMessageId
+		fromMessageId: messages[fromIndex].id,
+		toMessageId: messages[toIndex].id
 	};
 	const nextProjection = applyModelCompaction(messages, nextState);
 	if (!nextProjection) return {
@@ -3797,6 +3893,7 @@ async function withModelCompaction(modelMessages, transcript, state, tools) {
 				text: state.summary
 			}]
 		},
+		...await convert(partitionCompactionRange(transcript, from, to).retained),
 		...modelMessages.slice((await convert(transcript.slice(0, to + 1))).length)
 	];
 }
@@ -4098,7 +4195,7 @@ var ChatAgent = class extends Agent {
 				const messages = await withModelCompaction(ctx.messages, this.messages, prepared.state, tools);
 				if (messages) return {
 					...config,
-					messages: this.pruneTurnMessages([...messages, ...skillInvocation?.messages ?? []])
+					messages: this.pruneTurnMessages([...messages, ...skillInvocation?.messages ?? []], ctx.continuation)
 				};
 			}
 		} catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@economic/agents",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "A starter for creating a TypeScript package.",
   "license": "MIT",
   "files": [