@noodleseed/one 0.138.0 → 0.139.1

package/node_modules/@noodle-borg/connector-defs/dist/schema.js

@@ -276,6 +276,16 @@ const httpAuthSchema = z
         });
     }
 });
+/** Phase-1 upstream MCP auth: broker-owned service credentials only (ADR 0189 Decision 7). */
+const mcpAuthSchema = httpAuthSchema.superRefine((auth, ctx) => {
+    if (auth.kind === 'bearer' || auth.kind === 'apiKey' || auth.kind === 'clientCredentials') {
+        return;
+    }
+    ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'MCP connectors currently accept only bearer, apiKey, or clientCredentials auth; delegated upstream OAuth requires the consent-broker slice',
+    });
+});
 /** Public HTTP response allowance: explicit per operation, bounded to cap concurrent memory cost. */
 const httpOperationLimitsSchema = z
     .object({
@@ -341,6 +351,54 @@ const httpOperationSchema = z
         });
     }
 });
+const mcpOperationFakeSchema = z.union([
+    z.object({ structuredContent: z.record(z.string(), z.unknown()) }).strict(),
+    z.object({ text: z.string() }).strict(),
+]);
+const mcpToolNameSchema = z
+    .string()
+    .min(1)
+    .max(256)
+    .refine((value) => !/\p{Cc}/u.test(value), 'upstream MCP tool name contains a control character');
+/** One frozen upstream MCP tool projected as one ordinary connector operation. */
+const mcpOperationSchema = z
+    .object({
+    type: z.enum(['read', 'action']),
+    tool: mcpToolNameSchema,
+    input: ioSchema.optional(),
+    output: ioSchema.optional(),
+    /** `text` means the imported upstream tool had no outputSchema. */
+    result: z.enum(['structured', 'text']).default('structured'),
+    auth: mcpAuthSchema.optional(),
+    limits: httpOperationLimitsSchema.optional(),
+    fake: mcpOperationFakeSchema.optional(),
+    credentials: operationCredentialsSchema.optional(),
+})
+    .strict()
+    .superRefine((operation, ctx) => {
+    for (const [field, schema] of [
+        ['input', operation.input],
+        ['output', operation.output],
+    ]) {
+        if (schema !== undefined && hasExternalSchemaRef(schema)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [field],
+                message: 'external JSON Schema references are not allowed for MCP operations',
+            });
+        }
+    }
+});
+function hasExternalSchemaRef(value) {
+    if (Array.isArray(value))
+        return value.some(hasExternalSchemaRef);
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    if (typeof record.$ref === 'string' && !record.$ref.startsWith('#'))
+        return true;
+    return Object.values(record).some(hasExternalSchemaRef);
+}
 /** Per-operation resource bounds for a compute operation; omitted fields fall back to `DEFAULT_LIMITS`. */
 const computeLimitsSchema = z
     .object({
@@ -369,6 +427,61 @@ const computeOperationSchema = z
 const managedVariableExpressionSchema = z
     .string()
     .regex(/^\$\{env\.[A-Za-z0-9_]+\}$/, 'must be an exact managed variable expression');
+const mcpEndpointSchema = z
+    .string()
+    .min(1)
+    .superRefine((value, ctx) => {
+    if (managedVariableExpressionSchema.safeParse(value).success)
+        return;
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'MCP endpoint must be an absolute URL',
+        });
+        return;
+    }
+    const loopback = url.protocol === 'http:' &&
+        (url.hostname === 'localhost' || url.hostname === '127.0.0.1' || url.hostname === '[::1]');
+    if (url.protocol !== 'https:' && !loopback) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'MCP endpoint must use HTTPS' });
+    }
+    if (url.username !== '' || url.password !== '' || url.hash !== '') {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'MCP endpoint cannot contain userinfo or a fragment',
+        });
+    }
+});
+const mcpOriginSchema = z
+    .string()
+    .min(1)
+    .superRefine((value, ctx) => {
+    if (managedVariableExpressionSchema.safeParse(value).success)
+        return;
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'MCP origin must be an absolute URL' });
+        return;
+    }
+    const loopback = url.protocol === 'http:' &&
+        (url.hostname === 'localhost' || url.hostname === '127.0.0.1' || url.hostname === '[::1]');
+    if (url.protocol !== 'https:' && !loopback) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'MCP origin must use HTTPS' });
+    }
+    if (value !== url.origin) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'MCP origin must be a canonical bare origin',
+        });
+    }
+});
 const connectorIdentity = {
     id: z.string().min(1),
     version: z.string().min(1),
@@ -394,6 +507,31 @@ const httpConnectorDefSchema = z
     operations: z.record(z.string(), httpOperationSchema),
 })
     .strict();
