@mariozechner/pi-web-ui 0.5.44 → 0.5.46

package/src/ChatPanel.ts

@@ -1,29 +1,29 @@
 import { Badge, html } from "@mariozechner/mini-lit";
-import { type AgentTool, getModel } from "@mariozechner/pi-ai";
 import { LitElement } from "lit";
-import { customElement, property, state } from "lit/decorators.js";
+import { customElement, state } from "lit/decorators.js";
+import type { Agent } from "./agent/agent.js";
 import "./components/AgentInterface.js";
-import { AgentSession, type AgentSessionState, type ThinkingLevel } from "./state/agent-session.js";
-import { ArtifactsPanel } from "./tools/artifacts/index.js";
-import { createJavaScriptReplTool } from "./tools/javascript-repl.js";
+import type { AgentTool } from "@mariozechner/pi-ai";
+import type { AgentInterface } from "./components/AgentInterface.js";
+import { ArtifactsRuntimeProvider } from "./components/sandbox/ArtifactsRuntimeProvider.js";
+import { AttachmentsRuntimeProvider } from "./components/sandbox/AttachmentsRuntimeProvider.js";
+import type { SandboxRuntimeProvider } from "./components/sandbox/SandboxRuntimeProvider.js";
+import { ArtifactsPanel, ArtifactsToolRenderer } from "./tools/artifacts/index.js";
 import { registerToolRenderer } from "./tools/renderer-registry.js";
