@agent-vm/mcp-portal 0.0.68 → 0.0.70

package/dist/{tool-vm → portal-config}/index.js

@@ -1,4 +1,3 @@
-import { t as generateTypescriptCatalogArtifact } from "../typescript-artifact-BqU8okQy.js";
-import { t as buildZodValidatorFromJsonSchema } from "../zod-schema-loader-CDDtoRE1.js";
-import "../tool-vm-ihnzDyjJ.js";
+import { t as buildZodValidatorFromJsonSchema } from "../zod-schema-loader-yNekKNpm.js";
+import { t as generateTypescriptCatalogArtifact } from "../typescript-artifact-BVLt3Ifd.js";
 export { buildZodValidatorFromJsonSchema, generateTypescriptCatalogArtifact };

package/dist/portal-core-CZQI7Ob6.d.ts

@@ -0,0 +1,264 @@
+import { n as PortalToolRecord, s as JsonObject } from "./catalog-types-BVuB4Ynx.js";
+import { M as PortalAgentIdentity, N as PortalAgentScopeSource, b as SkillGraphInput, j as PortalAccessPolicyConfig, o as PortalSessionRuntime, r as PortalSession } from "./portal-session-DG2CUjIo.js";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/core/portal-tools.d.ts
+interface PortalToolSuccess {
+  readonly input: Readonly<Record<string, unknown>>;
+  readonly ok: true;
+  readonly output: Readonly<Record<string, unknown>>;
+}
+interface PortalToolFailure {
+  readonly error: unknown;
+  readonly input: Readonly<Record<string, unknown>>;
+  readonly ok: false;
+}
+type PortalToolResult = PortalToolFailure | PortalToolSuccess;
+type PortalToolResultMap = Readonly<Record<string, PortalToolResult>>;
+interface PortalBatchError {
+  readonly id?: string;
+  readonly kind: string;
+  readonly message: string;
+}
+interface PortalBatchDiagnostic {
+  readonly kind: string;
+  readonly message: string;
+  readonly namespace?: string;
+}
+interface PortalBatchResult {
+  readonly diagnostics: readonly PortalBatchDiagnostic[];
+  readonly errors: readonly PortalBatchError[];
+  readonly ok: boolean;
+  readonly results: PortalToolResultMap;
+}
+interface PortalApprovalCall {
+  readonly arguments: JsonObject;
+  readonly id: string;
+  readonly namespace: string;
+  readonly tool: PortalToolRecord;
+  readonly toolName: string;
+}
+declare const portalToolInputSchemas: {
+  readonly mcp_portal_call: {
+    [x: string]: unknown;
+    type: "object";
+    properties?: {
+      [x: string]: object;
+    } | undefined;
+    required?: string[] | undefined;
+  };
+  readonly mcp_portal_describe: {
+    [x: string]: unknown;
+    type: "object";
+    properties?: {
+      [x: string]: object;
+    } | undefined;
+    required?: string[] | undefined;
+  };
+  readonly mcp_portal_list: {
+    [x: string]: unknown;
+    type: "object";
+    properties?: {
+      [x: string]: object;
+    } | undefined;
+    required?: string[] | undefined;
+  };
+  readonly mcp_portal_search: {
+    [x: string]: unknown;
+    type: "object";
+    properties?: {
+      [x: string]: object;
+    } | undefined;
+    required?: string[] | undefined;
+  };
+};
+interface PortalToolHandlerCall {
+  readonly identity: PortalAgentIdentity;
+  readonly input: unknown;
+}
+interface PortalCallUpstreamTool {
+  readonly arguments: JsonObject;
+  readonly agentScopeId: string;
+  readonly namespace: string;
+  readonly onEvent?: (event: PortalUpstreamEvent) => Promise<void> | void;
+  readonly requestId: string;
+  readonly signal?: AbortSignal;
+  readonly toolName: string;
+}
+type PortalUpstreamEvent = {
+  readonly kind: 'progress';
+  readonly message?: string;
+  readonly progress?: number;
+  readonly total?: number;
+} | {
+  readonly kind: 'upstream_notification';
+  readonly method: string;
+  readonly params: unknown;
+} | {
+  readonly content: {
+    readonly text: string;
+    readonly type: 'text';
+  } | {
+    readonly type: 'json';
+    readonly value: unknown;
+  };
+  readonly kind: 'partial_content';
+};
+interface PortalToolRuntime {
+  readonly approval?: (calls: readonly PortalApprovalCall[], identity: PortalAgentIdentity, approvalToken: string | undefined) => {
+    readonly kind: 'allow';
+  } | {
+    readonly kind: 'approval_token_invalid';
+    readonly reason: string;
+  } | {
+    readonly kind: 'approval_token_missing';
+  } | {
+    readonly kind: 'approval_required';
+    readonly level: 'critical' | 'standard';
+  };
+  readonly callUpstreamTool: (call: PortalCallUpstreamTool) => Promise<unknown>;
+  readonly getSession: (identity: PortalAgentIdentity) => Promise<PortalSession>;
+}
+interface PortalToolHandlers {
+  readonly call: (call: PortalToolHandlerCall) => Promise<PortalBatchResult>;
+  readonly describe: (call: PortalToolHandlerCall) => Promise<PortalBatchResult>;
+  readonly list: (call: PortalToolHandlerCall) => Promise<PortalBatchResult>;
+  readonly search: (call: PortalToolHandlerCall) => Promise<PortalBatchResult>;
+}
+declare function createPortalToolHandlers(runtime: PortalToolRuntime): PortalToolHandlers;
+//#endregion
+//#region src/core/portal-core.d.ts
+type PortalAgentScope = PortalAgentIdentity;
+type PortalCoreToolName = 'mcp_portal_list' | 'mcp_portal_search' | 'mcp_portal_describe' | 'mcp_portal_call';
+interface PortalAuditEvent {
+  readonly kind: string;
+  readonly message: string;
+  readonly namespace?: string;
+}
+interface PortalCoreResult {
+  readonly auditEvents?: readonly PortalAuditEvent[];
+  readonly content: readonly PortalCoreContentBlock[];
+  readonly items: readonly PortalCoreItemResult[];
+  readonly structuredContent?: unknown;
+}
+type PortalCoreItemResult = {
+  readonly content: readonly PortalCoreContentBlock[];
+  readonly requestId: string;
+  readonly status: 'success';
+  readonly structuredContent?: unknown;
+} | {
+  readonly error: PortalCoreItemError;
+  readonly requestId: string;
+  readonly status: 'failed';
+};
+interface PortalCoreItemError {
+  readonly code: string;
+  readonly message: string;
+  readonly namespace?: string;
+  readonly toolName?: string;
+}
+type PortalCoreContentBlock = {
+  readonly text: string;
+  readonly type: 'text';
+} | {
+  readonly type: 'json';
+  readonly value: unknown;
+};
+type PortalCoreEvent = {
+  readonly kind: 'started';
+  readonly toolName: PortalCoreToolName;
+} | {
+  readonly kind: 'item_started';
+  readonly namespace?: string;
+  readonly requestId: string;
+  readonly toolName?: string;
+} | {
+  readonly kind: 'progress';
+  readonly message?: string;
+  readonly progress?: number;
+  readonly requestId?: string;
+  readonly total?: number;
+} | {
+  readonly kind: 'upstream_notification';
+  readonly method: string;
+  readonly params: unknown;
+  readonly requestId?: string;
+} | {
+  readonly content: PortalCoreContentBlock;
+  readonly kind: 'partial_content';
+  readonly requestId?: string;
+} | {
+  readonly kind: 'item_completed';
+  readonly requestId: string;
+  readonly result: Extract<PortalCoreItemResult, {
+    readonly status: 'success';
+  }>;
+} | {
+  readonly error: PortalCoreItemError;
+  readonly kind: 'item_failed';
+  readonly requestId: string;
+} | {
+  readonly kind: 'completed';
+  readonly result: PortalCoreResult;
+} | {
+  readonly error: unknown;
+  readonly kind: 'failed';
+};
+interface PortalCoreStreamCall {
+  readonly input: unknown;
+  readonly scope: PortalAgentScope;
+  readonly signal?: AbortSignal;
+  readonly toolName: PortalCoreToolName;
+}
+interface PortalCoreCollectOptions {
+  readonly onEvent?: (event: PortalCoreEvent) => Promise<void> | void;
+}
+interface PortalCoreRuntime extends PortalSessionRuntime {
+  readonly callUpstreamTool: PortalToolRuntime['callUpstreamTool'];
+}
+type PortalApprovalEvaluator = NonNullable<PortalToolRuntime['approval']>;
+interface CreatePortalCoreBaseProps {
+  readonly accessPolicy: PortalAccessPolicyConfig;
+  readonly catalogTtlMs: number;
+  readonly runtime: PortalCoreRuntime;
+  readonly skills?: readonly SkillGraphInput[];
+  readonly upstreamNamespaces: readonly string[];
+}
+type CreatePortalCoreProps = (CreatePortalCoreBaseProps & {
+  readonly approval: PortalApprovalEvaluator;
+  readonly approvalTrustBoundary?: never;
+}) | (CreatePortalCoreBaseProps & {
+  readonly approval?: never;
+  readonly approvalTrustBoundary: 'openclaw-before-tool-call-hook';
+});
+interface PortalCore {
+  readonly approval: {
+    readonly evaluateCalls: (calls: readonly PortalApprovalCall[], scope: PortalAgentScope, approvalToken: string | undefined) => ReturnType<PortalApprovalEvaluator>;
+  };
+  readonly callStream: (call: PortalCoreStreamCall) => AsyncIterable<PortalCoreEvent>;
+  readonly close: () => Promise<void>;
+  readonly collectPortalCoreResult: typeof collectPortalCoreResult;
+  readonly createAgentScope: (input: {
+    readonly agentId: string;
+    readonly agentScopeId: string;
+    readonly authSubject?: string;
+    readonly sessionId?: string;
+    readonly sessionKey?: string;
+    readonly source: PortalAgentScopeSource;
+  }) => PortalAgentScope;
+  readonly describeTools: (scope: PortalAgentScope) => readonly PortalCoreToolDescriptor[];
+  readonly invalidateAgentScope: (agentScopeId: string) => Promise<void>;
+  readonly invalidateSession: (scope: PortalAgentScope) => Promise<void>;
+  readonly upstreamNamespaces: readonly string[];
+}
+interface PortalCoreToolDescriptor {
+  readonly description: string;
+  readonly inputSchema: Tool['inputSchema'];
+  readonly name: PortalCoreToolName;
+}
+declare function listPortalCoreToolDescriptors(namespaces?: readonly string[]): readonly PortalCoreToolDescriptor[];
+declare function collectPortalCoreResult(events: AsyncIterable<PortalCoreEvent>, options?: PortalCoreCollectOptions): Promise<PortalCoreResult>;
+declare function createPortalCore(props: CreatePortalCoreProps): PortalCore;
+//#endregion
+export { PortalToolSuccess as A, PortalCallUpstreamTool as C, PortalToolResult as D, PortalToolHandlers as E, createPortalToolHandlers as M, portalToolInputSchemas as N, PortalToolResultMap as O, PortalBatchResult as S, PortalToolHandlerCall as T, createPortalCore as _, PortalCore as a, PortalBatchDiagnostic as b, PortalCoreEvent as c, PortalCoreResult as d, PortalCoreRuntime as f, collectPortalCoreResult as g, PortalCoreToolName as h, PortalAuditEvent as i, PortalUpstreamEvent as j, PortalToolRuntime as k, PortalCoreItemError as l, PortalCoreToolDescriptor as m, PortalAgentScope as n, PortalCoreCollectOptions as o, PortalCoreStreamCall as p, PortalApprovalEvaluator as r, PortalCoreContentBlock as s, CreatePortalCoreProps as t, PortalCoreItemResult as u, listPortalCoreToolDescriptors as v, PortalToolFailure as w, PortalBatchError as x, PortalApprovalCall as y };
+//# sourceMappingURL=portal-core-CZQI7Ob6.d.ts.map

