@nexface/agent 0.1.13-alpha.4 → 0.1.13-alpha.5

package/dist/request.js

@@ -2,17 +2,25 @@ import { assertCurrentHistory } from "./history-version.js";
 import { MessageSchema } from "@ag-ui/core";
 import { getToolResultError } from "./tool-result.js";
 export const approvalResponseSchema = {
-    type: "object", properties: { approved: { type: "boolean" } }, required: ["approved"], additionalProperties: false,
+    type: "object",
+    properties: { approved: { type: "boolean" } },
+    required: ["approved"],
+    additionalProperties: false,
 };
 export const toolResultResponseSchema = {
-    type: "object", properties: { toolResultMessageId: { type: "string" }, confirmed: { type: "boolean" } }, required: ["toolResultMessageId"], additionalProperties: false,
+    type: "object",
+    properties: { toolResultMessageId: { type: "string" }, confirmed: { type: "boolean" } },
+    required: ["toolResultMessageId"],
+    additionalProperties: false,
 };
 export function parseResume(value, allowMetadata = false) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error("Invalid resume entry.");
     const entry = value;
     const allowed = ["interruptId", "status", "payload", ...(allowMetadata ? ["metadata"] : [])];
-    if (Object.keys(entry).some((key) => !allowed.includes(key)) || typeof entry.interruptId !== "string" || !entry.interruptId)
+    if (Object.keys(entry).some((key) => !allowed.includes(key)) ||
+        typeof entry.interruptId !== "string" ||
+        !entry.interruptId)
         throw new Error("Invalid resume entry.");
     if (entry.status === "cancelled") {
         if (entry.payload !== undefined)
@@ -20,13 +28,31 @@ export function parseResume(value, allowMetadata = false) {
         return { interruptId: entry.interruptId, status: "cancelled" };
     }
     const payload = entry.payload;
-    if (entry.status !== "resolved" || !payload || typeof payload !== "object" || Array.isArray(payload))
+    if (entry.status !== "resolved" ||
+        !payload ||
+        typeof payload !== "object" ||
+        Array.isArray(payload))
         throw new Error("A resolved response requires a payload.");
-    if (typeof payload.approved === "boolean" && Object.keys(payload).every((key) => key === "approved")) {
-        return { interruptId: entry.interruptId, status: "resolved", payload: { approved: payload.approved } };
+    if (typeof payload.approved === "boolean" &&
+        Object.keys(payload).every((key) => key === "approved")) {
+        return {
+            interruptId: entry.interruptId,
+            status: "resolved",
+            payload: { approved: payload.approved },
+        };
     }
-    if (typeof payload.toolResultMessageId === "string" && payload.toolResultMessageId && (payload.confirmed === undefined || typeof payload.confirmed === "boolean") && Object.keys(payload).every((key) => key === "toolResultMessageId" || key === "confirmed")) {
-        return { interruptId: entry.interruptId, status: "resolved", payload: { toolResultMessageId: payload.toolResultMessageId, ...(payload.confirmed === undefined ? {} : { confirmed: payload.confirmed }) } };
+    if (typeof payload.toolResultMessageId === "string" &&
+        payload.toolResultMessageId &&
+        (payload.confirmed === undefined || typeof payload.confirmed === "boolean") &&
+        Object.keys(payload).every((key) => key === "toolResultMessageId" || key === "confirmed")) {
+        return {
+            interruptId: entry.interruptId,
+            status: "resolved",
+            payload: {
+                toolResultMessageId: payload.toolResultMessageId,
+                ...(payload.confirmed === undefined ? {} : { confirmed: payload.confirmed }),
+            },
+        };
     }
     throw new Error("Invalid resume payload.");
 }
@@ -43,23 +69,41 @@ export function convertMessages(values) {
         if (message.role === "assistant") {
             for (const call of message.toolCalls ?? [])
                 calls.set(call.id, call.function.name);
-            return [{ id: message.id, role: "assistant", content: message.content ?? null, toolCalls: (message.toolCalls ?? []).map((call) => ({ id: call.id, ...call.function })) }];
+            return [
+                {
+                    id: message.id,
+                    role: "assistant",
+                    content: message.content ?? null,
+                    toolCalls: (message.toolCalls ?? []).map((call) => ({ id: call.id, ...call.function })),
+                },
+            ];
         }
         if (message.role === "tool") {
             const name = calls.get(message.toolCallId);
             if (!name)
                 throw new Error("A tool result has no preceding tool call.");
             const content = message.error !== undefined && getToolResultError(message.content) === undefined
-                ? JSON.stringify({ error: { code: "TOOL_ERROR", message: message.error }, content: message.content }) : message.content;
+                ? JSON.stringify({
+                    error: { code: "TOOL_ERROR", message: message.error },
+                    content: message.content,
+                })
+                : message.content;
             return [{ id: message.id, role: "tool", name, toolCallId: message.toolCallId, content }];
         }
         if (message.role === "user") {
-            if (Array.isArray(message.content) && message.content.some((part) => part.type !== "text" && part.type !== "image"))
+            if (Array.isArray(message.content) &&
+                message.content.some((part) => part.type !== "text" && part.type !== "image"))
                 throw new Error("This Agent supports text and image input only.");
             const content = typeof message.content === "string" ? message.content.trim() : message.content;
             if (!content.length)
                 throw new Error("Agent message content is required.");
-            return [{ id: message.id, role: "user", content: content }];
+            return [
+                {
+                    id: message.id,
+                    role: "user",
+                    content: content,
+                },
+            ];
         }
         throw new Error(`Unsupported model history role: ${message.role}.`);
     });
@@ -68,22 +112,29 @@ export function convertMessages(values) {
 }
 export function decodeRequest(value) {
     const extension = value.forwardedProps?.nexface;
-    if (extension && (extension.version !== 3 || "checkpoint" in extension || "confirmedToolCallId" in extension))
+    if (extension &&
+        (extension.version !== 3 || "checkpoint" in extension || "confirmedToolCallId" in extension))
         throw new Error("Unsupported Nexface request version or recovery channel. Upgrade client and server together and start a new conversation.");
     const state = value.state;
     if (state != null && (typeof state !== "object" || Array.isArray(state)))
         throw new Error("Invalid Agent state.");
-    if (state && "nexface" in state && (!state.nexface || typeof state.nexface !== "object" || Array.isArray(state.nexface)))
+    if (state &&
+        "nexface" in state &&
+        (!state.nexface || typeof state.nexface !== "object" || Array.isArray(state.nexface)))
         throw new Error("Invalid Nexface state.");
     const restored = state?.nexface;
-    if (restored && (restored.version !== 3 || restored.threadId !== value.threadId || !Array.isArray(restored.timeline)))
+    if (restored &&
+        (restored.version !== 3 ||
+            restored.threadId !== value.threadId ||
+            !Array.isArray(restored.timeline)))
         throw new Error("Agent state does not match this thread or version. Start a new conversation.");
     const converted = new Map(convertMessages(value.messages).map((message) => [message.id, message]));
     const source = new Map(value.messages.map((message) => [message.id, message]));
     const used = new Set();
     const messages = (restored?.timeline ?? []).flatMap((entry) => {
         if ("internal" in entry) {
-            if (!entry.internal || (entry.internal.role !== "system" && entry.internal.role !== "application_context"))
+            if (!entry.internal ||
+                (entry.internal.role !== "system" && entry.internal.role !== "application_context"))
                 throw new Error("Invalid internal history.");
             return [structuredClone(entry.internal)];
         }
@@ -100,7 +151,10 @@ export function decodeRequest(value) {
     const receipts = [];
     let toolResult;
     if (pending) {
-        if (!resume || resume.interruptId !== pending.interruptId || !Array.isArray(pending.calls) || !pending.calls.length)
+        if (!resume ||
+            resume.interruptId !== pending.interruptId ||
+            !Array.isArray(pending.calls) ||
+            !pending.calls.length)
             throw new Error("Resume does not match the pending interrupt.");
         if (pending.kind !== "client-tool-execution")
             throw new Error("Invalid pending kind.");
@@ -108,12 +162,19 @@ export function decodeRequest(value) {
             if (!("toolResultMessageId" in resume.payload))
                 throw new Error("A client tool requires a result reference.");
             const message = source.get(resume.payload.toolResultMessageId);
-            if (!message || used.has(message.id) || message.role !== "tool" || message.toolCallId !== pending.calls[0].id)
+            if (!message ||
+                used.has(message.id) ||
+                message.role !== "tool" ||
+                message.toolCallId !== pending.calls[0].id)
                 throw new Error("Resume result does not match the pending call.");
             const owner = [...messages].reverse().find((item) => item.role === "assistant");
             const ownerIndex = value.messages.findIndex((item) => item.id === owner?.id);
             const receiptIndex = value.messages.indexOf(message);
-            if (ownerIndex < 0 || receiptIndex <= ownerIndex || value.messages.slice(ownerIndex + 1, receiptIndex).some((item) => item.role === "user" || (item.role === "assistant" && item.toolCalls?.length)))
+            if (ownerIndex < 0 ||
+                receiptIndex <= ownerIndex ||
+                value.messages
+                    .slice(ownerIndex + 1, receiptIndex)
+                    .some((item) => item.role === "user" || (item.role === "assistant" && item.toolCalls?.length)))
                 throw new Error("The receipt does not belong to the pending assistant batch.");
             let payload;
             try {
@@ -125,11 +186,18 @@ export function decodeRequest(value) {
             }
             if (message.error !== undefined)
                 payload = { error: { code: payload?.error?.code ?? "TOOL_ERROR", message: message.error } };
-            if (!payload || typeof payload !== "object" || (!("result" in payload) && !("error" in payload)))
+            if (!payload ||
+                typeof payload !== "object" ||
+                (!("result" in payload) && !("error" in payload)))
                 throw new Error("Invalid tool result.");
-            if (payload.error && (typeof payload.error.code !== "string" || typeof payload.error.message !== "string"))
+            if (payload.error &&
+                (typeof payload.error.code !== "string" || typeof payload.error.message !== "string"))
                 throw new Error("Invalid tool error.");
-            toolResult = { toolCallId: message.toolCallId, ...(payload.error ? { error: payload.error } : { result: payload.result }), ...(resume.payload.confirmed === undefined ? {} : { confirmed: resume.payload.confirmed }) };
+            toolResult = {
+                toolCallId: message.toolCallId,
+                ...(payload.error ? { error: payload.error } : { result: payload.result }),
+                ...(resume.payload.confirmed === undefined ? {} : { confirmed: resume.payload.confirmed }),
+            };
             receipts.push(message);
         }
         else {
@@ -138,7 +206,9 @@ export function decodeRequest(value) {
             for (const message of value.messages.slice(ownerIndex + 1)) {
                 if (message.role === "user")
                     break;
-                if (used.has(message.id) || message.role !== "tool" || !pending.calls.some((call) => call.id === message.toolCallId))
+                if (used.has(message.id) ||
+                    message.role !== "tool" ||
+                    !pending.calls.some((call) => call.id === message.toolCallId))
                     continue;
                 let payload;
                 try {
@@ -148,7 +218,9 @@ export function decodeRequest(value) {
                     throw new Error("Invalid cancellation receipt.");
                 }
                 const first = message.toolCallId === pending.calls[0].id;
-                if (!(first ? ["TOOL_CANCELLED", "TOOL_CONFIRMATION_INVALIDATED"] : ["TOOL_SKIPPED", "TOOL_CANCELLED"]).includes(payload?.error?.code))
+                if (!(first
+                    ? ["TOOL_CANCELLED", "TOOL_CONFIRMATION_INVALIDATED"]
+                    : ["TOOL_SKIPPED", "TOOL_CANCELLED"]).includes(payload?.error?.code))
                     throw new Error("Cancellation cannot replace an execution result.");
                 if (receipts.some((receipt) => receipt.role === "tool" && receipt.toolCallId === message.toolCallId))
                     throw new Error("Repeated cancellation receipt.");
@@ -162,7 +234,9 @@ export function decodeRequest(value) {
     const newMessages = value.messages.flatMap((message) => {
         if (used.has(message.id) || receiptIds.has(message.id))
             return [];
-        if (pending && message.role === "tool" && pending.calls.some((call) => call.id === message.toolCallId))
+        if (pending &&
+            message.role === "tool" &&
+            pending.calls.some((call) => call.id === message.toolCallId))
             throw new Error("Repeated or unexpected pending result.");
         const convertedMessage = converted.get(message.id);
         if (pending && resume?.status === "resolved" && convertedMessage)
@@ -170,17 +244,33 @@ export function decodeRequest(value) {
         return convertedMessage ? [convertedMessage] : [];
     });
     return {
-        messages, newMessages, receipts, ...(restored ? { continuation: structuredClone(restored) } : {}), ...(resume ? { resume } : {}), ...(toolResult ? { toolResult } : {}),
-        tools: value.tools.map((tool) => ({ name: tool.name, description: tool.description, inputSchema: tool.parameters, effect: extension?.toolMetadata?.[tool.name]?.effect ?? "action" })),
+        messages,
+        newMessages,
+        receipts,
+        ...(restored ? { continuation: structuredClone(restored) } : {}),
+        ...(resume ? { resume } : {}),
+        ...(toolResult ? { toolResult } : {}),
+        tools: value.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.parameters,
+            effect: extension?.toolMetadata?.[tool.name]?.effect ?? "action",
+        })),
         contexts: value.context.map((context, index) => {
             let data = context.value;
             try {
                 data = JSON.parse(context.value);
             }
-            catch { /* Context values may be plain text. */ }
+            catch {
+                /* Context values may be plain text. */
+            }
             if (data && typeof data === "object" && "name" in data && "value" in data)
                 return data;
-            return { name: `context${index}`, description: context.description, value: data };
+            return {
+                name: `context${index}`,
+                description: context.description,
+                value: data,
+            };
         }),
     };
 }
@@ -190,10 +280,29 @@ export function toProtocolMessages(messages) {
         if (message.role === "system" || message.role === "application_context")
             return [];
         if (message.role === "assistant")
-            return [{ id: message.id, role: "assistant", ...(message.content === null ? {} : { content: message.content }), toolCalls: message.toolCalls.map(({ id, name, arguments: args }) => ({ id, type: "function", function: { name, arguments: args } })) }];
+            return [
+                {
+                    id: message.id,
+                    role: "assistant",
+                    ...(message.content === null ? {} : { content: message.content }),
+                    toolCalls: message.toolCalls.map(({ id, name, arguments: args }) => ({
+                        id,
+                        type: "function",
+                        function: { name, arguments: args },
+                    })),
+                },
+            ];
         if (message.role === "tool") {
             const error = getToolResultError(message.content);
-            return [{ id: message.id, role: "tool", toolCallId: message.toolCallId, content: message.content, ...(error === undefined ? {} : { error }) }];
+            return [
+                {
+                    id: message.id,
+                    role: "tool",
+                    toolCallId: message.toolCallId,
+                    content: message.content,
+                    ...(error === undefined ? {} : { error }),
+                },
+            ];
         }
         return [{ id: message.id, role: "user", content: message.content }];
     });
@@ -215,15 +324,22 @@ export function runResponse(run) {
                 controller.error(error);
             }
         },
-        async cancel() { run.cancel(); await iterator.return?.(); },
-    }), { headers: {
+        async cancel() {
+            run.cancel();
+            await iterator.return?.();
+        },
+    }), {
+        headers: {
             "Content-Type": "text/event-stream",
             "Cache-Control": "no-cache, no-transform",
             "X-Accel-Buffering": "no",
-        } });
+        },
+    });
 }
 export function mergeProtocolMessages(messages, previous) {
-    const reasoningOwners = new Set(previous.filter((message) => message.role === "reasoning").map((message) => message.metadata?.nexface?.reasoningOwnerId));
+    const reasoningOwners = new Set(previous
+        .filter((message) => message.role === "reasoning")
+        .map((message) => message.metadata?.nexface?.reasoningOwnerId));
     const remaining = new Map(messages.map((message) => [message.id, message]));
     const mergedHistory = previous.flatMap((old) => {
         const message = remaining.get(old.id);
@@ -231,17 +347,30 @@ export function mergeProtocolMessages(messages, previous) {
             return old.role === "activity" || old.role === "reasoning" ? [old] : [];
         remaining.delete(old.id);
         const merged = { ...old, ...message };
-        if (old.role === "assistant" && message.role === "assistant" && old.content === "" && message.content === undefined)
+        if (old.role === "assistant" &&
+            message.role === "assistant" &&
+            old.content === "" &&
+            message.content === undefined)
             delete merged.content;
         // Preserve streamed display offsets when a finish tool replaces model text.
-        if (old.role === "assistant" && message.role === "assistant" && reasoningOwners.has(old.id)
-            && old.content && old.content !== message.content && old.metadata?.nexface?.reasoningText === undefined) {
-            merged.metadata = { ...old.metadata, nexface: { ...old.metadata?.nexface, reasoningText: old.content } };
+        if (old.role === "assistant" &&
+            message.role === "assistant" &&
+            reasoningOwners.has(old.id) &&
+            old.content &&
+            old.content !== message.content &&
+            old.metadata?.nexface?.reasoningText === undefined) {
+            merged.metadata = {
+                ...old.metadata,
+                nexface: { ...old.metadata?.nexface, reasoningText: old.content },
+            };
         }
         if (message.role === "tool" && old.role === "tool" && old.error !== undefined)
             merged.content = old.content;
         if (message.role === "assistant" && old.role === "assistant")
-            merged.toolCalls = message.toolCalls?.map((call) => ({ ...old.toolCalls?.find((item) => item.id === call.id), ...call }));
+            merged.toolCalls = message.toolCalls?.map((call) => ({
+                ...old.toolCalls?.find((item) => item.id === call.id),
+                ...call,
+            }));
         return [MessageSchema.parse(merged)];
     });
     return [...mergedHistory, ...remaining.values()];

package/dist/shared/errors.d.ts

@@ -1,5 +1,5 @@
 export declare const TOOL_ERROR_CODES: readonly ["EXECUTION_OUTCOME_UNKNOWN", "ACTION_IN_FLIGHT", "ACTION_NOT_HANDLED", "ACTION_TARGET_UNAVAILABLE", "BROWSER_EXECUTION_FAILED", "BROWSER_SNAPSHOT_REQUIRED", "BROWSER_TOOLS_UNAVAILABLE", "CONTRACT_MISMATCH", "DUPLICATE_BINDING", "INVALID_INPUT", "INVALID_TOOL_RUNTIME", "OPERATION_BUSY", "TOOL_CANCELLED", "TOOL_CONFIRMATION_INVALIDATED", "TOOL_CONFIRMATION_REJECTED", "TOOL_ERROR", "TOOL_REGISTRATION_TIMEOUT", "TOOL_SKIPPED", "TOOL_UNAVAILABLE", "UNKNOWN_TOOL"];
-type AgentToolErrorCode = typeof TOOL_ERROR_CODES[number];
+type AgentToolErrorCode = (typeof TOOL_ERROR_CODES)[number];
 export declare class AgentToolError extends Error {
     readonly code: AgentToolErrorCode;
     readonly details?: unknown | undefined;

package/dist/shared/schema.js

@@ -3,8 +3,17 @@ const types = new Set(["object", "array", "string", "number", "integer", "boolea
 const counts = ["minLength", "maxLength", "minItems", "maxItems"];
 const bounds = ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"];
 const keywords = new Set([
-    "type", "description", "properties", "required", "items", "enum", "additionalProperties",
-    ...counts, ...bounds, "pattern", "uniqueItems",
+    "type",
+    "description",
+    "properties",
+    "required",
+    "items",
+    "enum",
+    "additionalProperties",
+    ...counts,
+    ...bounds,
+    "pattern",
+    "uniqueItems",
 ]);
 const checkedSchemas = new WeakSet();
 const patterns = new WeakMap();
@@ -24,7 +33,9 @@ function assertJson(value, path, ancestors = new Set()) {
         invalid(path, "must be JSON-compatible.");
     if (ancestors.has(value))
         invalid(path, "must not contain circular references.");
-    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    if (!Array.isArray(value) &&
+        Object.getPrototypeOf(value) !== Object.prototype &&
+        Object.getPrototypeOf(value) !== null) {
         invalid(path, "must be a plain JSON object.");
     }
     if (Object.getOwnPropertySymbols(value).length)
@@ -85,7 +96,8 @@ function assertSchema(value, path) {
             invalid(`${path}.${key}`, "must be a non-negative integer.");
     }
     for (const key of bounds) {
-        if (value[key] !== undefined && (typeof value[key] !== "number" || !Number.isFinite(value[key])))
+        if (value[key] !== undefined &&
+            (typeof value[key] !== "number" || !Number.isFinite(value[key])))
             invalid(`${path}.${key}`, "must be a finite number.");
     }
     if (value.pattern !== undefined) {
@@ -95,7 +107,8 @@ function assertSchema(value, path) {
     }
     if (value.enum !== undefined && (!Array.isArray(value.enum) || value.enum.length === 0))
         invalid(`${path}.enum`, "must be a non-empty array.");
-    if (Array.isArray(value.enum) && value.enum.some((item, index, entries) => entries.slice(0, index).some((other) => jsonEqual(item, other))))
+    if (Array.isArray(value.enum) &&
+        value.enum.some((item, index, entries) => entries.slice(0, index).some((other) => jsonEqual(item, other))))
         invalid(`${path}.enum`, "must contain unique values.");
     if (value.properties !== undefined) {
         if (value.type !== "object" || !isRecord(value.properties))
@@ -104,7 +117,10 @@ function assertSchema(value, path) {
             assertSchema(property, `${path}.properties.${name}`);
     }
     if (value.required !== undefined) {
-        if (value.type !== "object" || !Array.isArray(value.required) || value.required.some((name) => typeof name !== "string") || new Set(value.required).size !== value.required.length)
+        if (value.type !== "object" ||
+            !Array.isArray(value.required) ||
+            value.required.some((name) => typeof name !== "string") ||
+            new Set(value.required).size !== value.required.length)
             invalid(`${path}.required`, "must contain unique property names.");
         const properties = value.properties;
         if (value.required.some((name) => !properties || !Object.hasOwn(properties, name)))
@@ -118,7 +134,7 @@ function assertSchema(value, path) {
 }
 export function assertAgentToolInputSchema(value, path = "inputSchema") {
     if (!isRecord(value) || value.type !== "object")
-        invalid(path, 'root type must be object.');
+        invalid(path, "root type must be object.");
     if (checkedSchemas.has(value))
         return;
     const frozen = assertJson(value, path);
@@ -130,21 +146,29 @@ function jsonEqual(left, right) {
     if (left === right)
         return true;
     if (Array.isArray(left) && Array.isArray(right))
-        return left.length === right.length && left.every((item, index) => jsonEqual(item, right[index]));
+        return (left.length === right.length && left.every((item, index) => jsonEqual(item, right[index])));
     if (!isRecord(left) || !isRecord(right))
         return false;
     const keys = Object.keys(left);
-    return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && jsonEqual(left[key], right[key]));
+    return (keys.length === Object.keys(right).length &&
+        keys.every((key) => Object.hasOwn(right, key) && jsonEqual(left[key], right[key])));
 }
 function typeMatches(schema, value) {
     switch (schema.type) {
-        case undefined: return true;
-        case "null": return value === null;
-        case "array": return Array.isArray(value);
-        case "object": return isRecord(value);
-        case "integer": return typeof value === "number" && Number.isInteger(value);
-        case "number": return typeof value === "number" && Number.isFinite(value);
-        default: return typeof value === schema.type;
+        case undefined:
+            return true;
+        case "null":
+            return value === null;
+        case "array":
+            return Array.isArray(value);
+        case "object":
+            return isRecord(value);
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        default:
+            return typeof value === schema.type;
     }
 }
 export function validateAgentToolInput(schema, value, path = "input") {
@@ -177,7 +201,8 @@ export function validateAgentToolInput(schema, value, path = "input") {
             errors.push(`${path} must have at least ${schema.minItems} items.`);
         if (schema.maxItems !== undefined && value.length > schema.maxItems)
             errors.push(`${path} must have at most ${schema.maxItems} items.`);
-        if (schema.uniqueItems && value.some((item, index) => value.slice(0, index).some((other) => jsonEqual(item, other))))
+        if (schema.uniqueItems &&
+            value.some((item, index) => value.slice(0, index).some((other) => jsonEqual(item, other))))
             errors.push(`${path} must contain unique items.`);
         if (schema.items)
             value.forEach((item, index) => errors.push(...validateAgentToolInput(schema.items, item, `${path}[${index}]`)));
@@ -188,7 +213,9 @@ export function validateAgentToolInput(schema, value, path = "input") {
                 errors.push(`${path}.${key} is required.`);
         }
         for (const [key, item] of Object.entries(value)) {
-            const property = schema.properties && Object.hasOwn(schema.properties, key) ? schema.properties[key] : undefined;
+            const property = schema.properties && Object.hasOwn(schema.properties, key)
+                ? schema.properties[key]
+                : undefined;
             if (property)
                 errors.push(...validateAgentToolInput(property, item, `${path}.${key}`));
             else if (schema.additionalProperties === false)

package/dist/tool-catalog.js

@@ -15,9 +15,7 @@ function invalidResponse(message, details) {
     throw new CatalogValidationError("INVALID_TOOL_CATALOG", message, details);
 }
 function assertJsonCompatible(value, path, seen = new WeakSet()) {
-    if (value === null
-        || typeof value === "string"
-        || typeof value === "boolean")
+    if (value === null || typeof value === "string" || typeof value === "boolean")
         return;
     if (typeof value === "number") {
         if (!Number.isFinite(value))
@@ -54,10 +52,7 @@ function canonicalize(value) {
         return value;
     return Object.fromEntries(Object.keys(value)
         .sort()
-        .map((key) => [
-        key,
-        canonicalize(value[key]),
-    ]));
+        .map((key) => [key, canonicalize(value[key])]));
 }
 function deepFreeze(value, seen = new WeakSet()) {
     if (!value || typeof value !== "object" || seen.has(value))
@@ -72,8 +67,10 @@ function sameDefinition(left, right) {
 }
 const BUSINESS_TOOL_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
 const RESERVED_BUSINESS_TOOL_NAMES = new Set([
-    "nxf_beginOperation", "nxf_endOperation",
-    "nxf_applyAction", "nxf_delegatePageTask",
+    "nxf_beginOperation",
+    "nxf_endOperation",
+    "nxf_applyAction",
+    "nxf_delegatePageTask",
     "nxf_callAppTool",
     "nxf_finish",
     "nxf_getSnapshot",
@@ -81,8 +78,8 @@ const RESERVED_BUSINESS_TOOL_NAMES = new Set([
     "nxf_loadSkill",
 ]);
 function assertBusinessToolDefinition(definition) {
-    if (!BUSINESS_TOOL_NAME_PATTERN.test(definition.name)
-        || RESERVED_BUSINESS_TOOL_NAMES.has(definition.name)) {
+    if (!BUSINESS_TOOL_NAME_PATTERN.test(definition.name) ||
+        RESERVED_BUSINESS_TOOL_NAMES.has(definition.name)) {
         invalidResponse(`Tool catalog returned an invalid tool name "${definition.name}".`);
     }
     if (typeof definition.description !== "string" || !definition.description.trim()) {
@@ -101,8 +98,7 @@ export function validateToolCatalog(value) {
             invalidResponse(`Tool definition at index ${index} must be an object.`);
         }
         const candidate = definition;
-        const unexpectedKeys = Object.keys(candidate)
-            .filter((key) => !["name", "description", "inputSchema", "effect"].includes(key));
+        const unexpectedKeys = Object.keys(candidate).filter((key) => !["name", "description", "inputSchema", "effect"].includes(key));
         if (unexpectedKeys.length > 0) {
             invalidResponse(`Tool definition at index ${index} has unexpected fields: ${unexpectedKeys.join(", ")}.`);
         }
@@ -143,8 +139,7 @@ export function validateToolCatalog(value) {
     }
     for (const definition of value)
         deepFreeze(definition);
-    return [...value]
-        .sort((left, right) => left.name.localeCompare(right.name));
+    return [...value].sort((left, right) => left.name.localeCompare(right.name));
 }
 export function validateContextCatalog(value) {
     if (!Array.isArray(value)) {
@@ -156,26 +151,30 @@ export function validateContextCatalog(value) {
             invalidResponse(`Context at index ${index} must be an object.`);
         }
         const candidate = entry;
-        const unexpectedKeys = Object.keys(candidate)
-            .filter((key) => !["name", "description", "value"].includes(key));
+        const unexpectedKeys = Object.keys(candidate).filter((key) => !["name", "description", "value"].includes(key));
         if (unexpectedKeys.length > 0) {
             invalidResponse(`Context at index ${index} has unexpected fields: ${unexpectedKeys.join(", ")}.`);
         }
-        if (!/^[A-Za-z0-9_-]{1,64}$/.test(candidate.name ?? "")
-            || ["nxf_callAppTool", "nxf_finish", "nxf_getSnapshot", "nxf_executeAction", "nxf_applyAction", "nxf_delegatePageTask"]
-                .includes(candidate.name)) {
+        if (!/^[A-Za-z0-9_-]{1,64}$/.test(candidate.name ?? "") ||
+            [
+                "nxf_callAppTool",
+                "nxf_finish",
+                "nxf_getSnapshot",
+                "nxf_executeAction",
+                "nxf_applyAction",
+                "nxf_delegatePageTask",
+            ].includes(candidate.name)) {
             invalidResponse(`Context at index ${index} has an invalid name.`);
         }
         if (names.has(candidate.name)) {
             invalidResponse(`Tool catalog returned duplicate context name "${candidate.name}".`);
         }
         names.add(candidate.name);
-        if (candidate.description !== undefined
-            && (typeof candidate.description !== "string" || !candidate.description.trim())) {
+        if (candidate.description !== undefined &&
+            (typeof candidate.description !== "string" || !candidate.description.trim())) {
             invalidResponse(`Context "${candidate.name}" must have a non-empty description when provided.`);
         }
         assertJsonCompatible(candidate.value, `contexts[${index}].value`);
     }
-    return [...value]
-        .sort((left, right) => left.name.localeCompare(right.name));
+    return [...value].sort((left, right) => left.name.localeCompare(right.name));
 }

package/dist/tool-result.js

@@ -3,9 +3,14 @@ export function getToolResultError(content) {
         const error = JSON.parse(content)?.error;
         if (typeof error === "string")
             return error;
-        if (error && typeof error === "object" && "message" in error && typeof error.message === "string")
+        if (error &&
+            typeof error === "object" &&
+            "message" in error &&
+            typeof error.message === "string")
             return error.message;
     }
-    catch { /* Tool results may contain plain text. */ }
+    catch {
+        /* Tool results may contain plain text. */
+    }
     return undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexface/agent",
-  "version": "0.1.13-alpha.4",
+  "version": "0.1.13-alpha.5",
   "type": "module",
   "engines": {
     "node": ">=22.19.0"
@@ -43,7 +43,7 @@
     "@ag-ui/core": "0.0.59"
   },
   "peerDependencies": {
-    "@nexface/tools": "0.1.13-alpha.4"
+    "@nexface/tools": "0.1.13-alpha.5"
   },
   "repository": {
     "type": "git",