-import { getAuthToken } from "./utils/auth-token.js";
+import type { Attachment } from "./utils/attachment-utils.js";
 import { i18n } from "./utils/i18n.js";
 
 const BREAKPOINT = 800; // px - switch between overlay and side-by-side
 
 @customElement("pi-chat-panel")
 export class ChatPanel extends LitElement {
-	@state() private session!: AgentSession;
-	@state() private artifactsPanel!: ArtifactsPanel;
+	@state() public agent?: Agent;
+	@state() public agentInterface?: AgentInterface;
+	@state() public artifactsPanel?: ArtifactsPanel;
 	@state() private hasArtifacts = false;
 	@state() private artifactCount = 0;
 	@state() private showArtifactsPanel = false;
-	@state() private windowWidth = window.innerWidth;
-	@property({ type: String }) systemPrompt = "You are a helpful AI assistant.";
-	@property({ type: Array }) additionalTools: AgentTool<any, any>[] = [];
-	@property({ attribute: false }) sandboxUrlProvider?: () => string;
-	@property({ attribute: false }) onApiKeyRequired?: (provider: string) => Promise<boolean>;
+	@state() private windowWidth = 0;
 
 	private resizeHandler = () => {
 		this.windowWidth = window.innerWidth;
@@ -34,64 +34,89 @@ export class ChatPanel extends LitElement {
 		return this;
 	}
 
-	override async connectedCallback() {
+	override connectedCallback() {
 		super.connectedCallback();
-
-		// Listen to window resize
+		this.windowWidth = window.innerWidth; // Set initial width after connection
 		window.addEventListener("resize", this.resizeHandler);
-
-		// Ensure panel fills height and allows flex layout
 		this.style.display = "flex";
 		this.style.flexDirection = "column";
 		this.style.height = "100%";
 		this.style.minHeight = "0";
+		// Update width after initial render
+		requestAnimationFrame(() => {
+			this.windowWidth = window.innerWidth;
+			this.requestUpdate();
+		});
+	}
 
-		// Create JavaScript REPL tool with attachments provider
-		const javascriptReplTool = createJavaScriptReplTool();
-		if (this.sandboxUrlProvider) {
-			javascriptReplTool.sandboxUrlProvider = this.sandboxUrlProvider;
-		}
+	override disconnectedCallback() {
+		super.disconnectedCallback();
+		window.removeEventListener("resize", this.resizeHandler);
+	}
+
+	async setAgent(
+		agent: Agent,
+		config?: {
+			onApiKeyRequired?: (provider: string) => Promise<boolean>;
+			onBeforeSend?: () => void | Promise<void>;
+			sandboxUrlProvider?: () => string;
+			toolsFactory?: (
+				agent: Agent,
+				agentInterface: AgentInterface,
+				artifactsPanel: ArtifactsPanel,
+				runtimeProvidersFactory: () => SandboxRuntimeProvider[],
+			) => AgentTool<any>[];
+		},
+	) {
+		this.agent = agent;
+
+		// Create AgentInterface
+		this.agentInterface = document.createElement("agent-interface") as AgentInterface;
+		this.agentInterface.session = agent;
+		this.agentInterface.enableAttachments = true;
+		this.agentInterface.enableModelSelector = true;
+		this.agentInterface.enableThinkingSelector = true;
+		this.agentInterface.showThemeToggle = false;
+		this.agentInterface.onApiKeyRequired = config?.onApiKeyRequired;
+		this.agentInterface.onBeforeSend = config?.onBeforeSend;
 
 		// Set up artifacts panel
 		this.artifactsPanel = new ArtifactsPanel();
-		if (this.sandboxUrlProvider) {
-			this.artifactsPanel.sandboxUrlProvider = this.sandboxUrlProvider;
+		this.artifactsPanel.agent = agent; // Pass agent for HTML artifact runtime providers
+		if (config?.sandboxUrlProvider) {
+			this.artifactsPanel.sandboxUrlProvider = config.sandboxUrlProvider;
 		}
-		registerToolRenderer("artifacts", this.artifactsPanel);
+		// Register the standalone tool renderer (not the panel itself)
+		registerToolRenderer("artifacts", new ArtifactsToolRenderer(this.artifactsPanel));
 
-		// Attachments provider for both REPL and artifacts
-		const getAttachments = () => {
-			// Get all attachments from conversation messages
-			const attachments: any[] = [];
-			for (const message of this.session.state.messages) {
+		// Runtime providers factory for REPL tools (read-write access)
+		const runtimeProvidersFactory = () => {
+			const attachments: Attachment[] = [];
+			for (const message of this.agent!.state.messages) {
 				if (message.role === "user") {
-					const content = Array.isArray(message.content) ? message.content : [message.content];
-					for (const block of content) {
-						if (typeof block !== "string" && block.type === "image") {
-							attachments.push({
-								id: `image-${attachments.length}`,
-								fileName: "image.png",
-								mimeType: block.mimeType || "image/png",
-								size: 0,
-								content: block.data,
-							});
-						}
-					}
+					message.attachments?.forEach((a) => {
+						attachments.push(a);
+					});
 				}
 			}
-			return attachments;
-		};
+			const providers: SandboxRuntimeProvider[] = [];
+
+			// Add attachments provider if there are attachments
+			if (attachments.length > 0) {
+				providers.push(new AttachmentsRuntimeProvider(attachments));
+			}
+
+			// Add artifacts provider with read-write access (for REPL)
+			providers.push(new ArtifactsRuntimeProvider(this.artifactsPanel!, this.agent!, true));
 
-		javascriptReplTool.attachmentsProvider = getAttachments;
-		this.artifactsPanel.attachmentsProvider = getAttachments;
+			return providers;
+		};
 
 		this.artifactsPanel.onArtifactsChange = () => {
-			const count = this.artifactsPanel.artifacts?.size ?? 0;
+			const count = this.artifactsPanel?.artifacts?.size ?? 0;
 			const created = count > this.artifactCount;
 			this.hasArtifacts = count > 0;
 			this.artifactCount = count;
-
-			// Auto-open when new artifacts are created
 			if (this.hasArtifacts && created) {
 				this.showArtifactsPanel = true;
 			}
@@ -108,48 +133,30 @@ export class ChatPanel extends LitElement {
 			this.requestUpdate();
 		};
 
-		const initialState = {
-			systemPrompt: this.systemPrompt,
-			model: getModel("anthropic", "claude-sonnet-4-5-20250929"),
-			tools: [...this.additionalTools, javascriptReplTool, this.artifactsPanel.tool],
-			thinkingLevel: "off" as ThinkingLevel,
-			messages: [],
-		} satisfies Partial<AgentSessionState>;
-		// initialState = { ...initialState, ...(simpleHtml as any) };
-		// initialState = { ...initialState, ...(longSession as any) };
-
-		// Create agent session first so attachments provider works
-		this.session = new AgentSession({
-			initialState,
-			authTokenProvider: async () => getAuthToken(),
-			transportMode: "provider", // Use provider mode by default (API keys from storage, optional CORS proxy)
-		});
+		// Set tools on the agent
+		// Pass runtimeProvidersFactory so consumers can configure their own REPL tools
+		const additionalTools =
+			config?.toolsFactory?.(agent, this.agentInterface, this.artifactsPanel, runtimeProvidersFactory) || [];
+		const tools = [this.artifactsPanel.tool, ...additionalTools];
+		this.agent.setTools(tools);
 
-		// Reconstruct artifacts panel from initial messages (session must exist first)
-		await this.artifactsPanel.reconstructFromMessages(initialState.messages);
-		this.hasArtifacts = this.artifactsPanel.artifacts.size > 0;
-	}
+		// Reconstruct artifacts from existing messages
+		// Temporarily disable the onArtifactsChange callback to prevent auto-opening on load
+		const originalCallback = this.artifactsPanel.onArtifactsChange;
+		this.artifactsPanel.onArtifactsChange = undefined;
+		await this.artifactsPanel.reconstructFromMessages(this.agent.state.messages);
+		this.artifactsPanel.onArtifactsChange = originalCallback;
 
-	override disconnectedCallback() {
-		super.disconnectedCallback();
-		window.removeEventListener("resize", this.resizeHandler);
-	}
+		this.hasArtifacts = this.artifactsPanel.artifacts.size > 0;
+		this.artifactCount = this.artifactsPanel.artifacts.size;
 
-	// Expose method to toggle artifacts panel
-	public toggleArtifactsPanel() {
-		this.showArtifactsPanel = !this.showArtifactsPanel;
 		this.requestUpdate();
 	}
 
-	// Check if artifacts panel is currently visible
-	public get artifactsPanelVisible(): boolean {
-		return this.showArtifactsPanel;
-	}
-
 	render() {
-		if (!this.session) {
+		if (!this.agent || !this.agentInterface) {
 			return html`<div class="flex items-center justify-center h-full">
-				<div class="text-muted-foreground">Loading...</div>
+				<div class="text-muted-foreground">No agent set</div>
 			</div>`;
 		}
 
@@ -164,15 +171,7 @@ export class ChatPanel extends LitElement {
 		return html`
 			<div class="relative w-full h-full overflow-hidden flex">
 				<div class="h-full" style="${!isMobile && this.showArtifactsPanel && this.hasArtifacts ? "width: 50%;" : "width: 100%;"}">
-						<agent-interface
-							.session=${this.session}
-							.enableAttachments=${true}
-							.enableModelSelector=${true}
-							.enableThinking=${true}
-							.showThemeToggle=${false}
-							.showDebugToggle=${false}
-							.onApiKeyRequired=${this.onApiKeyRequired}
-						></agent-interface>
+						${this.agentInterface}
 					</div>
 
 					<!-- Floating pill when artifacts exist and panel is collapsed -->
@@ -190,14 +189,7 @@ export class ChatPanel extends LitElement {
 									${Badge(html`
 										<span class="inline-flex items-center gap-1">
 											<span>${i18n("Artifacts")}</span>
-											${
-												this.artifactCount > 1
-													? html`<span
-														class="text-[10px] leading-none bg-primary-foreground/20 text-primary-foreground rounded px-1 font-mono tabular-nums"
-														>${this.artifactCount}</span
-													>`
-													: ""
-											}
+											<span class="text-[10px] leading-none bg-primary-foreground/20 text-primary-foreground rounded px-1 font-mono tabular-nums">${this.artifactCount}</span>
 										</span>
 									`)}
 								</button>

package/src/{state/agent-session.ts → agent/agent.ts}

@@ -1,4 +1,4 @@
-import type { Context } from "@mariozechner/pi-ai";
+import type { Context, QueuedMessage } from "@mariozechner/pi-ai";
 import {
 	type AgentTool,
 	type AssistantMessage as AssistantMessageType,
@@ -10,17 +10,31 @@ import {
 } from "@mariozechner/pi-ai";
 import type { AppMessage } from "../components/Messages.js";
 import type { Attachment } from "../utils/attachment-utils.js";
-import { AppTransport } from "./transports/AppTransport.js";
-import { ProviderTransport } from "./transports/ProviderTransport.js";
 import type { AgentRunConfig, AgentTransport } from "./transports/types.js";
 import type { DebugLogEntry } from "./types.js";
 
+// Default transformer: Keep only LLM-compatible messages, strip app-specific fields
+function defaultMessageTransformer(messages: AppMessage[]): Message[] {
+	return messages
+		.filter((m) => {
+			// Only keep standard LLM message roles
+			return m.role === "user" || m.role === "assistant" || m.role === "toolResult";
+		})
+		.map((m) => {
+			if (m.role === "user") {
+				// Strip attachments field (app-specific)
+				const { attachments, ...rest } = m as any;
+				return rest as Message;
+			}
+			return m as Message;
+		});
+}
+
 export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high";
 
-export interface AgentSessionState {
-	id: string;
+export interface AgentState {
 	systemPrompt: string;
-	model: Model<any> | null;
+	model: Model<any>;
 	thinkingLevel: ThinkingLevel;
 	tools: AgentTool<any>[];
 	messages: AppMessage[];
@@ -30,24 +44,23 @@ export interface AgentSessionState {
 	error?: string;
 }
 
-export type AgentSessionEvent =
-	| { type: "state-update"; state: AgentSessionState }
+export type AgentEvent =
+	| { type: "state-update"; state: AgentState }
 	| { type: "error-no-model" }
-	| { type: "error-no-api-key"; provider: string };
-
-export type TransportMode = "provider" | "app";
+	| { type: "error-no-api-key"; provider: string }
+	| { type: "started" }
+	| { type: "completed" };
 
-export interface AgentSessionOptions {
-	initialState?: Partial<AgentSessionState>;
-	messagePreprocessor?: (messages: AppMessage[]) => Promise<Message[]>;
+export interface AgentOptions {
+	initialState?: Partial<AgentState>;
 	debugListener?: (entry: DebugLogEntry) => void;
-	transportMode?: TransportMode;
-	authTokenProvider?: () => Promise<string | undefined>;
+	transport: AgentTransport;
+	// Transform app messages to LLM-compatible messages before sending to transport
+	messageTransformer?: (messages: AppMessage[]) => Message[] | Promise<Message[]>;
 }
 
-export class AgentSession {
-	private _state: AgentSessionState = {
-		id: "default",
+export class Agent {
+	private _state: AgentState = {
 		systemPrompt: "",
 		model: getModel("google", "gemini-2.5-flash-lite-preview-06-17"),
 		thinkingLevel: "off",
@@ -58,42 +71,25 @@ export class AgentSession {
 		pendingToolCalls: new Set<string>(),
 		error: undefined,
 	};
-	private listeners = new Set<(e: AgentSessionEvent) => void>();
+	private listeners = new Set<(e: AgentEvent) => void>();
 	private abortController?: AbortController;
 	private transport: AgentTransport;
-	private messagePreprocessor?: (messages: AppMessage[]) => Promise<Message[]>;
 	private debugListener?: (entry: DebugLogEntry) => void;
+	private messageTransformer: (messages: AppMessage[]) => Message[] | Promise<Message[]>;
+	private messageQueue: Array<QueuedMessage<AppMessage>> = [];
 
-	constructor(opts: AgentSessionOptions = {}) {
+	constructor(opts: AgentOptions) {
 		this._state = { ...this._state, ...opts.initialState };
-		this.messagePreprocessor = opts.messagePreprocessor;
 		this.debugListener = opts.debugListener;
-
-		const mode = opts.transportMode || "provider";
-
-		if (mode === "app") {
-			this.transport = new AppTransport(async () => this.preprocessMessages());
-		} else {
-			this.transport = new ProviderTransport(async () => this.preprocessMessages());
-		}
-	}
-
-	private async preprocessMessages(): Promise<Message[]> {
-		const filtered = this._state.messages.map((m) => {
-			if (m.role === "user") {
-				const { attachments, ...rest } = m as AppMessage & { attachments?: Attachment[] };
-				return rest;
-			}
-			return m;
-		});
-		return this.messagePreprocessor ? this.messagePreprocessor(filtered as AppMessage[]) : (filtered as Message[]);
+		this.transport = opts.transport;
+		this.messageTransformer = opts.messageTransformer || defaultMessageTransformer;
 	}
 
-	get state(): AgentSessionState {
+	get state(): AgentState {
 		return this._state;
 	}
 
-	subscribe(fn: (e: AgentSessionEvent) => void): () => void {
+	subscribe(fn: (e: AgentEvent) => void): () => void {
 		this.listeners.add(fn);
 		fn({ type: "state-update", state: this._state });
 		return () => this.listeners.delete(fn);
@@ -103,7 +99,7 @@ export class AgentSession {
 	setSystemPrompt(v: string) {
 		this.patch({ systemPrompt: v });
 	}
-	setModel(m: Model<any> | null) {
+	setModel(m: Model<any>) {
 		this.patch({ model: m });
 	}
 	setThinkingLevel(l: ThinkingLevel) {
@@ -118,6 +114,14 @@ export class AgentSession {
 	appendMessage(m: AppMessage) {
 		this.patch({ messages: [...this._state.messages, m] });
 	}
+	async queueMessage(m: AppMessage) {
+		// Transform message and queue it for injection at next turn
+		const transformed = await this.messageTransformer([m]);
+		this.messageQueue.push({
+			original: m,
+			llm: transformed[0], // undefined if filtered out
+		});
+	}
 	clearMessages() {
 		this.patch({ messages: [] });
 	}
@@ -126,6 +130,11 @@ export class AgentSession {
 		this.abortController?.abort();
 	}
 
+	private logState(message: string) {
+		const { systemPrompt, model, messages } = this._state;
+		console.log(message, { systemPrompt, model, messages });
+	}
+
 	async prompt(input: string, attachments?: Attachment[]) {
 		const model = this._state.model;
 		if (!model) {
@@ -157,6 +166,7 @@ export class AgentSession {
 
 		this.abortController = new AbortController();
 		this.patch({ isStreaming: true, streamMessage: null, error: undefined });
+		this.emit({ type: "started" });
 
 		const reasoning =
 			this._state.thinkingLevel === "off"
@@ -169,21 +179,38 @@ export class AgentSession {
 			tools: this._state.tools,
 			model,
 			reasoning,
+			getQueuedMessages: async <T>() => {
+				// Return queued messages (they'll be added to state via message_end event)
+				const queued = this.messageQueue.slice();
+				this.messageQueue = [];
+				return queued as QueuedMessage<T>[];
+			},
 		};
 
 		try {
 			let partial: Message | null = null;
 			let turnDebug: DebugLogEntry | null = null;
 			let turnStart = 0;
-			for await (const ev of this.transport.run(userMessage as Message, cfg, this.abortController.signal)) {
+
+			this.logState("prompt started, current state:");
+
+			// Transform app messages to LLM-compatible messages (initial set)
+			const llmMessages = await this.messageTransformer(this._state.messages);
+
+			console.log("transformed messages:", llmMessages);
+			for await (const ev of this.transport.run(
+				llmMessages,
+				userMessage as Message,
+				cfg,
+				this.abortController.signal,
+			)) {
 				switch (ev.type) {
 					case "turn_start": {
 						turnStart = performance.now();
-						// Build request context snapshot
-						const existing = this._state.messages as Message[];
+						// Build request context snapshot (use transformed messages)
 						const ctx: Context = {
 							systemPrompt: this._state.systemPrompt,
-							messages: [...existing],
+							messages: [...llmMessages],
 							tools: this._state.tools,
 						};
 						turnDebug = {
@@ -291,19 +318,17 @@ export class AgentSession {
 		} finally {
 			this.patch({ isStreaming: false, streamMessage: null, pendingToolCalls: new Set<string>() });
 			this.abortController = undefined;
+			this.emit({ type: "completed" });
 		}
-		{
-			const { systemPrompt, model, messages } = this._state;
-			console.log("final state:", { systemPrompt, model, messages });
-		}
+		this.logState("final state:");
 	}
 
-	private patch(p: Partial<AgentSessionState>): void {
+	private patch(p: Partial<AgentState>): void {
 		this._state = { ...this._state, ...p };
 		this.emit({ type: "state-update", state: this._state });
 	}
 
-	private emit(e: AgentSessionEvent) {
+	private emit(e: AgentEvent) {
 		for (const listener of this.listeners) {
 			listener(e);
 		}

package/src/{state → agent}/transports/AppTransport.ts

@@ -1,12 +1,12 @@
 import type {
 	AgentContext,
+	AgentLoopConfig,
 	Api,
 	AssistantMessage,
 	AssistantMessageEvent,
 	Context,
 	Message,
 	Model,
-	PromptConfig,
 	SimpleStreamOptions,
 	ToolCall,
 	UserMessage,
@@ -322,9 +322,7 @@ export class AppTransport implements AgentTransport {
 	// Hardcoded proxy URL for now - will be made configurable later
 	private readonly proxyUrl = "https://genai.mariozechner.at";
 
-	constructor(private readonly getMessages: () => Promise<Message[]>) {}
-
-	async *run(userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
+	async *run(messages: Message[], userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
 		const authToken = await getAuthToken();
 		if (!authToken) {
 			throw new Error(i18n("Auth token is required for proxy transport"));
@@ -343,15 +341,17 @@ export class AppTransport implements AgentTransport {
 			);
 		};
 
+		// Messages are already LLM-compatible (filtered by Agent)
 		const context: AgentContext = {
 			systemPrompt: cfg.systemPrompt,
-			messages: await this.getMessages(),
+			messages,
 			tools: cfg.tools,
 		};
 
-		const pc: PromptConfig = {
+		const pc: AgentLoopConfig = {
 			model: cfg.model,
 			reasoning: cfg.reasoning,
+			getQueuedMessages: cfg.getQueuedMessages,
 		};
 
 		// Yield events from the upstream agentLoop iterator

package/src/{state → agent}/transports/ProviderTransport.ts

@@ -1,4 +1,10 @@
-import { type AgentContext, agentLoop, type Message, type PromptConfig, type UserMessage } from "@mariozechner/pi-ai";
+import {
+	type AgentContext,
+	type AgentLoopConfig,
+	agentLoop,
+	type Message,
+	type UserMessage,
+} from "@mariozechner/pi-ai";
 import { getAppStorage } from "../../storage/app-storage.js";
 import type { AgentRunConfig, AgentTransport } from "./types.js";
 
@@ -7,11 +13,9 @@ import type { AgentRunConfig, AgentTransport } from "./types.js";
  * Optionally routes calls through a CORS proxy if enabled in settings.
  */
 export class ProviderTransport implements AgentTransport {
-	constructor(private readonly getMessages: () => Promise<Message[]>) {}
-
-	async *run(userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
+	async *run(messages: Message[], userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
 		// Get API key from storage
-		const apiKey = await getAppStorage().providerKeys.getKey(cfg.model.provider);
+		const apiKey = await getAppStorage().providerKeys.get(cfg.model.provider);
 		if (!apiKey) {
 			throw new Error("no-api-key");
 		}
@@ -29,16 +33,18 @@ export class ProviderTransport implements AgentTransport {
 			};
 		}
 
+		// Messages are already LLM-compatible (filtered by Agent)
 		const context: AgentContext = {
 			systemPrompt: cfg.systemPrompt,
-			messages: await this.getMessages(),
+			messages,
 			tools: cfg.tools,
 		};
 
-		const pc: PromptConfig = {
+		const pc: AgentLoopConfig = {
 			model,
 			reasoning: cfg.reasoning,
 			apiKey,
+			getQueuedMessages: cfg.getQueuedMessages,
 		};
 
 		// Yield events from agentLoop

package/src/{state → agent}/transports/types.ts

@@ -1,4 +1,4 @@
-import type { AgentEvent, AgentTool, Message, Model } from "@mariozechner/pi-ai";
+import type { AgentEvent, AgentTool, Message, Model, QueuedMessage } from "@mariozechner/pi-ai";
 
 // The minimal configuration needed to run a turn.
 export interface AgentRunConfig {
@@ -6,11 +6,17 @@ export interface AgentRunConfig {
 	tools: AgentTool<any>[];
 	model: Model<any>;
 	reasoning?: "low" | "medium" | "high";
+	getQueuedMessages?: <T>() => Promise<QueuedMessage<T>[]>;
 }
 
 // Events yielded by transports must match the @mariozechner/pi-ai prompt() events.
 // We re-export the Message type above; consumers should use the upstream AgentEvent type.
 
 export interface AgentTransport {
-	run(userMessage: Message, config: AgentRunConfig, signal?: AbortSignal): AsyncIterable<AgentEvent>; // passthrough of AgentEvent from upstream
+	run(
+		messages: Message[],
+		userMessage: Message,
+		config: AgentRunConfig,
+		signal?: AbortSignal,
+	): AsyncIterable<AgentEvent>; // passthrough of AgentEvent from upstream
 }