+/** A governed remote MCP connector with a compile-time-frozen tool snapshot. */
+const mcpConnectorDefSchema = z
+    .object({
+    ...connectorIdentity,
+    mcp: z
+        .object({
+        endpoint: mcpEndpointSchema,
+        allowedOrigins: z.array(mcpOriginSchema).min(1).max(32).optional(),
+        auth: mcpAuthSchema.optional(),
+        timeoutMs: z.number().int().positive().max(300_000).optional(),
+        maxResponseBytes: z
+            .number()
+            .int()
+            .positive()
+            .max(6 * 1024 * 1024)
+            .optional(),
+        protocol: z.enum(['auto', 'legacy', 'modern']).optional(),
+    })
+        .strict(),
+    operations: z
+        .record(z.string(), mcpOperationSchema)
+        .refine((operations) => Object.keys(operations).length > 0, 'MCP connector needs an operation')
+        .refine((operations) => Object.keys(operations).length <= 256, 'MCP connector supports at most 256 curated operations'),
+})
+    .strict();
 /** A compute connector: sandboxed-code operations, no `http` block. */
 const computeConnectorDefSchema = z
     .object({
@@ -405,7 +543,11 @@ const computeConnectorDefSchema = z
  * A connector is **either** an HTTP connector (has an `http` block) **or** a compute connector (no `http`;
  * operations carry `code`). Both shapes are `.strict()`, so a given entry matches exactly one branch.
  */
-const connectorDefSchema = z.union([httpConnectorDefSchema, computeConnectorDefSchema]);
+const connectorDefSchema = z.union([
+    httpConnectorDefSchema,
+    mcpConnectorDefSchema,
+    computeConnectorDefSchema,
+]);
 export const connectorFileSchema = z
     .object({
     connectors: z.array(connectorDefSchema).min(1),

package/node_modules/@noodle-borg/connector-http/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { type HttpAuthScheme, HttpConnector, type HttpConnectorConfig, type HttpOperation, type HttpOperationFake, type HttpOperationPagination, type HttpPaginationAggregate, type HttpPaginationStopReason, } from './http-connector.js';
+export * from './mcp/index.js';
 export type { HttpOperationProjection } from './projection.js';
 export type { GuardedFetchOptions } from './ssrf.js';
 export { createGuardedAgent, type DnsLookup, guardedFetch, isPublicUnicast, needsGuard, pinnedLookup, } from './ssrf.js';

package/node_modules/@noodle-borg/connector-http/dist/index.js

@@ -1,3 +1,4 @@
 export { HttpConnector, } from './http-connector.js';
+export * from './mcp/index.js';
 export { createGuardedAgent, guardedFetch, isPublicUnicast, needsGuard, pinnedLookup, } from './ssrf.js';
 //# sourceMappingURL=index.js.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/config.js

@@ -0,0 +1,76 @@
+import { ConnectorInvocationError } from '@noodle-borg/runtime';
+const VARIABLE = /^\$\{env\.([A-Za-z0-9_]+)\}$/;
+const MAX_RESPONSE_BYTES = 6 * 1024 * 1024;
+export const DEFAULT_RESPONSE_BYTES = 1 << 20;
+export function isVariable(value) {
+    return VARIABLE.test(value);
+}
+export function resolveManagedString(configured, env) {
+    const match = VARIABLE.exec(configured);
+    if (match === null)
+        return configured;
+    const name = match[1];
+    const value = env[name];
+    if (value === undefined || value.length === 0) {
+        throw new ConnectorInvocationError(`managed variable "${name}" is unavailable`, {
+            category: 'invalid_response',
+            retryable: false,
+        });
+    }
+    return value;
+}
+export function responseLimit(value) {
+    const limit = value ?? DEFAULT_RESPONSE_BYTES;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_RESPONSE_BYTES) {
+        throw new ConnectorInvocationError('invalid MCP response size limit', {
+            category: 'invalid_response',
+            retryable: false,
+        });
+    }
+    return limit;
+}
+export function parsedEndpoint(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new ConnectorInvocationError('upstream MCP endpoint is not a valid URL', {
+            category: 'invalid_response',
+            retryable: false,
+        });
+    }
+    if (url.username !== '' || url.password !== '' || url.hash !== '') {
+        throw new ConnectorInvocationError('upstream MCP endpoint contains forbidden URL components', {
+            category: 'invalid_response',
+            retryable: false,
+        });
+    }
+    if (!isSecureOrLoopback(url)) {
+        throw new ConnectorInvocationError('upstream MCP endpoint must use HTTPS', {
+            category: 'invalid_response',
+            retryable: false,
+        });
+    }
+    return url;
+}
+export function configuredOrigins(configured, env) {
+    const origins = new Set();
+    for (const entry of configured) {
+        const resolved = resolveManagedString(entry, env);
+        const url = parsedEndpoint(resolved);
+        if (isVariable(entry) && url.origin !== resolved) {
+            throw new ConnectorInvocationError('managed MCP egress origin must resolve to a canonical bare origin', { category: 'invalid_response', retryable: false });
+        }
+        origins.add(url.origin);
+    }
+    return origins;
+}
+function isSecureOrLoopback(url) {
+    if (url.protocol === 'https:')
+        return true;
+    if (url.protocol !== 'http:')
+        return false;
+    return url.hostname === 'localhost' || url.hostname === '127.0.0.1' || url.hostname === '[::1]';
+}
+//# sourceMappingURL=config.js.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/egress.js

@@ -0,0 +1,125 @@
+import { ConnectorInvocationError, } from '@noodle-borg/runtime';
+import { guardedFetch } from '../ssrf.js';
+/** Build one invocation-scoped fetch so credential material can never outlive or cross a call. */
+export function invocationFetch(options) {
+    return async (input, init = {}) => {
+        const url = new URL(input);
+        if (!options.allowedOrigins.has(url.origin)) {
+            throw new ConnectorInvocationError(`upstream MCP request resolved to a disallowed origin "${url.origin}"`, { category: 'invalid_response', retryable: false });
+        }
+        const headers = new Headers(init.headers);
+        attachCredential(headers, options.call.credentialPresentation ?? options.auth, options.call.credential);
+        const request = { ...init, headers, redirect: 'manual' };
+        let response;
+        try {
+            response =
+                options.dependencies.fetch === undefined
+                    ? await guardedFetch(url, request, {
+                        ...(options.dependencies.lookup === undefined
+                            ? {}
+                            : { lookup: options.dependencies.lookup }),
+                    })
+                    : await options.dependencies.fetch(url, request);
+        }
+        catch (error) {
+            options.onNetworkFailure();
+            throw error;
+        }
+        if (response.status >= 300 && response.status <= 399) {
+            throw new ConnectorInvocationError('upstream MCP redirect rejected', {
+                status: response.status,
+                category: 'invalid_response',
+                retryable: false,
+            });
+        }
+        if (response.status === 429) {
+            const retryAfterMs = parseRetryAfterMs(response.headers.get('retry-after'));
+            if (retryAfterMs !== undefined)
+                options.onRetryAfter(retryAfterMs);
+        }
+        return boundedResponse(response, options.maxResponseBytes, options.onResponseLimitExceeded);
+    };
+}
+function parseRetryAfterMs(value) {
+    if (value === null || value.trim() === '')
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.round(seconds * 1_000);
+    const time = Date.parse(value);
+    if (!Number.isFinite(time))
+        return undefined;
+    return Math.max(0, time - Date.now());
+}
+function attachCredential(headers, scheme, credential) {
+    if (scheme === undefined)
+        return;
+    if (scheme.kind === 'cookie') {
+        if (credential.kind !== 'cookie') {
+            throw new ConnectorInvocationError('MCP cookie auth requires a cookie credential', {
+                category: 'invalid_response',
+                retryable: false,
+            });
+        }
+        headers.set('cookie', credential.cookie);
+        return;
+    }
+    if (credential.kind === 'cookie') {
+        throw new ConnectorInvocationError('MCP token auth requires a token credential', {
+            category: 'invalid_response',
+            retryable: false,
+        });
+    }
+    if (scheme.kind === 'bearer')
+        headers.set('authorization', `Bearer ${credential.token}`);
+    else
+        headers.set(scheme.header, credential.token);
+}
+function boundedResponse(response, maxBytes, onExceeded) {
+    const length = response.headers.get('content-length');
+    if (length !== null && Number(length) > maxBytes) {
+        onExceeded();
+        throw responseTooLarge();
+    }
+    if (response.body === null)
+        return response;
+    const reader = response.body.getReader();
+    let size = 0;
+    const body = new ReadableStream({
+        async pull(controller) {
+            try {
+                const chunk = await reader.read();
+                if (chunk.done) {
+                    controller.close();
+                    return;
+                }
+                size += chunk.value.byteLength;
+                if (size > maxBytes) {
+                    onExceeded();
+                    await reader.cancel().catch(() => undefined);
+                    controller.error(responseTooLarge());
+                    return;
+                }
+                controller.enqueue(chunk.value);
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            await reader.cancel(reason).catch(() => undefined);
+        },
+    });
+    return new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+function responseTooLarge() {
+    return new ConnectorInvocationError('upstream MCP response exceeds the size limit', {
+        category: 'response_too_large',
+        retryable: false,
+    });
+}
+//# sourceMappingURL=egress.js.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/failure.js

@@ -0,0 +1,48 @@
+import { ProtocolError, SdkError, SdkErrorCode, SdkHttpError } from '@modelcontextprotocol/client';
+import { ConnectorInvocationError, isConnectorInvocationError } from '@noodle-borg/runtime';
+export function normalizeMcpFailure(error, options) {
+    if (isConnectorInvocationError(error))
+        return error;
+    if (options.timedOut ||
+        (SdkError.isInstance(error) && error.code === SdkErrorCode.RequestTimeout)) {
+        return new ConnectorInvocationError('upstream MCP request timed out', {
+            category: 'timeout',
+            retryable: false,
+        });
+    }
+    if (SdkHttpError.isInstance(error)) {
+        return new ConnectorInvocationError('upstream MCP transport rejected the request', {
+            status: error.status,
+            category: categoryForStatus(error.status),
+            retryable: false,
+            ...(options.retryAfterMs === undefined ? {} : { retryAfterMs: options.retryAfterMs }),
+        });
+    }
+    if (SdkError.isInstance(error) &&
+        (error.code === SdkErrorCode.UnsupportedResultType ||
+            error.code === SdkErrorCode.InvalidResult ||
+            error.code === SdkErrorCode.EraNegotiationFailed)) {
+        return new ConnectorInvocationError('upstream MCP server returned an unsupported response', {
+            category: 'invalid_response',
+            retryable: false,
+        });
+    }
+    if (ProtocolError.isInstance(error)) {
+        return new ConnectorInvocationError('upstream MCP protocol request failed', {
+            category: error.code === -32601 ? 'upstream_4xx' : 'invalid_response',
+            retryable: false,
+        });
+    }
+    return new ConnectorInvocationError('upstream MCP network request failed', {
+        category: 'network_error',
+        retryable: false,
+    });
+}
+function categoryForStatus(status) {
+    if (status === 429)
+        return 'rate_limited';
+    if (status >= 500)
+        return 'upstream_5xx';
+    return 'upstream_4xx';
+}
+//# sourceMappingURL=failure.js.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export { McpConnector } from './mcp-connector.js';
+export type { McpAuthScheme, McpConnectorConfig, McpConnectorDependencies, McpOperation, McpOperationFake, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/index.js

@@ -0,0 +1,2 @@
+export { McpConnector } from './mcp-connector.js';
+//# sourceMappingURL=index.js.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/mcp-connector.d.ts

@@ -0,0 +1,12 @@
+import type { Connector, ConnectorCall } from '@noodle-borg/runtime';
+import { type McpConnectorConfig, type McpConnectorDependencies } from './types.js';
+/** Governed, invocation-scoped client for one imported remote Streamable HTTP MCP server. */
+export declare class McpConnector implements Connector {
+    #private;
+    readonly id: string;
+    readonly version: string;
+    constructor(config: McpConnectorConfig, dependencies?: McpConnectorDependencies);
+    signature(operation: string): import("@noodle-borg/compiler").OperationSignature | undefined;
+    invoke(call: ConnectorCall): Promise<unknown>;
+}
+//# sourceMappingURL=mcp-connector.d.ts.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/mcp-connector.js

@@ -0,0 +1,125 @@
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { ConnectorInvocationError } from '@noodle-borg/runtime';
+import { configuredOrigins, isVariable, parsedEndpoint, resolveManagedString, responseLimit, } from './config.js';
+import { invocationFetch } from './egress.js';
+import { normalizeMcpFailure } from './failure.js';
+import { normalizeToolResult } from './result.js';
+import { toolDefinition } from './types.js';
+const DEFAULT_TIMEOUT_MS = 10_000;
+/** Governed, invocation-scoped client for one imported remote Streamable HTTP MCP server. */
+export class McpConnector {
+    id;
+    version;
+    #config;
+    #dependencies;
+    constructor(config, dependencies = {}) {
+        this.id = config.id;
+        this.version = config.version;
+        this.#config = config;
+        this.#dependencies = dependencies;
+        if (Object.keys(config.operations).length === 0) {
+            throw new Error('an MCP connector must declare at least one curated operation');
+        }
+        if (isVariable(config.endpoint) && config.allowedOrigins === undefined) {
+            throw new Error('mcp.allowedOrigins is required when endpoint is a managed variable');
+        }
+        if (!isVariable(config.endpoint))
+            parsedEndpoint(config.endpoint);
+        responseLimit(config.maxResponseBytes);
+    }
+    signature(operation) {
+        return this.#config.operations[operation]?.signature;
+    }
+    async invoke(call) {
+        const operation = this.#config.operations[call.operation];
+        if (operation === undefined) {
+            throw new Error(`connector "${this.id}" has no operation "${call.operation}"`);
+        }
+        const maxBytes = responseLimit(operation.maxResponseBytes ?? this.#config.maxResponseBytes);
+        if (this.#config.fakeMode === true) {
+            if (operation.fake === undefined) {
+                throw new ConnectorInvocationError(`fake MCP response missing for operation "${call.operation}"`, { category: 'invalid_response', retryable: false });
+            }
+            return normalizeToolResult('structuredContent' in operation.fake
+                ? { structuredContent: operation.fake.structuredContent, content: [] }
+                : { content: [{ type: 'text', text: operation.fake.text }] }, maxBytes);
+        }
+        const env = call.env ?? {};
+        const endpoint = parsedEndpoint(resolveManagedString(this.#config.endpoint, env));
+        const allowed = configuredOrigins(this.#config.allowedOrigins ?? [this.#config.endpoint], env);
+        if (!allowed.has(endpoint.origin)) {
+            throw new ConnectorInvocationError(`upstream MCP endpoint resolved to a disallowed origin "${endpoint.origin}"`, { category: 'invalid_response', retryable: false });
+        }
+        const timeoutMs = this.#config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        const signal = call.signal === undefined ? timeoutSignal : AbortSignal.any([timeoutSignal, call.signal]);
+        const client = new Client({ name: 'noodle-mcp-connector', version: '1.0.0' }, {
+            capabilities: {},
+            versionNegotiation: { mode: protocolMode(this.#config.protocol) },
+            inputRequired: { autoFulfill: false },
+        });
+        let responseLimitExceeded = false;
+        let networkFailure = false;
+        let retryAfterMs;
+        const transport = new StreamableHTTPClientTransport(endpoint, {
+            fetch: invocationFetch({
+                allowedOrigins: allowed,
+                ...((operation.auth ?? this.#config.auth) === undefined
+                    ? {}
+                    : { auth: operation.auth ?? this.#config.auth }),
+                call,
+                maxResponseBytes: maxBytes,
+                dependencies: this.#dependencies,
+                onResponseLimitExceeded: () => {
+                    responseLimitExceeded = true;
+                },
+                onNetworkFailure: () => {
+                    networkFailure = true;
+                },
+                onRetryAfter: (value) => {
+                    retryAfterMs = value;
+                },
+            }),
+            onInsufficientScope: 'throw',
+        });
+        const closeTransportOnAbort = () => {
+            void transport.close().catch(() => undefined);
+        };
+        signal.addEventListener('abort', closeTransportOnAbort, { once: true });
+        if (signal.aborted)
+            closeTransportOnAbort();
+        try {
+            await client.connect(transport, { signal, timeout: timeoutMs });
+            const result = await client.callTool({ name: operation.upstreamTool, arguments: { ...call.args } }, { signal, timeout: timeoutMs, toolDefinition: toolDefinition(operation) });
+            return normalizeToolResult(result, maxBytes);
+        }
+        catch (error) {
+            if (responseLimitExceeded) {
+                throw new ConnectorInvocationError('upstream MCP response exceeds the size limit', {
+                    category: 'response_too_large',
+                    retryable: false,
+                });
+            }
+            if (networkFailure && !signal.aborted) {
+                throw new ConnectorInvocationError('upstream MCP network request failed', {
+                    category: 'network_error',
+                    retryable: false,
+                });
+            }
+            throw normalizeMcpFailure(error, {
+                timedOut: signal.aborted,
+                ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+            });
+        }
+        finally {
+            signal.removeEventListener('abort', closeTransportOnAbort);
+            await client.close().catch(() => undefined);
+        }
+    }
+}
+function protocolMode(protocol) {
+    if (protocol === 'modern')
+        return { pin: '2026-07-28' };
+    return protocol ?? 'auto';
+}
+//# sourceMappingURL=mcp-connector.js.map

package/node_modules/@noodle-borg/connector-http/dist/mcp/result.js

@@ -0,0 +1,55 @@
+import { ConnectorInvocationError } from '@noodle-borg/runtime';
+export function normalizeToolResult(result, maxBytes) {
+    if (result.isError === true) {
+        throw new ConnectorInvocationError('upstream MCP tool reported an execution error', {
+            category: 'upstream_4xx',
+            retryable: false,
+        });
+    }
+    if (result.structuredContent !== undefined) {
+        if (!isRecord(result.structuredContent)) {
+            throw invalidResult('upstream MCP structured content must be an object');
+        }
+        assertEncodedSize(result.structuredContent, maxBytes);
+        return result.structuredContent;
+    }
+    const text = result.content
+        .filter((block) => isTextBlock(block))
+        .map((block) => block.text)
+        .join('\n');
+    if (text.length === 0) {
+        throw invalidResult('upstream MCP tool returned no structured or text content');
+    }
+    assertEncodedSize(text, maxBytes);
+    return { text };
+}
+function isTextBlock(value) {
+    if (!isRecord(value))
+        return false;
+    return value.type === 'text' && typeof value.text === 'string';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertEncodedSize(value, maxBytes) {
+    let encoded;
+    try {
+        encoded = typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    catch {
+        throw invalidResult('upstream MCP result was not serializable');
+    }
+    if (new TextEncoder().encode(encoded).byteLength > maxBytes) {
+        throw new ConnectorInvocationError('upstream MCP result exceeds the size limit', {
+            category: 'response_too_large',
+            retryable: false,
+        });
+    }
+}
+function invalidResult(message) {
+    return new ConnectorInvocationError(message, {
+        category: 'invalid_response',
+        retryable: false,
+    });
+}
+//# sourceMappingURL=result.js.map