@xopcai/xopc 0.0.187 → 0.0.189

package/dist/src/agent/external-tools/mcp-provider.d.ts

@@ -0,0 +1,29 @@
+import type { AgentToolResult } from '@earendil-works/pi-agent-core';
+import type { Config } from '../../config/schema.js';
+import type { ExtensionHookRunner } from '../../extensions/index.js';
+import type { SessionMcpRuntime } from '../mcp/bundle-mcp-types.js';
+import type { ExternalToolDescriptor, ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit } from './types.js';
+export interface McpToolProviderDeps {
+    workspace: string;
+    getConfig: () => Config | undefined;
+    getSessionKey: () => string | undefined;
+    agentId?: string;
+    hookRunner?: ExtensionHookRunner;
+    getRuntime?: (params: {
+        sessionId: string;
+        sessionKey?: string;
+        workspaceDir: string;
+        cfg?: Config;
+    }) => Promise<SessionMcpRuntime>;
+}
+export declare class McpToolProvider implements ExternalToolProvider {
+    private readonly deps;
+    readonly source: "mcp";
+    constructor(deps: McpToolProviderDeps);
+    search(_query: string): Promise<ExternalToolSearchHit[]>;
+    describe(toolRef: string): Promise<ExternalToolDescriptor | undefined>;
+    execute(toolRef: string, args: Record<string, unknown>, _approvalId: string | undefined, context: ExternalToolExecutionContext): Promise<AgentToolResult<Record<string, unknown>>>;
+    private resolve;
+    private isAllowed;
+    private withRuntime;
+}

package/dist/src/agent/external-tools/mcp-provider.js

