asqend-mcp-contracts 0.3.2

package/dist/batch-execute.d.ts

@@ -0,0 +1,29 @@
+export type BatchOperation = {
+    tool: string;
+    args: Record<string, unknown>;
+};
+export type BatchOperationResult = {
+    index: number;
+    tool: string;
+    status: 'ok';
+    durationMs: number;
+    data: unknown;
+} | {
+    index: number;
+    tool: string;
+    status: 'error';
+    durationMs: number;
+    error: string;
+};
+export interface BatchExecuteResult {
+    results: BatchOperationResult[];
+    totalMs: number;
+    operationCount: number;
+}
+export declare function parseBatchExecuteOperations(input: Record<string, unknown>): BatchOperation[];
+export declare function resolveBatchExecuteConcurrency(input: Record<string, unknown>): number;
+export declare function executeBatchExecuteOperations(args: {
+    operations: BatchOperation[];
+    concurrency: number;
+    executeOperation: (operation: BatchOperation, index: number) => Promise<unknown>;
+}): Promise<BatchExecuteResult>;

package/dist/batch-execute.js

@@ -0,0 +1,109 @@
+import { generatedWriteTools } from './write-set.js';
+const MAX_BATCH_OPERATIONS = 20;
+const DEFAULT_BATCH_CONCURRENCY = 5;
+const MAX_BATCH_CONCURRENCY = 10;
+export function parseBatchExecuteOperations(input) {
+    const operations = input.operations;
+    if (!Array.isArray(operations)) {
+        throw new Error('batch_execute requires operations[]');
+    }
+    if (operations.length === 0) {
+        throw new Error('batch_execute requires at least one operation');
+    }
+    if (operations.length > MAX_BATCH_OPERATIONS) {
+        throw new Error(`batch_execute supports at most ${MAX_BATCH_OPERATIONS} operations`);
+    }
+    return operations.map((operation, index) => {
+        if (!operation || typeof operation !== 'object' || Array.isArray(operation)) {
+            throw new Error(`batch_execute operation ${index} must be an object`);
+        }
+        const candidate = operation;
+        const tool = candidate.tool;
+        const args = candidate.args;
+        if (typeof tool !== 'string' || tool.trim().length === 0) {
+            throw new Error(`batch_execute operation ${index} requires tool`);
+        }
+        if (args !== undefined &&
+            (!args || typeof args !== 'object' || Array.isArray(args))) {
+            throw new Error(`batch_execute operation ${index} args must be an object`);
+        }
+        return {
+            tool: tool.trim(),
+            args: args ?? {},
+        };
+    });
+}
+export function resolveBatchExecuteConcurrency(input) {
+    const rawConcurrency = input.concurrency;
+    if (rawConcurrency === undefined) {
+        return DEFAULT_BATCH_CONCURRENCY;
+    }
+    if (typeof rawConcurrency !== 'number' || !Number.isFinite(rawConcurrency)) {
+        throw new Error('batch_execute concurrency must be a finite number');
+    }
+    return Math.min(Math.max(1, Math.trunc(rawConcurrency)), MAX_BATCH_CONCURRENCY);
+}
+async function mapWithConcurrency(items, concurrency, worker) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+        while (true) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            if (currentIndex >= items.length) {
+                return;
+            }
+            results[currentIndex] = await worker(items[currentIndex], currentIndex);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+export async function executeBatchExecuteOperations(args) {
+    const startedAt = Date.now();
+    const results = await mapWithConcurrency(args.operations, args.concurrency, async (operation, index) => {
+        if (operation.tool === 'batch_execute') {
+            return {
+                index,
+                tool: operation.tool,
+                status: 'error',
+                durationMs: 0,
+                error: 'batch_execute does not support nested batch_execute operations',
+            };
+        }
+        if (generatedWriteTools.has(operation.tool)) {
+            return {
+                index,
+                tool: operation.tool,
+                status: 'error',
+                durationMs: 0,
+                error: `batch_execute only supports read tools; ${operation.tool} is a write tool`,
+            };
+        }
+        const operationStartedAt = Date.now();
+        try {
+            const data = await args.executeOperation(operation, index);
+            return {
+                index,
+                tool: operation.tool,
+                status: 'ok',
+                durationMs: Date.now() - operationStartedAt,
+                data,
+            };
+        }
+        catch (error) {
+            return {
+                index,
+                tool: operation.tool,
+                status: 'error',
+                durationMs: Date.now() - operationStartedAt,
+                error: error instanceof Error ? error.message : 'Tool call failed',
+            };
+        }
+    });
+    return {
+        results,
+        totalMs: Date.now() - startedAt,
+        operationCount: args.operations.length,
+    };
+}

package/dist/definitions.d.ts

@@ -0,0 +1 @@
+export { generatedToolDefinitions } from './generated/tools.definitions.js';

package/dist/definitions.js

@@ -0,0 +1 @@
+export { generatedToolDefinitions } from './generated/tools.definitions.js';

package/dist/dispatch.d.ts

@@ -0,0 +1 @@
+export { generatedDispatch } from './generated/tools.dispatch.js';

package/dist/dispatch.js

@@ -0,0 +1 @@
+export { generatedDispatch } from './generated/tools.dispatch.js';

package/dist/fallback-set.d.ts

@@ -0,0 +1 @@
+export { generatedFallbackTools } from './generated/tools.fallback-set.js';

package/dist/fallback-set.js

@@ -0,0 +1 @@
+export { generatedFallbackTools } from './generated/tools.fallback-set.js';