@economic/agents 2.14.0 → 2.14.2

package/dist/index.d.mts

@@ -226,6 +226,16 @@ interface TurnSnapshot {
   frameworkToolNames: string[];
   messages: ModelMessage[];
 }
+type CurrentTurnState<RequestContext extends Record<string, unknown>, UserContext extends Record<string, unknown>> = {
+  context?: ToolContext<RequestContext, UserContext>;
+  inputTools: ToolSet;
+  preparedTools: ToolSet;
+  unavailableSkillIds: Set<string>;
+  skillsSystemBlock: string;
+  visibleSkillNames: string[];
+  authorizedSkillNames: Set<string>;
+  baseSystem: string;
+};
 type Authentication<UserContext> = {
   success: true;
   userContext?: UserContext;
@@ -249,8 +259,9 @@ declare abstract class Agent<RequestContext extends Record<string, unknown> = Re
   onStart(): Promise<void>;
   configureSession(session: Session): Session;
   onConnect(connection: Connection, ctx: ConnectionContext): Promise<void>;
-  private _turn;
-  private getToolContextForCurrentTurn;
+  protected _turn: CurrentTurnState<RequestContext, UserContext>;
+  protected createToolContextForCurrentTurn(requestContext?: RequestContext): ToolContext<RequestContext, UserContext>;
+  protected getToolContextForCurrentTurn(): ToolContext<RequestContext, UserContext> | undefined;
   /**
    * Merges the client request `body` into `experimental_context` for tools
    * returned from {@link getTools} only (Think-internal tools are unchanged).
@@ -508,6 +519,8 @@ declare abstract class ChatAgent<RequestContext extends Record<string, unknown>
    * returned immediately and each event reaches the client as it is produced.
    */
   private streamMessage;
+  private streamToolApproval;
+  private streamTurn;
   /**
    * Submit feedback for a message by its id.
    * @param messageId - The id of the message to give feedback on.

package/dist/index.mjs

@@ -4,6 +4,7 @@ import { Output, convertToModelMessages, generateText, jsonSchema, pruneMessages
 import { createRemoteJWKSet, decodeJwt, errors, jwtVerify } from "jose";
 import { BasicTracerProvider, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { genericObservability } from "agents/observability";
+import { applyToolUpdate, toolApprovalUpdate } from "agents/chat";
 import { createCompactFunction, estimateMessageTokens, estimateStringTokens, sanitizeToolPairs, truncateOlderMessages } from "agents/experimental/memory/utils";
 import { nanoid } from "nanoid";
 //#region src/server/features/auth/index.ts
@@ -1158,13 +1159,17 @@ var Agent = class extends Think {
 		authorizedSkillNames: /* @__PURE__ */ new Set(),
 		baseSystem: ""
 	};