package/dist/portal-core-CZQI7Ob6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal-core-CZQI7Ob6.d.ts","names":[],"sources":["../src/core/portal-tools.ts","../src/core/portal-core.ts"],"mappings":"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"}

package/dist/portal-core-Cgu714CL.js

@@ -0,0 +1,416 @@
+import { l as jsonObjectSchema } from "./zod-schema-loader-yNekKNpm.js";
+import { f as resolvePortalAccessPolicy, u as createPortalAgentIdentity } from "./upstream-response-middleware-BjUWZ2G8.js";
+import { n as createPortalSessionManager } from "./upstream-mcp-client-runtime-JlsfTm7_.js";
+import { n as portalToolInputSchemas, t as createPortalToolHandlers } from "./portal-tools-DKci1szO.js";
+import { z } from "zod";
+import { mcpConfigToResolvedProviders } from "@agent-vm/config-contracts";
+//#region src/core/provider-runtime.ts
+async function resolveProviderSecretRecord(secrets, resolveSecret) {
+	const resolvedEntries = await Promise.all(Object.entries(secrets).map(async ([name, secret]) => [name, await resolveSecret(secret)]));
+	return Object.fromEntries(resolvedEntries);
+}
+async function resolveUpstreamServer(provider, resolveSecret) {
+	if (provider.transport === "stdio") return {
+		args: provider.args,
+		command: provider.command,
+		...provider.cwd === void 0 ? {} : { cwd: provider.cwd },
+		env: await resolveProviderSecretRecord(provider.env, resolveSecret),
+		namespace: provider.namespace,
+		transport: "stdio"
+	};
+	return {
+		headers: await resolveProviderSecretRecord(provider.headers, resolveSecret),
+		namespace: provider.namespace,
+		transport: provider.transport,
+		url: provider.url
+	};
+}
+async function resolveUpstreamServers(props) {
+	return await Promise.all(mcpConfigToResolvedProviders(props.config).map(async (provider) => resolveUpstreamServer(provider, props.resolveSecret)));
+}
+//#endregion
+//#region src/core/portal-core.ts
+const maxQueuedPortalCoreEvents = 1024;
+const maxPortalCoreEventBytes = 256 * 1024;
+const portalCallRequestSchema = z.object({
+	arguments: jsonObjectSchema,
+	id: z.string().min(1),
+	namespace: z.string().min(1),
+	toolName: z.string().min(1)
+}).strict();
+const portalCallInputSchema = z.object({
+	calls: z.array(portalCallRequestSchema).min(1),
+	portalApprovalToken: z.string().min(1).optional()
+}).strict();
+function diagnosticsToAuditEvents(diagnostics) {
+	return diagnostics.map((diagnostic) => ({
+		kind: diagnostic.kind,
+		message: diagnostic.message,
+		...diagnostic.namespace !== void 0 ? { namespace: diagnostic.namespace } : {}
+	}));
+}
+function isUnknownRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorRecordFromUnknown(error) {
+	return isUnknownRecord(error) ? error : {};
+}
+function messageFromUnknown(error) {
+	if (error instanceof Error) return error.message;
+	const message = errorRecordFromUnknown(error).message;
+	return typeof message === "string" ? message : String(error);
+}
+function errorFromAbortSignal(signal) {
+	const reason = signal.reason;
+	return reason instanceof Error ? reason : /* @__PURE__ */ new Error("MCP Portal core stream aborted.");
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw errorFromAbortSignal(signal);
+}
+function assertPortalCoreEventSize(event) {
+	const serialized = JSON.stringify(event);
+	if (serialized === void 0) return;
+	const byteLength = Buffer.byteLength(serialized, "utf8");
+	if (byteLength > maxPortalCoreEventBytes) throw new Error(`MCP Portal core event exceeded ${String(maxPortalCoreEventBytes)} bytes (${String(byteLength)} bytes).`);
+}
+function waitForQueuedCoreEvent(props) {
+	if (props.signal === void 0) return new Promise((resolve) => {
+		props.setNotifyQueuedEvent(resolve);
+	});
+	const signal = props.signal;
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const settle = (complete) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			props.setNotifyQueuedEvent(void 0);
+			complete();
+		};
+		const onNotify = () => {
+			settle(resolve);
+		};
+		const onAbort = () => {
+			settle(() => reject(errorFromAbortSignal(signal)));
+		};
+		props.setNotifyQueuedEvent(onNotify);
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) onAbort();
+	});
+}
+function itemErrorFromPortalResult(result) {
+	if (result.ok) throw new Error("Cannot convert successful portal result into an item error.");
+	const errorRecord = errorRecordFromUnknown(result.error);
+	const kind = errorRecord.kind;
+	const namespace = errorRecord.namespace;
+	const toolName = errorRecord.toolName;
+	return {
+		code: typeof kind === "string" ? kind : "portal_item_failed",
+		message: messageFromUnknown(result.error),
+		...typeof namespace === "string" ? { namespace } : {},
+		...typeof toolName === "string" ? { toolName } : {}
+	};
+}
+function itemResultFromPortalToolResult(requestId, result) {
+	if (!result.ok) return {
+		error: itemErrorFromPortalResult(result),
+		requestId,
+		status: "failed"
+	};
+	return {
+		content: [{
+			type: "json",
+			value: result.output
+		}],
+		requestId,
+		status: "success",
+		structuredContent: result.output
+	};
+}
+function scalarBatchResultToCoreResult(batchResult) {
+	return {
+		auditEvents: diagnosticsToAuditEvents(batchResult.diagnostics),
+		content: [{
+			type: "json",
+			value: batchResult
+		}],
+		items: [],
+		structuredContent: batchResult
+	};
+}
+function batchItemsToCoreResult(props) {
+	return {
+		auditEvents: diagnosticsToAuditEvents(props.diagnostics),
+		content: [],
+		items: props.items
+	};
+}
+function namespaceDescription(namespaces) {
+	return namespaces.length === 0 ? "No upstream MCP namespaces are authorized for this agent scope." : `Authorized MCP namespaces for this agent scope: ${namespaces.join(", ")}.`;
+}
+function listPortalCoreToolDescriptors(namespaces = []) {
+	const scopeDescription = namespaceDescription(namespaces);
+	return [
+		{
+			description: `List authorized MCP namespaces and compact tool summaries. ${scopeDescription}`,
+			inputSchema: portalToolInputSchemas.mcp_portal_list,
+			name: "mcp_portal_list"
+		},
+		{
+			description: `Search the caller scoped MCP Portal index. ${scopeDescription}`,
+			inputSchema: portalToolInputSchemas.mcp_portal_search,
+			name: "mcp_portal_search"
+		},
+		{
+			description: `Describe exact MCP tool schemas and optional TypeScript/Zod helpers. ${scopeDescription}`,
+			inputSchema: portalToolInputSchemas.mcp_portal_describe,
+			name: "mcp_portal_describe"
+		},
+		{
+			description: `Validate and call an authorized upstream MCP tool by namespace and toolName. ${scopeDescription}`,
+			inputSchema: portalToolInputSchemas.mcp_portal_call,
+			name: "mcp_portal_call"
+		}
+	];
+}
+async function collectPortalCoreResult(events, options = {}) {
+	let result;
+	for await (const event of events) {
+		await options.onEvent?.(event);
+		if (event.kind === "completed") result = event.result;
+		if (event.kind === "failed") throw event.error;
+	}
+	if (result === void 0) throw new Error("MCP Portal core stream ended without a completed event.");
+	return result;
+}
+async function* scalarToolStream(props) {
+	const handlers = createPortalToolHandlers(props.toolRuntime);
+	const handler = props.toolName === "mcp_portal_list" ? handlers.list : props.toolName === "mcp_portal_search" ? handlers.search : handlers.describe;
+	throwIfAborted(props.signal);
+	const batchResult = await handler({
+		identity: props.scope,
+		input: props.input
+	});
+	throwIfAborted(props.signal);
+	yield {
+		kind: "completed",
+		result: scalarBatchResultToCoreResult(batchResult)
+	};
+}
+async function* callToolStream(props) {
+	const parsedInput = portalCallInputSchema.safeParse(props.input);
+	const queuedEvents = [];
+	let notifyQueuedEvent;
+	let executionDone = false;
+	const pushEvent = (event) => {
+		assertPortalCoreEventSize(event);
+		if (queuedEvents.length >= maxQueuedPortalCoreEvents) throw new Error(`MCP Portal core event queue exceeded ${maxQueuedPortalCoreEvents} events.`);
+		queuedEvents.push(event);
+		notifyQueuedEvent?.();
+		notifyQueuedEvent = void 0;
+	};
+	const handlers = createPortalToolHandlers({
+		...props.toolRuntime,
+		callUpstreamTool: async (call) => {
+			throwIfAborted(props.signal);
+			pushEvent({
+				kind: "item_started",
+				namespace: call.namespace,
+				requestId: call.requestId,
+				toolName: call.toolName
+			});
+			pushEvent({
+				kind: "progress",
+				message: `Calling upstream MCP tool ${call.namespace}.${call.toolName}.`,
+				requestId: call.requestId
+			});
+			return await props.toolRuntime.callUpstreamTool({
+				...call,
+				...props.signal !== void 0 ? { signal: props.signal } : {},
+				onEvent: (event) => {
+					if (event.kind === "progress") {
+						pushEvent({
+							kind: "progress",
+							...event.message !== void 0 ? { message: event.message } : {},
+							...event.progress !== void 0 ? { progress: event.progress } : {},
+							requestId: call.requestId,
+							...event.total !== void 0 ? { total: event.total } : {}
+						});
+						return;
+					}
+					if (event.kind === "partial_content") {
+						pushEvent({
+							content: event.content,
+							kind: "partial_content",
+							requestId: call.requestId
+						});
+						return;
+					}
+					pushEvent({
+						kind: "upstream_notification",
+						method: event.method,
+						params: event.params,
+						requestId: call.requestId
+					});
+				}
+			});
+		}
+	});
+	if (!parsedInput.success) {
+		yield {
+			kind: "completed",
+			result: scalarBatchResultToCoreResult(await handlers.call({
+				identity: props.scope,
+				input: props.input
+			}))
+		};
+		return;
+	}
+	const itemResults = [];
+	const batchResultPromise = handlers.call({
+		identity: props.scope,
+		input: props.input
+	}).finally(() => {
+		executionDone = true;
+		notifyQueuedEvent?.();
+		notifyQueuedEvent = void 0;
+	});
+	const hasPendingExecutionEvents = () => !executionDone || queuedEvents.length > 0;
+	while (hasPendingExecutionEvents()) {
+		const event = queuedEvents.shift();
+		if (event !== void 0) {
+			yield event;
+			continue;
+		}
+		throwIfAborted(props.signal);
+		await waitForQueuedCoreEvent({
+			setNotifyQueuedEvent: (notify) => {
+				notifyQueuedEvent = notify;
+			},
+			...props.signal !== void 0 ? { signal: props.signal } : {}
+		});
+	}
+	const batchResult = await batchResultPromise;
+	throwIfAborted(props.signal);
+	if (batchResult.errors.length > 0) {
+		yield {
+			kind: "completed",
+			result: scalarBatchResultToCoreResult(batchResult)
+		};
+		return;
+	}
+	for (const request of parsedInput.data.calls) {
+		const portalResult = batchResult.results[request.id];
+		const itemResult = portalResult === void 0 ? {
+			error: {
+				code: "portal_item_missing",
+				message: `MCP Portal did not return a result for request "${request.id}".`,
+				namespace: request.namespace,
+				toolName: request.toolName
+			},
+			requestId: request.id,
+			status: "failed"
+		} : itemResultFromPortalToolResult(request.id, portalResult);
+		itemResults.push(itemResult);
+		if (itemResult.status === "success") yield {
+			kind: "item_completed",
+			requestId: request.id,
+			result: itemResult
+		};
+		else yield {
+			error: itemResult.error,
+			kind: "item_failed",
+			requestId: request.id
+		};
+	}
+	yield {
+		kind: "completed",
+		result: batchItemsToCoreResult({
+			diagnostics: batchResult.diagnostics,
+			items: itemResults
+		})
+	};
+}
+function createPortalCore(props) {
+	const sessionManager = createPortalSessionManager({
+		accessPolicy: props.accessPolicy,
+		catalogTtlMs: props.catalogTtlMs,
+		runtime: props.runtime,
+		...props.skills !== void 0 ? { skills: props.skills } : {},
+		upstreamNamespaces: props.upstreamNamespaces
+	});
+	const createdAgentScopeIds = /* @__PURE__ */ new Set();
+	const approval = props.approval ?? (() => {
+		if (props.approvalTrustBoundary === "openclaw-before-tool-call-hook") return { kind: "allow" };
+		throw new Error("MCP Portal approval evaluation is not configured.");
+	});
+	const toolRuntime = {
+		approval,
+		callUpstreamTool: props.runtime.callUpstreamTool,
+		getSession: sessionManager.getSession
+	};
+	async function* callStream(call) {
+		try {
+			throwIfAborted(call.signal);
+			yield {
+				kind: "started",
+				toolName: call.toolName
+			};
+			throwIfAborted(call.signal);
+			if (call.toolName === "mcp_portal_call") {
+				yield* callToolStream({
+					input: call.input,
+					scope: call.scope,
+					...call.signal !== void 0 ? { signal: call.signal } : {},
+					toolRuntime
+				});
+				return;
+			}
+			yield* scalarToolStream({
+				input: call.input,
+				scope: call.scope,
+				...call.signal !== void 0 ? { signal: call.signal } : {},
+				sessionManager,
+				toolName: call.toolName,
+				toolRuntime
+			});
+		} catch (error) {
+			yield {
+				error,
+				kind: "failed"
+			};
+		}
+	}
+	return {
+		approval: { evaluateCalls: (calls, scope, approvalToken) => approval(calls, scope, approvalToken) },
+		callStream,
+		close: async () => {
+			await Promise.all([...createdAgentScopeIds].map((agentScopeId) => sessionManager.invalidateAgentScope(agentScopeId)));
+		},
+		collectPortalCoreResult,
+		createAgentScope: (input) => {
+			const scope = createPortalAgentIdentity(input);
+			createdAgentScopeIds.add(scope.agentScopeId);
+			return scope;
+		},
+		describeTools: (scope) => {
+			return listPortalCoreToolDescriptors(resolvePortalAccessPolicy({
+				config: props.accessPolicy,
+				identity: scope,
+				upstreamNamespaces: props.upstreamNamespaces
+			}).allowedNamespaces);
+		},
+		invalidateAgentScope: async (agentScopeId) => {
+			createdAgentScopeIds.delete(agentScopeId);
+			await sessionManager.invalidateAgentScope(agentScopeId);
+		},
+		invalidateSession: async (scope) => {
+			await sessionManager.invalidateSession(scope);
+		},
+		upstreamNamespaces: props.upstreamNamespaces
+	};
+}
+//#endregion
+export { resolveUpstreamServers as i, createPortalCore as n, listPortalCoreToolDescriptors as r, collectPortalCoreResult as t };
+
+//# sourceMappingURL=portal-core-Cgu714CL.js.map