@mastra/code-sdk 1.15.0-alpha.1 → 1.15.0-alpha.3

package/dist/factory/remote-session.d.ts

@@ -0,0 +1,210 @@
+import type { AgentControllerModeInfo } from '@mastra/client-js';
+import type { AgentControllerDisplayState, AgentControllerEventListener, AgentControllerRequestStateUpdater, AgentControllerThread, PermissionRules, Session } from '@mastra/core/agent-controller';
+import type { FactoryAddress } from './client.js';
+import { createFactoryClient } from './client.js';
+type RemoteHandle = ReturnType<ReturnType<ReturnType<typeof createFactoryClient>['getAgentController']>['session']>;
+type RemoteMode = AgentControllerModeInfo;
+type Files = Array<{
+    data: string;
+    mediaType: string;
+    filename?: string;
+}>;
+/**
+ * Stands in for an in-process `Session` while the agent, tools, and storage
+ * run inside a Factory. Reads are served from state mirrored off the session's
+ * event stream; every action is forwarded to the Factory over HTTP.
+ *
+ * Only the surface the TUI drives is implemented. Anything else resolves to a
+ * no-op so local-only features (thread locks, grants) degrade instead of crash.
+ */
+export declare class RemoteSession {
+    #private;
+    constructor(address: FactoryAddress, resourceId: string, remote?: RemoteHandle);
+    /** Create/resume the remote session, hydrate the mirror, and open the event stream. */
+    connect(): Promise<void>;
+    /** Modes come from the controller; used to resolve the current mode's name and color. */
+    setModes(modes: RemoteMode[]): void;
+    disconnect(): void;
+    subscribe(listener: AgentControllerEventListener): () => void;
+    onBeforeAgentEnd(): () => void;
+    readonly identity: {
+        getResourceId: () => string;
+        getDefaultResourceId: () => string;
+        getId: () => string;
+        getOwnerId: () => string;
+        setResourceId: () => void;
+    };
+    readonly thread: {
+        getId: () => string | null;
+        isSet: () => boolean;
+        requireId: () => string;
+        ensureId: () => Promise<string>;
+        list: () => Promise<AgentControllerThread[]>;
+        getById: ({ threadId }: {
+            threadId: string;
+        }) => Promise<AgentControllerThread | null>;
+        create: ({ title }?: {
+            title?: string;
+        }) => Promise<AgentControllerThread>;
+        switch: ({ threadId }: {
+            threadId: string;
+        }) => Promise<void>;
+        clone: ({ sourceThreadId, title }?: {
+            sourceThreadId?: string;
+            title?: string;
+        }) => Promise<AgentControllerThread>;
+        rename: ({ title }: {
+            title: string;
+        }) => Promise<void>;
+        delete: ({ threadId }: {
+            threadId: string;
+        }) => Promise<void>;
+        listMessages: ({ threadId, limit }: {
+            threadId: string;
+            limit?: number;
+        }) => Promise<import("@mastra/client-js").MastraDBMessage[]>;
+        listActiveMessages: ({ limit }?: {
+            limit?: number;
+        }) => Promise<never[] | import("@mastra/client-js").MastraDBMessage[]>;
+        firstUserMessage: () => Promise<null>;
+        firstUserMessages: () => Promise<Map<any, any>>;
+        getSetting: () => Promise<undefined>;
+        getSettingOn: () => Promise<undefined>;
+        setSetting: () => Promise<void>;
+        setSettingOn: () => Promise<void>;
+        deleteSetting: () => Promise<void>;
+        cleanupSubscription: () => void;
+        detachFromCurrent: () => void;
+        clear: () => void;
+        clearAndReleaseLock: () => Promise<void>;
+        cloneToCurrentResource: ({ sourceThreadId }: {
+            sourceThreadId: string;
+        }) => Promise<AgentControllerThread>;
+        loadMetadata: () => Promise<void>;
+    };
+    readonly mode: {
+        get: () => string;
+        hasSelection: () => boolean;
+        resolve: () => {
+            id: string;
+            name?: string | undefined | undefined;
+        };
+        set: ({ modeId }: {
+            modeId: string;
+        }) => void;
+        switch: ({ modeId }: {
+            modeId: string;
+        }) => Promise<void>;
+    };
+    readonly model: {
+        get: () => string;
+        hasSelection: () => boolean;
+        displayName: () => string;
+        set: ({ modelId }: {
+            modelId: string;
+        }) => void;
+        switch: (modelId: string, options?: {
+            thinkingLevel?: any;
+        }) => Promise<void>;
+        syncFromPersisted: () => Promise<void>;
+    };
+    readonly state: {
+        get: () => Record<string, unknown>;
+        set: (updates: Record<string, unknown>) => Promise<void>;
+        setIf: (updates: Record<string, unknown>, shouldApply: () => boolean) => Promise<boolean>;
+        update: <TResult>(updater: AgentControllerRequestStateUpdater<any, TResult>) => Promise<TResult>;
+    };
+    readonly displayState: {
+        get: () => AgentControllerDisplayState;
+        clearModifiedFiles: () => void;
+        restoreTasks: () => void;
+        clearPendingSuspensions: () => void;
+        deletePendingSuspension: () => void;
+        clearPendingApprovals: () => void;
+        resetThread: () => void;
+        apply: () => void;
+    };
+    readonly run: {
+        isRunning: () => boolean;
+        getRunId: () => null;
+        getTraceId: () => null;
+    };
+    readonly stream: {
+        isActive: () => boolean;
+        isOpen: () => boolean;
+    };
+    readonly suspensions: {
+        hasPending: () => boolean;
+        get: ({ toolCallId }: {
+            toolCallId: string;
+        }) => {
+            toolCallId: string;
+            toolName: string;
+            args: unknown;
+            suspendPayload: unknown;
+            resumeSchema?: string;
+            resourceId?: string;
+            threadId?: string;
+            runId?: string;
+        } | undefined;
+        has: ({ toolCallId }: {
+            toolCallId: string;
+        }) => boolean;
+        delete: () => void;
+    };
+    readonly permissions: {
+        getRules: () => PermissionRules;
+        setForCategory: ({ category, policy }: {
+            category: any;
+            policy: any;
+        }) => Promise<void>;
+        setForTool: ({ toolName, policy }: {
+            toolName: string;
+            policy: any;
+        }) => Promise<void>;
+    };
+    getCurrentRunId(): string | null;
+    getTags(): Record<string, string>;
+    getTokenUsage(): import("@mastra/core/harness").TokenUsage;
+    getGrants(): {
+        categories: never[];
+        tools: never[];
+    };
+    sendMessage({ content, files }: {
+        content: string;
+        files?: Files;
+    }): Promise<void>;
+    queueMessage({ content }: {
+        content: string;
+    }): Promise<void>;
+    sendSignal(input: Parameters<Session['sendSignal']>[0]): {
+        id: `${string}-${string}-${string}-${string}-${string}`;
+        type: "user";
+        accepted: Promise<{
+            accepted: true;
+        }>;
+        persisted: Promise<void>;
+    };
+    steer({ content }: {
+        content: string;
+    }): Promise<void>;
+    followUp({ content }: {
+        content: string;
+    }): Promise<void>;
+    respondToToolApproval({ decision, toolCallId, }: {
+        decision: 'approve' | 'decline' | 'always_allow_category';
+        toolCallId: string;
+    }): {
+        accepted: true;
+    };
+    respondToToolSuspension({ resumeData, toolCallId }: {
+        resumeData: unknown;
+        toolCallId?: string;
+    }): Promise<void>;
+    claimToolResponse(): boolean;
+    releaseToolResponse(): void;
+    abort(): void;
+    abortRun(): void;
+}
+export {};
+//# sourceMappingURL=remote-session.d.ts.map

