crow-central-agency 0.26.8 → 0.26.9

package/dist/mcp/agents/search-workspace.js

@@ -21,16 +21,16 @@ export function getSearchWorkspaceToolConfig(agentId, documentSearchService, tas
             .number()
             .optional()
             .describe(`Maximum number of hits to return per page. Default ${DEFAULT_SEARCH_LIMIT}.`),
-        skip: z.number().optional().describe("Number of hits to skip for pagination."),
+        offset: z.number().optional().describe("Number of hits to skip before the page starts (0-based offset)."),
     };
-    const handler = async ({ query, sources, limit, skip }) => {
+    const handler = async ({ query, sources, limit, offset }) => {
         try {
             const filter = buildAccessFilter(agentId, taskManager, circleManager, sources);
             const hits = documentSearchService.search(query, { filter, limit: MAX_SEARCH_LIMIT });
             if (hits.length === 0) {
                 return textToolResult([`No matches found for query "${query}".`]);
             }
-            const pagination = applyPagination(hits, limit || DEFAULT_SEARCH_LIMIT, skip);
+            const pagination = applyPagination(hits, limit || DEFAULT_SEARCH_LIMIT, offset);
             const header = formatPaginationHeader(`Workspace search for query "${query}"`, pagination);
             return textToolResult(header.concat("", renderHits(pagination.items)));
         }

package/dist/mcp/artifacts/list-artifacts.js

@@ -16,9 +16,9 @@ export function getListArtifactsToolConfig(agentId, artifactManager, registry, c
             .optional()
             .describe("Filter by tags. Only artifacts that have every specified tag are returned."),
         limit: z.number().optional().describe("Number of artifacts to return per page."),
-        skip: z.number().optional().describe("Number of artifacts to skip for pagination."),
+        offset: z.number().optional().describe("Number of artifacts to skip before the page starts (0-based offset)."),
     };
-    const handler = async ({ agent_id, type, tags, limit, skip }) => {
+    const handler = async ({ agent_id, type, tags, limit, offset }) => {
         const targetId = agent_id ?? agentId;
         if (agent_id) {
             try {
@@ -47,7 +47,7 @@ export function getListArtifactsToolConfig(agentId, artifactManager, registry, c
                 const suffix = filterParts.length ? ` matching ${filterParts.join(" and ")}` : "";
                 return textToolResult([`No artifacts found for agent ${targetId}${suffix}.`]);
             }
-            const pagination = applyPagination(artifacts, limit || DEFAULT_ARTIFACTS_LIMIT, skip);
+            const pagination = applyPagination(artifacts, limit || DEFAULT_ARTIFACTS_LIMIT, offset);
             const lines = pagination.items.map((artifact) => `- ${artifact.filename} (owner: ${artifact.entityId}, type: ${artifact.type}, modified: ${formatLocalDateTime(new Date(artifact.updatedTimestamp), userTimezone)})`);
             const header = formatPaginationHeader(`Artifacts for agent ${targetId}`, pagination);
             return textToolResult(header.concat("", lines));

package/dist/mcp/artifacts/list-circle-artifacts.js

@@ -16,9 +16,9 @@ export function getListCircleArtifactsToolConfig(agentId, artifactManager, senso
             .optional()
             .describe("Filter by tags. Only artifacts that have every specified tag are returned."),
         limit: z.number().optional().describe("Number of artifacts to return per page."),
-        skip: z.number().optional().describe("Number of artifacts to skip for pagination."),
+        offset: z.number().optional().describe("Number of artifacts to skip before the page starts (0-based offset)."),
     };
-    const handler = async ({ circle_id, type, tags, limit, skip }) => {
+    const handler = async ({ circle_id, type, tags, limit, offset }) => {
         if (!artifactManager.isDirectCircleMember(circle_id, agentId)) {
             return textToolResult(["You are not a direct member of this circle."], true);
         }
@@ -38,7 +38,7 @@ export function getListCircleArtifactsToolConfig(agentId, artifactManager, senso
                 const suffix = filterParts.length ? ` matching ${filterParts.join(" and ")}` : "";
                 return textToolResult([`No artifacts found for circle ${circle_id}${suffix}.`]);
             }
-            const pagination = applyPagination(artifacts, limit || DEFAULT_CIRCLE_ARTIFACTS_LIMIT, skip);
+            const pagination = applyPagination(artifacts, limit || DEFAULT_CIRCLE_ARTIFACTS_LIMIT, offset);
             const lines = pagination.items.map((artifact) => `- ${artifact.filename} (type: ${artifact.type}, modified: ${formatLocalDateTime(new Date(artifact.updatedTimestamp), userTimezone)})`);
             const header = formatPaginationHeader(`Artifacts for circle ${circle_id}`, pagination);
             return textToolResult(header.concat("", lines));

package/dist/mcp/claude-mcp-adapter.js

@@ -1,13 +1,41 @@
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 import { MCP_CONFIG_TYPE } from "../_shared/index.js";
-/** Wrap a server's registered tools into an in-process Claude SDK MCP server. */
+import { buildStrictToolSchema } from "./tool-utils.js";
+const hasRegisteredTools = (instance) => {
+    if (!("_registeredTools" in instance)) {
+        return false;
+    }
+    const registeredTools = instance._registeredTools;
+    return typeof registeredTools === "object" && registeredTools !== null;
+};
+/**
+ * Swap each registered tool's input schema for a strict variant so unknown parameters are rejected instead of
+ * silently dropped. The raw shape is passed to tool() first so the SDK caches per-field descriptions; the strict
+ * object reuses the same field instances, so those descriptions survive the swap (a strict object passed directly
+ * to tool() would lose them). Guarded so an SDK internals change degrades to the default lenient
+ * behavior rather than throwing.
+ */
+function applyStrictToolSchemas(instance, tools) {
+    if (!hasRegisteredTools(instance)) {
+        return;
+    }
+    for (const registeredTool of tools) {
+        const entry = instance._registeredTools[registeredTool.name];
+        if (entry) {
+            entry.inputSchema = buildStrictToolSchema(registeredTool.inputSchema);
+        }
+    }
+}
+/** Wrap a server's registered tools into an in-process Claude SDK MCP server with strict parameter validation. */
 export function toClaudeServer(name, tools) {
-    return createSdkMcpServer({
+    const server = createSdkMcpServer({
         name,
         tools: tools.map((registeredTool) => tool(registeredTool.name, registeredTool.description, registeredTool.inputSchema, registeredTool.handler, {
             annotations: registeredTool.annotations,
         })),
     });
+    applyStrictToolSchemas(server.instance, tools);
+    return server;
 }
 /** Map a Crow MCP transport to the Claude SDK's stdio/http/sse server config. */
 export function toClaudeTransport(transport) {

package/dist/mcp/copilot-mcp-adapter.js

@@ -1,16 +1,24 @@
 import { convertMcpCallToolResult } from "@github/copilot-sdk";
 import { z } from "zod";
 import { MCP_CONFIG_TYPE } from "../_shared/index.js";
+import { buildStrictToolSchema, getValidationErrorToolResult } from "./tool-utils.js";
 /** Flatten an internal server's tools into Copilot in-process tools, prefixed to keep `mcp__server__tool` names. */
 export function toCopilotTools(server) {
     return server.tools.map((registeredTool) => toCopilotTool(registeredTool, server));
 }
 function toCopilotTool(registeredTool, server) {
+    const inputSchema = buildStrictToolSchema(registeredTool.inputSchema);
     return {
         name: `${server.mcpToolPrefix}${registeredTool.name}`,
         description: registeredTool.description,
-        parameters: z.toJSONSchema(z.object(registeredTool.inputSchema)),
-        handler: async (args, invocation) => toCopilotToolResult(await registeredTool.handler(args, invocation)),
+        parameters: z.toJSONSchema(inputSchema),
+        handler: async (args, invocation) => {
+            const parsed = inputSchema.safeParse(args);
+            if (!parsed.success) {
+                return toCopilotToolResult(getValidationErrorToolResult(registeredTool.name, parsed.error));
+            }
+            return toCopilotToolResult(await registeredTool.handler(parsed.data, invocation));
+        },
         skipPermission: server.isAutoApproved,
     };
 }

package/dist/mcp/feed/get-feed-items.js

@@ -8,9 +8,9 @@ export function getFeedItemsToolConfig(agentId, registry, feedManager, sensorMan
     const inputSchema = {
         feedId: z.string().describe("The news/RSS feed ID from which to get items."),
         limit: z.number().optional().describe(`Number of items to return per page.`),
-        skip: z.number().optional().describe("Number of items to skip for pagination."),
+        offset: z.number().optional().describe("Number of items to skip before the page starts (0-based offset)."),
     };
-    const handler = async ({ feedId, limit, skip }) => {
+    const handler = async ({ feedId, limit, offset }) => {
         try {
             const visibleFeedIds = await resolveVisibleFeedIds(agentId, registry, systemSettingsManager);
             if (!visibleFeedIds.has(feedId)) {
@@ -22,7 +22,7 @@ export function getFeedItemsToolConfig(agentId, registry, feedManager, sensorMan
             }
             const timezone = await sensorManager.getUserTimezone();
             const allItems = await feedManager.getItemsFromFeed(feedId);
-            const pagination = applyPagination(allItems, limit || DEFAULT_FEED_ITEMS_LIMIT, skip);
+            const pagination = applyPagination(allItems, limit || DEFAULT_FEED_ITEMS_LIMIT, offset);
             const formattedItems = pagination.items.map((item) => formatFeedItemSummary(item, feed.title, timezone));
             const header = formatPaginationHeader(`Items from feed [${feed.title}]`, pagination, "Items show summary only — use get_feed_item_content with an item ID for full content");
             return textToolResult(header.concat("", formattedItems.flatMap((item) => [item, "---"])));

package/dist/mcp/feed/get-recent-feed-items.js

@@ -13,9 +13,9 @@ export function getRecentFeedItemsToolConfig(agentId, registry, feedManager, sen
             .optional()
             .describe(`Number of minutes to look back from now for recent items (default: ${DEFAULT_RECENCY_IN_MINUTES}).`),
         limit: z.number().optional().describe(`Number of items to return per page.`),
-        skip: z.number().optional().describe("Number of items to skip for pagination."),
+        offset: z.number().optional().describe("Number of items to skip before the page starts (0-based offset)."),
     };
-    const handler = async ({ recencyInMinutes, limit, skip }) => {
+    const handler = async ({ recencyInMinutes, limit, offset }) => {
         try {
             const timezone = await sensorManager.getUserTimezone();
             const visibleFeedIdSet = await resolveVisibleFeedIds(agentId, registry, systemSettingsManager);
@@ -27,7 +27,7 @@ export function getRecentFeedItemsToolConfig(agentId, registry, feedManager, sen
             if (!allItems.length) {
                 return textToolResult([`No items found in the last ${effectiveRecency} minutes. Try increase the minutes.`]);
             }
-            const pagination = applyPagination(allItems, limit || DEFAULT_FEED_ITEMS_LIMIT, skip);
+            const pagination = applyPagination(allItems, limit || DEFAULT_FEED_ITEMS_LIMIT, offset);
             const formattedItems = pagination.items.map((item) => formatFeedItemSummary(item, feedsMap.get(item.feedId), timezone));
             const header = formatPaginationHeader(`Recent items from all feeds (last ${effectiveRecency} minutes)`, pagination, "Items show summary only — use get_feed_item_content with an item ID for full content");
             return textToolResult(header.concat("", formattedItems.flatMap((item) => [item, "---"])));

package/dist/mcp/feed/list-feeds.js

@@ -7,14 +7,14 @@ export const LIST_FEEDS_TOOL_NAME = "list_feeds";
 export function getListFeedsToolConfig(agentId, registry, feedManager, sensorManager, systemSettingsManager) {
     const inputSchema = {
         limit: z.number().optional().describe(`Number of feeds to return per page.`),
-        skip: z.number().optional().describe("Number of feeds to skip for pagination."),
+        offset: z.number().optional().describe("Number of feeds to skip before the page starts (0-based offset)."),
     };
-    const handler = async ({ limit, skip }) => {
+    const handler = async ({ limit, offset }) => {
         try {
             const timezone = await sensorManager.getUserTimezone();
             const visibleFeedIdSet = await resolveVisibleFeedIds(agentId, registry, systemSettingsManager);
             const feeds = await feedManager.getFeeds(Array.from(visibleFeedIdSet));
-            const pagination = applyPagination(feeds, limit || DEFAULT_FEEDS_LIMIT, skip);
+            const pagination = applyPagination(feeds, limit || DEFAULT_FEEDS_LIMIT, offset);
             const formattedFeeds = pagination.items.map((feed) => formatFeed(feed, timezone));
             const header = formatPaginationHeader("Available feeds", pagination);
             return textToolResult(header.concat("", formattedFeeds));

package/dist/mcp/feed/search-feed-items.js

@@ -9,9 +9,9 @@ export function getSearchFeedItemsToolConfig(agentId, registry, feedManager, sen
         query: z.string().describe("Natural-language phrase or topic to match against feed items."),
         feedId: z.string().optional().describe("Optional feed ID to filter search results to a specific feed."),
         limit: z.number().optional().describe(`Number of items to return per page.`),
-        skip: z.number().optional().describe("Number of items to skip for pagination."),
+        offset: z.number().optional().describe("Number of items to skip before the page starts (0-based offset)."),
     };
-    const handler = async ({ query, feedId, limit, skip }) => {
+    const handler = async ({ query, feedId, limit, offset }) => {
         try {
             const timezone = await sensorManager.getUserTimezone();
             const visibleFeedIdSet = await resolveVisibleFeedIds(agentId, registry, systemSettingsManager);
@@ -25,7 +25,7 @@ export function getSearchFeedItemsToolConfig(agentId, registry, feedManager, sen
             if (!allItems.length) {
                 return textToolResult([`No items found matching "${query}".`]);
             }
-            const pagination = applyPagination(allItems, limit || DEFAULT_FEED_ITEMS_LIMIT, skip);
+            const pagination = applyPagination(allItems, limit || DEFAULT_FEED_ITEMS_LIMIT, offset);
             const formattedItems = pagination.items.map((item) => formatFeedItemSummary(item, feedsMap.get(item.feedId), timezone));
             const header = formatPaginationHeader(`Items matching "${query}"`, pagination, "Items show summary only — use get_feed_item_content with an item ID for full content");
             return textToolResult(header.concat("", formattedItems.flatMap((item) => [item, "---"])));

package/dist/mcp/places/geocode-place.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { PLACES_SOURCE } from "../../services/places/places-manager.types.js";
 import { getErrorToolResult, textToolResult } from "../tool-utils.js";
 import { formatPlaceSummary } from "./places-format-utils.js";
+import { resolveRoutingOrigin, routingDescriptionLine, routingOriginInputSchema } from "./places-routing-input.js";
 const DEFAULT_GEOCODE_LIMIT = 10;
 const MAX_GEOCODE_LIMIT = 25;
 export const GEOCODE_PLACE_TOOL_NAME = "geocode_place";
@@ -25,7 +26,9 @@ function selectForSource(map, source, fallback) {
 }
 export function getGeocodePlaceToolConfig(placesManager) {
     const defaultSource = placesManager.getDefaultSource();
-    const description = selectForSource(DESCRIPTION_BY_SOURCE, defaultSource, NEUTRAL_DESCRIPTION);
+    const baseDescription = selectForSource(DESCRIPTION_BY_SOURCE, defaultSource, NEUTRAL_DESCRIPTION);
+    const routingLine = routingDescriptionLine(defaultSource);
+    const description = routingLine ? `${baseDescription} ${routingLine}` : baseDescription;
     const resultGuidance = selectForSource(RESULT_GUIDANCE_BY_SOURCE, defaultSource, NEUTRAL_RESULT_GUIDANCE);
     const inputSchema = {
         query: z.string().min(1).describe("A place name, a full address, or a landmark (e.g. 'Eiffel Tower')."),
@@ -42,6 +45,7 @@ export function getGeocodePlaceToolConfig(placesManager) {
             .optional()
             .describe("Optional latitude for ranking bias - prefers candidates near this point."),
         nearLongitude: z.number().min(-180).max(180).optional().describe("Optional longitude paired with nearLatitude."),
+        ...routingOriginInputSchema,
         limit: z
             .number()
             .int()
@@ -54,6 +58,10 @@ export function getGeocodePlaceToolConfig(placesManager) {
         if ((args.nearLatitude === undefined) !== (args.nearLongitude === undefined)) {
             return textToolResult(["nearLatitude and nearLongitude must both be provided or both omitted."], true);
         }
+        const routing = resolveRoutingOrigin(args);
+        if ("error" in routing) {
+            return textToolResult([routing.error], true);
+        }
         const queryParts = [args.query, args.city, args.country]
             .map((part) => part?.trim())
             .filter((part) => part !== undefined && part.length > 0);
@@ -68,6 +76,7 @@ export function getGeocodePlaceToolConfig(placesManager) {
             const places = await placesManager.geocode({
                 text: queryText,
                 near,
+                routingOrigin: routing.routingOrigin,
                 limit: args.limit ?? DEFAULT_GEOCODE_LIMIT,
             });
             if (places.length === 0) {

package/dist/mcp/places/places-format-utils.js

@@ -25,8 +25,32 @@ export function formatPlaceSummary(place) {
     if (place.mapsUrl !== undefined && place.mapsUrl.length > 0) {
         lines.push(`    - Map: ${place.mapsUrl}`);
     }
+    if (place.routing !== undefined) {
+        const { durationSeconds, distanceMeters, travelMode, directionsUrl } = place.routing;
+        lines.push(`    - Travel: ${humanizeDuration(durationSeconds)} · ${humanizeDistance(distanceMeters)} (${travelMode})`);
+        if (directionsUrl !== undefined && directionsUrl.length > 0) {
+            lines.push(`    - Directions: ${directionsUrl}`);
+        }
+    }
     return lines.join("\n");
 }
+/** "8 min" under an hour, "1 h 12 min" (or "2 h" on the hour) above. */
+function humanizeDuration(totalSeconds) {
+    const totalMinutes = Math.round(totalSeconds / 60);
+    if (totalMinutes < 60) {
+        return `${totalMinutes} min`;
+    }
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    return minutes === 0 ? `${hours} h` : `${hours} h ${minutes} min`;
+}
+/** "850 m" under a kilometre, "3.2 km" (one decimal) above. */
+function humanizeDistance(meters) {
+    if (meters < 1000) {
+        return `${Math.round(meters)} m`;
+    }
+    return `${(meters / 1000).toFixed(1)} km`;
+}
 /** Full-detail block returned by `places_get_details`. Layers attributes on top of the summary. */
 export function formatPlaceDetails(details) {
     const lines = [formatPlaceSummary(details)];

package/dist/mcp/places/places-routing-input.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { PLACES_SOURCE, TRAVEL_MODE, } from "../../services/places/places-manager.types.js";
+const TRAVEL_MODE_VALUES = Object.values(TRAVEL_MODE);
+/** Optional routing-origin inputs shared by the place search and geocode tools. */
+export const routingOriginInputSchema = {
+    originLatitude: z
+        .number()
+        .min(-90)
+        .max(90)
+        .optional()
+        .describe("Latitude of the travel origin; pair with originLongitude to attach travel time and distance."),
+    originLongitude: z
+        .number()
+        .min(-180)
+        .max(180)
+        .optional()
+        .describe("Longitude of the travel origin; must be paired with originLatitude."),
+    travelMode: z
+        .enum(TRAVEL_MODE_VALUES)
+        .optional()
+        .describe("Travel mode for the origin (default DRIVE). Ignored unless an origin is provided."),
+};
+/**
+ * Validate the both-or-neither origin pair and build a `RoutingOrigin`. A
+ * `travelMode` without an origin is a no-op rather than an error.
+ */
+export function resolveRoutingOrigin(args) {
+    const { originLatitude, originLongitude, travelMode } = args;
+    if ((originLatitude === undefined) !== (originLongitude === undefined)) {
+        return { error: "originLatitude and originLongitude must both be provided or both omitted." };
+    }
+    if (originLatitude === undefined || originLongitude === undefined) {
+        return { routingOrigin: undefined };
+    }
+    const routingOrigin = { point: { latitude: originLatitude, longitude: originLongitude } };
+    if (travelMode) {
+        routingOrigin.travelMode = travelMode;
+    }
+    return { routingOrigin };
+}
+const ROUTING_DESCRIPTION_BY_SOURCE = {
+    [PLACES_SOURCE.GOOGLE]: "Provide originLatitude/originLongitude to attach travel time and distance to each result.",
+    [PLACES_SOURCE.OSM]: "Travel time and distance to results are not available on this source.",
+};
+/** One-line, source-aware note about routing support for a tool description. */
+export function routingDescriptionLine(source) {
+    return ROUTING_DESCRIPTION_BY_SOURCE[source];
+}
+//# sourceMappingURL=places-routing-input.js.map

package/dist/mcp/places/search-nearby-places.js

@@ -2,12 +2,17 @@ import { z } from "zod";
 import { PLACE_CATEGORY } from "../../services/places/places-manager.types.js";
 import { getErrorToolResult, textToolResult } from "../tool-utils.js";
 import { formatPlaceSummary } from "./places-format-utils.js";
+import { resolveRoutingOrigin, routingDescriptionLine, routingOriginInputSchema } from "./places-routing-input.js";
 const DEFAULT_SEARCH_NEARBY_LIMIT = 20;
 const MAX_SEARCH_NEARBY_LIMIT = 50;
 const MAX_SEARCH_NEARBY_RADIUS_METERS = 50_000;
 const CATEGORY_VALUES = Object.values(PLACE_CATEGORY);
 export const SEARCH_NEARBY_PLACES_TOOL_NAME = "search_nearby_places";
+const BASE_DESCRIPTION = "Find places of a given category within a radius around a point. Use get_place_details with a returned id " +
+    "for opening hours, contact info, and other attributes.";
 export function getSearchNearbyPlacesToolConfig(placesManager) {
+    const routingLine = routingDescriptionLine(placesManager.getDefaultSource());
+    const description = routingLine ? `${BASE_DESCRIPTION} ${routingLine}` : BASE_DESCRIPTION;
     const inputSchema = {
         latitude: z.number().min(-90).max(90).describe("Latitude of the search center."),
         longitude: z.number().min(-180).max(180).describe("Longitude of the search center."),
@@ -20,6 +25,7 @@ export function getSearchNearbyPlacesToolConfig(placesManager) {
         category: z
             .enum(CATEGORY_VALUES)
             .describe("Curated place category to filter by. Use OTHER only as a last resort - prefer a more specific value."),
+        ...routingOriginInputSchema,
         limit: z
             .number()
             .int()
@@ -29,6 +35,10 @@ export function getSearchNearbyPlacesToolConfig(placesManager) {
             .describe(`Max results to return (default ${DEFAULT_SEARCH_NEARBY_LIMIT}, max ${MAX_SEARCH_NEARBY_LIMIT}).`),
     };
     const handler = async (args) => {
+        const routing = resolveRoutingOrigin(args);
+        if ("error" in routing) {
+            return textToolResult([routing.error], true);
+        }
         try {
             const places = await placesManager.searchPlaces({
                 area: {
@@ -37,6 +47,7 @@ export function getSearchNearbyPlacesToolConfig(placesManager) {
                     radiusMeters: args.radiusMeters,
                 },
                 category: args.category,
+                routingOrigin: routing.routingOrigin,
                 limit: args.limit ?? DEFAULT_SEARCH_NEARBY_LIMIT,
             });
             const areaLabel = `within ${args.radiusMeters}m of ${args.latitude.toFixed(6)}, ${args.longitude.toFixed(6)}`;
@@ -53,7 +64,7 @@ export function getSearchNearbyPlacesToolConfig(placesManager) {
     };
     const config = {
         name: SEARCH_NEARBY_PLACES_TOOL_NAME,
-        description: "Find places of a given category within a radius around a point. Use get_place_details with a returned id for opening hours, contact info, and other attributes.",
+        description,
         inputSchema,
         handler,
     };

package/dist/mcp/reminders/list-reminders.js

@@ -6,16 +6,16 @@ export const LIST_REMINDERS_TOOL_NAME = "list_reminders";
 export function getListRemindersToolConfig(agentId, scheduler, sensorManager) {
     const inputSchema = {
         limit: z.number().optional().describe("Number of reminders to return per page."),
-        skip: z.number().optional().describe("Number of reminders to skip for pagination."),
+        offset: z.number().optional().describe("Number of reminders to skip before the page starts (0-based offset)."),
     };
-    const handler = async ({ limit, skip }) => {
+    const handler = async ({ limit, offset }) => {
         try {
             const userTimezone = await sensorManager.getUserTimezone();
             const reminders = scheduler.listAgentReminders(agentId);
             if (reminders.length === 0) {
                 return textToolResult(["You have no upcoming reminders."]);
             }
-            const pagination = applyPagination(reminders, limit || DEFAULT_REMINDERS_LIMIT, skip);
+            const pagination = applyPagination(reminders, limit || DEFAULT_REMINDERS_LIMIT, offset);
             const formatted = pagination.items.map((reminder) => formatReminder(reminder, userTimezone)).join("\n---\n");
             const header = formatPaginationHeader("Your reminders", pagination);
             return textToolResult(header.concat("", formatted));

package/dist/mcp/tool-utils.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 /**
  * Creates a tool result object with text content.
  *
@@ -29,32 +30,48 @@ export const getErrorToolResult = (error, fallbackMessage) => {
     const errorMessage = exceptionError ? exceptionError : fallbackMessage;
     return textToolResult([errorMessage], true);
 };
-export const applyPagination = (allItems, limit, skip) => {
-    const effectiveSkip = skip || 0;
-    const items = allItems.slice(effectiveSkip, effectiveSkip + limit);
+/**
+ * Build an object schema from a tool input shape. Schemas with parameters are strict so unknown parameters are
+ * rejected rather than silently dropped; no-arg tools stay lenient since there is no parameter to confuse.
+ */
+export const buildStrictToolSchema = (inputSchema) => {
+    const schema = z.object(inputSchema);
+    return Object.keys(inputSchema).length > 0 ? schema.strict() : schema;
+};
+/** Format a Zod validation failure as an agent-facing error result that names the offending parameters. */
+export const getValidationErrorToolResult = (toolName, error) => {
+    const issues = error.issues.map((issue) => {
+        const path = issue.path.join(".");
+        return path ? `${path}: ${issue.message}` : issue.message;
+    });
+    return textToolResult([`Invalid arguments for ${toolName}:`, ...issues], true);
+};
+export const applyPagination = (allItems, limit, offset) => {
+    const effectiveOffset = offset || 0;
+    const items = allItems.slice(effectiveOffset, effectiveOffset + limit);
     return {
         items,
         totalCount: allItems.length,
-        effectiveSkip,
-        hasMore: effectiveSkip + items.length < allItems.length,
+        effectiveOffset,
+        hasMore: effectiveOffset + items.length < allItems.length,
     };
 };
 export const formatPaginationHeader = (description, pagination, note) => {
-    const { items, totalCount, effectiveSkip, hasMore } = pagination;
-    const isPaginated = effectiveSkip > 0 || hasMore;
+    const { items, totalCount, effectiveOffset, hasMore } = pagination;
+    const isPaginated = effectiveOffset > 0 || hasMore;
     const metaParts = [`Total: ${totalCount}`];
     if (isPaginated) {
         metaParts.push(`Showing: ${items.length}`);
     }
-    if (effectiveSkip > 0) {
-        metaParts.push(`Skipped: ${effectiveSkip}`);
+    if (effectiveOffset > 0) {
+        metaParts.push(`Offset: ${effectiveOffset}`);
     }
     const lines = [`--- ${description.toUpperCase()} ---`, `[${metaParts.join(" | ")}]`];
     if (note) {
         lines.push(`[${note}]`);
     }
     if (hasMore) {
-        lines.push(`[More available: use skip=${effectiveSkip + items.length} for next page]`);
+        lines.push(`[More available: use offset=${effectiveOffset + items.length} for next page]`);
     }
     return lines;
 };