@yolk-sdk/agent 0.1.0-canary.104 → 0.1.0-canary.106

package/dist/classification/errors.d.mts

@@ -1,5 +1,5 @@
-import { ProviderErrorInfo } from "@yolk-sdk/agent/protocol";
 import * as Schema from "effect/Schema";
+import { ProviderErrorInfo } from "@yolk-sdk/agent/protocol";
 
 //#region src/classification/errors.d.ts
 /**

package/dist/classification/errors.mjs

@@ -1,6 +1,6 @@
 import { ClassificationUsage } from "./schema.mjs";
-import { ProviderErrorInfo } from "@yolk-sdk/agent/protocol";
 import * as Schema from "effect/Schema";
+import { ProviderErrorInfo } from "@yolk-sdk/agent/protocol";
 //#region src/classification/errors.ts
 /**
 * Why an answer does not fit its question:

package/dist/client/transport.d.mts

@@ -1,7 +1,7 @@
 import { AgentTranscript } from "./state.mjs";
 import { Cause, Effect, Layer, Stream } from "effect";
-import { AgentEvent, AgentReasoningEffort, HitlResponse, InputResponse, InteractionResponse, QuestionResponse, ToolApprovalResponse } from "@yolk-sdk/agent/protocol";
 import * as Schema$1 from "effect/Schema";
+import { AgentEvent, AgentReasoningEffort, HitlResponse, InputResponse, InteractionResponse, QuestionResponse, ToolApprovalResponse } from "@yolk-sdk/agent/protocol";
 import { HttpClient } from "effect/http";
 
 //#region src/client/transport.d.ts

package/dist/client/transport.mjs

@@ -1,6 +1,6 @@
 import { Cause, Channel, Data, Effect, Exit, Match, Predicate, Pull, Queue, Ref, Result, Scope, Stream } from "effect";
-import { AgentEvent, AgentWebSocketServerMessage, InputResponseInput, InteractionResponseInput, QuestionResponseInput, ToolApprovalResponseInput, UserInput, isTerminalAgentEvent } from "@yolk-sdk/agent/protocol";
 import * as Schema$1 from "effect/Schema";
+import { AgentEvent, AgentWebSocketServerMessage, InputResponseInput, InteractionResponseInput, QuestionResponseInput, ToolApprovalResponseInput, UserInput, isTerminalAgentEvent } from "@yolk-sdk/agent/protocol";
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
 //#region src/client/transport.ts
 var AgentTransportError = class extends Schema$1.TaggedError()("AgentTransportError", {

package/dist/loop/error.d.mts

@@ -1,5 +1,5 @@
-import { AgentError, ProviderErrorInfo } from "@yolk-sdk/agent/protocol";
 import * as Schema from "effect/Schema";
+import { AgentError, ProviderErrorInfo } from "@yolk-sdk/agent/protocol";
 
 //#region src/loop/error.d.ts
 declare const LLMResponseIssue: Schema.Literal<"missing_done">;

package/dist/loop/error.mjs

@@ -1,6 +1,6 @@
 import { Match } from "effect";
-import { AgentError, ProviderErrorInfo } from "@yolk-sdk/agent/protocol";
 import * as Schema$1 from "effect/Schema";
+import { AgentError, ProviderErrorInfo } from "@yolk-sdk/agent/protocol";
 //#region src/loop/error.ts
 const LLMResponseIssue = Schema$1.Literal("missing_done");
 var LLMError = class extends Schema$1.TaggedError()("LLMError", {

package/dist/loop/llm-event.d.mts

@@ -1,5 +1,5 @@
-import { AgentUsage, ToolCall, ToolResult } from "@yolk-sdk/agent/protocol";
 import * as Schema from "effect/Schema";
+import { AgentUsage, ToolCall, ToolResult } from "@yolk-sdk/agent/protocol";
 
 //#region src/loop/llm-event.d.ts
 declare const LLMTextDelta_base: Schema.Class<LLMTextDelta, Schema.TaggedStruct<"TextDelta", {

package/dist/loop/llm-event.mjs

@@ -1,5 +1,5 @@
-import { AgentUsage, ToolCall, ToolResult } from "@yolk-sdk/agent/protocol";
 import * as Schema from "effect/Schema";
+import { AgentUsage, ToolCall, ToolResult } from "@yolk-sdk/agent/protocol";
 //#region src/loop/llm-event.ts
 var LLMTextDelta = class extends Schema.TaggedClass()("TextDelta", { text: Schema.String }) {};
 var LLMReasoningDelta = class extends Schema.TaggedClass()("ReasoningDelta", { text: Schema.String }) {};

package/dist/loop/run.d.mts

@@ -23,6 +23,16 @@ type RunConfig = {
    * ResolvedToolSet.approvalPreviews): pending approval requests carry their preview.
    */
   readonly approvalPreviews?: Readonly<Record<string, ToolApprovalPreviewer>>;