@@ -0,0 +1,118 @@
+import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
+import { externalToolRef, parseExternalToolRef } from "./refs.js";
+import { isMcpCatalogToolDenied, mcpToolPolicyId } from "../mcp/bundle-mcp-policy.js";
+import { getOrCreateSessionMcpRuntime } from "../mcp/bundle-mcp-runtime.js";
+//#region src/agent/external-tools/mcp-provider.ts
+function policyToolId(tool) {
+	return mcpToolPolicyId(tool.safeServerName, tool.toolName);
+}
+function toAgentToolResult(params) {
+	const content = Array.isArray(params.result.content) ? params.result.content : [];
+	return {
+		content: content.length > 0 ? content : [{
+			type: "text",
+			text: JSON.stringify(params.result.structuredContent ?? {
+				status: params.result.isError === true ? "error" : "ok",
+				server: params.serverName,
+				tool: params.toolName
+			}, null, 2)
+		}],
+		details: {
+			mcpServer: params.serverName,
+			mcpTool: params.toolName,
+			...params.result.structuredContent !== void 0 ? { structuredContent: params.result.structuredContent } : {},
+			...params.result.isError === true ? { status: "error" } : {}
+		}
+	};
+}
+var McpToolProvider = class {
+	source = "mcp";
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async search(_query) {
+		return this.withRuntime(async (runtime) => {
+			return (await runtime.getCatalog()).tools.filter((tool) => this.isAllowed(tool)).map((tool) => ({
+				toolRef: externalToolRef(this.source, tool.serverName, tool.toolName),
+				source: this.source,
+				namespace: tool.serverName,
+				title: tool.title || tool.toolName,
+				summary: tool.description || tool.fallbackDescription
+			}));
+		});
+	}
+	async describe(toolRef) {
+		return this.withRuntime(async (runtime) => {
+			const tool = await this.resolve(runtime, toolRef);
+			if (!tool) return void 0;
+			const summary = tool.description || tool.fallbackDescription;
+			return {
+				toolRef,
+				source: this.source,
+				namespace: tool.serverName,
+				title: tool.title || tool.toolName,
+				summary,
+				description: summary,
+				inputSchema: tool.inputSchema
+			};
+		});
+	}
+	async execute(toolRef, args, _approvalId, context) {
+		return this.withRuntime(async (runtime) => {
+			const tool = await this.resolve(runtime, toolRef);
+			if (!tool) throw new Error(`MCP tool is unavailable or denied: ${toolRef}`);
+			let executionArgs = args;
+			if (this.deps.hookRunner) {
+				const hook = await this.deps.hookRunner.runBeforeToolCall(policyToolId(tool), args, {
+					sessionKey: this.deps.getSessionKey(),
+					isMcpTool: true,
+					mcpServerId: tool.serverName
+				});
+				if (!hook.allowed) throw new Error(hook.reason ?? "MCP tool call blocked by policy hook.");
+				executionArgs = hook.params ?? args;
+			}
+			const result = await runtime.callTool(tool.serverName, tool.toolName, executionArgs, context.signal);
+			return toAgentToolResult({
+				serverName: tool.serverName,
+				toolName: tool.toolName,
+				result
+			});
+		});
+	}
+	async resolve(runtime, toolRef) {
+		const parsed = parseExternalToolRef(toolRef, this.source);
+		if (!parsed) return void 0;
+		const tool = (await runtime.getCatalog()).tools.find((candidate) => candidate.serverName === parsed.namespace && candidate.toolName === parsed.toolName);
+		return tool && this.isAllowed(tool) ? tool : void 0;
+	}
+	isAllowed(tool) {
+		const cfg = this.deps.getConfig();
+		const sessionKey = this.deps.getSessionKey();
+		const profile = cfg && sessionKey ? resolveEffectiveAgentProfileForSession(cfg, sessionKey) : void 0;
+		const policyName = policyToolId(tool);
+		return !profile?.tools.denied.has(policyName) && !isMcpCatalogToolDenied({
+			serverId: tool.safeServerName,
+			policyToolId: policyName
+		}, profile?.manifest.tools.mcp);
+	}
+	async withRuntime(run) {
+		const cfg = this.deps.getConfig();
+		const sessionKey = this.deps.getSessionKey();
+		const sessionId = sessionKey ?? `agent:${this.deps.agentId ?? "main"}`;
+		const runtime = await (this.deps.getRuntime ?? getOrCreateSessionMcpRuntime)({
+			sessionId,
+			sessionKey,
+			workspaceDir: this.deps.workspace,
+			cfg
+		});
+		const releaseLease = runtime.acquireLease?.();
+		runtime.markUsed();
+		try {
+			return await run(runtime);
+		} finally {
+			releaseLease?.();
+		}
+	}
+};
+//#endregion
+export { McpToolProvider };

package/dist/src/agent/external-tools/memory-provider.d.ts

@@ -0,0 +1,21 @@
+import type { ExtensionHookRunner } from '../../extensions/index.js';
+import type { MemoryManager } from '../memory/manager.js';
+import { type ToolExecutorConfig } from '../tools/executor.js';
+import type { ExternalToolDescriptor, ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit } from './types.js';
+export interface MemoryToolProviderDeps {
+    getMemoryManager?: () => MemoryManager;
+    disabledTools?: Set<string>;
+    getSessionKey: () => string | undefined;
+    hookRunner?: ExtensionHookRunner;
+    toolExecutorConfig?: Partial<ToolExecutorConfig>;
+}
+export declare class MemoryToolProvider implements ExternalToolProvider {
+    private readonly deps;
+    readonly source: "memory";
+    constructor(deps: MemoryToolProviderDeps);
+    search(_query: string): Promise<ExternalToolSearchHit[]>;
+    describe(toolRef: string): Promise<ExternalToolDescriptor | undefined>;
+    execute(toolRef: string, args: Record<string, unknown>, _approvalId: string | undefined, context: ExternalToolExecutionContext): Promise<import("@earendil-works/pi-agent-core").AgentToolResult<any>>;
+    private entries;
+    private resolve;
+}

package/dist/src/agent/external-tools/memory-provider.js

