diff --git a/.gitignore b/.gitignore
index af66e2f..aeac7ea 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,5 @@ node_modules
 *.vsix
 .DS_Store
 launch_folder
-types/
 extension.vsix
-extension.hash
\ No newline at end of file
+extension.hash
diff --git a/types/git.d.ts b/types/git.d.ts
new file mode 100644
index 0000000..ee45e7a
--- /dev/null
+++ b/types/git.d.ts
@@ -0,0 +1,415 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Uri, Event, Disposable, ProviderResult, Command, CancellationToken } from 'vscode';
+export { ProviderResult } from 'vscode';
+
+export interface Git {
+	readonly path: string;
+}
+
+export interface InputBox {
+	value: string;
+}
+
+export const enum ForcePushMode {
+	Force,
+	ForceWithLease,
+	ForceWithLeaseIfIncludes,
+}
+
+export const enum RefType {
+	Head,
+	RemoteHead,
+	Tag
+}
+
+export interface Ref {
+	readonly type: RefType;
+	readonly name?: string;
+	readonly commit?: string;
+	readonly remote?: string;
+}
+
+export interface UpstreamRef {
+	readonly remote: string;
+	readonly name: string;
+	readonly commit?: string;
+}
+
+export interface Branch extends Ref {
+	readonly upstream?: UpstreamRef;
+	readonly ahead?: number;
+	readonly behind?: number;
+}
+
+export interface CommitShortStat {
+	readonly files: number;
+	readonly insertions: number;
+	readonly deletions: number;
+}
+
+export interface Commit {
+	readonly hash: string;
+	readonly message: string;
+	readonly parents: string[];
+	readonly authorDate?: Date;
+	readonly authorName?: string;
+	readonly authorEmail?: string;
+	readonly commitDate?: Date;
+	readonly shortStat?: CommitShortStat;
+}
+
+export interface Submodule {
+	readonly name: string;
+	readonly path: string;
+	readonly url: string;
+}
+
+export interface Remote {
+	readonly name: string;
+	readonly fetchUrl?: string;
+	readonly pushUrl?: string;
+	readonly isReadOnly: boolean;
+}
+
+export const enum Status {
+	INDEX_MODIFIED,
+	INDEX_ADDED,
+	INDEX_DELETED,
+	INDEX_RENAMED,
+	INDEX_COPIED,
+
+	MODIFIED,
+	DELETED,
+	UNTRACKED,
+	IGNORED,
+	INTENT_TO_ADD,
+	INTENT_TO_RENAME,
+	TYPE_CHANGED,
+
+	ADDED_BY_US,
+	ADDED_BY_THEM,
+	DELETED_BY_US,
+	DELETED_BY_THEM,
+	BOTH_ADDED,
+	BOTH_DELETED,
+	BOTH_MODIFIED
+}
+
+export interface Change {
+
+	/**
+	 * Returns either `originalUri` or `renameUri`, depending
+	 * on whether this change is a rename change. When
+	 * in doubt always use `uri` over the other two alternatives.
+	 */
+	readonly uri: Uri;
+	readonly originalUri: Uri;
+	readonly renameUri: Uri | undefined;
+	readonly status: Status;
+}
+
+export interface RepositoryState {
+	readonly HEAD: Branch | undefined;
+	readonly refs: Ref[];
+	readonly remotes: Remote[];
+	readonly submodules: Submodule[];
+	readonly rebaseCommit: Commit | undefined;
+
+	readonly mergeChanges: Change[];
+	readonly indexChanges: Change[];
+	readonly workingTreeChanges: Change[];
+	readonly untrackedChanges: Change[];
+
+	readonly onDidChange: Event<void>;
+}
+
+export interface RepositoryUIState {
+	readonly selected: boolean;
+	readonly onDidChange: Event<void>;
+}
+
+/**
+ * Log options.
+ */
+export interface LogOptions {
+	/** Max number of log entries to retrieve. If not specified, the default is 32. */
+	readonly maxEntries?: number;
+	readonly path?: string;
+	/** A commit range, such as "0a47c67f0fb52dd11562af48658bc1dff1d75a38..0bb4bdea78e1db44d728fd6894720071e303304f" */
+	readonly range?: string;
+	readonly reverse?: boolean;
+	readonly sortByAuthorDate?: boolean;
+	readonly shortStats?: boolean;
+	readonly author?: string;
+	readonly refNames?: string[];
+	readonly maxParents?: number;
+	readonly skip?: number;
+}
+
+export interface CommitOptions {
+	all?: boolean | 'tracked';
+	amend?: boolean;
+	signoff?: boolean;
+	signCommit?: boolean;
+	empty?: boolean;
+	noVerify?: boolean;
+	requireUserConfig?: boolean;
+	useEditor?: boolean;
+	verbose?: boolean;
+	/**
+	 * string    - execute the specified command after the commit operation
+	 * undefined - execute the command specified in git.postCommitCommand
+	 *             after the commit operation
+	 * null      - do not execute any command after the commit operation
+	 */
+	postCommitCommand?: string | null;
+}
+
+export interface FetchOptions {
+	remote?: string;
+	ref?: string;
+	all?: boolean;
+	prune?: boolean;
+	depth?: number;
+}
+
+export interface InitOptions {
+	defaultBranch?: string;
+}
+
+export interface RefQuery {
+	readonly contains?: string;
+	readonly count?: number;
+	readonly pattern?: string | string[];
+	readonly sort?: 'alphabetically' | 'committerdate';
+}
+
+export interface BranchQuery extends RefQuery {
+	readonly remote?: boolean;
+}
+
+export interface Repository {
+
+	readonly rootUri: Uri;
+	readonly inputBox: InputBox;
+	readonly state: RepositoryState;
+	readonly ui: RepositoryUIState;
+
+	readonly onDidCommit: Event<void>;
+
+	getConfigs(): Promise<{ key: string; value: string; }[]>;
+	getConfig(key: string): Promise<string>;
+	setConfig(key: string, value: string): Promise<string>;
+	getGlobalConfig(key: string): Promise<string>;
+
+	getObjectDetails(treeish: string, path: string): Promise<{ mode: string, object: string, size: number }>;
+	detectObjectType(object: string): Promise<{ mimetype: string, encoding?: string }>;
+	buffer(ref: string, path: string): Promise<Buffer>;
+	show(ref: string, path: string): Promise<string>;
+	getCommit(ref: string): Promise<Commit>;
+
+	add(paths: string[]): Promise<void>;
+	revert(paths: string[]): Promise<void>;
+	clean(paths: string[]): Promise<void>;
+
+	apply(patch: string, reverse?: boolean): Promise<void>;
+	diff(cached?: boolean): Promise<string>;
+	diffWithHEAD(): Promise<Change[]>;
+	diffWithHEAD(path: string): Promise<string>;
+	diffWith(ref: string): Promise<Change[]>;
+	diffWith(ref: string, path: string): Promise<string>;
+	diffIndexWithHEAD(): Promise<Change[]>;
+	diffIndexWithHEAD(path: string): Promise<string>;
+	diffIndexWith(ref: string): Promise<Change[]>;
+	diffIndexWith(ref: string, path: string): Promise<string>;
+	diffBlobs(object1: string, object2: string): Promise<string>;
+	diffBetween(ref1: string, ref2: string): Promise<Change[]>;
+	diffBetween(ref1: string, ref2: string, path: string): Promise<string>;
+
+	hashObject(data: string): Promise<string>;
+
+	createBranch(name: string, checkout: boolean, ref?: string): Promise<void>;
+	deleteBranch(name: string, force?: boolean): Promise<void>;
+	getBranch(name: string): Promise<Branch>;
+	getBranches(query: BranchQuery, cancellationToken?: CancellationToken): Promise<Ref[]>;
+	getBranchBase(name: string): Promise<Branch | undefined>;
+	setBranchUpstream(name: string, upstream: string): Promise<void>;
+
+	checkIgnore(paths: string[]): Promise<Set<string>>;
+
+	getRefs(query: RefQuery, cancellationToken?: CancellationToken): Promise<Ref[]>;
+
+	getMergeBase(ref1: string, ref2: string): Promise<string | undefined>;
+
+	tag(name: string, upstream: string): Promise<void>;
+	deleteTag(name: string): Promise<void>;
+
+	status(): Promise<void>;
+	checkout(treeish: string): Promise<void>;
+
+	addRemote(name: string, url: string): Promise<void>;
+	removeRemote(name: string): Promise<void>;
+	renameRemote(name: string, newName: string): Promise<void>;
+
+	fetch(options?: FetchOptions): Promise<void>;
+	fetch(remote?: string, ref?: string, depth?: number): Promise<void>;
+	pull(unshallow?: boolean): Promise<void>;
+	push(remoteName?: string, branchName?: string, setUpstream?: boolean, force?: ForcePushMode): Promise<void>;
+
+	blame(path: string): Promise<string>;
+	log(options?: LogOptions): Promise<Commit[]>;
+
+	commit(message: string, opts?: CommitOptions): Promise<void>;
+	merge(ref: string): Promise<void>;
+	mergeAbort(): Promise<void>;
+}
+
+export interface RemoteSource {
+	readonly name: string;
+	readonly description?: string;
+	readonly url: string | string[];
+}
+
+export interface RemoteSourceProvider {
+	readonly name: string;
+	readonly icon?: string; // codicon name
+	readonly supportsQuery?: boolean;
+	getRemoteSources(query?: string): ProviderResult<RemoteSource[]>;
+	getBranches?(url: string): ProviderResult<string[]>;
+	publishRepository?(repository: Repository): Promise<void>;
+}
+
+export interface RemoteSourcePublisher {
+	readonly name: string;
+	readonly icon?: string; // codicon name
+	publishRepository(repository: Repository): Promise<void>;
+}
+
+export interface Credentials {
+	readonly username: string;
+	readonly password: string;
+}
+
+export interface CredentialsProvider {
+	getCredentials(host: Uri): ProviderResult<Credentials>;
+}
+
+export interface PostCommitCommandsProvider {
+	getCommands(repository: Repository): Command[];
+}
+
+export interface PushErrorHandler {
+	handlePushError(repository: Repository, remote: Remote, refspec: string, error: Error & { gitErrorCode: GitErrorCodes }): Promise<boolean>;
+}
+
+export interface BranchProtection {
+	readonly remote: string;
+	readonly rules: BranchProtectionRule[];
+}
+
+export interface BranchProtectionRule {
+	readonly include?: string[];
+	readonly exclude?: string[];
+}
+
+export interface BranchProtectionProvider {
+	onDidChangeBranchProtection: Event<Uri>;
+	provideBranchProtection(): BranchProtection[];
+}
+
+export type APIState = 'uninitialized' | 'initialized';
+
+export interface PublishEvent {
+	repository: Repository;
+	branch?: string;
+}
+
+export interface API {
+	readonly state: APIState;
+	readonly onDidChangeState: Event<APIState>;
+	readonly onDidPublish: Event<PublishEvent>;
+	readonly git: Git;
+	readonly repositories: Repository[];
+	readonly onDidOpenRepository: Event<Repository>;
+	readonly onDidCloseRepository: Event<Repository>;
+
+	toGitUri(uri: Uri, ref: string): Uri;
+	getRepository(uri: Uri): Repository | null;
+	init(root: Uri, options?: InitOptions): Promise<Repository | null>;
+	openRepository(root: Uri): Promise<Repository | null>
+
+	registerRemoteSourcePublisher(publisher: RemoteSourcePublisher): Disposable;
+	registerRemoteSourceProvider(provider: RemoteSourceProvider): Disposable;
+	registerCredentialsProvider(provider: CredentialsProvider): Disposable;
+	registerPostCommitCommandsProvider(provider: PostCommitCommandsProvider): Disposable;
+	registerPushErrorHandler(handler: PushErrorHandler): Disposable;
+	registerBranchProtectionProvider(root: Uri, provider: BranchProtectionProvider): Disposable;
+}
+
+export interface GitExtension {
+
+	readonly enabled: boolean;
+	readonly onDidChangeEnablement: Event<boolean>;
+
+	/**
+	 * Returns a specific API version.
+	 *
+	 * Throws error if git extension is disabled. You can listen to the
+	 * [GitExtension.onDidChangeEnablement](#GitExtension.onDidChangeEnablement) event
+	 * to know when the extension becomes enabled/disabled.
+	 *
+	 * @param version Version number.
+	 * @returns API instance
+	 */
+	getAPI(version: 1): API;
+}
+
+export const enum GitErrorCodes {
+	BadConfigFile = 'BadConfigFile',
+	AuthenticationFailed = 'AuthenticationFailed',
+	NoUserNameConfigured = 'NoUserNameConfigured',
+	NoUserEmailConfigured = 'NoUserEmailConfigured',
+	NoRemoteRepositorySpecified = 'NoRemoteRepositorySpecified',
+	NotAGitRepository = 'NotAGitRepository',
+	NotAtRepositoryRoot = 'NotAtRepositoryRoot',
+	Conflict = 'Conflict',
+	StashConflict = 'StashConflict',
+	UnmergedChanges = 'UnmergedChanges',
+	PushRejected = 'PushRejected',
+	ForcePushWithLeaseRejected = 'ForcePushWithLeaseRejected',
+	ForcePushWithLeaseIfIncludesRejected = 'ForcePushWithLeaseIfIncludesRejected',
+	RemoteConnectionError = 'RemoteConnectionError',
+	DirtyWorkTree = 'DirtyWorkTree',
+	CantOpenResource = 'CantOpenResource',
+	GitNotFound = 'GitNotFound',
+	CantCreatePipe = 'CantCreatePipe',
+	PermissionDenied = 'PermissionDenied',
+	CantAccessRemote = 'CantAccessRemote',
+	RepositoryNotFound = 'RepositoryNotFound',
+	RepositoryIsLocked = 'RepositoryIsLocked',
+	BranchNotFullyMerged = 'BranchNotFullyMerged',
+	NoRemoteReference = 'NoRemoteReference',
+	InvalidBranchName = 'InvalidBranchName',
+	BranchAlreadyExists = 'BranchAlreadyExists',
+	NoLocalChanges = 'NoLocalChanges',
+	NoStashFound = 'NoStashFound',
+	LocalChangesOverwritten = 'LocalChangesOverwritten',
+	NoUpstreamBranch = 'NoUpstreamBranch',
+	IsInSubmodule = 'IsInSubmodule',
+	WrongCase = 'WrongCase',
+	CantLockRef = 'CantLockRef',
+	CantRebaseMultipleBranches = 'CantRebaseMultipleBranches',
+	PatchDoesNotApply = 'PatchDoesNotApply',
+	NoPathFound = 'NoPathFound',
+	UnknownPath = 'UnknownPath',
+	EmptyCommitMessage = 'EmptyCommitMessage',
+	BranchFastForwardRejected = 'BranchFastForwardRejected',
+	BranchNotYetBorn = 'BranchNotYetBorn',
+	TagConflict = 'TagConflict',
+	CherryPickEmpty = 'CherryPickEmpty',
+	CherryPickConflict = 'CherryPickConflict'
+}
diff --git a/types/vscode.proposed.chatParticipantAdditions.d.ts b/types/vscode.proposed.chatParticipantAdditions.d.ts
new file mode 100644
index 0000000..0eed88b
--- /dev/null
+++ b/types/vscode.proposed.chatParticipantAdditions.d.ts
@@ -0,0 +1,391 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	export interface ChatParticipant {
+		onDidPerformAction: Event<ChatUserActionEvent>;
+	}
+
+	/**
+	 * Now only used for the "intent detection" API below
+	 */
+	export interface ChatCommand {
+		readonly name: string;
+		readonly description: string;
+	}
+
+	export class ChatResponseDetectedParticipantPart {
+		participant: string;
+		// TODO@API validate this against statically-declared slash commands?
+		command?: ChatCommand;
+		constructor(participant: string, command?: ChatCommand);
+	}
+
+	export interface ChatVulnerability {
+		title: string;
+		description: string;
+		// id: string; // Later we will need to be able to link these across multiple content chunks.
+	}
+
+	export class ChatResponseMarkdownWithVulnerabilitiesPart {
+		value: MarkdownString;
+		vulnerabilities: ChatVulnerability[];
+		constructor(value: string | MarkdownString, vulnerabilities: ChatVulnerability[]);
+	}
+
+	export class ChatResponseCodeblockUriPart {
+		value: Uri;
+		constructor(value: Uri);
+	}
+
+	/**
+	 * Displays a {@link Command command} as a button in the chat response.
+	 */
+	export interface ChatCommandButton {
+		command: Command;
+	}
+
+	export interface ChatDocumentContext {
+		uri: Uri;
+		version: number;
+		ranges: Range[];
+	}
+
+	export class ChatResponseTextEditPart {
+		uri: Uri;
+		edits: TextEdit[];
+		constructor(uri: Uri, edits: TextEdit | TextEdit[]);
+	}
+
+	export class ChatResponseConfirmationPart {
+		title: string;
+		message: string;
+		data: any;
+		buttons?: string[];
+		constructor(title: string, message: string, data: any, buttons?: string[]);
+	}
+
+	export class ChatResponseCodeCitationPart {
+		value: Uri;
+		license: string;
+		snippet: string;
+		constructor(value: Uri, license: string, snippet: string);
+	}
+
+	export type ExtendedChatResponsePart = ChatResponsePart | ChatResponseTextEditPart | ChatResponseDetectedParticipantPart | ChatResponseConfirmationPart | ChatResponseCodeCitationPart | ChatResponseReferencePart2 | ChatResponseMovePart;
+
+	export class ChatResponseWarningPart {
+		value: MarkdownString;
+		constructor(value: string | MarkdownString);
+	}
+
+	export class ChatResponseProgressPart2 extends ChatResponseProgressPart {
+		value: string;
+		task?: (progress: Progress<ChatResponseWarningPart | ChatResponseReferencePart>) => Thenable<string | void>;
+		constructor(value: string, task?: (progress: Progress<ChatResponseWarningPart | ChatResponseReferencePart>) => Thenable<string | void>);
+	}
+
+	export class ChatResponseReferencePart2 {
+		/**
+		 * The reference target.
+		 */
+		value: Uri | Location | { variableName: string; value?: Uri | Location } | string;
+
+		/**
+		 * The icon for the reference.
+		 */
+		iconPath?: Uri | ThemeIcon | {
+			/**
+			 * The icon path for the light theme.
+			 */
+			light: Uri;
+			/**
+			 * The icon path for the dark theme.
+			 */
+			dark: Uri;
+		};
+		options?: { status?: { description: string; kind: ChatResponseReferencePartStatusKind } };
+
+		/**
+		 * Create a new ChatResponseReferencePart.
+		 * @param value A uri or location
+		 * @param iconPath Icon for the reference shown in UI
+		 */
+		constructor(value: Uri | Location | { variableName: string; value?: Uri | Location } | string, iconPath?: Uri | ThemeIcon | {
+			/**
+			 * The icon path for the light theme.
+			 */
+			light: Uri;
+			/**
+			 * The icon path for the dark theme.
+			 */
+			dark: Uri;
+		}, options?: { status?: { description: string; kind: ChatResponseReferencePartStatusKind } });
+	}
+
+	export class ChatResponseMovePart {
+
+		readonly uri: Uri;
+		readonly range: Range;
+
+		constructor(uri: Uri, range: Range);
+	}
+
+	export interface ChatResponseAnchorPart {
+		/**
+		 * The target of this anchor.
+		 *
+		 * If this is a {@linkcode Uri} or {@linkcode Location}, this is rendered as a normal link.
+		 *
+		 * If this is a {@linkcode SymbolInformation}, this is rendered as a symbol link.
+		 *
+		 * TODO mjbvz: Should this be a full `SymbolInformation`? Or just the parts we need?
+		 * TODO mjbvz: Should we allow a `SymbolInformation` without a location? For example, until `resolve` completes?
+		 */
+		value2: Uri | Location | SymbolInformation;
+
+		/**
+		 * Optional method which fills in the details of the anchor.
+		 *
+		 * THis is currently only implemented for symbol links.
+		 */
+		resolve?(token: CancellationToken): Thenable<void>;
+	}
+
+	export interface ChatResponseStream {
+
+		/**
+		 * Push a progress part to this stream. Short-hand for
+		 * `push(new ChatResponseProgressPart(value))`.
+		*
+		* @param value A progress message
+		* @param task If provided, a task to run while the progress is displayed. When the Thenable resolves, the progress will be marked complete in the UI, and the progress message will be updated to the resolved string if one is specified.
+		* @returns This stream.
+		*/
+		progress(value: string, task?: (progress: Progress<ChatResponseWarningPart | ChatResponseReferencePart>) => Thenable<string | void>): void;
+
+		textEdit(target: Uri, edits: TextEdit | TextEdit[]): void;
+		markdownWithVulnerabilities(value: string | MarkdownString, vulnerabilities: ChatVulnerability[]): void;
+		codeblockUri(uri: Uri): void;
+		detectedParticipant(participant: string, command?: ChatCommand): void;
+		push(part: ChatResponsePart | ChatResponseTextEditPart | ChatResponseDetectedParticipantPart | ChatResponseWarningPart | ChatResponseProgressPart2): void;
+
+		/**
+		 * Show an inline message in the chat view asking the user to confirm an action.
+		 * Multiple confirmations may be shown per response. The UI might show "Accept All" / "Reject All" actions.
+		 * @param title The title of the confirmation entry
+		 * @param message An extra message to display to the user
+		 * @param data An arbitrary JSON-stringifiable object that will be included in the ChatRequest when
+		 * the confirmation is accepted or rejected
+		 * TODO@API should this be MarkdownString?
+		 * TODO@API should actually be a more generic function that takes an array of buttons
+		 */
+		confirmation(title: string, message: string, data: any, buttons?: string[]): void;
+
+		/**
+		 * Push a warning to this stream. Short-hand for
+		 * `push(new ChatResponseWarningPart(message))`.
+		 *
+		 * @param message A warning message
+		 * @returns This stream.
+		 */
+		warning(message: string | MarkdownString): void;
+
+		reference(value: Uri | Location | { variableName: string; value?: Uri | Location }, iconPath?: Uri | ThemeIcon | { light: Uri; dark: Uri }): void;
+
+		reference2(value: Uri | Location | string | { variableName: string; value?: Uri | Location }, iconPath?: Uri | ThemeIcon | { light: Uri; dark: Uri }, options?: { status?: { description: string; kind: ChatResponseReferencePartStatusKind } }): void;
+
+		codeCitation(value: Uri, license: string, snippet: string): void;
+
+		push(part: ExtendedChatResponsePart): void;
+	}
+
+	export enum ChatResponseReferencePartStatusKind {
+		Complete = 1,
+		Partial = 2,
+		Omitted = 3
+	}
+
+	/**
+	 * Does this piggy-back on the existing ChatRequest, or is it a different type of request entirely?
+	 * Does it show up in history?
+	 */
+	export interface ChatRequest {
+		/**
+		 * The `data` for any confirmations that were accepted
+		 */
+		acceptedConfirmationData?: any[];
+
+		/**
+		 * The `data` for any confirmations that were rejected
+		 */
+		rejectedConfirmationData?: any[];
+	}
+
+	// TODO@API fit this into the stream
+	export interface ChatUsedContext {
+		documents: ChatDocumentContext[];
+	}
+
+	export interface ChatParticipant {
+		/**
+		 * Provide a set of variables that can only be used with this participant.
+		 */
+		participantVariableProvider?: { provider: ChatParticipantCompletionItemProvider; triggerCharacters: string[] };
+	}
+
+	export interface ChatParticipantCompletionItemProvider {
+		provideCompletionItems(query: string, token: CancellationToken): ProviderResult<ChatCompletionItem[]>;
+	}
+
+	export class ChatCompletionItem {
+		id: string;
+		label: string | CompletionItemLabel;
+		values: ChatVariableValue[];
+		fullName?: string;
+		icon?: ThemeIcon;
+		insertText?: string;
+		detail?: string;
+		documentation?: string | MarkdownString;
+		command?: Command;
+
+		constructor(id: string, label: string | CompletionItemLabel, values: ChatVariableValue[]);
+	}
+
+	export type ChatExtendedRequestHandler = (request: ChatRequest, context: ChatContext, response: ChatResponseStream, token: CancellationToken) => ProviderResult<ChatResult | void>;
+
+	export interface ChatResult {
+		nextQuestion?: {
+			prompt: string;
+			participant?: string;
+			command?: string;
+		};
+	}
+
+	export namespace chat {
+		/**
+		 * Create a chat participant with the extended progress type
+		 */
+		export function createChatParticipant(id: string, handler: ChatExtendedRequestHandler): ChatParticipant;
+
+		export function registerChatParticipantDetectionProvider(participantDetectionProvider: ChatParticipantDetectionProvider): Disposable;
+	}
+
+	export interface ChatParticipantMetadata {
+		participant: string;
+		command?: string;
+		disambiguation: { category: string; description: string; examples: string[] }[];
+	}
+
+	export interface ChatParticipantDetectionResult {
+		participant: string;
+		command?: string;
+	}
+
+	export interface ChatParticipantDetectionProvider {
+		provideParticipantDetection(chatRequest: ChatRequest, context: ChatContext, options: { participants?: ChatParticipantMetadata[]; location: ChatLocation }, token: CancellationToken): ProviderResult<ChatParticipantDetectionResult>;
+	}
+
+	/*
+	 * User action events
+	 */
+
+	export enum ChatCopyKind {
+		// Keyboard shortcut or context menu
+		Action = 1,
+		Toolbar = 2
+	}
+
+	export interface ChatCopyAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'copy';
+		codeBlockIndex: number;
+		copyKind: ChatCopyKind;
+		copiedCharacters: number;
+		totalCharacters: number;
+		copiedText: string;
+	}
+
+	export interface ChatInsertAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'insert';
+		codeBlockIndex: number;
+		totalCharacters: number;
+		newFile?: boolean;
+	}
+
+	export interface ChatApplyAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'apply';
+		codeBlockIndex: number;
+		totalCharacters: number;
+		newFile?: boolean;
+		codeMapper?: string;
+	}
+
+	export interface ChatTerminalAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'runInTerminal';
+		codeBlockIndex: number;
+		languageId?: string;
+	}
+
+	export interface ChatCommandAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'command';
+		commandButton: ChatCommandButton;
+	}
+
+	export interface ChatFollowupAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'followUp';
+		followup: ChatFollowup;
+	}
+
+	export interface ChatBugReportAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'bug';
+	}
+
+	export interface ChatEditorAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'editor';
+		accepted: boolean;
+	}
+
+	export interface ChatEditingSessionAction {
+		// eslint-disable-next-line local/vscode-dts-string-type-literals
+		kind: 'chatEditingSessionAction';
+		uri: Uri;
+		hasRemainingEdits: boolean;
+		outcome: ChatEditingSessionActionOutcome;
+	}
+
+	export enum ChatEditingSessionActionOutcome {
+		Accepted = 1,
+		Rejected = 2
+	}
+
+	export interface ChatUserActionEvent {
+		readonly result: ChatResult;
+		readonly action: ChatCopyAction | ChatInsertAction | ChatApplyAction | ChatTerminalAction | ChatCommandAction | ChatFollowupAction | ChatBugReportAction | ChatEditorAction | ChatEditingSessionAction;
+	}
+
+	export interface ChatPromptReference {
+		/**
+		 * TODO Needed for now to drive the variableName-type reference, but probably both of these should go away in the future.
+		 */
+		readonly name: string;
+	}
+
+	export interface ChatResultFeedback {
+		readonly unhelpfulReason?: string;
+	}
+
+	export namespace lm {
+		export function fileIsIgnored(uri: Uri, token: CancellationToken): Thenable<boolean>;
+	}
+}
diff --git a/types/vscode.proposed.chatParticipantPrivate.d.ts b/types/vscode.proposed.chatParticipantPrivate.d.ts
new file mode 100644
index 0000000..3f056e6
--- /dev/null
+++ b/types/vscode.proposed.chatParticipantPrivate.d.ts
@@ -0,0 +1,119 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// version: 2
+
+declare module 'vscode' {
+
+	/**
+	 * The location at which the chat is happening.
+	 */
+	export enum ChatLocation {
+		/**
+		 * The chat panel
+		 */
+		Panel = 1,
+		/**
+		 * Terminal inline chat
+		 */
+		Terminal = 2,
+		/**
+		 * Notebook inline chat
+		 */
+		Notebook = 3,
+		/**
+		 * Code editor inline chat
+		 */
+		Editor = 4,
+		/**
+		 * Chat is happening in an editing session
+		 */
+		EditingSession = 5,
+	}
+
+	export class ChatRequestEditorData {
+		//TODO@API should be the editor
+		document: TextDocument;
+		selection: Selection;
+		wholeRange: Range;
+
+		constructor(document: TextDocument, selection: Selection, wholeRange: Range);
+	}
+
+	export class ChatRequestNotebookData {
+		//TODO@API should be the editor
+		readonly cell: TextDocument;
+
+		constructor(cell: TextDocument);
+	}
+
+	export interface ChatRequest {
+		/**
+		 * The attempt number of the request. The first request has attempt number 0.
+		 */
+		readonly attempt: number;
+
+		/**
+		 * If automatic command detection is enabled.
+		 */
+		readonly enableCommandDetection: boolean;
+
+		/**
+		 * If the chat participant or command was automatically assigned.
+		 */
+		readonly isParticipantDetected: boolean;
+
+		/**
+		 * The location at which the chat is happening. This will always be one of the supported values
+		 *
+		 * @deprecated
+		 */
+		readonly location: ChatLocation;
+
+		/**
+		 * Information that is specific to the location at which chat is happening, e.g within a document, notebook,
+		 * or terminal. Will be `undefined` for the chat panel.
+		 */
+		readonly location2: ChatRequestEditorData | ChatRequestNotebookData | undefined;
+	}
+
+	export interface ChatParticipant {
+		supportIssueReporting?: boolean;
+
+		/**
+		 * Temp, support references that are slow to resolve and should be tools rather than references.
+		 */
+		supportsSlowReferences?: boolean;
+	}
+
+	export interface ChatErrorDetails {
+		/**
+		 * If set to true, the message content is completely hidden. Only ChatErrorDetails#message will be shown.
+		 */
+		responseIsRedacted?: boolean;
+	}
+
+	export namespace chat {
+		export function createDynamicChatParticipant(id: string, dynamicProps: DynamicChatParticipantProps, handler: ChatExtendedRequestHandler): ChatParticipant;
+	}
+
+	/**
+	 * These don't get set on the ChatParticipant after creation, like other props, because they are typically defined in package.json and we want them at the time of creation.
+	 */
+	export interface DynamicChatParticipantProps {
+		name: string;
+		publisherName: string;
+		description?: string;
+		fullName?: string;
+	}
+
+	export namespace lm {
+		export function registerIgnoredFileProvider(provider: LanguageModelIgnoredFileProvider): Disposable;
+	}
+
+	export interface LanguageModelIgnoredFileProvider {
+		provideFileIgnored(uri: Uri, token: CancellationToken): ProviderResult<boolean>;
+	}
+}
diff --git a/types/vscode.proposed.chatProvider.d.ts b/types/vscode.proposed.chatProvider.d.ts
new file mode 100644
index 0000000..3ab4fb3
--- /dev/null
+++ b/types/vscode.proposed.chatProvider.d.ts
@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	export interface ChatResponseFragment {
+		index: number;
+		part: string;
+	}
+
+	export interface ChatResponseFragment2 {
+		index: number;
+		part: LanguageModelTextPart | LanguageModelToolCallPart;
+	}
+
+	// @API extension ship a d.ts files for their options
+
+	/**
+	 * Represents a large language model that accepts ChatML messages and produces a streaming response
+	 */
+	export interface LanguageModelChatProvider {
+
+		onDidReceiveLanguageModelResponse2?: Event<{ readonly extensionId: string; readonly participant?: string; readonly tokenCount?: number }>;
+
+		provideLanguageModelResponse(messages: LanguageModelChatMessage[], options: { [name: string]: any }, extensionId: string, progress: Progress<ChatResponseFragment>, token: CancellationToken): Thenable<any>;
+
+		provideLanguageModelResponse2?(messages: LanguageModelChatMessage[], options: LanguageModelChatRequestOptions, extensionId: string, progress: Progress<ChatResponseFragment2>, token: CancellationToken): Thenable<any>;
+
+		provideTokenCount(text: string | LanguageModelChatMessage, token: CancellationToken): Thenable<number>;
+	}
+
+	export type ChatResponseProvider = LanguageModelChatProvider;
+
+	export interface ChatResponseProviderMetadata {
+
+		readonly vendor: string;
+
+		/**
+		 * Human-readable name of the language model.
+		 */
+		readonly name: string;
+		/**
+		 * Opaque family-name of the language model. Values might be `gpt-3.5-turbo`, `gpt4`, `phi2`, or `llama`
+		 * but they are defined by extensions contributing languages and subject to change.
+		 */
+		readonly family: string;
+
+		/**
+		 * Opaque version string of the model. This is defined by the extension contributing the language model
+		 * and subject to change while the identifier is stable.
+		 */
+		readonly version: string;
+
+		readonly maxInputTokens: number;
+
+		readonly maxOutputTokens: number;
+
+		/**
+		 * When present, this gates the use of `requestLanguageModelAccess` behind an authorization flow where
+		 * the user must approve of another extension accessing the models contributed by this extension.
+		 * Additionally, the extension can provide a label that will be shown in the UI.
+		 */
+		auth?: true | { label: string };
+
+		// TODO@API maybe an enum, LanguageModelChatProviderPickerAvailability?
+		readonly isDefault?: boolean;
+		readonly isUserSelectable?: boolean;
+	}
+
+	export interface ChatResponseProviderMetadata {
+		// limit this provider to some extensions
+		extensions?: string[];
+	}
+
+	export namespace chat {
+
+		/**
+		 * @deprecated use `lm.registerChatResponseProvider` instead
+		*/
+		export function registerChatResponseProvider(id: string, provider: ChatResponseProvider, metadata: ChatResponseProviderMetadata): Disposable;
+	}
+
+	export namespace lm {
+
+		export function registerChatModelProvider(id: string, provider: LanguageModelChatProvider, metadata: ChatResponseProviderMetadata): Disposable;
+	}
+
+}
diff --git a/types/vscode.proposed.chatVariableResolver.d.ts b/types/vscode.proposed.chatVariableResolver.d.ts
new file mode 100644
index 0000000..ec386ec
--- /dev/null
+++ b/types/vscode.proposed.chatVariableResolver.d.ts
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	export namespace chat {
+
+		/**
+		 * Register a variable which can be used in a chat request to any participant.
+		 * @param id A unique ID for the variable.
+		 * @param name The name of the variable, to be used in the chat input as `#name`.
+		 * @param userDescription A description of the variable for the chat input suggest widget.
+		 * @param modelDescription A description of the variable for the model.
+		 * @param isSlow Temp, to limit access to '#codebase' which is not a 'reference' and will fit into a tools API later.
+		 * @param resolver Will be called to provide the chat variable's value when it is used.
+		 * @param fullName The full name of the variable when selecting context in the picker UI.
+		 * @param icon An icon to display when selecting context in the picker UI.
+		 */
+		export function registerChatVariableResolver(id: string, name: string, userDescription: string, modelDescription: string | undefined, isSlow: boolean | undefined, resolver: ChatVariableResolver, fullName?: string, icon?: ThemeIcon): Disposable;
+	}
+
+	export interface ChatVariableValue {
+		/**
+		 * The detail level of this chat variable value. If possible, variable resolvers should try to offer shorter values that will consume fewer tokens in an LLM prompt.
+		 */
+		level: ChatVariableLevel;
+
+		/**
+		 * The variable's value, which can be included in an LLM prompt as-is, or the chat participant may decide to read the value and do something else with it.
+		 */
+		value: string | Uri;
+
+		/**
+		 * A description of this value, which could be provided to the LLM as a hint.
+		 */
+		description?: string;
+	}
+
+	// TODO@API align with ChatRequest
+	export interface ChatVariableContext {
+		/**
+		 * The message entered by the user, which includes this variable.
+		 */
+		// TODO@API AS-IS, variables as types, agent/commands stripped
+		prompt: string;
+
+		// readonly variables: readonly ChatResolvedVariable[];
+	}
+
+	export interface ChatVariableResolver {
+		/**
+		 * A callback to resolve the value of a chat variable.
+		 * @param name The name of the variable.
+		 * @param context Contextual information about this chat request.
+		 * @param token A cancellation token.
+		 */
+		resolve(name: string, context: ChatVariableContext, token: CancellationToken): ProviderResult<ChatVariableValue[]>;
+
+		/**
+		 * A callback to resolve the value of a chat variable.
+		 * @param name The name of the variable.
+		 * @param context Contextual information about this chat request.
+		 * @param token A cancellation token.
+		*/
+		resolve2?(name: string, context: ChatVariableContext, stream: ChatVariableResolverResponseStream, token: CancellationToken): ProviderResult<ChatVariableValue[]>;
+	}
+
+
+	/**
+	 * The detail level of this chat variable value.
+	 */
+	export enum ChatVariableLevel {
+		Short = 1,
+		Medium = 2,
+		Full = 3
+	}
+
+	export interface ChatVariableResolverResponseStream {
+		/**
+		 * Push a progress part to this stream. Short-hand for
+		 * `push(new ChatResponseProgressPart(value))`.
+		 *
+		 * @param value
+		 * @returns This stream.
+		 */
+		progress(value: string): ChatVariableResolverResponseStream;
+
+		/**
+		 * Push a reference to this stream. Short-hand for
+		 * `push(new ChatResponseReferencePart(value))`.
+		 *
+		 * *Note* that the reference is not rendered inline with the response.
+		 *
+		 * @param value A uri or location
+		 * @returns This stream.
+		 */
+		reference(value: Uri | Location): ChatVariableResolverResponseStream;
+
+		/**
+		 * Pushes a part to this stream.
+		 *
+		 * @param part A response part, rendered or metadata
+		 */
+		push(part: ChatVariableResolverResponsePart): ChatVariableResolverResponseStream;
+	}
+
+	export type ChatVariableResolverResponsePart = ChatResponseProgressPart | ChatResponseReferencePart;
+}
diff --git a/types/vscode.proposed.defaultChatParticipant.d.ts b/types/vscode.proposed.defaultChatParticipant.d.ts
new file mode 100644
index 0000000..927bc75
--- /dev/null
+++ b/types/vscode.proposed.defaultChatParticipant.d.ts
@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// version: 2
+
+declare module 'vscode' {
+
+	export interface ChatWelcomeMessageContent {
+		icon: ThemeIcon;
+		title: string;
+		message: MarkdownString;
+	}
+
+	export interface ChatWelcomeMessageProvider {
+		provideWelcomeMessage?(token: CancellationToken): ProviderResult<ChatWelcomeMessageContent>;
+		provideSampleQuestions?(location: ChatLocation, token: CancellationToken): ProviderResult<ChatFollowup[]>;
+	}
+
+	export interface ChatRequesterInformation {
+		name: string;
+
+		/**
+		 * A full URI for the icon of the request.
+		 */
+		icon?: Uri;
+	}
+
+	export interface ChatTitleProvider {
+		/**
+		 * TODO@API Should this take a ChatResult like the followup provider, or just take a new ChatContext that includes the current message as history?
+		 */
+		provideChatTitle(context: ChatContext, token: CancellationToken): ProviderResult<string>;
+	}
+
+	export interface ChatParticipant {
+		/**
+		 * When true, this participant is invoked when the user submits their query using ctrl/cmd+enter
+		 * TODO@API name
+		 */
+		isSecondary?: boolean;
+
+		/**
+		 * A string that will be added before the listing of chat participants in `/help`.
+		 */
+		helpTextPrefix?: string | MarkdownString;
+
+		/**
+		 * A string that will be added before the listing of chat variables in `/help`.
+		 */
+		helpTextVariablesPrefix?: string | MarkdownString;
+
+		/**
+		 * A string that will be appended after the listing of chat participants in `/help`.
+		 */
+		helpTextPostfix?: string | MarkdownString;
+
+		welcomeMessageProvider?: ChatWelcomeMessageProvider;
+		titleProvider?: ChatTitleProvider;
+		requester?: ChatRequesterInformation;
+	}
+}
diff --git a/types/vscode.proposed.terminalExecuteCommandEvent.d.ts b/types/vscode.proposed.terminalExecuteCommandEvent.d.ts
new file mode 100644
index 0000000..5d28eb3
--- /dev/null
+++ b/types/vscode.proposed.terminalExecuteCommandEvent.d.ts
@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	// https://github.com/microsoft/vscode/issues/145234
+
+	export interface TerminalExecutedCommand {
+		/**
+		 * The {@link Terminal} the command was executed in.
+		 */
+		terminal: Terminal;
+		/**
+		 * The full command line that was executed, including both the command and the arguments.
+		 */
+		commandLine: string | undefined;
+		/**
+		 * The current working directory that was reported by the shell. This will be a {@link Uri}
+		 * if the string reported by the shell can reliably be mapped to the connected machine.
+		 */
+		cwd: Uri | string | undefined;
+		/**
+		 * The exit code reported by the shell.
+		 */
+		exitCode: number | undefined;
+		/**
+		 * The output of the command when it has finished executing. This is the plain text shown in
+		 * the terminal buffer and does not include raw escape sequences. Depending on the shell
+		 * setup, this may include the command line as part of the output.
+		 */
+		output: string | undefined;
+	}
+
+	export namespace window {
+		/**
+		 * An event that is emitted when a terminal with shell integration activated has completed
+		 * executing a command.
+		 *
+		 * Note that this event will not fire if the executed command exits the shell, listen to
+		 * {@link onDidCloseTerminal} to handle that case.
+		 *
+		 * @deprecated Use {@link window.onDidStartTerminalShellExecution}
+		 */
+		export const onDidExecuteTerminalCommand: Event<TerminalExecutedCommand>;
+	}
+}
diff --git a/types/vscode.proposed.terminalSelection.d.ts b/types/vscode.proposed.terminalSelection.d.ts
new file mode 100644
index 0000000..706bcda
--- /dev/null
+++ b/types/vscode.proposed.terminalSelection.d.ts
@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+
+	// https://github.com/microsoft/vscode/issues/188173
+
+	export interface Terminal {
+		/**
+		 * The selected text of the terminal or undefined if there is no selection.
+		 */
+		readonly selection: string | undefined;
+	}
+}