+  /** The requests of the pause being resumed (`AgentAwaitingInput.requests`). An unanswered
+   * approval request listed here stays pending even when its tool no longer requires approval.
+   */
+  readonly awaitingRequests?: ReadonlyArray<HitlRequest>;
+  /** Whether the transcript's pending tool calls resume a pause. Default: they do when
+   * `hitlResponses`, `awaitingRequests` or an `interactionHost` is given (otherwise a new model
+   * turn runs). `true` resumes them even without responses; `false` prepares them as a fresh
+   * batch (current policy, no recorded approval responses consulted).
+   */
+  readonly resume?: boolean;
   readonly model: string;
   readonly reasoningEffort?: AgentReasoningEffort;
   readonly capabilities?: AgentModelCapabilities;
@@ -41,6 +51,18 @@ type ToolBatchConfig = {
    * ResolvedToolSet.approvalPreviews).
    */
   readonly approvalPreviews?: Readonly<Record<string, ToolApprovalPreviewer>>;
+  /** The requests of the pause being resumed (`AgentAwaitingInput.requests`). An unanswered
+   * approval request listed here stays pending even when its tool no longer requires approval.
+   * A batch with `awaitingRequests` or any `hitlResponses` is a resume (recorded answers win
+   * over the current policy); pass only the responses of the batch being resumed, or set
+   * `resume`.
+   */
+  readonly awaitingRequests?: ReadonlyArray<HitlRequest>;
+  /** Whether this batch resumes a pause (default: `awaitingRequests` given, or any
+   * `hitlResponses`). Set `false` for a new model turn's batch even when passing responses: a
+   * provider may reuse call ids, and only a resume lets recorded answers override the policy.
+   */
+  readonly resume?: boolean;
   readonly model?: string;
   readonly createdMessages?: ReadonlyArray<AgentMessage>;
   readonly turn?: number;
@@ -87,6 +109,17 @@ declare const prepareToolBatch: (input: {
    * is pending, at most 8 at a time.
    */
   readonly approvalPreviews?: Readonly<Record<string, ToolApprovalPreviewer>>;
+  /** The requests of the pause being resumed (`AgentAwaitingInput.requests`). An unanswered
+   * approval request listed here stays pending even when its tool no longer requires approval;
+   * a recorded answer always wins over the current policy.
+   */
+  readonly awaitingRequests?: ReadonlyArray<HitlRequest>;
+  /** Whether this batch resumes a pause (default: `awaitingRequests` given, or any `responses`).
+   * Only a resume consults recorded approvals and the pause; a fresh batch (a new model turn,
+   * whose provider may reuse call ids) never settles an approval from `responses`: the current
+   * policy decides, and a gated call asks again.
+   */
+  readonly resume?: boolean | undefined;
 }) => Effect.Effect<PreparedToolBatch, ToolError>;
 declare const runModelTurn: (config: ModelTurnConfig) => Stream.Stream<AgentEvent, AgentLoopError, ContextTransformer | LLMProvider | LoopConfig>;
 declare const runToolBatch: (config: ToolBatchConfig) => Stream.Stream<AgentEvent, AgentLoopError, LoopConfig | ToolExecutor>;

package/dist/loop/run.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.mts","names":[],"sources":["../../src/loop/run.ts"],"mappings":"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"}
+{"version":3,"file":"run.d.mts","names":[],"sources":["../../src/loop/run.ts"],"mappings":"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"}

