diff --git a/apps/vscode/.vscodeignore b/apps/vscode/.vscodeignore
new file mode 100644
index 00000000000..77f1925a04a
--- /dev/null
+++ b/apps/vscode/.vscodeignore
@@ -0,0 +1,6 @@
+.vscode/**
+node_modules/**
+src/**
+tsconfig.json
+vite.config.*
+*.test.*
diff --git a/apps/vscode/README.md b/apps/vscode/README.md
new file mode 100644
index 00000000000..8386c738385
--- /dev/null
+++ b/apps/vscode/README.md
@@ -0,0 +1,47 @@
+# T3 Code for VS Code
+
+
+
+This package exposes T3 Code as a dedicated VS Code secondary-sidebar chat tab, alongside the
+Claude Code, Chat, and Codex tabs. It connects directly to the same T3 Code server used by the web,
+desktop, and mobile clients, so projects, threads, messages, turn state, and assistant streaming
+remain synchronized. It also provides an optional native `@t3` participant inside VS Code Chat.
+
+## Development
+
+1. Start T3 Code (`pnpm dev`), which listens at `http://127.0.0.1:3773` by default.
+2. Build the extension with `pnpm --filter t3-code build`.
+3. Open this repository in VS Code, choose **Run Extension** from the Run and Debug view, and point
+ the extension-development host at `apps/vscode` if prompted.
+4. Select the **T3 Code** tab in the secondary sidebar. Use **T3 Code: Open Chat** from the Command
+ Palette if the secondary sidebar is hidden.
+
+The extension first uses the backend advertised by the T3 Desktop runtime beside its extension
+host. This works independently in local, SSH, and other remote windows and avoids treating a
+synced `127.0.0.1` setting as the same machine. For a fallback backend, set `t3Code.serverUrl`.
+Remote servers can use **T3 Code: Set Server Bearer Token**; the token is stored in VS Code secret
+storage and exchanged for a short-lived WebSocket ticket.
+
+## Dedicated chat workflow
+
+The T3 Code tab contains a worktree-scoped thread picker, synchronized transcript, context control,
+and prompt composer. Select a thread to continue it on any T3 client, or use **+** to create one for
+the open worktree. Enter sends; Shift+Enter inserts a newline.
+
+The same operations are also available through the optional native Chat participant:
+
+- `@t3 /threads` selects an existing thread whose worktree matches the open workspace folder.
+- `@t3 /new` creates a synchronized thread (and a project when the folder is not registered yet).
+- A normal `@t3` prompt continues the last selected thread, or the most recently updated matching
+ thread. If none exists, it creates one.
+- `@t3 /history`, `/status`, and `/stop` inspect or control the selected server thread.
+
+Active editor context is included by default and can be toggled from the composer, with
+`@t3 /context`, or **T3 Code: Toggle Automatic Editor Context**. This preference is kept in VS Code's
+extension state and never written to workspace settings. A non-empty
+selection includes the exact character range; an empty selection includes the cursor line and
+column. Explicit Chat references such as `#file` and attached selections are always included.
+
+The **T3 Code: Ask About Selection** editor action opens Chat with `@t3` prefilled. Context is sent
+as structured-looking provider context using workspace-relative paths and language-aware Markdown
+fences. T3 Code clients present that envelope as a context reference rather than authored text.
diff --git a/apps/vscode/media/screenshot.jpg b/apps/vscode/media/screenshot.jpg
new file mode 100644
index 00000000000..5d7df918794
Binary files /dev/null and b/apps/vscode/media/screenshot.jpg differ
diff --git a/apps/vscode/media/t3-code.svg b/apps/vscode/media/t3-code.svg
new file mode 100644
index 00000000000..fd6dba4e5e5
--- /dev/null
+++ b/apps/vscode/media/t3-code.svg
@@ -0,0 +1,3 @@
+
diff --git a/apps/vscode/package.json b/apps/vscode/package.json
new file mode 100644
index 00000000000..d89b3d49803
--- /dev/null
+++ b/apps/vscode/package.json
@@ -0,0 +1,203 @@
+{
+ "name": "t3-code",
+ "displayName": "T3 Code",
+ "version": "0.0.37",
+ "private": true,
+ "description": "A dedicated VS Code chat client for synchronized T3 Code threads.",
+ "categories": [
+ "AI",
+ "Chat",
+ "Other"
+ ],
+ "publisher": "t3code",
+ "type": "module",
+ "main": "./dist/extension.cjs",
+ "scripts": {
+ "build": "esbuild src/extension.ts --bundle --platform=node --format=cjs --target=node20 --external:vscode --outfile=dist/extension.cjs && esbuild src/webview.ts --bundle --platform=browser --format=iife --target=es2022 --outfile=dist/webview.js",
+ "typecheck": "tsgo --noEmit",
+ "test": "vp test run"
+ },
+ "dependencies": {
+ "@t3tools/client-runtime": "workspace:*",
+ "@t3tools/contracts": "workspace:*",
+ "@t3tools/shared": "workspace:*",
+ "dompurify": "^3.2.6",
+ "effect": "catalog:",
+ "marked": "^15.0.12"
+ },
+ "devDependencies": {
+ "@types/vscode": "1.95.0",
+ "esbuild": "^0.28.0",
+ "vite-plus": "catalog:"
+ },
+ "contributes": {
+ "viewsContainers": {
+ "activitybar": [
+ {
+ "id": "t3CodeViewContainer",
+ "title": "T3 Code",
+ "icon": "media/t3-code.svg",
+ "when": "t3Code.useActivityBar"
+ }
+ ],
+ "secondarySidebar": [
+ {
+ "id": "t3CodeSecondaryViewContainer",
+ "title": "T3 Code",
+ "icon": "media/t3-code.svg",
+ "when": "!t3Code.useActivityBar"
+ }
+ ]
+ },
+ "views": {
+ "t3CodeViewContainer": [
+ {
+ "id": "t3Code.chatView",
+ "type": "webview",
+ "name": "T3 Code",
+ "when": "t3Code.useActivityBar"
+ }
+ ],
+ "t3CodeSecondaryViewContainer": [
+ {
+ "id": "t3Code.chatViewSecondary",
+ "type": "webview",
+ "name": "T3 Code",
+ "when": "!t3Code.useActivityBar"
+ }
+ ]
+ },
+ "chatParticipants": [
+ {
+ "id": "t3-code.chat",
+ "name": "t3",
+ "fullName": "T3 Code",
+ "description": "Work with synchronized Codex, Claude, Cursor, Grok, and OpenCode threads.",
+ "isSticky": true,
+ "commands": [
+ {
+ "name": "new",
+ "description": "Create a thread for this worktree"
+ },
+ {
+ "name": "threads",
+ "description": "Choose a thread for this worktree"
+ },
+ {
+ "name": "history",
+ "description": "Show the synchronized thread history"
+ },
+ {
+ "name": "context",
+ "description": "Toggle automatic editor context"
+ },
+ {
+ "name": "stop",
+ "description": "Interrupt the active turn"
+ },
+ {
+ "name": "status",
+ "description": "Show connection and thread status"
+ }
+ ]
+ }
+ ],
+ "commands": [
+ {
+ "command": "t3Code.newThread",
+ "title": "T3 Code: New Thread for Worktree",
+ "category": "T3 Code"
+ },
+ {
+ "command": "t3Code.selectThread",
+ "title": "T3 Code: Select Worktree Thread",
+ "category": "T3 Code"
+ },
+ {
+ "command": "t3Code.askSelection",
+ "title": "T3 Code: Ask About Selection",
+ "category": "T3 Code",
+ "icon": "$(comment-discussion)"
+ },
+ {
+ "command": "t3Code.toggleEditorContext",
+ "title": "T3 Code: Toggle Automatic Editor Context",
+ "category": "T3 Code"
+ },
+ {
+ "command": "t3Code.showDiagnostics",
+ "title": "T3 Code: Show Diagnostics",
+ "category": "T3 Code"
+ },
+ {
+ "command": "t3Code.setBearerToken",
+ "title": "T3 Code: Set Server Bearer Token",
+ "category": "T3 Code"
+ },
+ {
+ "command": "t3Code.clearBearerToken",
+ "title": "T3 Code: Clear Server Bearer Token",
+ "category": "T3 Code"
+ },
+ {
+ "command": "t3Code.openChat",
+ "title": "T3 Code: Open Chat",
+ "category": "T3 Code"
+ }
+ ],
+ "menus": {
+ "editor/context": [
+ {
+ "command": "t3Code.askSelection",
+ "group": "navigation@90",
+ "when": "editorHasSelection"
+ }
+ ]
+ },
+ "configuration": {
+ "title": "T3 Code",
+ "properties": {
+ "t3Code.serverUrl": {
+ "type": "string",
+ "scope": "machine",
+ "default": "http://127.0.0.1:3773",
+ "description": "Fallback T3 Code server HTTP URL when no local T3 Desktop runtime is advertised. WebSocket and environment endpoints are derived from it."
+ },
+ "t3Code.defaultRuntimeMode": {
+ "type": "string",
+ "enum": [
+ "approval-required",
+ "auto-accept-edits",
+ "full-access"
+ ],
+ "default": "full-access",
+ "description": "Runtime mode for new T3 Code threads."
+ },
+ "t3Code.desktopClientSettingsPath": {
+ "type": "string",
+ "default": "",
+ "description": "Optional path to T3 Desktop's client-settings.json for sharing provider and model favorites. The default auto-detects ~/.t3/userdata or ~/.t3/dev."
+ }
+ }
+ }
+ },
+ "activationEvents": [
+ "onChatParticipant:t3-code.chat",
+ "onCommand:t3Code.askSelection",
+ "onCommand:t3Code.clearBearerToken",
+ "onCommand:t3Code.newThread",
+ "onCommand:t3Code.openChat",
+ "onCommand:t3Code.selectThread",
+ "onCommand:t3Code.setBearerToken",
+ "onCommand:t3Code.showDiagnostics",
+ "onCommand:t3Code.toggleEditorContext",
+ "onView:t3Code.chatView",
+ "onView:t3Code.chatViewSecondary"
+ ],
+ "extensionKind": [
+ "workspace"
+ ],
+ "engines": {
+ "vscode": "^1.95.0"
+ }
+}
diff --git a/apps/vscode/src/chatViewProvider.ts b/apps/vscode/src/chatViewProvider.ts
new file mode 100644
index 00000000000..09f6ccd7f78
--- /dev/null
+++ b/apps/vscode/src/chatViewProvider.ts
@@ -0,0 +1,732 @@
+/* oxlint-disable unicorn/require-post-message-target-origin -- VS Code Webview.postMessage is not Window.postMessage. */
+import type {
+ ModelSelection,
+ OrchestrationThread,
+ OrchestrationThreadShell,
+ RuntimeMode,
+ ThreadId,
+ UploadChatAttachment,
+} from "@t3tools/contracts";
+import { ApprovalRequestId, ProviderInstanceId } from "@t3tools/contracts";
+import * as vscode from "vscode";
+
+import { composePrompt, type TextContext } from "./editorContext.ts";
+import { derivePendingInteractions } from "./pendingInteractions.ts";
+import type { T3Client } from "./t3Client.ts";
+import { resolveThreadDisplayStatus } from "./threadStatus.ts";
+import { presentTasks } from "./taskPresentation.ts";
+import { presentToolCalls } from "./toolPresentation.ts";
+import { presentResolvedUserInputs } from "./userInputPresentation.ts";
+
+interface ChatViewActions {
+ readonly worktreePath: () => string;
+ readonly ensureConnected: () => Promise;
+ readonly restoreThread: () => Promise;
+ readonly createThread: (title?: string, modelSelection?: ModelSelection) => Promise;
+ readonly selectThread: (threadId: string) => Promise;
+ readonly toggleContext: () => Promise;
+ readonly contextEnabled: () => boolean;
+ readonly runtimeMode: () => RuntimeMode;
+ readonly editorContext: () => TextContext | null;
+ readonly favoriteProviderIds: () => ReadonlyArray;
+ readonly favoriteModelKeys: () => ReadonlyArray;
+ readonly toggleProviderFavorite: (instanceId: string) => Promise;
+ readonly toggleModelFavorite: (modelKey: string) => Promise;
+ readonly onFavoritesChanged: vscode.Event;
+}
+
+type WebviewRequest =
+ | { readonly type: "ready" | "refresh" | "stop" | "toggleContext" }
+ | {
+ readonly type: "sendNewThread";
+ readonly text: string;
+ readonly instanceId: string;
+ readonly model: string;
+ readonly options: ModelSelection["options"];
+ readonly images: ReadonlyArray;
+ }
+ | { readonly type: "selectThread"; readonly threadId: string }
+ | {
+ readonly type: "selectModel";
+ readonly instanceId: string;
+ readonly model: string;
+ readonly options: ModelSelection["options"];
+ }
+ | { readonly type: "openLink"; readonly href: string }
+ | { readonly type: "openEditorContext"; readonly path: string; readonly detail: string }
+ | { readonly type: "copyText"; readonly text: string }
+ | {
+ readonly type: "approvalResponse";
+ readonly requestId: string;
+ readonly decision: "accept" | "acceptForSession" | "decline";
+ }
+ | {
+ readonly type: "userInputResponse";
+ readonly requestId: string;
+ readonly answers: Readonly>>;
+ }
+ | { readonly type: "toggleProviderFavorite"; readonly instanceId: string }
+ | { readonly type: "toggleModelFavorite"; readonly modelKey: string }
+ | {
+ readonly type: "send";
+ readonly text: string;
+ readonly images: ReadonlyArray;
+ };
+
+function hasImageArray(value: object): boolean {
+ return (
+ "images" in value &&
+ Array.isArray(value.images) &&
+ value.images.every(
+ (image) =>
+ typeof image === "object" &&
+ image !== null &&
+ "type" in image &&
+ image.type === "image" &&
+ "name" in image &&
+ typeof image.name === "string" &&
+ "mimeType" in image &&
+ typeof image.mimeType === "string" &&
+ "sizeBytes" in image &&
+ typeof image.sizeBytes === "number" &&
+ "dataUrl" in image &&
+ typeof image.dataUrl === "string",
+ )
+ );
+}
+
+function nonce(): string {
+ return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(16)), (byte) =>
+ byte.toString(16).padStart(2, "0"),
+ ).join("");
+}
+
+function isRequest(value: unknown): value is WebviewRequest {
+ if (typeof value !== "object" || value === null || !("type" in value)) return false;
+ const type = (value as { readonly type?: unknown }).type;
+ if (type === "ready" || type === "refresh" || type === "stop" || type === "toggleContext") {
+ return true;
+ }
+ if (type === "sendNewThread") {
+ return (
+ "text" in value &&
+ typeof value.text === "string" &&
+ "instanceId" in value &&
+ typeof value.instanceId === "string" &&
+ "model" in value &&
+ typeof value.model === "string" &&
+ "options" in value &&
+ (value.options === undefined || Array.isArray(value.options)) &&
+ hasImageArray(value)
+ );
+ }
+ if (type === "selectThread") {
+ return "threadId" in value && typeof value.threadId === "string";
+ }
+ if (type === "selectModel") {
+ return (
+ "instanceId" in value &&
+ typeof value.instanceId === "string" &&
+ "model" in value &&
+ typeof value.model === "string" &&
+ "options" in value &&
+ (value.options === undefined || Array.isArray(value.options))
+ );
+ }
+ if (type === "openLink") return "href" in value && typeof value.href === "string";
+ if (type === "approvalResponse") {
+ return (
+ "requestId" in value &&
+ typeof value.requestId === "string" &&
+ "decision" in value &&
+ (value.decision === "accept" ||
+ value.decision === "acceptForSession" ||
+ value.decision === "decline")
+ );
+ }
+ if (type === "userInputResponse") {
+ return (
+ "requestId" in value &&
+ typeof value.requestId === "string" &&
+ "answers" in value &&
+ typeof value.answers === "object" &&
+ value.answers !== null &&
+ Object.values(value.answers).every(
+ (answer) =>
+ typeof answer === "string" ||
+ (Array.isArray(answer) && answer.every((entry) => typeof entry === "string")),
+ )
+ );
+ }
+ if (type === "openEditorContext") {
+ return (
+ "path" in value &&
+ typeof value.path === "string" &&
+ "detail" in value &&
+ typeof value.detail === "string"
+ );
+ }
+ if (type === "copyText") return "text" in value && typeof value.text === "string";
+ if (type === "toggleProviderFavorite") {
+ return "instanceId" in value && typeof value.instanceId === "string";
+ }
+ if (type === "toggleModelFavorite") {
+ return "modelKey" in value && typeof value.modelKey === "string";
+ }
+ return (
+ type === "send" && "text" in value && typeof value.text === "string" && hasImageArray(value)
+ );
+}
+
+export class T3ChatViewProvider implements vscode.WebviewViewProvider, vscode.Disposable {
+ static readonly primaryViewType = "t3Code.chatView";
+ static readonly secondaryViewType = "t3Code.chatViewSecondary";
+
+ #view: vscode.WebviewView | null = null;
+ #busy = false;
+ #error: string | null = null;
+ readonly client: T3Client;
+ readonly actions: ChatViewActions;
+ readonly extensionUri: vscode.Uri;
+ readonly #disposables: vscode.Disposable[];
+ readonly #attachmentUrls = new Map();
+ readonly #attachmentLoads = new Set();
+
+ constructor(client: T3Client, actions: ChatViewActions, extensionUri: vscode.Uri) {
+ this.client = client;
+ this.actions = actions;
+ this.extensionUri = extensionUri;
+ this.#disposables = [
+ client.onShellChanged(() => this.#publish()),
+ client.onThreadChanged(() => this.#publish()),
+ client.onConnectionChanged((connected) => {
+ if (!connected) this.#error = "Connection lost. Refresh to reconnect to T3 Code.";
+ this.#publish();
+ }),
+ vscode.window.onDidChangeActiveTextEditor(() => this.#publish()),
+ vscode.window.onDidChangeTextEditorSelection(() => this.#publish()),
+ vscode.workspace.onDidChangeConfiguration((event) => {
+ if (event.affectsConfiguration("t3Code")) void this.#refresh();
+ }),
+ actions.onFavoritesChanged(() => this.#publish()),
+ ];
+ }
+
+ resolveWebviewView(view: vscode.WebviewView): void {
+ this.#view = view;
+ view.webview.options = {
+ enableScripts: true,
+ localResourceRoots: [vscode.Uri.joinPath(this.extensionUri, "dist")],
+ };
+ view.webview.html = this.#html(view.webview);
+ this.#disposables.push(
+ view.webview.onDidReceiveMessage((message: unknown) => {
+ if (isRequest(message)) void this.#handle(message);
+ }),
+ view.onDidDispose(() => {
+ if (this.#view === view) this.#view = null;
+ }),
+ view.onDidChangeVisibility(() => {
+ if (view.visible && this.client.serverConfig === null) void this.#refresh();
+ }),
+ );
+ }
+
+ dispose(): void {
+ for (const disposable of this.#disposables) disposable.dispose();
+ this.#disposables.length = 0;
+ }
+
+ async reveal(): Promise {
+ try {
+ await vscode.commands.executeCommand(`${T3ChatViewProvider.secondaryViewType}.focus`);
+ } catch {
+ await vscode.commands.executeCommand(`${T3ChatViewProvider.primaryViewType}.focus`);
+ }
+ await this.#view?.webview.postMessage({ type: "focusComposer" });
+ }
+
+ async #handle(message: WebviewRequest): Promise {
+ try {
+ switch (message.type) {
+ case "ready":
+ case "refresh":
+ await this.#refresh();
+ return;
+ case "sendNewThread":
+ await this.#run(async () => {
+ const authored = message.text.trim();
+ if (authored === "" && message.images.length === 0) return;
+ const modelSelection: ModelSelection = {
+ instanceId: ProviderInstanceId.make(message.instanceId),
+ model: message.model,
+ ...(message.options === undefined ? {} : { options: message.options }),
+ };
+ const threadId = await this.actions.createThread(
+ authored.slice(0, 80) || "Image",
+ modelSelection,
+ );
+ const editorContext = this.actions.contextEnabled()
+ ? this.actions.editorContext()
+ : null;
+ await this.client.sendPrompt({
+ threadId,
+ prompt: composePrompt(authored, editorContext === null ? [] : [editorContext]),
+ runtimeMode: this.actions.runtimeMode(),
+ modelSelection,
+ attachments: message.images,
+ });
+ // The shell/title update can arrive before the detail stream. Hydrate
+ // the authoritative first message before the webview leaves draft mode.
+ await this.client.selectThread(threadId);
+ await this.client.waitForActiveThread();
+ await this.#view?.webview.postMessage({ type: "sentNewThread" });
+ });
+ return;
+ case "selectThread":
+ await this.#run(async () => {
+ await this.actions.selectThread(message.threadId);
+ await this.client.waitForActiveThread();
+ });
+ return;
+ case "selectModel":
+ await this.#run(() =>
+ this.client.setModelSelection({
+ instanceId: ProviderInstanceId.make(message.instanceId),
+ model: message.model,
+ ...(message.options === undefined ? {} : { options: message.options }),
+ }),
+ );
+ return;
+ case "openLink":
+ await this.#openLink(message.href);
+ return;
+ case "openEditorContext": {
+ if (message.path.split("/").includes("..")) return;
+ const uri = vscode.Uri.joinPath(
+ vscode.Uri.file(this.actions.worktreePath()),
+ ...message.path.split("/"),
+ );
+ const document = await vscode.workspace.openTextDocument(uri);
+ const editor = await vscode.window.showTextDocument(document);
+ const line = /(?:line|lines)\s+(\d+)/u.exec(message.detail)?.[1];
+ if (line !== undefined) {
+ const position = new vscode.Position(Math.max(0, Number(line) - 1), 0);
+ editor.selection = new vscode.Selection(position, position);
+ editor.revealRange(new vscode.Range(position, position));
+ }
+ return;
+ }
+ case "copyText":
+ await vscode.env.clipboard.writeText(message.text);
+ return;
+ case "approvalResponse":
+ await this.#run(() =>
+ this.client.respondToApproval(
+ ApprovalRequestId.make(message.requestId),
+ message.decision,
+ ),
+ );
+ return;
+ case "userInputResponse":
+ await this.#run(() =>
+ this.client.respondToUserInput(ApprovalRequestId.make(message.requestId), {
+ ...message.answers,
+ }),
+ );
+ return;
+ case "toggleProviderFavorite":
+ await this.actions.toggleProviderFavorite(message.instanceId);
+ this.#publish();
+ return;
+ case "toggleModelFavorite":
+ await this.actions.toggleModelFavorite(message.modelKey);
+ this.#publish();
+ return;
+ case "stop":
+ await this.#run(() => this.client.interrupt());
+ return;
+ case "toggleContext":
+ await this.actions.toggleContext();
+ this.#publish();
+ return;
+ case "send": {
+ const authored = message.text.trim();
+ if (authored === "" && message.images.length === 0) return;
+ await this.#run(async () => {
+ await this.actions.ensureConnected();
+ // Resolve/restore thread for the *current* worktree (multi-root safe) before reusing activeThread.
+ await this.actions.restoreThread();
+ const threadId =
+ this.client.activeThread?.id ??
+ (await this.actions.createThread(authored.slice(0, 80)));
+ const context = this.actions.contextEnabled() ? this.actions.editorContext() : null;
+ await this.client.sendPrompt({
+ threadId,
+ prompt: composePrompt(authored, context === null ? [] : [context]),
+ runtimeMode: this.actions.runtimeMode(),
+ attachments: message.images,
+ });
+ await this.#view?.webview.postMessage({ type: "sent" });
+ });
+ return;
+ }
+ }
+ } catch (cause) {
+ this.#error = cause instanceof Error ? cause.message : String(cause);
+ this.#publish();
+ }
+ }
+
+ async #refresh(): Promise {
+ await this.#run(async () => {
+ await this.actions.ensureConnected();
+ await this.actions.restoreThread();
+ });
+ }
+
+ async #run(action: () => Promise): Promise {
+ if (this.#busy) return;
+ this.#busy = true;
+ this.#error = null;
+ this.#publish();
+ try {
+ await action();
+ } catch (cause) {
+ this.#error = cause instanceof Error ? cause.message : String(cause);
+ } finally {
+ this.#busy = false;
+ this.#publish();
+ }
+ }
+
+ #publish(): void {
+ const view = this.#view;
+ if (view === null) return;
+ let threads: ReadonlyArray = [];
+ try {
+ threads = this.client.threadsForWorktree(this.actions.worktreePath());
+ } catch {
+ // The empty-workspace message below is more useful than surfacing this as a connection error.
+ }
+ const editorContext = this.actions.editorContext();
+ this.#loadAttachmentUrls(this.client.activeThread);
+ void view.webview.postMessage({
+ type: "state",
+ state: {
+ busy: this.#busy,
+ error: this.#error,
+ connected: this.client.serverConfig !== null,
+ environmentLabel: this.client.serverConfig?.environment.label ?? "T3 Code",
+ threads: threads.map((thread) => ({
+ id: thread.id,
+ title: thread.title,
+ model: thread.modelSelection.model,
+ status: resolveThreadDisplayStatus(thread),
+ updatedAt: thread.updatedAt,
+ })),
+ activeThread: this.#serializeThread(this.client.activeThread),
+ models:
+ this.client.serverConfig?.providers
+ .filter((provider) => provider.enabled && provider.installed)
+ .flatMap((provider) =>
+ provider.models.map((model) => ({
+ instanceId: provider.instanceId,
+ model: model.slug,
+ driver: provider.driver,
+ providerLabel: provider.displayName ?? provider.driver,
+ modelLabel: model.name,
+ optionDescriptors: model.capabilities?.optionDescriptors ?? [],
+ })),
+ ) ?? [],
+ favoriteProviderIds: this.actions.favoriteProviderIds(),
+ favoriteModelKeys: this.actions.favoriteModelKeys(),
+ contextEnabled: this.actions.contextEnabled(),
+ editorContext:
+ editorContext === null
+ ? null
+ : {
+ path: editorContext.relativePath,
+ startLine: editorContext.startLine,
+ endLine: editorContext.endLine,
+ kind: editorContext.kind,
+ },
+ },
+ });
+ }
+
+ #serializeThread(thread: OrchestrationThread | null) {
+ if (thread === null) return null;
+ return {
+ id: thread.id,
+ title: thread.title,
+ model: thread.modelSelection.model,
+ instanceId: thread.modelSelection.instanceId,
+ runtimeMode: thread.runtimeMode,
+ status: resolveThreadDisplayStatus({
+ latestTurn: thread.latestTurn,
+ session: thread.session,
+ }),
+ turnStartedAt: thread.latestTurn?.startedAt ?? thread.latestTurn?.requestedAt ?? null,
+ pendingInteractions: derivePendingInteractions(thread.activities),
+ tasks: presentTasks(thread.activities, thread.latestTurn?.turnId ?? null),
+ toolCalls: presentToolCalls(thread.activities, {
+ latestTurn: thread.latestTurn,
+ session: thread.session,
+ }),
+ resolvedUserInputs: presentResolvedUserInputs(thread.activities),
+ messages: thread.messages.map((message) => ({
+ id: message.id,
+ role: message.role,
+ text: message.text,
+ streaming: message.streaming,
+ createdAt: message.createdAt,
+ attachments: (message.attachments ?? []).map((attachment) => ({
+ ...attachment,
+ previewUrl: this.#attachmentUrls.get(attachment.id) ?? null,
+ })),
+ })),
+ };
+ }
+
+ #loadAttachmentUrls(thread: OrchestrationThread | null): void {
+ for (const message of thread?.messages ?? []) {
+ for (const attachment of message.attachments ?? []) {
+ if (this.#attachmentUrls.has(attachment.id) || this.#attachmentLoads.has(attachment.id)) {
+ continue;
+ }
+ this.#attachmentLoads.add(attachment.id);
+ void this.client
+ .createAttachmentUrl(attachment.id)
+ .then((url) => vscode.env.asExternalUri(vscode.Uri.parse(url)))
+ .then((uri) => this.#attachmentUrls.set(attachment.id, uri.toString(true)))
+ .catch(() => undefined)
+ .finally(() => {
+ this.#attachmentLoads.delete(attachment.id);
+ this.#publish();
+ });
+ }
+ }
+ }
+
+ async #openLink(rawHref: string): Promise {
+ const href = rawHref.trim();
+ if (href === "" || href.startsWith("#")) return;
+ if (/^https?:\/\//iu.test(href)) {
+ await vscode.env.openExternal(vscode.Uri.parse(href));
+ return;
+ }
+ if (/^[a-z][a-z0-9+.-]*:/iu.test(href) && !href.startsWith("file:")) return;
+ const [pathPart = "", fragment = ""] = href.replace(/^file:\/\//iu, "").split("#", 2);
+ const worktree = this.actions.worktreePath();
+ const uri = pathPart.startsWith("/")
+ ? vscode.Uri.file(pathPart)
+ : vscode.Uri.joinPath(vscode.Uri.file(worktree), pathPart);
+ // Defense-in-depth: only allow files inside the current worktree (consistent with editor context).
+ const normalizedWorktree = worktree.replace(/\\/gu, "/");
+ const normalizedPath = uri.fsPath.replace(/\\/gu, "/");
+ if (
+ !normalizedPath.startsWith(normalizedWorktree + "/") &&
+ normalizedPath !== normalizedWorktree
+ ) {
+ void vscode.window.showWarningMessage("Cannot open file outside the current worktree.");
+ return;
+ }
+ const document = await vscode.workspace.openTextDocument(uri);
+ const lineMatch = /^(?:L)?(\d+)/u.exec(fragment);
+ const line = Math.max(0, Number(lineMatch?.[1] ?? 1) - 1);
+ await vscode.window.showTextDocument(document, {
+ selection: new vscode.Range(line, 0, line, 0),
+ preview: true,
+ });
+ }
+
+ #html(webview: vscode.Webview): string {
+ const scriptNonce = nonce();
+ const scriptUri = webview.asWebviewUri(
+ vscode.Uri.joinPath(this.extensionUri, "dist", "webview.js"),
+ );
+ return `
+
+
+
+
+
+
+
+
+
+
+
Connecting to T3 Code…
+
+
+
+
+
+
+
+
+