@economic/agents 3.0.0 → 3.1.0-alpha.41659660763.1.0

package/README.md

@@ -385,15 +385,12 @@ const send_invoice = tool<ToolContext>({
   inputSchema: z.object({ invoiceId: z.string() }),
   executeTask: async ({ invoiceId }, { step }) => {
     const invoice = await step.do("load", () => loadInvoice(invoiceId));
-    const approved = await step.requestApproval("send", {
+    await step.requestApproval("send", {
       summary: `Send invoice ${invoice.number} to ${invoice.customer}`,
       risk: "high",
+      required: true,
     });
 
-    if (!approved) {
-      return { sent: false };
-    }
-
     return step.do("send", () => sendInvoice(invoiceId));
   },
 });
@@ -401,6 +398,8 @@ const send_invoice = tool<ToolContext>({
 
 `step.requestApproval(name, { summary, risk })` stops the call until a person answers, and resolves to their decision. An approval nobody answers within `expiresAfterMs` (a day by default) counts as rejected. With `useChat` or `useAssistant` from `@economic/agents-react`, a client sees and answers it as it does a tool's approval: its part has the same `state` and `approval`, and `chat.addToolApprovalResponse` answers it. Other clients use the `pendingApprovals`, `approveExecution` and `rejectExecution` callables.
 
+Set `required: true` to end the tool call with the SDK's rejected result when the approval is rejected or expires. The rejection remains terminal even if the tool catches its signal or uses branches. `required` defaults to `false`: callers receive `true` or `false` and decide how to proceed. An approved request always resolves to `true`.
+
 `step.runAgent(name, Agent, input, { inheritAuth })` runs another agent and returns its answer; see [migration](./MIGRATION.md#agents-you-run-can-act-as-your-caller) for `inheritAuth`.
 
 ### MCP tools

package/dist/hook-proxy-DY2sBNa0-CzaK5b-p.mjs

@@ -0,0 +1,114 @@
+// ../../node_modules/@cloudflare/think/dist/hook-proxy-DY2sBNa0.js
+/**
+* Best-effort JSON-safe normalization. Strips functions, AbortSignals,
+* symbols, and replaces `Error` instances with `{ name, message, stack }`.
+* Falls back to `String(value)` for anything that won't round-trip.
+*/
+function jsonSafe(value, depth = 0) {
+	if (depth > 6) return void 0;
+	if (value === null || value === void 0) return value;
+	const t = typeof value;
+	if (t === "string" || t === "number" || t === "boolean") return value;
+	if (t === "bigint") return String(value);
+	if (t === "function" || t === "symbol") return void 0;
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		stack: value.stack
+	};
+	if (Array.isArray(value)) return value.map((v) => jsonSafe(v, depth + 1));
+	if (t === "object") {
+		const out = {};
+		for (const [k, v] of Object.entries(value)) {
+			if (v instanceof AbortSignal) continue;
+			const safe = jsonSafe(v, depth + 1);
+			if (safe !== void 0) out[k] = safe;
+		}
+		return out;
+	}
+	try {
+		return String(value);
+	} catch {
+		return;
+	}
+}
+/**
+* Create a serializable snapshot from a TurnContext.
+*
+* Pass `model` when `beforeTurn` already overrode it: `ctx.model` lazily
+* resolves the default model, which may need an AI binding the turn never uses.
+*/
+function createTurnContextSnapshot(ctx, model = ctx.model) {
+	return {
+		system: ctx.system,
+		toolNames: Object.keys(ctx.tools),
+		messageCount: ctx.messages.length,
+		continuation: ctx.continuation,
+		body: ctx.body,
+		modelId: typeof model === "string" ? model : model.modelId ?? "unknown",
+		...ctx.requestId !== void 0 && { requestId: ctx.requestId },
+		...ctx.trigger !== void 0 && { trigger: ctx.trigger }
+	};
+}
+/**
+* Parse a hook result from the extension Worker's JSON response.
+* Returns a TurnConfig or null if the extension skipped/errored.
+*/
+function parseHookResult(json) {
+	try {
+		const parsed = JSON.parse(json);
+		if (parsed.skipped) return { skipped: true };
+		if (parsed.error) return { error: parsed.error };
+		return { config: parsed.result ?? {} };
+	} catch {
+		return { error: "Failed to parse hook result" };
+	}
+}
+function createToolCallStartSnapshot(event) {
+	return {
+		toolName: event.toolCall.toolName,
+		toolCallId: event.toolCall.toolCallId,
+		input: jsonSafe(event.toolCall.input),
+		stepNumber: event.stepNumber,
+		...event.toolCall.dynamic !== void 0 ? { dynamic: event.toolCall.dynamic } : {}
+	};
+}
+function createToolCallFinishSnapshot(event) {
+	return {
+		toolName: event.toolCall.toolName,
+		toolCallId: event.toolCall.toolCallId,
+		input: jsonSafe(event.toolCall.input),
+		stepNumber: event.stepNumber,
+		durationMs: event.durationMs,
+		success: event.success,
+		...event.success ? { output: jsonSafe(event.output) } : { error: jsonSafe(event.error) },
+		...event.toolCall.dynamic !== void 0 ? { dynamic: event.toolCall.dynamic } : {}
+	};
+}
+function createStepFinishSnapshot(event) {
+	return {
+		stepNumber: event.stepNumber,
+		finishReason: event.finishReason,
+		text: event.text,
+		reasoningText: event.reasoningText,
+		toolCallCount: event.toolCalls.length,
+		toolResultCount: event.toolResults.length,
+		usage: event.usage ? {
+			inputTokens: event.usage.inputTokens,
+			outputTokens: event.usage.outputTokens,
+			totalTokens: event.usage.totalTokens,
+			reasoningTokens: event.usage.outputTokenDetails?.reasoningTokens ?? event.usage.reasoningTokens,
+			cachedInputTokens: event.usage.inputTokenDetails?.cacheReadTokens ?? event.usage.cachedInputTokens
+		} : void 0,
+		providerMetadata: event.providerMetadata
+	};
+}
+function createChunkSnapshot(event) {
+	const c = event.chunk;
+	const snapshot = { type: c.type };
+	if (typeof c.text === "string") snapshot.text = c.text;
+	if (typeof c.toolName === "string") snapshot.toolName = c.toolName;
+	if (typeof c.toolCallId === "string") snapshot.toolCallId = c.toolCallId;
+	return snapshot;
+}
+export { createChunkSnapshot, createStepFinishSnapshot, createToolCallFinishSnapshot, createToolCallStartSnapshot, createTurnContextSnapshot, parseHookResult };