@@ -0,0 +1,56 @@
+import { externalToolRef, parseExternalToolRef } from "./refs.js";
+import { executeToolWithProtection } from "../tools/executor.js";
+//#region src/agent/external-tools/memory-provider.ts
+function toolSummary(tool) {
+	return tool.description || tool.label || tool.name;
+}
+var MemoryToolProvider = class {
+	source = "memory";
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async search(_query) {
+		return this.entries().map(({ providerId, tool }) => ({
+			toolRef: externalToolRef(this.source, providerId, tool.name),
+			source: this.source,
+			namespace: providerId,
+			title: tool.label || tool.name,
+			summary: toolSummary(tool)
+		}));
+	}
+	async describe(toolRef) {
+		const resolved = this.resolve(toolRef);
+		if (!resolved) return void 0;
+		const summary = toolSummary(resolved.tool);
+		return {
+			toolRef,
+			source: this.source,
+			namespace: resolved.providerId,
+			title: resolved.tool.label || resolved.tool.name,
+			summary,
+			description: summary,
+			inputSchema: resolved.tool.parameters
+		};
+	}
+	async execute(toolRef, args, _approvalId, context) {
+		const resolved = this.resolve(toolRef);
+		if (!resolved) throw new Error(`Memory provider tool is unavailable: ${toolRef}`);
+		let executionArgs = args;
+		if (this.deps.hookRunner) {
+			const hook = await this.deps.hookRunner.runBeforeToolCall(resolved.tool.name, args, { sessionKey: this.deps.getSessionKey() });
+			if (!hook.allowed) throw new Error(hook.reason ?? "Memory provider tool call blocked by policy hook.");
+			executionArgs = hook.params ?? args;
+		}
+		return executeToolWithProtection(resolved.tool, context.toolCallId, executionArgs, context.signal, context.onUpdate, this.deps.toolExecutorConfig);
+	}
+	entries() {
+		return (this.deps.getMemoryManager?.().getExternalToolEntries() ?? []).filter(({ tool }) => !this.deps.disabledTools?.has(tool.name));
+	}
+	resolve(toolRef) {
+		const parsed = parseExternalToolRef(toolRef, this.source);
+		if (!parsed) return void 0;
+		return this.entries().find(({ providerId, tool }) => providerId === parsed.namespace && tool.name === parsed.toolName);
+	}
+};
+//#endregion
+export { MemoryToolProvider };

package/dist/src/agent/external-tools/refs.d.ts

@@ -0,0 +1,5 @@
+export declare function externalToolRef(source: string, namespace: string, toolName: string): string;
+export declare function parseExternalToolRef(toolRef: string, expectedSource: string): {
+    namespace: string;
+    toolName: string;
+} | undefined;

package/dist/src/agent/external-tools/refs.js