package/dist/loop/run.mjs

@@ -8,9 +8,9 @@ import "../protocol/change-preview.mjs";
 import { truncateCodePoints } from "../protocol/bounded-text.mjs";
 import { validInteractionReceipt as validInteractionReceipt$1 } from "../protocol/tool.mjs";
 import { withToolArgumentsErrorHint } from "../protocol/tool-argument-hints.mjs";
-import { Clock, Data, Effect, Match, Option, Predicate, Ref, Stream } from "effect";
-import { AgentAwaitingInput, AgentEnd, AgentRetry, AgentStart, AssistantMessageEvent, InputRequest, InputRequested, InteractionRequest, InteractionRequested, InteractionResponse, LLMReasoningDelta, LLMStreamEnd, LLMStreamStart, LLMTextDelta, ProviderToolResult, QuestionRequest, QuestionRequested, QuestionToolParams, SubagentCompleted, SubagentStarted, ToolApprovalRequest, ToolApprovalRequested, ToolExecutionAccepted, ToolExecutionCompleted, ToolExecutionError, ToolExecutionStarted, ToolInputDelta, ToolInputEnd, ToolInputStart, ToolResult, TurnEnd, TurnStart, UsageUpdate, addAgentUsage, assistantHostToolCalls, contentParts, contentPreview, decodeBackgroundToolInput, formatInputResponseContent, formatQuestionResponseContent, hitlResponseEvent, inputRequestId, inputResponseStructuredContent, interactionRequestId, makeSubagentRunId, providerToolDefs, questionResponseStructuredContent, toolResultMessageFromResult, zeroAgentUsage } from "@yolk-sdk/agent/protocol";
+import { Array as Array$1, Clock, Data, Effect, Match, Option, Predicate, Ref, Stream, Struct } from "effect";
 import * as Schema$1 from "effect/Schema";
+import { AgentAwaitingInput, AgentEnd, AgentRetry, AgentStart, AssistantMessageEvent, InputRequest, InputRequested, InteractionRequest, InteractionRequested, InteractionResponse, LLMReasoningDelta, LLMStreamEnd, LLMStreamStart, LLMTextDelta, ProviderToolResult, QuestionRequest, QuestionRequested, QuestionToolParams, SubagentCompleted, SubagentStarted, ToolApprovalRequest, ToolApprovalRequested, ToolExecutionAccepted, ToolExecutionCompleted, ToolExecutionError, ToolExecutionStarted, ToolInputDelta, ToolInputEnd, ToolInputStart, ToolResult, TurnEnd, TurnStart, UsageUpdate, addAgentUsage, assistantHostToolCalls, contentParts, contentPreview, decodeBackgroundToolInput, formatInputResponseContent, formatQuestionResponseContent, hitlResponseEvent, inputRequestId, inputResponseStructuredContent, interactionRequestId, makeSubagentRunId, providerToolDefs, questionResponseStructuredContent, toolResultMessageFromResult, zeroAgentUsage } from "@yolk-sdk/agent/protocol";
 //#region src/loop/run.ts
 const objectField = (input, key) => {
 	if (!Predicate.isObjectOrArray(input)) return;
@@ -198,6 +198,26 @@ const questionRequestId = (call) => `question:${call.id}`;
 const matchesApproval = (response, call, tools) => response.toolCallId === call.id && response.requestId === approvalRequestId(call, tools);
 const matchesQuestion = (response, call) => response.toolCallId === call.id && response.requestId === questionRequestId(call);
 const approvalResponseFor = (responses, call, tools) => responses.flatMap((response) => Predicate.isTagged(response, "ToolApprovalResponse") && matchesApproval(response, call, tools) ? [response] : [])[0];
+/** Resume only: a denial for this call under another approval id of the same call (its tool's
+* execution mode changed since the request) still denies. Approvals need the exact id.
+*/
+const callDenialFor = (responses, call) => responses.flatMap((response) => Predicate.isTagged(response, "ToolApprovalResponse") && response.decision === "denied" && response.toolCallId === call.id && (response.requestId === `approval:${call.id}` || response.requestId.startsWith(`approval:${call.id}:`)) ? [response] : [])[0];
+const outstandingApprovalFor = (awaiting, call) => awaiting.flatMap((request) => Predicate.isTagged(request, "ToolApprovalRequest") && request.toolCallId === call.id ? [request] : [])[0];
+const canonicalParams = (params) => Schema$1.decodeUnknownOption(Schema$1.Json)(params).pipe(Option.map(canonicalJson));
+const sameParams = (left, right) => {
+	const leftJson = canonicalParams(left);
+	const rightJson = canonicalParams(right);
+	return Option.isSome(leftJson) && Option.isSome(rightJson) && leftJson.value === rightJson.value;
+};
+/** The outstanding request, when it still describes this call exactly, without its preview
+* (recomputed only while the tool has a previewer).
+*/
+const reusableApprovalRequest = (outstanding, call, tools) => outstanding !== void 0 && outstanding.call.name === call.name && sameParams(outstanding.call.params, call.params) && outstanding.requestId === approvalRequestId(call, tools) ? ToolApprovalRequest.make({
+	requestId: outstanding.requestId,
+	toolCallId: outstanding.toolCallId,
+	call,
+	policy: outstanding.policy
+}) : void 0;
 const questionResponseFor = (responses, call) => responses.flatMap((response) => Predicate.isTagged(response, "QuestionResponse") && matchesQuestion(response, call) ? [response] : [])[0];
 const toolApprovalRequest = (tools, call) => ToolApprovalRequest.make({
 	requestId: approvalRequestId(call, tools),
@@ -262,7 +282,23 @@ const prepareQuestionCall = (call, index, responses) => Effect.gen(function* ()
 		events: [QuestionRequested.make({ request })]
 	});
 });
