@jskit-ai/assistant-core 0.2.43 → 0.2.45

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## 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.
 - `createConversationStorage`'s `write` saves nothing when its callback called no write method: the adapter's `writeRecord` does not run, so file storage no longer rewrites and flushes the whole conversation file, or creates an empty one for a missing conversation, when a write only looked (a delivery check, a message already saved), and the saved record stays cached.
 - Checking or recovering one message's delivery (`inspectDelivery`, and a send that finds its message already saved) finds that message's turn by its id instead of reading and cloning every turn of the conversation to find it.

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.43",
+    "@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.43",
+  "version": "0.2.45",
   "type": "module",
   "scripts": {
     "test": "jskit test"

package/src/client/conversation/AssistantGoalControl.vue

@@ -34,11 +34,16 @@ const statusLabel = computed(() => goal.value?.status === "usageLimited" && goal
 const label = computed(() => props.state.loading ? t("jskit.assistant.goal.loading") : props.state.available === false ? t("jskit.assistant.goal.unavailable")
   : starting.value ? t("jskit.assistant.goal.starting") : statusLabel.value);
 const nativeElapsed = computed(() => Number.isFinite(goal.value?.elapsedSeconds));
-const createdAt = computed(() => typeof goal.value?.createdAt === "string" ? Date.parse(goal.value.createdAt) : NaN);
+// A goal resumed by sending it again (Claude) keeps the time its first start
+// gave it, so its clock carries on across Pause, Resume and a server restart.
+const startedAt = computed(() => {
+  const value = goal.value?.startedAt ?? goal.value?.createdAt;
+  return typeof value === "string" ? Date.parse(value) : NaN;
+});
 const elapsedLabel = computed(() => nativeElapsed.value ? t("jskit.assistant.goal.runningTime") : t("jskit.assistant.goal.elapsedSinceStart"));
 const elapsedText = computed(() => elapsed.value ? t("jskit.assistant.goal.elapsed", { label: elapsedLabel.value, elapsed: elapsed.value }) : "");
 const clockRunning = computed(() => nativeElapsed.value ? running.value && Number.isFinite(goal.value?.sampledAt)
-  : Boolean(goal.value && goal.value.status !== "complete" && Number.isFinite(createdAt.value)));
+  : Boolean(goal.value && goal.value.status !== "complete" && Number.isFinite(startedAt.value)));
 const elapsed = computed(() => {
   let secondsUsed;
   if (nativeElapsed.value) {
@@ -47,8 +52,8 @@ const elapsed = computed(() => {
     secondsUsed = goal.value.elapsedSeconds + sinceSample;
   } else {
     const end = goal.value?.status === "complete" ? goal.value.sampledAt : now.value;
-    if (!Number.isFinite(createdAt.value) || !Number.isFinite(end)) return "";
-    secondsUsed = (end - createdAt.value) / 1000;
+    if (!Number.isFinite(startedAt.value) || !Number.isFinite(end)) return "";
+    secondsUsed = (end - startedAt.value) / 1000;
   }
   const total = Math.max(0, Math.floor(secondsUsed));
   const seconds = String(total % 60).padStart(2, "0");
@@ -64,7 +69,7 @@ const chipLabel = computed(() => props.state.loading || props.state.available ==
 const canSet = computed(() => !props.state.loading && props.state.available !== false && typeof props.state.set === "function" && (!goal.value || goal.value.status === "complete"));
 const validBudget = computed(() => props.state.tokenBudgetSupported === false || tokenBudget.value === "" || (Number.isSafeInteger(Number(tokenBudget.value)) && Number(tokenBudget.value) > 0));
 let timer;
-onMounted(() => watch(() => [props.state.enabled, clockRunning.value, goal.value?.elapsedSeconds, goal.value?.sampledAt, createdAt.value], () => {
+onMounted(() => watch(() => [props.state.enabled, clockRunning.value, goal.value?.elapsedSeconds, goal.value?.sampledAt, startedAt.value], () => {
   clearInterval(timer);
   now.value = Date.now();
   if (props.state.enabled !== false && clockRunning.value) {
@@ -86,7 +91,7 @@ async function cancelGoal() {
 </script>
 
 <template>
-  <v-menu v-if="state && state.enabled !== false" v-model="open" location="top" :close-on-content-click="false">
+  <v-menu v-if="state && state.enabled !== false" v-model="open" location="top" width="360" max-width="calc(100vw - 24px)" :close-on-content-click="false">
     <template #activator="{ props: menuProps }">
       <v-btn v-bind="menuProps" class="assistant-goal" size="small" variant="text" :aria-label="label" :title="[label, elapsedText, goal?.objective].filter(Boolean).join('\n')">
         <span v-if="goal" class="assistant-goal__light" :class="{ 'assistant-goal__light--running': running, 'assistant-goal__light--working': working, 'assistant-goal__light--paused': goal.status === 'paused' }" aria-hidden="true" />
@@ -94,7 +99,7 @@ async function cancelGoal() {
         <span v-if="elapsed && running" class="assistant-goal__elapsed" aria-hidden="true">{{ elapsed }}</span>
       </v-btn>
     </template>
-    <v-card class="assistant-goal__details pa-3" max-width="360">
+    <v-card class="assistant-goal__details pa-3">
       <strong role="status">{{ label }}</strong>
       <v-btn v-if="(running || (state.pauseBlocked && ['blocked', 'usageLimited'].includes(goal?.status))) && state.pause" size="small" :disabled="state.stopPending" @click="state.pause()">{{ state.action === 'pause' ? t('jskit.assistant.goal.pausing') : t('jskit.assistant.goal.pause') }}</v-btn>
       <v-btn v-if="['paused', 'blocked', 'usageLimited'].includes(goal?.status) && state.resume" size="small" :disabled="state.pending" @click="state.resume()">{{ state.action === 'resume' ? t('jskit.assistant.goal.resuming') : t('jskit.assistant.goal.resume') }}</v-btn>

package/src/client/types.js

@@ -48,7 +48,9 @@
  * @property {boolean} [cancelInterruptsTurn]
  * @property {boolean} [tokenBudgetSupported]
  * @property {string} [error]
- * @property {{ status: string, objective?: string, elapsedSeconds?: number, sampledAt?: number, createdAt?: string } | null} [goal]
+ * @property {{ status: string, objective?: string, elapsedSeconds?: number, sampledAt?: number, createdAt?: string,
+ *   startedAt?: string } | null} [goal] Without a native running time, its clock counts from startedAt (when the
+ *   unfinished goal first started, through any Resume), else createdAt.
  * @property {((input: { objective: string, tokenBudget?: number }) => unknown) | null} [set]
  *   Starts a goal; absent while starting one is not allowed, so Start stays disabled.
  * @property {() => unknown} [pause]

package/src/server/conversation/claudeHistory.js

@@ -212,6 +212,9 @@ async function readClaudeHistory(options) {
   const userIds = [];
   let lastUserId = "";
   let goal = null;
+  // The unfinished goal a clear removed: a paused goal's checker is cleared
+  // before its Resume sends the same objective again.
+  let clearedGoal = null;
   let goalStartId = "";
   let goalCommandId = "";
   let frames = [];
@@ -260,6 +263,7 @@ async function readClaudeHistory(options) {
         !frame.parent_tool_use_id && !frame.isMeta && frame.commandRun?.command === "goal" &&
         frame.commandRun.args === "clear" && typeof frame.content === "string" &&
         /^<local-command-stdout>(?:No goal set|Goal cleared: [\s\S]+)<\/local-command-stdout>$/u.test(frame.content)) {
+      if (goal && goal.status !== "complete") clearedGoal = goal;
       goal = null;
       goalStartId = "";
       const command = byId.get(frame.parentUuid);
@@ -282,15 +286,22 @@ async function readClaudeHistory(options) {
         goalStartId = status.sentinel === true && typeof status.met === "boolean" ? frame.uuid || "" : "";
         goalCommandId = "";
       }
-      if (status.met === true && status.sentinel === true) goal = null;
-      else if (status.met === false || status.met === true) {
+      if (status.met === true && status.sentinel === true) {
+        if (goal && goal.status !== "complete") clearedGoal = goal;
+        goal = null;
+      } else if (status.met === false || status.met === true) {
         const timestamp = Date.parse(frame.timestamp) / 1000;
+        const createdAt = goal?.objective === status.condition && !status.sentinel ? goal.createdAt : timestamp;
+        // Resume sends the same objective again and Claude starts it anew;
+        // the unfinished goal still started with its first command.
+        const previous = goal || clearedGoal;
         goal = {
-          threadId: options.conversationId, objective: status.condition,
-          createdAt: goal?.objective === status.condition && !status.sentinel ? goal.createdAt : timestamp,
+          threadId: options.conversationId, objective: status.condition, createdAt,
+          startedAt: previous?.objective === status.condition && previous.status !== "complete" ? previous.startedAt : createdAt,
           status: status.met ? "complete" : status.failed === true ? "blocked" : "active", updatedAt: timestamp,
           reason: typeof status.reason === "string" ? status.reason : ""
         };
+        clearedGoal = null;
       }
     }
     // This is native terminal evidence, not an inference from the assistant's

package/src/server/conversation/providers/claudeDriver.js

@@ -19,6 +19,7 @@ const nativeInput = input => input.content?.length ? [...(input.text ? [{ type:
 const claudeGoalValue = (goal, conversationId) => goal ? { ...goal,
   id: hash([conversationId, goal.createdAt, goal.objective]),
   ...(Number.isFinite(goal.createdAt) ? { createdAt: new Date(goal.createdAt * 1000).toISOString() } : {}),
+  ...(Number.isFinite(goal.startedAt) ? { startedAt: new Date(goal.startedAt * 1000).toISOString() } : {}),
   ...(Number.isFinite(goal.updatedAt) ? { updatedAt: new Date(goal.updatedAt * 1000).toISOString() } : {})
 } : null;
 const goalCapabilities = Object.freeze({ goals: true, goalBudgets: false,

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/assistantGoalControlChip.test.js

@@ -81,6 +81,14 @@ test("an active goal's chip shows its clock, and a finished goal's chip shows ne
   assert.equal(none.label, "jskit.assistant.goal.set");
 });
 
+test("a resumed goal's clock counts from its first start, not from the Resume that sent it again", async () => {
+  const control = await importControl();
+  const resumed = await render(control, { objective: "Finish every check", status: "active",
+    createdAt: new Date(Date.now() - 5 * 60 * 1000).toISOString(), startedAt: startedTwoHoursAgo });
+  assert.match(resumed.chip, /<span class="assistant-goal__elapsed" aria-hidden="true">2:00:0\d<\/span>/u);
+  assert.match(resumed.panel, /jskit\.assistant\.goal\.elapsedSinceStart=2:00:0\d/u);
+});
+
 test("a goal waiting at its AI account's limit names the limit and when it resets, and Resume is the person's to press", async () => {
   const control = await importControl();
   const reset = new Date();

package/test/assistantScroll.browser.test.js

@@ -889,10 +889,24 @@ test("long goal objectives keep Start reachable on short phone, tablet and deskt
   const { vite, browser } = await openFixture(t);
   try {
     const objective = "Complete the requested work and verify the result. ".repeat(80).slice(0, 3990);
-    for (const width of [390, 800, 1280]) {
+    for (const width of [320, 390, 800, 1280]) {
       const page = await browser.newPage({ viewport: { width, height: 578 } });
       await page.goto(`${vite.baseURL}/?conversation=1&goal=1`);
       await page.getByRole("button", { name: "Set goal", exact: true }).click();
+      await expect(page.getByRole("textbox", { name: "Goal objective" })).toBeVisible();
+      // The new goal's box fills its menu, which is 360 px wide or as wide as a phone allows.
+      const measure = () => page.locator(".assistant-goal__details").evaluate(card => {
+        const style = getComputedStyle(card);
+        const bounds = card.getBoundingClientRect();
+        return { left: bounds.left, right: bounds.right, card: bounds.width, field: card.querySelector(".v-textarea").getBoundingClientRect().width,
+          inner: card.clientWidth - parseFloat(style.paddingLeft) - parseFloat(style.paddingRight) };
+      });
+      const fills = box => box.card >= Math.min(360, width - 24) - 1 && box.left >= 0 && box.right <= width &&
+        Math.abs(box.field - box.inner) <= 1;
+      await expect.poll(async () => fills(await measure())).toBe(true).catch(async failure => {
+        failure.message += `\nat ${width} px: ${JSON.stringify(await measure())}`;
+        throw failure;
+      });
       await page.getByRole("textbox", { name: "Goal objective" }).fill(objective);
       const start = page.getByRole("button", { name: "Start goal", exact: true });
       await expect(start).toBeInViewport();

package/test/claudeTurn.test.js

@@ -129,6 +129,44 @@ test("Claude successful native clear removes a failed goal without a clearing se
   assert.equal((await readClaudeHistory(options)).goal.objective, "Next checks", "a later goal still wins");
 });
 
+test("a resumed Claude goal keeps the time it first started, across the clear before Resume", async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "claude-goal-start-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const directory = path.join(root, "projects", root.replace(/[^a-zA-Z0-9]/gu, "-"));
+  await mkdir(directory, { recursive: true });
+  const conversationId = "6b1f2c9e-4d3a-4c1b-9e7f-2a5d8c0b1e3f";
+  const file = path.join(directory, `${conversationId}.jsonl`);
+  const options = { configRoot: root, workdir: root, conversationId };
+  const append = (...frames) => writeFile(file, frames.map(JSON.stringify).join("\n") + "\n", { flag: "a" });
+  const goal = (uuid, timestamp, condition, extra = {}) => ({ type: "attachment", uuid, timestamp,
+    attachment: { type: "goal_status", condition, met: false, sentinel: true, ...extra } });
+  const first = Date.parse("2026-11-11T07:00:00.000Z") / 1000;
+  await append(goal("set", "2026-11-11T07:00:00.000Z", "Finish all checks"));
+  // Restart recovery sends the same objective again while the goal still runs.
+  await append(goal("recovered", "2026-11-11T07:30:00.000Z", "Finish all checks"));
+  let read = (await readClaudeHistory(options)).goal;
+  assert.equal(read.createdAt, Date.parse("2026-11-11T07:30:00.000Z") / 1000);
+  assert.equal(read.startedAt, first);
+  // A paused goal's checker is cleared when its process starts; Resume sends it again.
+  await append({ type: "system", subtype: "local_command", uuid: "suspended", timestamp: "2026-11-11T08:00:00.000Z",
+    commandRun: { command: "goal", args: "clear" }, content: "<local-command-stdout>Goal cleared: Finish all checks</local-command-stdout>" });
+  assert.equal((await readClaudeHistory(options)).goal, null);
+  await append(goal("resumed", "2026-11-11T08:05:00.000Z", "Finish all checks"));
+  read = (await readClaudeHistory(options)).goal;
+  assert.equal(read.status, "active");
+  assert.equal(read.startedAt, first, "Resume after the clear keeps the first start");
+  await append({ type: "attachment", uuid: "done", timestamp: "2026-11-11T09:00:00.000Z",
+    attachment: { type: "goal_status", condition: "Finish all checks", met: true } });
+  assert.equal((await readClaudeHistory(options)).goal.startedAt, first);
+  // A finished goal set again, or another objective, starts its own clock.
+  await append(goal("again", "2026-11-11T09:10:00.000Z", "Finish all checks"));
+  assert.equal((await readClaudeHistory(options)).goal.startedAt, Date.parse("2026-11-11T09:10:00.000Z") / 1000);
+  await append({ type: "attachment", uuid: "cleared", timestamp: "2026-11-11T09:20:00.000Z",
+    attachment: { type: "goal_status", condition: "Finish all checks", met: true, sentinel: true } },
+  goal("other", "2026-11-11T09:30:00.000Z", "Write the release notes"));
+  assert.equal((await readClaudeHistory(options)).goal.startedAt, Date.parse("2026-11-11T09:30:00.000Z") / 1000);
+});
+
 // Claude 2.1.308 history at a hosted goal's usage limit (2026-11-10), and the
 // message Claude Code writes when the account's credit balance is too low.
 test("Claude's own limit message makes its goal wait, with the reset time, until a later answer", async t => {

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 () => {