@jskit-ai/assistant-core 0.2.44 → 0.2.45

package/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Each tool set `createServiceToolCatalog` resolves carries its catalogue's `limits` (`maxToolArgumentBytes` and `maxToolResultBytes`), and an application conversation's tools hold calls to that tool set's `maxToolArgumentBytes` and give engines that value as `maximumArgumentBytes`, instead of reading the catalogue's own `limits`. A catalogue that resolves each surface's tool set from a catalogue of its own, as `@jskit-ai/assistant-runtime`'s does, now has each surface's argument limit enforced; its result limit already was, by that surface's catalogue. **Breaking** for a hand-written tool catalogue passed as `toolCatalog`: its `resolveToolSet` returns `limits: { maxToolArgumentBytes }` with its tools.
 - A Claude goal's clock counts from its first start: Resume and restart recovery send the same unfinished objective again, which Claude starts anew, so the clock went back to zero after every Pause and Resume and after a server restart. The Claude history keeps that first start, also across the clear that suspends a paused goal's checker, and the goal value carries it as `startedAt` (ISO), which `AssistantGoalControl` counts its wall-clock time from (else `createdAt`). A goal finished or cancelled and then set again starts a new clock.
 - The goal menu is 360 pixels wide, or the screen's width less the menu's 12-pixel margins on a narrower phone (the menu's `width` and `max-width`), so the new-goal objective box fills it instead of shrinking to its label.
 - `assistantConversationListItemOutputValidator` (from `@jskit-ai/assistant-core/shared`) is one conversation of `assistantContract`'s `conversationsList`, the record without its `metadata`; the contract's list output is built from it, and `@jskit-ai/assistant-runtime`'s conversations list route serializes its items with it.

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.44",
+    "@jskit-ai/assistant-core": "0.2.45",
     "@jskit-ai/http-runtime": "0.2.20",
     "@jskit-ai/kernel": "0.2.20",
     "@jskit-ai/material-web": "0.1.5",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.44",
+  "version": "0.2.45",
   "type": "module",
   "scripts": {
     "test": "jskit test"

package/src/server/conversation/tools.js

@@ -17,7 +17,7 @@ const TRANSIENT_HOOKS = new Set([authorizeTransientCall, saveTransientCalls, ann
  * One turn's application calls. Native/API adapters only transport these calls.
  * @param {object} options
  * @param {import("../types.js").ServiceToolCatalog} options.catalog
- * @param {{ tools: object[] }} [options.toolSet] A tool set resolved earlier for this turn.
+ * @param {{ tools: object[], limits: { maxToolArgumentBytes: number } }} [options.toolSet] A tool set resolved earlier for this turn.
  * @param {object} options.context The caller context the calls run as.
  * @param {() => Promise<object>} [options.prepareContext] Maps the context again before each call.
  * @param {AbortSignal} options.signal
@@ -42,6 +42,8 @@ export function createConversationTools({ catalog, toolSet: retainedToolSet, con
   // readable-check: allow method-probe - input validation: an optional context mapper must be a function
   if (prepareContext !== undefined && typeof prepareContext !== "function") throw new TypeError("Application tool context requires a server-owned mapper.");
   const toolSet = retainedToolSet ?? catalog.resolveToolSet(context, { discoveryOnly });
+  // The tool set's own limit: a surface-aware catalogue resolves each surface's set with that surface's.
+  const maximumArgumentBytes = toolSet.limits.maxToolArgumentBytes;
   const calls = new Map(structuredClone(previousCalls).map(call => [call.id, call]));
   let pending = Promise.resolve();
   let requested = 0;
@@ -61,7 +63,7 @@ export function createConversationTools({ catalog, toolSet: retainedToolSet, con
     signal.throwIfAborted();
     if (typeof id !== "string" || !id || id.length > 256 || typeof name !== "string" || !name || name.length > 256 ||
         typeof argumentsText !== "string") throw new TypeError("An application tool requires its call id, name and JSON arguments.");
-    if (Buffer.byteLength(argumentsText) > catalog.limits.maxToolArgumentBytes) throw Object.assign(new Error("The application tool arguments exceed their size limit."), {
+    if (Buffer.byteLength(argumentsText) > maximumArgumentBytes) throw Object.assign(new Error("The application tool arguments exceed their size limit."), {
       messageCode: "assistant.conversation.toolArgumentsTooLarge", messageParams: {}
     });
     const input = { id, name, arguments: argumentsText };
@@ -117,7 +119,7 @@ export function createConversationTools({ catalog, toolSet: retainedToolSet, con
     descriptors: toolSet.tools,
     schemas: toolSet.tools.map(catalog.toOpenAiToolSchema),
     execute,
-    maximumArgumentBytes: catalog.limits.maxToolArgumentBytes,
+    maximumArgumentBytes,
     records
   });
 }

package/src/server/lib/serviceToolCatalog.js

@@ -381,6 +381,8 @@ function createServiceToolCatalog(
   );
   const maxToolArgumentBytes = normalizePositiveInteger(rawMaxToolArgumentBytes, { fallback: DEFAULT_MAX_TOOL_ARGUMENT_BYTES });
   const maxToolResultBytes = normalizePositiveInteger(rawMaxToolResultBytes, { fallback: DEFAULT_MAX_TOOL_RESULT_BYTES });
+  // Every tool set carries these, so the calls made with one surface's set keep that surface's limits.
+  const limits = Object.freeze({ maxToolArgumentBytes, maxToolResultBytes });
   const toolSetStates = new WeakMap();
   let methodEntries = null;
 
@@ -446,7 +448,8 @@ function createServiceToolCatalog(
 
     const toolSet = Object.freeze({
       tools: Object.freeze(tools),
-      byName
+      byName,
+      limits
     });
     const actionEntriesById = new Map();
     const directEntriesByToolName = new Map();
@@ -669,10 +672,7 @@ function createServiceToolCatalog(
   }
 
   return Object.freeze({
-    limits: Object.freeze({
-      maxToolArgumentBytes,
-      maxToolResultBytes
-    }),
+    limits,
     resolveToolSet,
     toOpenAiToolSchema,
     executeToolCall

package/test/conversationTools.test.js

@@ -360,6 +360,36 @@ test("failed reservations and oversized arguments cannot reach application execu
   assert.equal(executions, 0);
 });
 
+test("the resolved tool set's argument limit is the one its calls are held to and the one engines are given", async () => {
+  const lengths = [];
+  const actions = createActionCatalogue();
+  actions.register({ contributorId: "test.documents", domain: "test", actions: [{
+    id: "documents.propose", version: 1, kind: "command", channels: ["automation"], surfaces: ["app", "home"],
+    permission: { require: "authenticated" },
+    input: { schema: createSchema({ text: { type: "string", required: true } }), mode: "replace" },
+    output: { schema: createSchema({ length: { type: "number", required: true } }), mode: "replace" },
+    execute: async ({ text }) => { lengths.push(text.length); return { length: text.length }; }
+  }] });
+  // One catalogue per surface behind one, as assistant-runtime's surface-aware catalogue is:
+  // the app surface allows 64 KiB of arguments, home keeps the default 32 KiB.
+  const surfaces = { app: createServiceToolCatalog(actions, { maxToolArgumentBytes: 64 * 1024 }), home: createServiceToolCatalog(actions) };
+  const catalog = {
+    resolveToolSet: (toolContext, options) => surfaces[toolContext.surface].resolveToolSet(toolContext, options),
+    toOpenAiToolSchema: surfaces.home.toOpenAiToolSchema,
+    executeToolCall: payload => surfaces[payload.context.surface].executeToolCall(payload)
+  };
+  const tools = surface => createConversationTools({ catalog, context: { ...context, surface }, signal: new AbortController().signal,
+    transient: true });
+  const proposal = name => ({ id: "propose", name, arguments: JSON.stringify({ text: "x".repeat(40 * 1024) }) });
+  const app = tools("app");
+  assert.equal(app.maximumArgumentBytes, 64 * 1024);
+  assert.deepEqual(await app.execute(proposal(app.descriptors[0].name)), { ok: true, result: { length: 40 * 1024 } });
+  const home = tools("home");
+  assert.equal(home.maximumArgumentBytes, 32 * 1024);
+  await assert.rejects(home.execute(proposal(home.descriptors[0].name)), { message: "The application tool arguments exceed their size limit." });
+  assert.deepEqual(lengths, [40 * 1024]);
+});
+
 test("closing a native tool connection prevents queued calls while retaining an invoked result", async () => {
   const entered = Promise.withResolvers(), complete = Promise.withResolvers();
   let executions = 0;

package/test/openCodeTools.test.js

@@ -54,6 +54,25 @@ test("the native tool connection requires its private credential and bounds inco
   assert.deepEqual(calls, [{}]);
 });
 
+test("arguments up to the limit reach the application through the native tool connection with the longest call identity", async t => {
+  const limit = 128 * 1024;
+  const sizes = [];
+  const bridge = await createOpenCodeToolBridge({ schemas: [], maxArgumentBytes: limit,
+    execute: async value => { sizes.push(Buffer.byteLength(JSON.stringify(value.input))); return { ok: true }; } });
+  t.after(() => bridge.close());
+  const { url, token } = bridge.configuration;
+  // The plugin's request: the call's identities, each at most 256 characters, around its input.
+  const identity = { sessionId: "s".repeat(256), messageId: "m".repeat(256), id: "c".repeat(256), name: "n".repeat(256) };
+  const send = text => fetch(url, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+    body: JSON.stringify({ ...identity, input: { text } }) });
+  assert.deepEqual(await (await send("x".repeat(limit - 11))).json(), { ok: true });
+  assert.deepEqual(sizes, [limit]);
+  const tooLarge = await send("x".repeat(limit + 4096));
+  assert.equal(tooLarge.status, 400);
+  assert.match((await tooLarge.json()).error, /size limit/);
+  assert.deepEqual(sizes, [limit]);
+});
+
 test("native plugin definitions retain exact schemas and native identity without enabling built-in tools", async t => {
   const schema = { type: "object", properties: { query: { type: "string" } }, additionalProperties: false };
   const calls = [];

package/test/serviceToolCatalog.test.js

@@ -631,6 +631,15 @@ test("discovery pages and persisted tool results stay within configured bounds",
   });
 });
 
+test("each tool set carries its catalog's size limits for the calls made with it", () => {
+  const context = { actor: { id: "7" }, surface: "admin" };
+  const actions = createActions([action()]);
+  const large = createServiceToolCatalog(actions, { maxToolArgumentBytes: 64 * 1024 });
+  assert.deepEqual(large.resolveToolSet(context).limits, { maxToolArgumentBytes: 64 * 1024, maxToolResultBytes: 48 * 1024 });
+  assert.equal(large.resolveToolSet(context, { discoveryOnly: true }).limits, large.limits);
+  assert.equal(createServiceToolCatalog(actions).resolveToolSet(context).limits.maxToolArgumentBytes, 32 * 1024);
+});
+
 test("assistant tools reject unknown tools and return safe action failures", async () => {
   const actions = createActions([action({
     execute: async () => {