-const prepareApprovalCall = (tools, call, index, responses) => {
+/**
+* Approval of one call. A fresh batch (a new model turn) follows the current policy and never
+* consults recorded answers: a provider may reuse call ids, so an earlier answer must never
+* settle a new call (a gated call asks again). A resume batch binds the call to its pause
+* instead, because hosts re-read tool policy at execution and the policy can change between the
+* request and the answer:
+*
+* 1. A recorded answer wins: the first exact-match response settles the call (`denied`: the
+*    denied result, never executed; `approved`: executed). A denial for the same call under
+*    another approval id of that call (`approval:<id>` or `approval:<id>:…`) also denies.
+* 2. Else an outstanding request from the resumed pause (`awaitingRequests`) stays pending: the
+*    same request while it still describes the call (name, canonical params, request id), else a
+*    fresh one.
+* 3. Else the current policy decides: `manual` asks, anything else executes.
+*/
+const prepareApprovalCall = (input) => {
+	const { tools, call, index, responses } = input;
 	const envelope = backgroundEnvelope(tools, call);
 	if (envelope !== void 0 && Option.isNone(envelope)) return PreparedToolCall.Result({
 		index,
@@ -274,31 +310,37 @@ const prepareApprovalCall = (tools, call, index, responses) => {
 			content: "Expected exactly execution (foreground or background) and arguments."
 		})
 	});
-	if (!approvalRequired(tools, call)) return PreparedToolCall.Execute({
+	if (!input.resume && !approvalRequired(tools, call)) return PreparedToolCall.Execute({
 		index,
 		call,
 		events: []
 	});
-	const request = toolApprovalRequest(tools, call);
-	const response = approvalResponseFor(responses, call, tools);
-	if (response === void 0) return PreparedToolCall.Pending({
-		request,
-		events: [ToolApprovalRequested.make({
-			call,
-			request
-		})]
-	});
-	if (response.decision === "denied") return PreparedToolCall.Result({
+	const response = input.resume ? approvalResponseFor(responses, call, tools) ?? callDenialFor(responses, call) : void 0;
+	if (response?.decision === "denied") return PreparedToolCall.Result({
 		index,
 		call,
 		result: deniedToolResult(call, response),
 		events: [hitlResponseEvent(response)]
 	});
-	return PreparedToolCall.Execute({
+	if (response !== void 0) return PreparedToolCall.Execute({
 		index,
 		call,
 		events: [hitlResponseEvent(response)]
 	});
+	const outstanding = input.resume ? outstandingApprovalFor(input.awaiting, call) : void 0;
+	if (outstanding === void 0 && !approvalRequired(tools, call)) return PreparedToolCall.Execute({
+		index,
+		call,
+		events: []
+	});
+	const request = reusableApprovalRequest(outstanding, call, tools) ?? toolApprovalRequest(tools, call);
+	return PreparedToolCall.Pending({
+		request,
+		events: [ToolApprovalRequested.make({
+			call,
+			request
+		})]
+	});
 };
 /** Most approval change previews one batch computes at once. */
 const approvalPreviewConcurrency = 8;
@@ -533,7 +575,14 @@ const prepareModelToolCall = (input) => !input.receipts.has(input.call.id) && to
 		content: "Question tool is unavailable",
 		isError: true
 	})
-})) : Effect.succeed(prepareApprovalCall(input.tools, input.call, input.index, input.responses));
+})) : Effect.succeed(prepareApprovalCall({
+	tools: input.tools,
+	call: input.call,
+	index: input.index,
+	responses: input.responses,
+	awaiting: input.awaiting,
+	resume: input.resume
+}));
 /** Preflight the entire batch before dispatching ANY call. Pending requests fence all execution.
 * Fails (`ToolError` `unavailable`) only when host storage an interaction call validator reads is
 * unavailable: the batch fails closed, like `loadInteractionReceipts`, and nothing runs.
@@ -542,12 +591,15 @@ const prepareToolBatch = (input) => Effect.gen(function* () {
 	const handlers = input.inputs ?? {};
 	const preflights = input.interactions ?? {};
 	const previewers = input.approvalPreviews ?? {};
+	const resume = input.resume ?? (input.awaitingRequests !== void 0 || input.responses.length > 0);
 	const planned = yield* Effect.forEach(input.calls, (call, index) => prepareToolCall({
 		tools: input.tools,
 		responses: input.responses,
 		handlers,
 		preflights,
 		receipts: input.interactionReceipts ?? /* @__PURE__ */ new Map(),