@@ -0,0 +1,18 @@
+//#region src/agent/external-tools/refs.ts
+function externalToolRef(source, namespace, toolName) {
+	return `${source}:${encodeURIComponent(namespace)}:${encodeURIComponent(toolName)}`;
+}
+function parseExternalToolRef(toolRef, expectedSource) {
+	const parts = toolRef.split(":");
+	if (parts.length !== 3 || parts[0] !== expectedSource) return void 0;
+	try {
+		return {
+			namespace: decodeURIComponent(parts[1]),
+			toolName: decodeURIComponent(parts[2])
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { externalToolRef, parseExternalToolRef };

package/dist/src/agent/external-tools/service.d.ts

@@ -0,0 +1,26 @@
+import type { ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit, ExternalToolSource, VersionedExternalToolDescriptor } from './types.js';
+export declare class ExternalToolService {
+    private readonly providerBySource;
+    private readonly ajv;
+    constructor(providers: ExternalToolProvider[]);
+    search(params: {
+        query: string;
+        sources?: ExternalToolSource[];
+        limit?: number;
+    }): Promise<{
+        tools: ExternalToolSearchHit[];
+        unavailableSources: ExternalToolSource[];
+    }>;
+    describe(toolRefs: string[]): Promise<{
+        tools: VersionedExternalToolDescriptor[];
+        notFound: string[];
+    }>;
+    execute(params: {
+        toolRef: string;
+        revision: string;
+        arguments?: Record<string, unknown>;
+        approvalId?: string;
+        context: ExternalToolExecutionContext;
+    }): Promise<import("@earendil-works/pi-agent-core").AgentToolResult<Record<string, unknown>>>;
+    private providerForRef;
+}

package/dist/src/agent/external-tools/service.js

@@ -0,0 +1,117 @@
+import crypto from "node:crypto";
+import Ajv2020 from "ajv/dist/2020.js";
+//#region src/agent/external-tools/service.ts
+const DEFAULT_SEARCH_LIMIT = 8;
+const MAX_SEARCH_LIMIT = 20;
+const MAX_DESCRIBE_COUNT = 3;
+const MAX_DESCRIPTOR_BYTES = 64 * 1024;
+function normalizedTokens(value) {
+	return value.toLowerCase().split(/[^\p{L}\p{N}_-]+/u).filter(Boolean);
+}
+function relevanceScore(hit, query) {
+	const haystack = `${hit.title} ${hit.summary} ${hit.namespace}`.toLowerCase();
+	const tokens = normalizedTokens(query);
+	if (tokens.length === 0) return 0;
+	return tokens.reduce((score, token) => {
+		if (hit.title.toLowerCase() === token) return score + 8;
+		if (hit.title.toLowerCase().includes(token)) return score + 4;
+		return haystack.includes(token) ? score + 1 : score;
+	}, 0);
+}
+function descriptorRevision(descriptor) {
+	return crypto.createHash("sha256").update(JSON.stringify({
+		toolRef: descriptor.toolRef,
+		description: descriptor.description,
+		inputSchema: descriptor.inputSchema
+	})).digest("hex").slice(0, 16);
+}
+function versionDescriptor(descriptor) {
+	return {
+		...descriptor,
+		revision: descriptorRevision(descriptor)
+	};
+}
+var ExternalToolService = class {
+	providerBySource;
+	ajv = new Ajv2020({
+		allErrors: true,
+		strict: false,
+		validateFormats: false,
+		validateSchema: false
+	});
+	constructor(providers) {
+		this.providerBySource = new Map(providers.map((provider) => [provider.source, provider]));
+	}
+	async search(params) {
+		const selected = params.sources?.length ? params.sources.map((source) => this.providerBySource.get(source)).filter((provider) => provider !== void 0) : [...this.providerBySource.values()];
+		const settled = await Promise.allSettled(selected.map(async (provider) => ({
+			provider,
+			hits: await provider.search(params.query)
+		})));
+		const unavailableSources = [];
+		const hits = [];
+		for (const [index, result] of settled.entries()) if (result.status === "fulfilled") hits.push(...result.value.hits);
+		else {
+			const provider = selected[index];
+			if (provider) unavailableSources.push(provider.source);
+		}
+		const limit = Math.min(MAX_SEARCH_LIMIT, Math.max(1, params.limit ?? DEFAULT_SEARCH_LIMIT));
+		return {
+			tools: hits.map((hit) => ({
+				hit,
+				score: relevanceScore(hit, params.query)
+			})).filter((entry) => entry.score > 0 || normalizedTokens(params.query).length === 0).toSorted((left, right) => right.score - left.score || left.hit.toolRef.localeCompare(right.hit.toolRef)).slice(0, limit).map(({ hit }) => ({
+				toolRef: hit.toolRef,
+				source: hit.source,
+				namespace: hit.namespace,
+				title: hit.title,
+				summary: hit.summary.slice(0, 300)
+			})),
+			unavailableSources
+		};
+	}
+	async describe(toolRefs) {
+		if (toolRefs.length === 0 || toolRefs.length > MAX_DESCRIBE_COUNT) throw new Error(`Describe between 1 and ${MAX_DESCRIBE_COUNT} tools per call.`);
+		const tools = [];
+		const notFound = [];
+		for (const toolRef of toolRefs) {
+			const provider = this.providerForRef(toolRef);
+			const descriptor = provider ? await provider.describe(toolRef) : void 0;
+			if (!descriptor) {
+				notFound.push(toolRef);
+				continue;
+			}
+			const versioned = versionDescriptor(descriptor);
+			if (Buffer.byteLength(JSON.stringify(versioned), "utf8") > MAX_DESCRIPTOR_BYTES) throw new Error(`Tool contract is too large to expose safely: ${toolRef}`);
+			tools.push(versioned);
+		}
+		return {
+			tools,
+			notFound
+		};
+	}
+	async execute(params) {
+		const provider = this.providerForRef(params.toolRef);
+		if (!provider) throw new Error(`Unknown external tool source: ${params.toolRef}`);
+		const descriptor = await provider.describe(params.toolRef);
+		if (!descriptor) throw new Error(`External tool is unavailable: ${params.toolRef}`);
+		const current = versionDescriptor(descriptor);
+		if (current.revision !== params.revision) throw new Error(`Tool contract changed. Describe ${params.toolRef} again before executing it.`);
+		const args = params.arguments ?? {};
+		let validate;
+		try {
+			validate = this.ajv.compile(current.inputSchema);
+		} catch (error) {
+			throw new Error(`Tool contract is invalid: ${params.toolRef}`, { cause: error });
+		}
+		if (!validate(args)) throw new Error(`Arguments do not match ${params.toolRef}: ${this.ajv.errorsText(validate.errors)}`);
+		return provider.execute(params.toolRef, args, params.approvalId, params.context);
+	}
+	providerForRef(toolRef) {
+		const separator = toolRef.indexOf(":");
+		if (separator <= 0) return void 0;
+		return this.providerBySource.get(toolRef.slice(0, separator));
+	}
+};
+//#endregion
+export { ExternalToolService };

package/dist/src/agent/external-tools/types.d.ts

@@ -0,0 +1,35 @@
+import type { AgentToolResult, AgentToolUpdateCallback } from '@earendil-works/pi-agent-core';
+import type { TurnOrigin } from '@xopcai/endpoint-tools-protocol';
+export declare const EXTERNAL_TOOL_SOURCES: readonly ["mcp", "composio", "extension", "memory", "endpoint"];
+export type ExternalToolSource = (typeof EXTERNAL_TOOL_SOURCES)[number];
+export interface ExternalToolSearchHit {
+    toolRef: string;
+    source: ExternalToolSource;
+    namespace: string;
+    title: string;
+    summary: string;
+}
+export interface ExternalToolDescriptor extends ExternalToolSearchHit {
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface VersionedExternalToolDescriptor extends ExternalToolDescriptor {
+    revision: string;
+}
+export interface ExternalToolExecutionContext {
+    toolCallId: string;
+    signal?: AbortSignal;
+    onUpdate?: AgentToolUpdateCallback<Record<string, unknown>>;
+}
+export interface ExternalToolTurnContext {
+    channel: string;
+    chatId: string;
+    sessionKey: string;
+    origin: TurnOrigin;
+}
+export interface ExternalToolProvider {
+    readonly source: ExternalToolSource;
+    search(query: string): Promise<ExternalToolSearchHit[]>;
+    describe(toolRef: string): Promise<ExternalToolDescriptor | undefined>;
+    execute(toolRef: string, args: Record<string, unknown>, approvalId: string | undefined, context: ExternalToolExecutionContext): Promise<AgentToolResult<Record<string, unknown>>>;
+}

package/dist/src/agent/external-tools/types.js

@@ -0,0 +1,10 @@
+//#region src/agent/external-tools/types.ts
+const EXTERNAL_TOOL_SOURCES = [
+	"mcp",
+	"composio",
+	"extension",
+	"memory",
+	"endpoint"
+];
+//#endregion
+export { EXTERNAL_TOOL_SOURCES };

package/dist/src/agent/inbound/inbound-loop.d.ts

@@ -23,7 +23,6 @@ import type { CommandHandler, OutboundCoordinator, StreamManager } from '../mess
 import type { MessageRouter } from '../messaging/message-router.js';
 import type { ModelManager } from '../models/index.js';
 import type { SessionContextManager, SessionHydrator, SessionLifecycleManager, SessionStateBag } from '../session/index.js';
-import type { FeedbackCoordinator } from '../feedback/index.js';
 import type { HookHandler } from '../lifecycle/hook-handler.js';
 import type { SessionStore } from '../../session/store.js';
 import type { StreamHandle } from '../service.types.js';
@@ -35,7 +34,6 @@ export interface InboundLoopConfig {
     messageRouter: MessageRouter;
     commandHandler: CommandHandler;
     sessionContextManager: SessionContextManager;
-    feedbackCoordinator: FeedbackCoordinator;
     agentManager: AgentManager;
     sessionLifecycleManager: SessionLifecycleManager;
     agentOrchestrator: AgentOrchestrator;

package/dist/src/agent/inbound/inbound-loop.js

@@ -83,6 +83,10 @@ var InboundLoop = class {
 				chatId: context.chatId,
 				senderId: context.senderId || "",
 				isGroup: context.isGroup || false,
+				origin: {
+					type: "channel",
+					channel: context.channel
+				},
 				metadata: { transcribedVoice: msg.metadata?.transcribedVoice === true }
 			};
 			const sessionMetadata = await this.cfg.sessionStore.getMetadata(sessionContext.sessionKey).catch(() => null);
@@ -91,7 +95,6 @@ var InboundLoop = class {
 				...sessionMetadata?.sessionId ? { sessionId: sessionMetadata.sessionId } : {}
 			});
 			await this.cfg.sessionContextManager.runWith(sessionContext, async () => {
-				this.cfg.feedbackCoordinator.setContext(sessionContext);
 				this.cfg.agentManager.getOrCreateAgent(sessionContext.sessionKey);
 				this.cfg.setupSessionEventHandling(sessionContext.sessionKey);
 				await this.cfg.sessionLifecycleManager.startSession(sessionContext);
@@ -196,8 +199,6 @@ var InboundLoop = class {
 						}
 						this.cfg.sessionState.endInboundTurn(sessionContext.sessionKey);
 					}
-					this.cfg.feedbackCoordinator.endTask();
-					this.cfg.feedbackCoordinator.clearContext();
 				}
 			});
 		});