package/dist/factory/remote-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-session.d.ts","sourceRoot":"","sources":["../../src/factory/remote-session.ts"],"names":[],"mappings":"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"}

package/dist/factory/remote-session.js

@@ -0,0 +1,416 @@
+import { createFactoryClient } from "./client.js";
+import { randomUUID } from "crypto";
+import { defaultDisplayState } from "@mastra/core/agent-controller";
+//#region src/factory/remote-session.ts
+const MAP_FIELDS = [
+	"activeTools",
+	"toolInputBuffers",
+	"pendingSuspensions",
+	"pendingApprovals",
+	"activeSubagents",
+	"modifiedFiles"
+];
+/** The wire flattens the display state's Maps to objects; restore them. */
+function hydrateDisplayState(wire) {
+	const state = {
+		...defaultDisplayState(),
+		...wire
+	};
+	for (const field of MAP_FIELDS) {
+		const value = wire[field];
+		state[field] = value instanceof Map ? value : new Map(Object.entries(value ?? {}));
+	}
+	return state;
+}
+/** The wire flattens errors to `{ name, message }`; restore them. */
+function hydrateEvent(event) {
+	const out = { ...event };
+	if (out.displayState && typeof out.displayState === "object") out.displayState = hydrateDisplayState(out.displayState);
+	const error = out.error;
+	if (error && typeof error === "object" && !(error instanceof Error)) out.error = Object.assign(new Error(error.message ?? "Remote error"), { name: error.name ?? "Error" });
+	return out;
+}
+function toThread(thread, resourceId) {
+	const date = (value) => value ? new Date(value) : /* @__PURE__ */ new Date();
+	return {
+		id: thread.id,
+		resourceId: thread.resourceId ?? resourceId,
+		title: thread.title ?? "",
+		createdAt: date(thread.createdAt),
+		updatedAt: date(thread.updatedAt)
+	};
+}
+/**
+* Stands in for an in-process `Session` while the agent, tools, and storage
+* run inside a Factory. Reads are served from state mirrored off the session's
+* event stream; every action is forwarded to the Factory over HTTP.
+*
+* Only the surface the TUI drives is implemented. Anything else resolves to a
+* no-op so local-only features (thread locks, grants) degrade instead of crash.
+*/
+var RemoteSession = class {
+	#remote;
+	#resourceId;
+	#listeners = /* @__PURE__ */ new Set();
+	#unsubscribe;
+	#threadId = null;
+	#modeId = "";
+	#modelId = "";
+	#running = false;
+	#state = {};
+	#displayState = defaultDisplayState();
+	#modes = [];
+	#permissionRules = {
+		categories: {},
+		tools: {}
+	};
+	#pendingUserIds = [];
+	#userIdMap = /* @__PURE__ */ new Map();
+	constructor(address, resourceId, remote) {
+		this.#resourceId = resourceId;
+		this.#remote = remote ?? createFactoryClient(address).getAgentController("code").session(resourceId);
+	}
+	/** Create/resume the remote session, hydrate the mirror, and open the event stream. */
+	async connect() {
+		await this.#remote.create();
+		await Promise.all([this.#hydrate(), this.#refreshPermissions()]);
+		const subscription = await this.#remote.subscribe({
+			reconnect: true,
+			onEvent: (event) => this.#receive(hydrateEvent(event)),
+			onReconnect: () => void this.#hydrate().catch(() => {})
+		});
+		this.#unsubscribe = subscription.unsubscribe;
+	}
+	/** Modes come from the controller; used to resolve the current mode's name and color. */
+	setModes(modes) {
+		this.#modes = modes;
+	}
+	disconnect() {
+		this.#unsubscribe?.();
+		this.#unsubscribe = void 0;
+	}
+	async #hydrate() {
+		const snapshot = await this.#remote.state();
+		this.#threadId = snapshot.threadId ?? null;
+		this.#modeId = snapshot.modeId;
+		this.#modelId = snapshot.modelId;
+		this.#running = Boolean(snapshot.running);
+		if (snapshot.settings) this.#state = {
+			...this.#state,
+			...snapshot.settings
+		};
+		this.#displayState = {
+			...this.#displayState,
+			...snapshot.tasks ? { tasks: snapshot.tasks } : {},
+			...snapshot.tokenUsage ? { tokenUsage: snapshot.tokenUsage } : {}
+		};
+	}
+	async #refreshPermissions() {
+		const rules = await this.#remote.getPermissions();
+		this.#permissionRules = {
+			categories: rules.categories ?? {},
+			tools: rules.tools ?? {}
+		};
+	}
+	/** Surface a failed remote command in the transcript instead of dropping it. */
+	#emitError(message) {
+		this.#receive({
+			type: "error",
+			error: new Error(message)
+		});
+	}
+	/**
+	* The TUI renders a user message as soon as it is sent, keyed by the id
+	* `sendSignal` returned. The Factory echoes it back under its own id, so map
+	* that echo onto the local id to keep it from rendering twice.
+	*/
+	#adoptLocalUserId(e) {
+		const message = e.message;
+		const isUser = message?.role === "user" || message?.role === "signal" && message.content?.metadata?.signal?.type === "user";
+		if (!message?.id || !isUser) return;
+		let localId = this.#userIdMap.get(message.id);
+		if (!localId && e.type === "message_start") {
+			localId = this.#pendingUserIds.shift();
+			if (localId) this.#userIdMap.set(message.id, localId);
+		}
+		if (localId) e.message = {
+			...message,
+			id: localId
+		};
+	}
+	#receive(event) {
+		const e = event;
+		if (e.type === "message_start" || e.type === "message_update" || e.type === "message_end") this.#adoptLocalUserId(e);
+		switch (e.type) {
+			case "mode_changed":
+				this.#modeId = e.modeId;
+				break;
+			case "model_changed":
+				this.#modelId = e.modelId;
+				break;
+			case "thread_changed":
+				this.#threadId = e.threadId;
+				break;
+			case "thread_created":
+				this.#threadId = e.thread.id;
+				break;
+			case "state_changed":
+				this.#state = {
+					...this.#state,
+					...e.state
+				};
+				break;
+			case "display_state_changed":
+				this.#displayState = e.displayState;
+				break;
+			case "agent_start":
+				this.#running = true;
+				break;
+			case "agent_end":
+				this.#running = false;
+				break;
+		}
+		for (const listener of this.#listeners) Promise.resolve(listener(event)).catch(() => {});
+	}
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	}
+	onBeforeAgentEnd() {
+		return () => {};
+	}
+	identity = {
+		getResourceId: () => this.#resourceId,
+		getDefaultResourceId: () => this.#resourceId,
+		getId: () => this.#resourceId,
+		getOwnerId: () => this.#resourceId,
+		setResourceId: () => {}
+	};
+	thread = (() => {
+		const remote = () => this.#remote;
+		const resourceId = this.#resourceId;
+		return {
+			getId: () => this.#threadId,
+			isSet: () => this.#threadId !== null,
+			requireId: () => {
+				if (!this.#threadId) throw new Error("No active thread");
+				return this.#threadId;
+			},
+			ensureId: async () => {
+				if (!this.#threadId) await this.thread.create();
+				return this.#threadId;
+			},
+			list: async () => (await remote().listThreads()).map((t) => toThread(t, resourceId)),
+			getById: async ({ threadId }) => (await this.thread.list()).find((t) => t.id === threadId) ?? null,
+			create: async ({ title } = {}) => {
+				const thread = toThread(await remote().createThread(title), resourceId);
+				this.#threadId = thread.id;
+				return thread;
+			},
+			switch: async ({ threadId }) => {
+				await remote().switchThread(threadId);
+				this.#threadId = threadId;
+			},
+			clone: async ({ sourceThreadId, title } = {}) => {
+				const thread = toThread(await remote().cloneThread({
+					sourceThreadId,
+					title
+				}), resourceId);
+				this.#threadId = thread.id;
+				return thread;
+			},
+			rename: async ({ title }) => {
+				if (this.#threadId) await remote().renameThread(this.#threadId, title);
+			},
+			delete: async ({ threadId }) => {
+				await remote().deleteThread(threadId);
+				if (this.#threadId === threadId) this.#threadId = null;
+			},
+			listMessages: ({ threadId, limit }) => remote().listMessages(threadId, limit),
+			listActiveMessages: async ({ limit } = {}) => this.#threadId ? remote().listMessages(this.#threadId, limit) : [],
+			firstUserMessage: async () => null,
+			firstUserMessages: async () => /* @__PURE__ */ new Map(),
+			getSetting: async () => void 0,
+			getSettingOn: async () => void 0,
+			setSetting: async () => {},
+			setSettingOn: async () => {},
+			deleteSetting: async () => {},
+			cleanupSubscription: () => {},
+			detachFromCurrent: () => {},
+			clear: () => {
+				this.#threadId = null;
+			},
+			clearAndReleaseLock: async () => {},
+			cloneToCurrentResource: async ({ sourceThreadId }) => this.thread.clone({ sourceThreadId }),
+			loadMetadata: async () => {}
+		};
+	})();
+	mode = {
+		get: () => this.#modeId,
+		hasSelection: () => Boolean(this.#modeId),
+		resolve: () => this.#modes.find((mode) => mode.id === this.#modeId) ?? {
+			id: this.#modeId,
+			name: this.#modeId
+		},
+		set: ({ modeId }) => {
+			this.#modeId = modeId;
+		},
+		switch: async ({ modeId }) => {
+			await this.#remote.switchMode(modeId);
+			this.#modeId = modeId;
+		}
+	};
+	model = {
+		get: () => this.#modelId,
+		hasSelection: () => Boolean(this.#modelId),
+		displayName: () => this.#modelId,
+		set: ({ modelId }) => {
+			this.#modelId = modelId;
+		},
+		switch: async (modelId, options = {}) => {
+			await this.#remote.switchModel(modelId, options);
+			this.#modelId = modelId;
+		},
+		syncFromPersisted: async () => {}
+	};
+	state = {
+		get: () => this.#state,
+		set: async (updates) => {
+			this.#state = {
+				...this.#state,
+				...updates
+			};
+			await this.#remote.setState(updates);
+		},
+		setIf: async (updates, shouldApply) => {
+			if (!shouldApply()) return false;
+			await this.state.set(updates);
+			return true;
+		},
+		update: async (updater) => {
+			const { updates, result } = await updater(this.#state);
+			if (updates) await this.state.set(updates);
+			return result;
+		}
+	};
+	displayState = {
+		get: () => this.#displayState,
+		clearModifiedFiles: () => {
+			this.#displayState = {
+				...this.#displayState,
+				modifiedFiles: /* @__PURE__ */ new Map()
+			};
+		},
+		restoreTasks: () => {},
+		clearPendingSuspensions: () => {},
+		deletePendingSuspension: () => {},
+		clearPendingApprovals: () => {},
+		resetThread: () => {},
+		apply: () => {}
+	};
+	run = {
+		isRunning: () => this.#running,
+		getRunId: () => null,
+		getTraceId: () => null
+	};
+	stream = {
+		isActive: () => this.#running,
+		isOpen: () => this.#running
+	};
+	suspensions = {
+		hasPending: () => this.#displayState.pendingSuspensions.size > 0,
+		get: ({ toolCallId }) => this.#displayState.pendingSuspensions.get(toolCallId),
+		has: ({ toolCallId }) => this.#displayState.pendingSuspensions.has(toolCallId),
+		delete: () => {}
+	};
+	permissions = {
+		getRules: () => this.#permissionRules,
+		setForCategory: async ({ category, policy }) => {
+			await this.#remote.setPermissionForCategory(category, policy);
+			await this.#refreshPermissions();
+		},
+		setForTool: async ({ toolName, policy }) => {
+			await this.#remote.setPermissionForTool(toolName, policy);
+			await this.#refreshPermissions();
+		}
+	};
+	getCurrentRunId() {
+		return null;
+	}
+	getTags() {
+		return {};
+	}
+	getTokenUsage() {
+		return this.#displayState.tokenUsage;
+	}
+	getGrants() {
+		return {
+			categories: [],
+			tools: []
+		};
+	}
+	async sendMessage({ content, files }) {
+		await this.#remote.sendMessage({
+			content,
+			files
+		});
+	}
+	async queueMessage({ content }) {
+		await this.#remote.followUp(content);
+	}
+	sendSignal(input) {
+		const content = "content" in input ? input.content : void 0;
+		const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => typeof part === "string" ? part : part?.text ?? "").join("") : JSON.stringify(content);
+		const files = "files" in input ? input.files : void 0;
+		const message = files?.length ? {
+			content: text,
+			files
+		} : text;
+		const id = randomUUID();
+		this.#pendingUserIds.push(id);
+		const sent = this.#running ? this.#remote.followUp(message) : this.#remote.sendMessage(message);
+		sent.catch(() => {
+			this.#pendingUserIds = this.#pendingUserIds.filter((pending) => pending !== id);
+		});
+		const accepted = sent.then(() => ({ accepted: true }));
+		accepted.catch(() => {});
+		return {
+			id,
+			type: "user",
+			accepted,
+			persisted: sent
+		};
+	}
+	async steer({ content }) {
+		await this.#remote.steer(content);
+	}
+	async followUp({ content }) {
+		await this.#remote.followUp(content);
+	}
+	respondToToolApproval({ decision, toolCallId }) {
+		(async () => {
+			const ack = await this.#remote.approveTool(toolCallId, decision !== "decline", { alwaysAllowCategory: decision === "always_allow_category" });
+			if (ack && "accepted" in ack && ack.accepted === false) this.#emitError(`Tool approval was not applied: ${ack.reason ?? "rejected"}`);
+		})().catch((error) => this.#emitError(`Tool approval failed: ${error instanceof Error ? error.message : String(error)}`));
+		return { accepted: true };
+	}
+	async respondToToolSuspension({ resumeData, toolCallId }) {
+		const id = toolCallId ?? this.#displayState.pendingSuspensions.keys().next().value;
+		if (!id) throw new Error("No pending tool suspension to respond to");
+		await this.#remote.respondToToolSuspension(id, resumeData);
+	}
+	claimToolResponse() {
+		return true;
+	}
+	releaseToolResponse() {}
+	abort() {
+		this.#remote.abort().catch((error) => this.#emitError(`Abort failed: ${error instanceof Error ? error.message : String(error)}`));
+	}
+	abortRun() {
+		this.abort();
+	}
+};
+//#endregion
+export { RemoteSession };
+
+//# sourceMappingURL=remote-session.js.map