@modelprofile.com/flexharness 10.20.0 → 10.22.0

package/dist_ts_mcp/index.d.ts

@@ -18,19 +18,27 @@ export interface IMcpServerClientOptions {
     clientOptions?: plugins.ClientOptions;
     requestOptions?: plugins.RequestOptions;
 }
-export interface IMcpStdioServerConfig extends plugins.StdioServerParameters, IMcpServerClientOptions {
+export interface IMcpServerTrustOptions {
+    /**
+     * Trusts the server's `readOnlyHint` annotations: `isReadOnlyToolCall` classifies a call of a tool
+     * the server annotates `readOnlyHint: true` as read-only. An annotation is the server's own claim,
+     * so no server's is trusted unless its configuration says so. Default: false.
+     */
+    trustReadOnlyHints?: boolean;
+}
+export interface IMcpStdioServerConfig extends plugins.StdioServerParameters, IMcpServerClientOptions, IMcpServerTrustOptions {
     type: 'stdio';
 }
-export interface IMcpStreamableHttpServerConfig extends IMcpServerClientOptions {
+export interface IMcpStreamableHttpServerConfig extends IMcpServerClientOptions, IMcpServerTrustOptions {
     type: 'streamableHttp' | 'http';
     url: string | URL;
     transportOptions?: plugins.StreamableHTTPClientTransportOptions;
 }
-export interface IMcpTransportServerConfig extends IMcpServerClientOptions {
+export interface IMcpTransportServerConfig extends IMcpServerClientOptions, IMcpServerTrustOptions {
     type: 'transport';
     transport: plugins.Transport;
 }
-export interface IMcpClientServerConfig {
+export interface IMcpClientServerConfig extends IMcpServerTrustOptions {
     type: 'client';
     client: IMcpClientLike;
 }
@@ -65,6 +73,8 @@ export interface IMcpConnectedServer {
     name: string;
     client: IMcpClientLike;
     tools: TMcpToolMetadata[];
+    /** Whether its configuration trusts the server's `readOnlyHint` annotations. */
+    trustReadOnlyHints: boolean;
 }
 export interface IMcpToolNameMapping {
     serverName: string;
@@ -74,8 +84,69 @@ export interface ICreateMcpToolsResult {
     tools: plugins.ToolSet;
     servers: IMcpConnectedServer[];
     toolNameMap: Record<string, IMcpToolNameMapping>;
+    /**
+     * Whether a call of `tools` only reads: its server's configuration trusts `readOnlyHint`, and the
+     * server annotates the tool `readOnlyHint: true`. Every other call is not read-only. Pass it as the
+     * tool handle's `isReadOnlyToolCall`, or ask it from that classifier.
+     */
+    isReadOnlyToolCall: (call: {
+        toolName: string;
+    }) => boolean;
     close: () => Promise<void>;
 }
 export declare const createMcpTools: (options: ICreateMcpToolsOptions) => Promise<ICreateMcpToolsResult>;
+/** The tools one MCP server lists, as `listTools` answered them. `IMcpConnectedServer` is one. */
+export interface IMcpToolCatalogServer {
+    name: string;
+    tools: readonly TMcpToolMetadata[];
+}
+export interface IMcpToolCatalogToolContext extends IMcpToolFormatContext {
+    tool: TMcpToolMetadata;
+}
+/** A catalog call of an MCP tool: the run's `call` context names the scope, session, run and `requestPermission`. */
+export interface IMcpToolCatalogCallContext<TScope = unknown> extends IMcpToolFormatContext {
+    call: plugins.IFlexCatalogRunContext<TScope>;
+}
+export interface IMcpToolCatalogAuthorizeToolCallContext<TScope = unknown> extends IMcpAuthorizeToolCallContext {
+    abortSignal: AbortSignal;
+    call: plugins.IFlexCatalogRunContext<TScope>;
+}
+export interface ICreateMcpToolCatalogOptions<TScope = unknown> {
+    /** The servers and the tools they list, in the order `createMcpTools` was given them. */
+    servers: readonly IMcpToolCatalogServer[];
+    /**
+     * The client that runs a call: the one connected for the call's run, which `call.provider.runId`
+     * names. The catalog stays the same object across runs; only the clients change.
+     */
+    resolveClient(context: IMcpToolCatalogCallContext<TScope>): IMcpClientLike | PromiseLike<IMcpClientLike>;
+    /** As for `createMcpTools`: `<server>__<tool>`, by default when there is more than one server. */
+    prefixToolNames?: boolean;
+    requestOptions?: plugins.RequestOptions;
+    callToolRequestOptions?: plugins.RequestOptions;
+    formatResult?: (result: TMcpCallToolResult, context: IMcpToolFormatContext) => unknown;
+    /**
+     * Resolve to allow the call, or throw to deny it, before the client is resolved. It sees `execute`
+     * and `run_code` calls as `createMcpTools`' hook sees tool calls. Omission allows all calls.
+     */
+    authorizeToolCall?: (context: IMcpToolCatalogAuthorizeToolCallContext<TScope>) => PromiseLike<void> | void;
+    /**
+     * Declares a tool's method read-only: its calls run concurrently with other reads and a turn
+     * answers identical ones once. A tool whose calls ask for permission must not be. Omission
+     * declares none; a server's `readOnlyHint` annotation is not trusted for it.
+     */
+    isReadOnly?: (context: IMcpToolCatalogToolContext) => boolean;
+}
+export interface ICreateMcpToolCatalogResult<TScope = unknown> {
+    catalog: plugins.IFlexToolCatalog<TScope>;
+    /** The server and tool of each method path. */
+    toolNameMap: Record<string, IMcpToolNameMapping>;
+}
+/**
+ * The MCP tools of `servers` as a tool catalog, which the model searches, describes and calls through
+ * `execute` and `run_code`. A method's path is the name `createMcpTools` gives the tool; a name that
+ * is no identifier (with `-`, or a reserved word) is declared as `FlexToolCatalog.identifierOf()`
+ * makes it. Create one catalog per set of tool definitions and return the same object on every run.
+ */
+export declare const createMcpToolCatalog: <TScope = unknown>(options: ICreateMcpToolCatalogOptions<TScope>) => ICreateMcpToolCatalogResult<TScope>;
 export declare const sanitizeMcpToolName: (name: string, fallback?: string) => string;
 export declare const formatMcpToolResult: (result: TMcpCallToolResult) => unknown;

package/dist_ts_mcp/index.js

@@ -11,63 +11,49 @@ export const createMcpTools = async (options) => {
     try {
         for (const [serverName, config] of serverEntries) {
             const client = await connectMcpServer(serverName, config, options);
-            const connectedServer = { name: serverName, client, tools: [] };
+            const connectedServer = {
+                name: serverName,
+                client,
+                tools: [],
+                trustReadOnlyHints: config.trustReadOnlyHints === true,
+            };
             connectedServers.push(connectedServer);
             connectedServer.tools = await listAllMcpTools(client, options.listToolsRequestOptions ?? getServerRequestOptions(config) ?? options.requestOptions, maxListToolsPages);
         }
         const exposedTools = {};
         const toolNameMap = {};
-        const usedToolNames = new Set(['invalid']);
-        const formatResult = options.formatResult ?? formatMcpToolResult;
+        const readOnlyToolNames = new Set();
         const shouldPrefixToolNames = options.prefixToolNames ?? connectedServers.length > 1;
-        for (const server of connectedServers) {
-            for (const mcpTool of server.tools) {
-                const baseToolName = createExposedToolName(server.name, mcpTool.name, shouldPrefixToolNames);
-                const exposedToolName = createUniqueToolName(baseToolName, usedToolNames);
-                usedToolNames.add(exposedToolName);
-                toolNameMap[exposedToolName] = {
+        for (const { server, tool: mcpTool, exposedToolName } of nameMcpTools(connectedServers, shouldPrefixToolNames)) {
+            toolNameMap[exposedToolName] = {
+                serverName: server.name,
+                toolName: mcpTool.name,
+            };
+            if (server.trustReadOnlyHints && mcpTool.annotations?.readOnlyHint === true) {
+                readOnlyToolNames.add(exposedToolName);
+            }
+            exposedTools[exposedToolName] = plugins.tool({
+                description: mcpTool.description ?? `MCP tool ${mcpTool.name} from ${server.name}`,
+                inputSchema: plugins.jsonSchema(mcpTool.inputSchema),
+                execute: async (input, invocationOptions) => callMcpTool({
                     serverName: server.name,
                     toolName: mcpTool.name,
-                };
-                exposedTools[exposedToolName] = plugins.tool({
-                    description: mcpTool.description ?? `MCP tool ${mcpTool.name} from ${server.name}`,
-                    inputSchema: plugins.jsonSchema(mcpTool.inputSchema),
-                    execute: async (input, invocationOptions) => {
-                        const normalizedArguments = normalizeMcpArguments(input);
-                        await options.authorizeToolCall?.({
-                            serverName: server.name,
-                            toolName: mcpTool.name,
-                            exposedToolName,
-                            arguments: normalizedArguments,
-                            tool: mcpTool,
-                            toolCallId: invocationOptions?.toolCallId ?? '',
-                            abortSignal: invocationOptions?.abortSignal,
-                        });
-                        const configuredCallToolOptions = {
-                            ...options.requestOptions,
-                            ...options.callToolRequestOptions,
-                        };
-                        const result = await withMcpRequestOptions(configuredCallToolOptions, invocationOptions?.abortSignal, (requestOptions) => server.client.callTool({
-                            name: mcpTool.name,
-                            arguments: normalizedArguments,
-                        }, undefined, requestOptions));
-                        const formattedResult = formatResult(result, {
-                            serverName: server.name,
-                            toolName: mcpTool.name,
-                            exposedToolName,
-                        });
-                        if (result.isError === true) {
-                            throw new Error(formatMcpError(formattedResult));
-                        }
-                        return formattedResult;
-                    },
-                });
-            }
+                    tool: mcpTool,
+                    exposedToolName,
+                    arguments: normalizeMcpArguments(input),
+                    toolCallId: invocationOptions?.toolCallId ?? '',
+                    abortSignal: invocationOptions?.abortSignal,
+                    authorize: (context) => options.authorizeToolCall?.(context),
+                    client: () => server.client,
+                    options,
+                }),
+            });
         }
         return {
             tools: exposedTools,
             servers: connectedServers,
             toolNameMap,
+            isReadOnlyToolCall: ({ toolName }) => readOnlyToolNames.has(toolName),
             close: async () => closeMcpClients(connectedServers),
         };
     }
@@ -75,6 +61,59 @@ export const createMcpTools = async (options) => {
         return rethrowAfterCleanup(error, () => closeMcpClients(connectedServers), 'Failed to create MCP tools and clean up connected clients.');
     }
 };
+/**
+ * The MCP tools of `servers` as a tool catalog, which the model searches, describes and calls through
+ * `execute` and `run_code`. A method's path is the name `createMcpTools` gives the tool; a name that
+ * is no identifier (with `-`, or a reserved word) is declared as `FlexToolCatalog.identifierOf()`
+ * makes it. Create one catalog per set of tool definitions and return the same object on every run.
+ */
+export const createMcpToolCatalog = (options) => {
+    if (typeof options?.resolveClient !== 'function') {
+        throw new Error('createMcpToolCatalog requires resolveClient().');
+    }
+    const shouldPrefixToolNames = options.prefixToolNames ?? options.servers.length > 1;
+    const named = nameMcpTools(options.servers, shouldPrefixToolNames);
+    // A name that is an identifier is its path; a mapped one gets a path no such name has.
+    const usedPaths = new Set(named.map(({ exposedToolName }) => exposedToolName)
+        .filter((exposedToolName) => catalogPathOf(exposedToolName) === exposedToolName));
+    const toolNameMap = {};
+    const methods = [];
+    for (const { server, tool: mcpTool, exposedToolName } of named) {
+        const identifier = catalogPathOf(exposedToolName);
+        const path = identifier === exposedToolName ? identifier : createUniqueToolName(identifier, usedPaths);
+        usedPaths.add(path);
+        toolNameMap[path] = { serverName: server.name, toolName: mcpTool.name };
+        const toolContext = {
+            serverName: server.name,
+            toolName: mcpTool.name,
+            exposedToolName: path,
+            tool: mcpTool,
+        };
+        const text = mcpTool.description?.trim() || `MCP tool ${mcpTool.name} from ${server.name}`;
+        const summary = summaryOf(text);
+        const description = text === summary ? undefined : truncateUtf8(text, plugins.FLEX_TOOL_CATALOG_LIMITS.maxDescriptionBytes);
+        methods.push({
+            method: path,
+            summary,
+            ...(description ? { description } : {}),
+            inputSchema: mcpTool.inputSchema,
+            ...(options.isReadOnly?.(toolContext) ? { readOnly: true } : {}),
+            run: (params, call) => callMcpTool({
+                serverName: server.name,
+                toolName: mcpTool.name,
+                tool: mcpTool,
+                exposedToolName: path,
+                arguments: normalizeMcpArguments(params),
+                toolCallId: call.toolCallId,
+                abortSignal: call.abortSignal,
+                authorize: (context) => options.authorizeToolCall?.({ ...context, abortSignal: call.abortSignal, call }),
+                client: () => options.resolveClient({ serverName: server.name, toolName: mcpTool.name, exposedToolName: path, call }),
+                options,
+            }),
+        });
+    }
+    return { catalog: { methods }, toolNameMap };
+};
 export const sanitizeMcpToolName = (name, fallback = 'mcp_tool') => {
     const sanitized = name
         .trim()
@@ -138,7 +177,7 @@ const connectMcpServer = async (serverName, config, options) => {
 };
 const createMcpTransport = (config) => {
     if (config.type === 'stdio') {
-        const { type, clientName, clientVersion, clientOptions, requestOptions, ...serverParameters } = config;
+        const { type, clientName, clientVersion, clientOptions, requestOptions, trustReadOnlyHints, ...serverParameters } = config;
         return new plugins.StdioClientTransport(serverParameters);
     }
     if (config.type === 'streamableHttp' || config.type === 'http') {
@@ -177,6 +216,73 @@ const normalizeMaxListToolsPages = (maxPages = DEFAULT_MAX_LIST_TOOLS_PAGES) =>
     }
     return maxPages;
 };
+/** Every tool of `servers` with the name it is exposed under, unique across them, in order. */
+const nameMcpTools = (servers, prefixToolNames) => {
+    const usedToolNames = new Set(['invalid']);
+    const named = [];
+    for (const server of servers) {
+        for (const mcpTool of server.tools) {
+            const exposedToolName = createUniqueToolName(createExposedToolName(server.name, mcpTool.name, prefixToolNames), usedToolNames);
+            usedToolNames.add(exposedToolName);
+            named.push({ server, tool: mcpTool, exposedToolName });
+        }
+    }
+    return named;
+};
+/** Authorizes a call, runs it on the client and formats its result; an MCP error result throws. */
+const callMcpTool = async (call) => {
+    await call.authorize({
+        serverName: call.serverName,
+        toolName: call.toolName,
+        exposedToolName: call.exposedToolName,
+        arguments: call.arguments,
+        tool: call.tool,
+        toolCallId: call.toolCallId,
+        abortSignal: call.abortSignal,
+    });
+    const client = await call.client();
+    const configuredCallToolOptions = {
+        ...call.options.requestOptions,
+        ...call.options.callToolRequestOptions,
+    };
+    const result = await withMcpRequestOptions(configuredCallToolOptions, call.abortSignal, (requestOptions) => client.callTool({
+        name: call.toolName,
+        arguments: call.arguments,
+    }, undefined, requestOptions));
+    const formattedResult = (call.options.formatResult ?? formatMcpToolResult)(result, {
+        serverName: call.serverName,
+        toolName: call.toolName,
+        exposedToolName: call.exposedToolName,
+    });
+    if (result.isError === true) {
+        throw new Error(formatMcpError(formattedResult));
+    }
+    return formattedResult;
+};
+/** A catalog method path: the exposed name where it is an identifier, else the identifier made of it. */
+const catalogPathOf = (exposedToolName) => plugins.FlexToolCatalog.identifierOf(exposedToolName);
+/** The first line of a description, as one line of at most the catalog's summary length. */
+const summaryOf = (text) => {
+    const line = text.split(/\r?\n/).find((candidate) => candidate.trim()).replace(/[\s\u0000-\u001f\u007f]+/g, ' ').trim();
+    const characters = [...line];
+    const max = plugins.FLEX_TOOL_CATALOG_LIMITS.maxSummaryCharacters;
+    return characters.length <= max ? line : `${characters.slice(0, max - 1).join('').trimEnd()}…`;
+};
+/** The text cut to at most `maxBytes` UTF-8 bytes on a character boundary, marked with `…` when cut. */
+const truncateUtf8 = (text, maxBytes) => {
+    const encoder = new TextEncoder();
+    if (encoder.encode(text).length <= maxBytes)
+        return text;
+    let bytes = encoder.encode('…').length;
+    let kept = '';
+    for (const character of text) {
+        bytes += encoder.encode(character).length;
+        if (bytes > maxBytes)
+            break;
+        kept += character;
+    }
+    return `${kept}…`;
+};
 const createExposedToolName = (serverName, toolName, prefixToolName) => {
     const safeToolName = sanitizeMcpToolName(toolName);
     if (!prefixToolName) {
@@ -278,4 +384,4 @@ const rethrowAfterCleanup = async (originalError, cleanup, message) => {
     }
     throw originalError;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts_mcp/index.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts_mcp/index.ts"],"names":[],"mappings":"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"}

package/dist_ts_mcp/plugins.d.ts

@@ -7,6 +7,9 @@ export type { StdioServerParameters } from '@modelcontextprotocol/sdk/client/std
 export type { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 export type { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
 export type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { FLEX_TOOL_CATALOG_LIMITS, FlexToolCatalog } from '@modelprofile.com/flexharness';
+export { FLEX_TOOL_CATALOG_LIMITS, FlexToolCatalog };
+export type { IFlexCatalogMethod, IFlexCatalogRunContext, IFlexToolCatalog } from '@modelprofile.com/flexharness';
 import { jsonSchema, tool } from 'ai';
 export { jsonSchema, tool };
 export type { ToolExecutionOptions, ToolSet } from 'ai';

package/dist_ts_mcp/plugins.js

@@ -3,7 +3,10 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 export { Client, StdioClientTransport, StreamableHTTPClientTransport };
+// @modelprofile.com scope
+import { FLEX_TOOL_CATALOG_LIMITS, FlexToolCatalog } from '@modelprofile.com/flexharness';
+export { FLEX_TOOL_CATALOG_LIMITS, FlexToolCatalog };
 // ai-sdk core
 import { jsonSchema, tool } from 'ai';
 export { jsonSchema, tool };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX21jcC9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDbkUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDakYsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sb0RBQW9ELENBQUM7QUFFbkcsT0FBTyxFQUFFLE1BQU0sRUFBRSxvQkFBb0IsRUFBRSw2QkFBNkIsRUFBRSxDQUFDO0FBT3ZFLGNBQWM7QUFDZCxPQUFPLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxNQUFNLElBQUksQ0FBQztBQUV0QyxPQUFPLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX21jcC9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDbkUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDakYsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sb0RBQW9ELENBQUM7QUFFbkcsT0FBTyxFQUFFLE1BQU0sRUFBRSxvQkFBb0IsRUFBRSw2QkFBNkIsRUFBRSxDQUFDO0FBT3ZFLDBCQUEwQjtBQUMxQixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsZUFBZSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFFMUYsT0FBTyxFQUFFLHdCQUF3QixFQUFFLGVBQWUsRUFBRSxDQUFDO0FBR3JELGNBQWM7QUFDZCxPQUFPLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxNQUFNLElBQUksQ0FBQztBQUV0QyxPQUFPLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxDQUFDIn0=

package/dist_ts_tools/index.d.ts

@@ -2,7 +2,7 @@ export { createBrowserTools } from './tool.browser.js';
 export { acquireToolExecutionContext, ToolExecutionAdapterCleanupError, } from './plugins.js';
 export type { IToolExecutionAdapter, IToolExecutionAdapterRequest, IToolExecutionContextLease, } from './plugins.js';
 export type { ICreateBrowserToolsOptions } from './tool.browser.js';
-export { createFilesystemTools } from './tool.filesystem.js';
+export { createFilesystemTools, isReadOnlyFilesystemToolCall } from './tool.filesystem.js';
 export type { ICreateFilesystemToolsOptions } from './tool.filesystem.js';
 export { createShellTools } from './tool.shell.js';
 export type { ICreateShellToolsOptions } from './tool.shell.js';

package/dist_ts_tools/index.js

@@ -1,10 +1,10 @@
 export { createBrowserTools } from './tool.browser.js';
 export { acquireToolExecutionContext, ToolExecutionAdapterCleanupError, } from './plugins.js';
-export { createFilesystemTools } from './tool.filesystem.js';
+export { createFilesystemTools, isReadOnlyFilesystemToolCall } from './tool.filesystem.js';
 export { createShellTools } from './tool.shell.js';
 export { formatShellResult, formatToolOutput } from './tool.context.js';
 export { InMemoryToolJobStore, ToolJobStoreConflictError } from './plugins.js';
 export { httpTool } from './tool.http.js';
 export { jsonTool } from './tool.json.js';
 export { truncateOutput } from './plugins.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190b29scy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN2RCxPQUFPLEVBQ0wsMkJBQTJCLEVBQzNCLGdDQUFnQyxHQUNqQyxNQUFNLGNBQWMsQ0FBQztBQU90QixPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUU3RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUduRCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQTJCeEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLHlCQUF5QixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRS9FLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUMxQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDMUMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190b29scy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN2RCxPQUFPLEVBQ0wsMkJBQTJCLEVBQzNCLGdDQUFnQyxHQUNqQyxNQUFNLGNBQWMsQ0FBQztBQU90QixPQUFPLEVBQUUscUJBQXFCLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUUzRixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUduRCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQTJCeEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLHlCQUF5QixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRS9FLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUMxQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDMUMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQyJ9

package/dist_ts_tools/tool.filesystem.d.ts

@@ -10,4 +10,12 @@ export interface ICreateFilesystemToolsOptions {
     /** Maximum output bytes before truncating. */
     maxBytes?: number;
 }
+/**
+ * Whether a call of `createFilesystemTools()`' tools only reads: `read_file` and `list_directory`
+ * change nothing and ask for no permission. Pass it as the tool handle's `isReadOnlyToolCall`, or ask
+ * it from that classifier, when the context's `fs.readFile` and `fs.listDirectory` do neither either.
+ */
+export declare function isReadOnlyFilesystemToolCall(call: {
+    toolName: string;
+}): boolean;
 export declare function createFilesystemTools(context: IToolExecutionContext, options?: ICreateFilesystemToolsOptions): plugins.ToolSet;

package/dist_ts_tools/tool.filesystem.js

@@ -1,5 +1,15 @@
 import * as plugins from './plugins.js';
 import { formatToolOutput, } from './tool.context.js';
+/** The tools of `createFilesystemTools()` that only read. */
+const readOnlyFilesystemToolNames = new Set(['read_file', 'list_directory']);
+/**
+ * Whether a call of `createFilesystemTools()`' tools only reads: `read_file` and `list_directory`
+ * change nothing and ask for no permission. Pass it as the tool handle's `isReadOnlyToolCall`, or ask
+ * it from that classifier, when the context's `fs.readFile` and `fs.listDirectory` do neither either.
+ */
+export function isReadOnlyFilesystemToolCall(call) {
+    return readOnlyFilesystemToolNames.has(call.toolName);
+}
 export function createFilesystemTools(context, options = {}) {
     const truncate = (output) => plugins.truncateOutput(formatToolOutput(output), {
         maxLines: options.maxLines,
@@ -144,4 +154,4 @@ export function createFilesystemTools(context, options = {}) {
     }
     return tools;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tool.filesystem.js","sourceRoot":"","sources":["../ts_tools/tool.filesystem.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness",
-  "version": "10.20.0",
+  "version": "10.22.0",
   "type": "module",
   "description": "Managed agent sessions with tools, MCP, chat, OCR, documents and browser control through focused subpath imports.",
   "main": "./dist_ts/index.js",
@@ -87,8 +87,8 @@
   },
   "dependencies": {
     "@cfworker/json-schema": "^4.1.1",
-    "@modelprofile.com/flexharness-agent": "10.20.0",
-    "@modelprofile.com/flexharness-models": "10.20.0",
+    "@modelprofile.com/flexharness-agent": "10.22.0",
+    "@modelprofile.com/flexharness-models": "10.22.0",
     "@push.rocks/smartrequest": "^5.5.1",
     "ai": "^7.0.111",
     "zod": "^4.6.5"

package/readme.md

@@ -65,7 +65,7 @@ or provider SDKs.
 | `/chat/harness` | `FlexHarnessTranscript` and intents for the `@design.estate/dees-catalog` harness components, browser-safe | `@design.estate/dees-catalog` `^17.0.0 \|\| ^19.5.0 \|\| ^20.0.0 \|\| ^21.0.0` (types only) |
 | `/kvm` | Browser control, terminal framing and OCR observation | `puppeteer` |
 | `/documents` | PDF and image documents, `extractTextFromPdf` | `@push.rocks/smartpdf`; for image documents `sharp` |
-| `/mcp` | MCP clients and AI SDK tool conversion | `@modelcontextprotocol/sdk` |
+| `/mcp` | MCP clients, AI SDK tool conversion and `createMcpToolCatalog`, the tool catalog of MCP tools | `@modelcontextprotocol/sdk` |
 | `/migration` | Existing versioned harness migrations | None |
 | `/stores/nosqldb` | `NoSqlFlexHarnessStores`: cross-process CAS stores on `@lossless.org/client/nosqldb` | `@lossless.org/client` |
 
@@ -108,6 +108,9 @@ A warm read joins outstanding projection writes and surfaces accounting failures
 | `inFlight` | A generation or actual compactor invocation has not settled its accounting yet. |
 | `lastObservedInputTokens`, `lastObservedInputTokensAt` | Input count and observation time of the last settled generation call with complete input/output totals. |
 | `lastObservedInputTokensFreshness` | Always `historical`. This is **not** current context size: output, steering, compaction and reversion can change context. |
+| `reportedLifetimeInputTokens` | Sum of the settled per-call reports' input tokens, prompt-cache reads included. |
+| `reportedLifetimeCacheReadTokens`, `reportedLifetimeCacheWriteTokens` | Sums of the settled per-call reports' input tokens read from and written to the prompt cache. |
+| `lifetimeTokenBreakdownComplete` | The three sums cover every call `lifetimeUsedTokens` covers: lifetime usage is complete and the session's calls were counted by input and cache since it began. Otherwise they are lower bounds. |
 
 Accounting covers this session's generation calls and reported compaction calls,
 including failure, cancellation and retries. Child sessions own their own spend;
@@ -122,6 +125,10 @@ conservative: unresolved operations are cleared without certifying their unknown
 spend. Undo, redo, compaction and transcript archiving never subtract lifetime
 spend. Importing visible history does not reconstruct historical billing.
 
+Sessions whose metrics were written before input and cache tokens were counted count
+them from their next settled call on and never report the breakdown complete; their
+lifetime total keeps its completeness.
+
 Conversational runs that exhaust `maxSteps` with tool work or unseen input remaining
 fail with `FlexHarnessStepLimitError` (`FLEX_STEP_LIMIT`), rather than being marked
 completed with an empty answer. Standalone Agent callers retain tool-only results
@@ -1137,7 +1144,7 @@ Each domain serializes its own mutations. A successful run first persists a hidd
 
 Projection stores accept schema version 1, 2, or 3 from `load()`, but every `save()` receives the current schema-3 shape. Schema 3 records explicit reversion protocol, transcript/workspace provenance, and V2 disposition. A terminal V2 segment must be conclusively `revertible`, `no-change`, or `nonrevertible`; a pending V2 capture remains owned by its capture WAL and is never treated as transcript history.
 
-Current schema-3 projections also persist optional `metrics` state. Older strict readers that do not recognize this key cannot reopen a projection after metrics have been written; downgrade or mixed-version access to that session is unsupported.
+Current schema-3 projections also persist optional `metrics` state. Older strict readers that do not recognize this key, or the token breakdown keys inside it (`reportedLifetimeInputTokens`, `reportedLifetimeCacheReadTokens`, `reportedLifetimeCacheWriteTokens`, `lifetimeTokenBreakdownComplete`), cannot reopen a projection after they have been written; downgrade or mixed-version access to that session is unsupported.
 
 A loaded schema-1 projection has no reversion state. Schema-2 `workspaceCaptured` segments migrate as protocol-1 workspace/revertible history without discarding references; transcript-only segments migrate as protocol-1 transcript provenance. Under `workspace-required`, that legacy transcript history is a barrier. The next projection mutation writes schema 3. Custom stores must preserve strict compare-and-swap revisions across schema-1 and schema-2 read-upgrade-write cycles, including uncertain-save reconciliation.
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '10.20.0',
+  version: '10.22.0',
   description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 }