package/dist/src/agent/inbound/turn-dispatcher.d.ts

@@ -4,7 +4,7 @@
  * Wraps the two existing direct-turn runners (one-shot and streaming) so the
  * parent `AgentService` no longer carries a pair of huge `createXxxDeps()`
  * factories. The public surface — `processDirect`, `processDirectStreaming`,
- * `steerWebchatSession`, `enqueueWebchatSseEvent`,
+ * `steerWebchatSession`, `enqueueWebchatStreamEvent`,
  * `notifyWebchatTranscriptAppend` — matches what `AgentService` exposed
  * previously, so callers (gateway, CLI) are unchanged.
  *
@@ -14,6 +14,7 @@
  * that wires those dependencies together; individual responsibilities now live
  * in their own classes and are unit-testable.
  */
+import type { TurnOrigin } from '@xopcai/endpoint-tools-protocol';
 import type { Config } from '../../config/schema.js';
 import type { ContextualLogger } from '../../utils/logger/types.js';
 import type { AgentManager } from '../agent-manager.js';
@@ -23,7 +24,7 @@ import type { SessionConfigStore } from '../../session/index.js';
 import type { SessionStore } from '../../session/store.js';
 import type { SessionContext, SessionHydrator, SessionStateBag } from '../session/index.js';
 import type { InboundAttachmentInput, MediaRef } from '../../channels/attachments/inbound-persist.js';