+		awaiting: resume ? input.awaitingRequests ?? [] : [],
+		resume,
 		call,
 		index
 	}));
@@ -574,10 +626,16 @@ const syntheticToolCompletionEvents = (prepared) => prepared.flatMap((item) => P
 	result: item.result
 })] : []);
 const toolResultIds = (messages) => new Set(messages.flatMap((message) => Predicate.isTagged(message, "ToolResult") ? [message.toolCallId] : []));
-const pendingHostToolCalls = (messages) => {
-	const completed = toolResultIds(messages);
-	return messages.flatMap((message) => Predicate.isTagged(message, "Assistant") ? assistantHostToolCalls(message).filter((call) => !completed.has(call.id)) : []);
-};
+/**
+* Host tool calls without a result. A call is settled only by a result in its result window: the
+* consecutive `ToolResult` messages right after its assistant message (the transcript rule of
+* `danglingHostToolCalls`). A provider-reused call id is never settled by an earlier call's result.
+*/
+const pendingHostToolCalls = (messages) => messages.flatMap((message, index) => {
+	if (!Predicate.isTagged(message, "Assistant")) return [];
+	const completed = toolResultIds(Array$1.takeWhile(messages.slice(index + 1), (later) => Predicate.isTagged(later, "ToolResult")));
+	return assistantHostToolCalls(message).filter((call) => !completed.has(call.id));
+});
 const nonEmptyHitlRequests = (requests) => {
 	const first = requests[0];
 	return first === void 0 ? void 0 : [first, ...requests.slice(1)];
@@ -652,6 +710,7 @@ const makeAfterLlmStream = (input, llmEventsRef) => Stream.unwrap(Effect.gen(fun
 	const toolResultMessages = yield* Ref.make([]);
 	const prepared = yield* prepareToolBatch({
 		tools: input.config.tools,
+		resume: false,
 		responses: input.config.hitlResponses ?? [],
 		calls: completion.toolCalls,
 		inputs: input.config.inputs,
@@ -699,6 +758,7 @@ const makeAfterLlmStream = (input, llmEventsRef) => Stream.unwrap(Effect.gen(fun
 			reason: completion.stopReason
 		})).pipe(Stream.concat(makeTurnStream({
 			...input,
+			config: withoutConsumedAnswers(input.config),
 			currentMessages: [
 				...input.currentMessages,
 				assistantMessage,
@@ -753,6 +813,15 @@ const makeModelOnlyLlmStream = (input, llmEvents, result) => {
 		return Ref.update(input.usage, (usage) => addAgentUsage(usage, event.usage)).pipe(Effect.flatMap(() => appendEvent));
 	}), Stream.flatMap((event) => Predicate.isTagged(event, "AgentRetry") ? Stream.make(event) : isLlmEvent(event) ? Stream.fromIterable(toLlmEvent(event)) : Stream.make(event)), Stream.concat(makeModelOnlyAfterLlmStream(input, llmEvents)));
 };
+/**
+* The config of the model turns after a batch settled: answers and the pause are consumed by the
+* batch they settled and never reach a later turn, where a provider may reuse a call id.
+*/
+const withoutConsumedAnswers = (config) => Struct.omit(config, [
+	"hitlResponses",
+	"awaitingRequests",
+	"resume"
+]);
 const makeTurnStream = (input) => Stream.suspend(() => {
 	if (input.turn > input.loopConfig.maxTurns) return Stream.fail(new AbortError({ reason: "max_turns" }));
 	const llmStream = Stream.unwrap(Effect.gen(function* () {
@@ -765,15 +834,19 @@ const makeTurnStream = (input) => Stream.suspend(() => {
 });
 const makePendingToolResumeStream = (input) => Stream.unwrap(Effect.gen(function* () {
 	const pendingCalls = pendingHostToolCalls(input.currentMessages);
-	if (pendingCalls.length === 0 || (input.config.hitlResponses ?? []).length === 0 && input.config.interactionHost === void 0) return makeTurnStream(input);
+	const detected = (input.config.hitlResponses ?? []).length > 0 || (input.config.awaitingRequests ?? []).length > 0 || input.config.interactionHost !== void 0;
+	if (pendingCalls.length === 0 || input.config.resume === void 0 && !detected) return makeTurnStream(input);
+	const resume = input.config.resume ?? true;
 	const toolResultMessages = yield* Ref.make([]);
 	const prepared = yield* prepareToolBatch({
 		tools: input.config.tools,
+		resume,
 		responses: input.config.hitlResponses ?? [],
 		calls: pendingCalls,
 		inputs: input.config.inputs,
 		interactions: input.config.interactions,
 		approvalPreviews: input.config.approvalPreviews,
+		awaitingRequests: input.config.awaitingRequests,
 		interactionReceipts: yield* loadInteractionReceipts(pendingCalls, input.config.interactionHost)
 	});
 	if (prepared.resultMessages.length > 0) yield* Ref.update(toolResultMessages, (results) => [...results, ...prepared.resultMessages]);
@@ -808,6 +881,7 @@ const makePendingToolResumeStream = (input) => Stream.unwrap(Effect.gen(function
 		const orderedResults = orderedToolResultMessages(results);
 		return Ref.update(input.createdMessages, (messages) => [...messages, ...orderedResults]).pipe(Effect.as(makeTurnStream({
 			...input,
+			config: withoutConsumedAnswers(input.config),
 			currentMessages: [...input.currentMessages, ...orderedResults]
 		})));
 	})));
@@ -852,6 +926,8 @@ const runToolBatch = (config) => Stream.unwrap(Effect.gen(function* () {
 		inputs: config.inputs,
 		interactions: config.interactions,
 		approvalPreviews: config.approvalPreviews,
+		awaitingRequests: config.awaitingRequests,
+		resume: config.resume,
 		interactionReceipts: yield* loadInteractionReceipts(config.calls, config.interactionHost)
 	});
 	const hasPendingRequests = prepared.pendingRequests.length > 0;