-	getToolContextForCurrentTurn(requestContext = {}) {
+	createToolContextForCurrentTurn(requestContext = {}) {
 		const connectionState = getCurrentAgent().connection?.state;
 		return {
+			...this._turn.context,
 			...requestContext,
 			_userContext: connectionState?.userContext ?? this.userContext
 		};
 	}
+	getToolContextForCurrentTurn() {
+		return this._turn.context;
+	}
 	/**
 	* Merges the client request `body` into `experimental_context` for tools
 	* returned from {@link getTools} only (Think-internal tools are unchanged).
@@ -1175,8 +1180,11 @@ var Agent = class extends Think {
 	async beforeTurn(ctx) {
 		this.analytics.promptReceived(ctx.messages, ctx.continuation);
 		this.registerInstanceActivity();
-		const body = await this._applyTokenExchange(ctx.body);
-		this._turn.context = this.getToolContextForCurrentTurn(body);
+		const body = await this._applyTokenExchange({
+			...this._turn.context,
+			...ctx.body
+		});
+		this._turn.context = this.createToolContextForCurrentTurn(body);
 		this._turn.inputTools = ctx.tools;
 		const activeSkillName = this._getLastActivatedSkillName(ctx.messages);
 		const { tools, activeTools } = await this._prepareTools(ctx.tools, activeSkillName, true);
@@ -2839,6 +2847,22 @@ var ChatAgent = class extends Agent {
 		if (action === "getMessages" && request.method === "GET") return Response.json(await this.getMessages());
 		if (action === "getInvocableSkills" && request.method === "GET") return Response.json(await this.getInvocableSkills(auth.userContext));
 		if (action === "sendMessage" && request.method === "POST") return this.streamMessage(request);
+		if (action === "submitToolApproval" && request.method === "POST") return this.streamToolApproval(request);
+		if (action === "getMessageFeedback" && request.method === "GET") return Response.json(await this.getMessageFeedback());
+		if (action === "submitMessageFeedback" && request.method === "POST") {
+			let payload;
+			try {
+				payload = await request.json();
+			} catch {
+				return Response.json({ error: "Request body must be valid JSON" }, { status: 400 });
+			}
+			if (!payload || typeof payload !== "object" || Array.isArray(payload)) return Response.json({ error: "Request body must be an object" }, { status: 400 });
+			const { messageId, rating, comment } = payload;
+			if (!messageId) return Response.json({ error: "Message ID is required" }, { status: 400 });
+			if (rating !== -1 && rating !== 0 && rating !== 1) return Response.json({ error: "Rating must be -1, 0, or 1" }, { status: 400 });
+			if (comment !== void 0 && typeof comment !== "string") return Response.json({ error: "Comment must be a string" }, { status: 400 });
+			return Response.json(await this.submitMessageFeedback(messageId, rating, comment));
+		}
 		if (action === "cancelChat" && request.method === "POST") {
 			const { requestId } = await request.json();
 			this.cancelChat(requestId);
@@ -2851,38 +2875,81 @@ var ChatAgent = class extends Agent {
 	* returned immediately and each event reaches the client as it is produced.
 	*/
 	async streamMessage(request) {
-		let message;
+		let payload;
 		try {
-			({message} = await request.json());
+			payload = await request.json();
 		} catch {
-			return Response.json({ error: "Invalid request body" }, { status: 400 });
+			return Response.json({ error: "Request body must be valid JSON" }, { status: 400 });
 		}
-		if (typeof message === "string") message = {
-			id: crypto.randomUUID(),
-			role: "user",
-			parts: [{
-				type: "text",
-				text: message
-			}]
-		};
-		else if (!message || message.role !== "user" || !Array.isArray(message.parts)) return Response.json({ error: "message must be a user message" }, { status: 400 });
+		if (!payload || typeof payload !== "object" || Array.isArray(payload)) return Response.json({ error: "Request body must be an object" }, { status: 400 });
+		let { message, context } = payload;
+		if (context !== void 0 && (context === null || typeof context !== "object" || Array.isArray(context))) return Response.json({ error: "Context must be an object" }, { status: 400 });
+		if (typeof message === "string") {
+			if (!message.trim()) return Response.json({ error: "Message must not be empty" }, { status: 400 });
+			message = {
+				id: crypto.randomUUID(),
+				role: "user",
+				parts: [{
+					type: "text",
+					text: message
+				}]
+			};
+		} else if (!message || typeof message !== "object" || Array.isArray(message) || typeof message.id !== "string" || !message.id || message.role !== "user" || !Array.isArray(message.parts)) return Response.json({ error: "Message must be a non-empty string or a user UIMessage" }, { status: 400 });
+		const input = context ? () => {
+			this._turn.context = this.createToolContextForCurrentTurn(context);
+			return [message];
+		} : message;
+		return this.streamTurn(input);
+	}
+	async streamToolApproval(request) {
+		let payload;
+		try {
+			payload = await request.json();
+		} catch {
+			return Response.json({ error: "Request body must be valid JSON" }, { status: 400 });
+		}
+		if (!payload || typeof payload !== "object" || Array.isArray(payload)) return Response.json({ error: "Request body must be an object" }, { status: 400 });
+		const { toolCallId, approved, context } = payload;
+		if (!toolCallId) return Response.json({ error: "Tool call ID is required" }, { status: 400 });
+		if (typeof approved !== "boolean") return Response.json({ error: "Approved must be a boolean" }, { status: 400 });
+		if (context !== void 0 && (context === null || typeof context !== "object" || Array.isArray(context))) return Response.json({ error: "Context must be an object" }, { status: 400 });
+		return this.streamTurn((messages) => {
+			if (context) this._turn.context = this.createToolContextForCurrentTurn(context);
+			const update = toolApprovalUpdate(toolCallId, approved);
+			let found = false;
+			const updatedMessages = messages.map((message) => {
+				if (found || message.role !== "assistant") return message;
+				const result = applyToolUpdate(message.parts, update);
+				if (!result) return message;
+				found = true;
+				return {
+					...message,
+					parts: result.parts
+				};
+			});
+			if (!found) throw new Error(`No pending tool approval found for ${toolCallId}`);
+			return updatedMessages;
+		});
+	}
+	streamTurn(input) {
 		const encoder = new TextEncoder();
 		const readable = new ReadableStream({ start: async (controller) => {
 			const send = (event, data) => controller.enqueue(encoder.encode(`event: ${event}\ndata: ${data}\n\n`));
+			const sendError = (error) => send("error", JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
 			try {
 				await this.runTurn({
 					mode: "stream",
-					input: message,
+					input,
 					callback: {
 						onStart: (event) => send("start", JSON.stringify(event)),
 						onEvent: (json) => send("chunk", json),
 						onDone: () => send("done", "{}"),
-						onError: (error) => send("error", JSON.stringify({ error })),
+						onError: sendError,
 						onInterrupted: () => send("interrupted", "{}")
 					}
 				});
 			} catch (error) {
-				send("error", JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+				sendError(error);
 			} finally {
 				controller.close();
 			}

package/package.json

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