-import { type ProcessDirectStreamingSseEvent } from '../service/process-direct-streaming.js';
+import { type ProcessDirectStreamEvent } from '../service/process-direct-streaming.js';
 import type { AgentSourceContextResolver } from '../source-context/types.js';
 export interface TurnDispatcherConfig {
     log: ContextualLogger;
@@ -41,7 +42,7 @@ export interface TurnDispatcherConfig {
         chatId: string;
     }>;
     /** Establish per-session context (also creates the Agent + subscribes to events). */
-    initSessionContext: (sessionKey: string, channel: string, chatId: string) => SessionContext;
+    initSessionContext: (sessionKey: string, channel: string, chatId: string, origin: TurnOrigin) => SessionContext;
     /** Per-session config hydration: workspace, model, thinking. */
     sessionHydrator: SessionHydrator;
     prepareInboundAttachments: (sessionKey: string, attachments?: InboundAttachmentInput[]) => Promise<MediaRef[] | undefined>;
@@ -67,14 +68,14 @@ export declare class TurnDispatcher {
     private readonly log;
     constructor(cfg: TurnDispatcherConfig);
     /** One-shot direct turn (CLI / embedded TUI). */
-    processDirect(content: string, sessionKey?: string, attachments?: DirectAttachment[], thinking?: string, options?: ProcessDirectOptions): Promise<string>;
-    /** Streaming direct turn (webchat SSE / CLI streaming). */
-    processDirectStreaming(content: string, sessionKey?: string, attachments?: DirectAttachment[], thinking?: string, options?: {
+    processDirect(content: string, sessionKey: string, origin: TurnOrigin, attachments?: DirectAttachment[], thinking?: string, options?: ProcessDirectOptions): Promise<string>;
+    /** Streaming direct turn (webchat realtime / CLI streaming). */
+    processDirectStreaming(content: string, sessionKey: string, origin: TurnOrigin, attachments?: DirectAttachment[], thinking?: string, options?: {
         signal?: AbortSignal;
         runId?: string;
-    }): AsyncGenerator<ProcessDirectStreamingSseEvent, void, unknown>;
+    }): AsyncGenerator<ProcessDirectStreamEvent, void, unknown>;
     /** Push an out-of-band event into the live webchat stream for a session. */
-    enqueueWebchatSseEvent(sessionKey: string, event: {
+    enqueueWebchatStreamEvent(sessionKey: string, event: {
         type: string;
         [key: string]: unknown;
     }): void;

package/dist/src/agent/inbound/turn-dispatcher.js

@@ -12,10 +12,11 @@ var TurnDispatcher = class {
 		this.log = cfg.log;
 	}
 	/** One-shot direct turn (CLI / embedded TUI). */
-	processDirect(content, sessionKey = "agent:main:main", attachments, thinking, options) {
+	processDirect(content, sessionKey, origin, attachments, thinking, options) {
 		return runProcessDirect(this.buildOneShotDeps(), {
 			content,
 			sessionKey,
+			origin,
 			attachments,
 			thinking,
 			signal: options?.signal,
@@ -23,11 +24,12 @@ var TurnDispatcher = class {
 			deadlineAtMs: options?.deadlineAtMs
 		});
 	}
-	/** Streaming direct turn (webchat SSE / CLI streaming). */
-	async *processDirectStreaming(content, sessionKey = "agent:main:main", attachments, thinking, options) {
+	/** Streaming direct turn (webchat realtime / CLI streaming). */
+	async *processDirectStreaming(content, sessionKey, origin, attachments, thinking, options) {
 		yield* runProcessDirectStreaming(this.buildStreamingDeps(), {
 			content,
 			sessionKey,
+			origin,
 			attachments,
 			thinking,
 			signal: options?.signal,
@@ -35,7 +37,7 @@ var TurnDispatcher = class {
 		});
 	}
 	/** Push an out-of-band event into the live webchat stream for a session. */
-	enqueueWebchatSseEvent(sessionKey, event) {
+	enqueueWebchatStreamEvent(sessionKey, event) {
 		const pub = this.cfg.sessionState.getWebchatPublisher(sessionKey);
 		if (pub) pub(event);
 	}
@@ -51,15 +53,15 @@ var TurnDispatcher = class {
 				}],
 				timestamp: Date.now()
 			};
-			this.enqueueWebchatSseEvent(sessionKey, {
+			this.enqueueWebchatStreamEvent(sessionKey, {
 				type: "message_start",
 				message
 			});
-			this.enqueueWebchatSseEvent(sessionKey, {
+			this.enqueueWebchatStreamEvent(sessionKey, {
 				type: "message_update",
 				message
 			});
-			this.enqueueWebchatSseEvent(sessionKey, {
+			this.enqueueWebchatStreamEvent(sessionKey, {
 				type: "message_end",
 				message
 			});
@@ -90,8 +92,8 @@ var TurnDispatcher = class {
 			log: this.log,
 			resolveSessionEndpoint: c.resolveSessionEndpoint,
 			initDirectStreamingSession: c.initSessionContext,
-			registerWebchatSsePublisher: (sk, publisher) => c.sessionState.registerWebchatPublisher(sk, publisher),
-			unregisterWebchatSsePublisher: (sk) => c.sessionState.unregisterWebchatPublisher(sk),
+			registerWebchatStreamPublisher: (sk, publisher) => c.sessionState.registerWebchatPublisher(sk, publisher),
+			unregisterWebchatStreamPublisher: (sk) => c.sessionState.unregisterWebchatPublisher(sk),
 			agentManager: c.agentManager,
 			hydrateSessionWorkspaceFromStore: (sk) => c.sessionHydrator.workspace(sk),
 			hydrateSessionModelFromStore: (sk) => c.sessionHydrator.model(sk),
@@ -139,8 +141,8 @@ var TurnDispatcher = class {
 			log: this.log,
 			config: cfg,
 			resolveSessionEndpoint: c.resolveSessionEndpoint,
-			initSessionContext: (sk, channel, chatId) => {
-				c.initSessionContext(sk, channel, chatId);
+			initSessionContext: (sk, channel, chatId, origin) => {
+				c.initSessionContext(sk, channel, chatId, origin);
 			},
 			hydrateSessionWorkspaceFromStore: (sk) => c.sessionHydrator.workspace(sk),
 			hydrateSessionModelFromStore: (sk) => c.sessionHydrator.model(sk),

package/dist/src/agent/mcp/{bundle-mcp-materialize.d.ts → bundle-mcp-gateway.d.ts}

@@ -1,6 +1,4 @@
-import type { AgentTool as AnyAgentTool } from "@earendil-works/pi-agent-core";
-import type { Config } from "../../config/schema.js";
-import type { BundleMcpToolRuntime, SessionMcpRuntime } from "./bundle-mcp-types.js";
+import type { Config } from '../../config/schema.js';
 export type McpGatewayToolEntry = {
     name: string;
     shortName: string;
@@ -28,7 +26,6 @@ export type McpGatewayCapabilitySummary = {
     resources: McpGatewayResourceEntry[];
     prompts: McpGatewayPromptEntry[];
 };
-export declare function mapBundleMcpToolsForGateway(tools: AnyAgentTool[], serverId: string): McpGatewayToolEntry[];
 export declare function listBundleMcpServerToolsForGateway(params: {
     workspaceDir: string;
     cfg?: Config;
@@ -39,18 +36,3 @@ export declare function listBundleMcpServerCapabilitiesForGateway(params: {
     cfg?: Config;
     serverId: string;
 }): Promise<McpGatewayCapabilitySummary>;
-export declare function materializeBundleMcpToolsForRun(params: {
-    runtime: SessionMcpRuntime;
-    reservedToolNames?: Iterable<string>;
-    disposeRuntime?: () => Promise<void>;
-}): Promise<BundleMcpToolRuntime>;
-export declare function createBundleMcpToolRuntime(params: {
-    workspaceDir: string;
-    cfg?: Config;
-    reservedToolNames?: Iterable<string>;
-    createRuntime?: (params: {
-        sessionId: string;
-        workspaceDir: string;
-        cfg?: Config;
-    }) => SessionMcpRuntime;
-}): Promise<BundleMcpToolRuntime>;