@sourcegraph/cody-web 0.36.0 → 0.38.0

package/dist/{agent.worker-CF9GgIzt.mjs → agent.worker-Bm74MuX8.mjs}

@@ -18,8 +18,8 @@ var __privateWrapper = (obj, member, setter2, getter) => ({
   }
 });
 var _root, _hasMagic, _uflag, _parts, _parent, _parentIndex, _negs, _filledNegs, _options, _toString, _emptyExt, _AST_instances, fillNegs_fn, _AST_static, parseAST_fn, partsToRegExp_fn, parseGlob_fn, _a2, _b, _c, _d, _e, _constructing, _f, _g, _max, _maxSize, _dispose, _disposeAfter, _fetchMethod, _size, _calculatedSize, _keyMap, _keyList, _valList, _next, _prev, _head, _tail, _free, _disposed, _sizes, _starts, _ttls, _hasDispose, _hasFetchMethod, _hasDisposeAfter, _LRUCache_instances, initializeTTLTracking_fn, _updateItemAge, _statusTTL, _setItemTTL, _isStale, initializeSizeTracking_fn, _removeItemSize, _addItemSize, _requireSize, indexes_fn, rindexes_fn, isValidIndex_fn, evict_fn, backgroundFetch_fn, isBackgroundFetch_fn, connect_fn2, moveToTail_fn, _h, _i, _j, _k, _l;
-import { O as Observable, aR as unsubscribe, aS as AsyncSerialScheduler, aT as authStatus, aU as pick, aV as distinctUntilChanged$1, aW as switchMapReplayOperation, aX as pendingOperation, aY as promiseFactoryToObservable, J as map$1, ac as isError$3, aZ as retry$1, a_ as logError$2, aE as firstResultFromOperation, a$ as graphqlClient, P as isDotCom, b0 as semver, b1 as debounceTime, b2 as interval, b3 as filter$3, b4 as startWith$1, b5 as switchMap$1, ar as firstValueFrom$1, as as skipPendingOperation, b6 as logDebug$1, b7 as isAbortError, b8 as expand, ab as LRUCache$1, b9 as TRANSIENT_REFETCH_INTERVAL_HINT, ba as createSubscriber, bb as fromVSCodeEvent, D as isEqual, bc as cenv, aC as lodashExports, bd as EXCLUDE_EVERYTHING_CONTEXT_FILTERS, be as isFileURI, w as wrapInActiveSpan, bf as INCLUDE_EVERYTHING_CONTEXT_FILTERS, bg as onAbort, bh as CHAT_INPUT_TOKEN_BUDGET, bi as CHAT_OUTPUT_TOKEN_BUDGET, ah as ModelTag, bj as EXTENDED_CHAT_INPUT_TOKEN_BUDGET, bk as EXTENDED_USER_CONTEXT_TOKEN_BUDGET, bl as addCodyClientIdentificationHeaders, bm as addTraceparent, bn as addAuthHeaders, bo as fetch$2, bp as verifyResponseCode, H as combineLatest$1, bq as take$2, br as clientCapabilities, bs as shareReplay$1, bt as tap$2, bu as featureFlagProvider, ae as FeatureFlag, bv as telemetryRecorder, bw as currentAuthStatusOrNotReadyYet, bx as mockAuthStatus, by as storeLastValue, bz as resolvedConfig, bA as ps, bB as GuardrailsMode, bC as currentResolvedConfig, aN as PromptString, a7 as CodyIDE, bD as CORPUS_CONTEXT_ALLOCATION, bE as recordErrorToSpan, bF as addClientInfoParams, bG as dependentAbortController, F as FILE_CONTEXT_MENTION_PROVIDER, S as SYMBOL_CONTEXT_MENTION_PROVIDER, R as REMOTE_REPOSITORY_PROVIDER_URI, a as REMOTE_FILE_PROVIDER_URI, b as REMOTE_DIRECTORY_PROVIDER_URI, W as WEB_PROVIDER_URI, C as ContextItemSource, bH as isS2, bI as GIT_OPENCTX_PROVIDER_URI, bJ as CODE_SEARCH_PROVIDER_URI, a9 as cryptoJsExports, bK as currentOpenCtxController, m as URI, bL as MulticastSubject, bM as AsyncSerialScheduler_1, g as getDefaultExportFromCjs, bN as workspace, p as path$1, bO as vscode, bP as Range, bQ as commands$1, bR as window$1, bS as Selection, U as Uri, bT as AgentEventEmitter, bU as MarkdownString, bV as Disposable, bW as TextEditorRevealType, bX as ThemeIcon, bY as StatusBarAlignment, bZ as readFile, b_ as env, b$ as UIKind, c0 as languages$1, c as commonjsGlobal, c1 as InvalidAccessTokenError, c2 as _baseAssignValue, c3 as eq_1, c4 as isArrayLike_1, c5 as isObjectLike_1, c6 as _copyObject, c7 as keysIn_1, c8 as _cloneBufferExports, c9 as _cloneTypedArray, ca as _copyArray, cb as _initCloneObject, cc as isArguments_1, cd as isArray_1, ce as isBufferExports, cf as isFunction_1, cg as isObject_1, ch as isPlainObject_1, ci as isTypedArray_1, cj as _Stack, ck as identity_1, cl as _overRest, cm as _setToString, cn as _isIndex, Y as isSourcegraphToken, aB as v4, co as CONFIG_KEY, aK as CodyAutoSuggestionMode, cp as ConfigurationTarget, cq as pathBrowserify, cr as stat, cs as extensions, ct as version$2, cu as setExtensionVersion, cv as isInvalidAccessTokenError, cw as DOTCOM_URL, cx as isNeedsAuthChallengeError, cy as EMPTY$1, cz as disposableSubscription, cA as externalAuthRefresh, cB as setAuthStatusObservable, X as isAvailabilityError, cC as normalizeServerEndpointURL, cD as AuthConfigError, Q as isWorkspaceInstance, cE as SourcegraphGraphQLAPIClient, cF as isExternalProviderAuthError, cG as isNetworkLikeError, cH as NeedsAuthChallengeError, cI as AvailabilityError, cJ as currentAuthStatus, cK as resolveAuth, cL as QuickPickItemKind, cM as getAuthHeaders, cN as toLightweightChatTranscript, cO as SUPPORTED_URI_SCHEMAS, cP as RelativePattern, cQ as _baseIsEqual, cR as keys_1, cS as _baseGet, cT as _castPath, cU as isLength_1, cV as _toKey, cW as _isKey, cX as toNumber_1, cY as _baseFindIndex, cZ as require$$0$2, c_ as NetworkError, c$ as isRateLimitError, V as isAuthError, d0 as FileType, d1 as dedent$1, d2 as FoldingRange, d3 as CancellationTokenSource, d4 as SymbolKind, d5 as convertGitCloneURLToCodebaseName, aI as isDefined, d6 as pluck, d7 as toRangeData, d8 as Position, d9 as DefaultChatCommands, da as pathFunctionsForURI, db as uriParseNameAndExtension, dc as uriDirname, dd as Utils$1, de as uriExtname, df as uriBasename, dg as DefaultEditCommands, dh as subscriptionDisposable, di as updateGlobalTelemetryInstances, dj as TelemetryRecorderProvider, dk as telemetryRecorderProvider, dl as createGitDiff, dm as AgentWorkspaceEdit, dn as TextDocumentChangeReason, dp as omit$1, dq as getEditorInsertSpaces, dr as escapeRegExp$1, ds as TimeoutError, dt as isNetworkError, du as displayPathWithoutWorkspaceFolderPrefix, dv as http, dw as open, dx as defer$2, dy as merge$2, dz as abortableOperation, dA as ruleSearchPaths, dB as isRuleFilename, dC as parseRuleFile, dD as languageFromFilename, f as displayLineRange, e as displayPath, dE as ruleTitle, dF as debounce_1, aM as isErrorLike, dG as isWindows, dH as GLOBAL_SEARCH_PROVIDER_URI, dI as mentionProvidersMetadata, dJ as ThemeColor, dK as QuickInputButtons, E as scanForMentionTriggerInUserTextInput, u as parseMentionQuery, L as LARGE_FILE_WARNING_LABEL, dL as GENERAL_HELP_LABEL, a8 as CodyTaskState, dM as CodeLens, dN as defaultWebviewPanel, x as createExtensionAPI, y as createMessageAPIForWebview, dO as EndOfLine, dP as ViewColumn, dQ as Location, dR as onDidChangeActiveTextEditor, dS as tabGroups, dT as workspaceTextDocuments, dU as visibleTextEditors, dV as onDidChangeVisibleTextEditors, dW as fs, dX as onDidCloseTextDocument, dY as setCreateWebviewPanel, dZ as getAugmentedNamespace, d_ as extensionConfiguration, d$ as main$1, e0 as setAgent, e1 as setWorkspaceDocuments, e2 as setLastOpenedWorkspaceFolder, e3 as onDidRegisterNewCodeActionProvider, e4 as onDidUnregisterNewCodeActionProvider, e5 as onDidRegisterNewCodeLensProvider, e6 as onDidUnregisterNewCodeLensProvider, e7 as setClientInfo, e8 as firstNonPendingAuthStatus, e9 as workspaceFolders$1, ea as setWorkspaceFolders, eb as onDidChangeWorkspaceFolders, ec as onDidChangeWindowState, ed as onDidOpenTextDocument, ee as onDidSaveTextDocument, ef as onDidRenameFiles, eg as packageJson, eh as progressBars, ei as CodeActionTriggerKind, ej as CodeAction, ek as UriString, el as DiagnosticSeverity, em as diagnostics, en as isIntegrationTesting, eo as TESTING_TELEMETRY_EXPORTER, ep as ProgressLocation, eq as dist, er as completionProvider, es as InlineCompletionTriggerKind, et as currentAuthStatusAuthed, eu as waitUntilComplete, ev as setExtensionConfiguration, ew as onDidChangeConfiguration, ex as onDidChangeTextDocument, ey as onDidChangeTextEditorSelection, an as isMacOS, ap as CustomCommandType, aL as setDisplayPathEnvInfo, aG as ACCOUNT_USAGE_URL, z as debounce$1, ez as structuredPatch, eA as dedupeWith$1, eB as AbortError, eC as createDisposables, eD as isNodeResponse, eE as getClientInfoQueryParams, eF as tracer, eG as getActiveTraceAndSpanId, eH as getClientIdentificationHeaders, eI as setJSONAcceptContentTypeHeaders, eJ as logResponseHeadersToSpan, eK as isCustomAuthChallengeResponse, eL as TracedError, $ as SpanStatusCode, ad as RateLimitError$1, eM as capitalize, eN as InlineCompletionItem, eO as createTwoFilesPatch, eP as vsCodeMocks, a2 as whitespace, a0 as svg, a3 as find$1, a4 as stringify$1, a5 as stringify$2, a6 as ccount, a1 as html$3, eQ as getEditorTabSize$1, eR as metrics, eS as _, aD as deserializeContextItem, eT as editorStateFromPromptString, eU as _baseGetTag, ag as isAbortErrorOrSocketHangUp, eV as inputTextWithoutContextChipsFromPromptEditorState, ai as DeepCodyAgentID, eW as exec, s as spawn, aw as UIToolStatus, i as displayPathBasename, eX as expandToLineRange, eY as openctxController, eZ as openCtxProviderMetadata, e_ as CODY_PASSTHROUGH_VSCODE_OPEN_COMMAND_ID, e$ as catchError$1, ay as diffWithLineNum, az as UITerminalOutputType, f0 as getPlatform$1, f1 as PromptMode, f2 as skip$1, _ as context, f3 as extractContextFromTraceparent, f4 as isContextWindowLimitError, q as serializeContextItem, K as forceHydration, af as reformatBotMessageForChat, M as hydrateAfterPostMessage, f5 as addMessageListenersForExtensionAPI, f6 as createMessageAPIForExtension, am as View, aF as ChatHistoryType, f7 as NEVER$1, f8 as CodeActionKind, av as pluralize, f9 as assertFileURI, d as RULES_PROVIDER_URI, fa as createCodeSearchProvider, fb as ProgrammingLanguage, fc as psDedent, fd as formatRuleForPrompt, fe as posixFilePaths, ff as DecorationRangeBehavior, fg as diffLines, fh as CODY_SUPPORT_URL, fi as CODY_DOC_URL, fj as CODY_FEEDBACK_URL, fk as DISCORD_URL, fl as globalAgentRef, fm as VSCODE_CHANGELOG_URL, fn as SG_CHANGELOG_URL, fo as ACCOUNT_LIMITS_INFO_URL, fp as assertUnreachable, fq as promise, fr as ExtensionMode, fs as setLogger, ft as setClientCapabilities, fu as setResolvedConfigurationObservable, fv as setClientNameVersion, fw as setOpenCtxControllerObservable, aJ as browser$4 } from "./vscode-shim-Csgwpsv8.mjs";
-import { r as requireUtil, i as inherits_browserExports, a as utilExports } from "./util-D8ltdME7.mjs";
+import { dt as Observable, dX as unsubscribe, dY as AsyncSerialScheduler, de as authStatus, cB as pick, cF as distinctUntilChanged$1, c$ as switchMapReplayOperation, c_ as pendingOperation, co as promiseFactoryToObservable, dw as map$1, a as isError$3, cZ as retry$1, a8 as logError$1, d1 as firstResultFromOperation, aD as graphqlClient, ag as isDotCom, dZ as semver, cP as debounceTime, d_ as interval, cX as filter$3, cJ as startWith$1, cN as switchMap$1, ci as firstValueFrom$1, d0 as skipPendingOperation, a7 as logDebug, i as isAbortError, d$ as expand, dK as LRUCache$1, e0 as TRANSIENT_REFETCH_INTERVAL_HINT, aR as createSubscriber, cw as fromVSCodeEvent, dv as isEqual, dc as cenv, dS as lodashExports, aG as EXCLUDE_EVERYTHING_CONTEXT_FILTERS, J as isFileURI, w as wrapInActiveSpan, aF as INCLUDE_EVERYTHING_CONTEXT_FILTERS, bn as onAbort, bN as CHAT_INPUT_TOKEN_BUDGET, bP as CHAT_OUTPUT_TOKEN_BUDGET, M as ModelTag, bS as EXTENDED_CHAT_INPUT_TOKEN_BUDGET, bR as EXTENDED_USER_CONTEXT_TOKEN_BUDGET, ae as addCodyClientIdentificationHeaders, bw as addTraceparent, bM as addAuthHeaders, bI as fetch$2, e1 as verifyResponseCode, ct as combineLatest$1, cK as take$2, d7 as clientCapabilities, cC as shareReplay$1, cG as tap$2, a3 as featureFlagProvider, a2 as FeatureFlag, bs as telemetryRecorder, dh as currentAuthStatusOrNotReadyYet, dj as mockAuthStatus, cO as storeLastValue, d4 as resolvedConfig, bD as AUTH_STATUS_FIXTURE_AUTHED_DOTCOM, bF as ps, e2 as logInfo, a5 as GuardrailsMode, d5 as currentResolvedConfig, bE as PromptString, bT as CodyIDE, T as displayPath, bQ as CORPUS_CONTEXT_ALLOCATION, bz as recordErrorToSpan, aa as addClientInfoParams, bm as dependentAbortController, aY as FILE_CONTEXT_MENTION_PROVIDER, aZ as SYMBOL_CONTEXT_MENTION_PROVIDER, b0 as REMOTE_REPOSITORY_PROVIDER_URI, b1 as REMOTE_FILE_PROVIDER_URI, b2 as REMOTE_DIRECTORY_PROVIDER_URI, b3 as WEB_PROVIDER_URI, C as ContextItemSource, bd as isS2, b4 as GIT_OPENCTX_PROVIDER_URI, b5 as CODE_SEARCH_PROVIDER_URI, dJ as cryptoJsExports, b7 as currentOpenCtxController, c as URI, e3 as MulticastSubject, e4 as AsyncSerialScheduler_1, dn as getDefaultExportFromCjs, e5 as workspace, p as path$1, e6 as vscode, e7 as Range, e8 as commands$1, e9 as window$1, ea as Selection, U as Uri, eb as AgentEventEmitter, ec as MarkdownString, ed as Disposable, ee as TextEditorRevealType, ef as ThemeIcon, eg as StatusBarAlignment, eh as readFile, ei as env, ej as UIKind, ek as languages$1, dm as commonjsGlobal, an as InvalidAccessTokenError, el as _baseAssignValue, em as eq_1, en as isArrayLike_1, eo as isObjectLike_1, ep as _copyObject, eq as keysIn_1, er as _cloneBufferExports, es as _cloneTypedArray, et as _copyArray, eu as _initCloneObject, ev as isArguments_1, ew as isArray_1, ex as isBufferExports, ey as isFunction_1, ez as isObject_1, eA as isPlainObject_1, eB as isTypedArray_1, eC as _Stack, eD as identity_1, eE as _overRest, eF as _setToString, eG as _isIndex, dx as isSourcegraphToken, dR as v4, eH as CONFIG_KEY, bU as CodyAutoSuggestionMode, eI as ConfigurationTarget, eJ as appendFileSync, eK as pathBrowserify, eL as stat, eM as extensions, eN as version$2, d9 as setExtensionVersion, eO as normalizeServerEndpointURL, ax as isInvalidAccessTokenError, eP as isOAuthProviderError, af as DOTCOM_URL, ay as isNeedsAuthChallengeError, cq as EMPTY$1, cf as disposableSubscription, eQ as externalAuthRefresh, dd as setAuthStatusObservable, av as isAvailabilityError, aj as AuthConfigError, be as isWorkspaceInstance, aC as SourcegraphGraphQLAPIClient, eR as isExternalAuthProviderError, aA as isNetworkLikeError, ao as NeedsAuthChallengeError, al as AvailabilityError, df as currentAuthStatus, eS as resolveAuth, eT as QuickPickItemKind, eU as revokeOAuthTokens, bL as getAuthHeaders, eV as toLightweightChatTranscript, S as SUPPORTED_URI_SCHEMAS, eW as RelativePattern, eX as _baseIsEqual, eY as keys_1, eZ as _baseGet, e_ as _castPath, e$ as isLength_1, f0 as _toKey, f1 as _isKey, f2 as toNumber_1, f3 as _baseFindIndex, f4 as require$$0$2, ap as NetworkError, aB as isRateLimitError, au as isAuthError, f5 as FileType, f6 as dedent$1, f7 as FoldingRange, f8 as CancellationTokenSource, f9 as SymbolKind, aQ as convertGitCloneURLToCodebaseName, b as isDefined, cA as pluck, t as toRangeData, fa as Position, D as DefaultChatCommands, A as pathFunctionsForURI, R as uriParseNameAndExtension, O as uriDirname, fb as Utils$1, Q as uriExtname, K as uriBasename, h as DefaultEditCommands, ce as subscriptionDisposable, bt as updateGlobalTelemetryInstances, aN as TelemetryRecorderProvider, br as telemetryRecorderProvider, bf as createGitDiff, fc as AgentWorkspaceEdit, fd as TextDocumentChangeReason, fe as omit$1, bo as getEditorInsertSpaces, ff as escapeRegExp$1, ar as TimeoutError, az as isNetworkError, Z as displayPathWithoutWorkspaceFolderPrefix, fg as http, fh as open, cW as defer$2, cs as merge$2, cT as abortableOperation, bl as ruleSearchPaths, bi as isRuleFilename, bk as parseRuleFile, q as languageFromFilename, m as displayLineRange, bj as ruleTitle, fi as debounce_1, k as isErrorLike, d as isWindows, b6 as GLOBAL_SEARCH_PROVIDER_URI, aW as mentionProvidersMetadata, fj as ThemeColor, fk as QuickInputButtons, aV as scanForMentionTriggerInUserTextInput, aU as parseMentionQuery, L as LARGE_FILE_WARNING_LABEL, G as GENERAL_HELP_LABEL, dI as CodyTaskState, fl as CodeLens, fm as defaultWebviewPanel, cd as createExtensionAPI, bb as createMessageAPIForWebview, y as isMatlabFile, fn as EndOfLine, fo as ViewColumn, fp as Location, fq as onDidChangeActiveTextEditor, fr as tabGroups, fs as workspaceTextDocuments, ft as visibleTextEditors, fu as onDidChangeVisibleTextEditors, fv as fs, fw as onDidCloseTextDocument, fx as setCreateWebviewPanel, fy as getAugmentedNamespace, fz as extensionConfiguration, fA as existsSync, fB as rmSync, fC as mkdirSync, fD as main$1, fE as setAgent, fF as setWorkspaceDocuments, fG as setLastOpenedWorkspaceFolder, fH as onDidRegisterNewCodeActionProvider, fI as onDidUnregisterNewCodeActionProvider, fJ as onDidRegisterNewCodeLensProvider, fK as onDidUnregisterNewCodeLensProvider, fL as setClientInfo, di as firstNonPendingAuthStatus, fM as workspaceFolders$1, fN as setWorkspaceFolders, fO as onDidChangeWorkspaceFolders, fP as onDidChangeWindowState, fQ as onDidOpenTextDocument, fR as onDidSaveTextDocument, fS as onDidRenameFiles, fT as packageJson, fU as progressBars, fV as CodeActionTriggerKind, fW as CodeAction, fX as UriString, fY as DiagnosticSeverity, fZ as diagnostics, f_ as isIntegrationTesting, f$ as TESTING_TELEMETRY_EXPORTER, g0 as ProgressLocation, g1 as dist, g2 as completionProvider, g3 as InlineCompletionTriggerKind, dg as currentAuthStatusAuthed, ck as waitUntilComplete, g4 as setExtensionConfiguration, g5 as onDidChangeConfiguration, g6 as onDidChangeTextDocument, g7 as onDidChangeTextEditorSelection, g8 as statSync, g9 as copySync, E as isMacOS, g as CustomCommandType, _ as setDisplayPathEnvInfo, dU as ACCOUNT_USAGE_URL, ga as getOIDCConfiguration$1, gb as getOAuthClientId, gc as OAuthCredential, du as debounce$1, gd as structuredPatch, j as dedupeWith$1, ai as AbortError, cz as createDisposables, aE as isNodeResponse, ab as getClientInfoQueryParams, bu as tracer, bv as getActiveTraceAndSpanId, ac as getClientIdentificationHeaders, aI as setJSONAcceptContentTypeHeaders, bx as logResponseHeadersToSpan, aJ as isCustomAuthChallengeResponse, as as TracedError, dA as SpanStatusCode, aq as RateLimitError$1, ge as capitalize, gf as InlineCompletionItem, gg as createTwoFilesPatch, gh as vsCodeMocks, dD as whitespace, dB as svg, dE as find$1, dF as stringify$1, dG as stringify$2, dH as ccount, dC as html$3, bp as getEditorTabSize$1, gi as metrics, gj as _, c6 as deserializeContextItem, c2 as editorStateFromPromptString, gk as _baseGetTag, at as isAbortErrorOrSocketHangUp, b_ as inputTextWithoutContextChipsFromPromptEditorState, dL as DeepCodyAgentID, gl as exec, s as spawn, dk as UIToolStatus, W as displayPathBasename, o as expandToLineRange, a$ as openctxController, aX as openCtxProviderMetadata, e as CODY_PASSTHROUGH_VSCODE_OPEN_COMMAND_ID, cU as catchError$1, dP as diffWithLineNum, dl as UITerminalOutputType, gm as getPlatform$1, aH as PromptMode, cL as skip$1, dz as context, bA as extractContextFromTraceparent, aw as isContextWindowLimitError, c5 as serializeContextItem, a0 as forceHydration, r as reformatBotMessageForChat, a1 as hydrateAfterPostMessage, ba as addMessageListenersForExtensionAPI, bc as createMessageAPIForExtension, dM as View, dT as ChatHistoryType, cr as NEVER$1, gn as CodeActionKind, l as pluralize, H as assertFileURI, b8 as RULES_PROVIDER_URI, go as createCodeSearchProvider, u as languageFromFilenameAndContent, P as ProgrammingLanguage, bG as psDedent, gp as formatRuleForPrompt, z as posixFilePaths, gq as DecorationRangeBehavior, gr as diffLines, gs as CODY_SUPPORT_URL, gt as CODY_DOC_URL, gu as DISCORD_URL, bJ as globalAgentRef, gv as VSCODE_CHANGELOG_URL, gw as SG_CHANGELOG_URL, gx as ACCOUNT_LIMITS_INFO_URL, aP as assertUnreachable, aT as promise, gy as ExtensionMode, a9 as setLogger, d8 as setClientCapabilities, d2 as setResolvedConfigurationObservable, ad as setClientNameVersion, a_ as setOpenCtxControllerObservable, dW as browser$4 } from "./vscode-shim-CdmSM8Q0.mjs";
+import { r as requireUtil, i as inherits_browserExports, a as utilExports } from "./util-Ci-ROool.mjs";
 var NOTHING = Symbol.for("immer-nothing");
 var DRAFTABLE = Symbol.for("immer-draftable");
 var DRAFT_STATE = Symbol.for("immer-state");
@@ -157,6 +157,10 @@ function getPlugin(pluginKey) {
   }
   return plugin;
 }
+function loadPlugin(pluginKey, implementation) {
+  if (!plugins[pluginKey])
+    plugins[pluginKey] = implementation;
+}
 var currentScope;
 function getCurrentScope$1() {
   return currentScope;
@@ -637,6 +641,254 @@ function currentImpl(value) {
   }
   return copy2;
 }
+function enableMapSet() {
+  class DraftMap extends Map {
+    constructor(target, parent) {
+      super();
+      this[DRAFT_STATE] = {
+        type_: 2,
+        parent_: parent,
+        scope_: parent ? parent.scope_ : getCurrentScope$1(),
+        modified_: false,
+        finalized_: false,
+        copy_: void 0,
+        assigned_: void 0,
+        base_: target,
+        draft_: this,
+        isManual_: false,
+        revoked_: false
+      };
+    }
+    get size() {
+      return latest(this[DRAFT_STATE]).size;
+    }
+    has(key2) {
+      return latest(this[DRAFT_STATE]).has(key2);
+    }
+    set(key2, value) {
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      if (!latest(state2).has(key2) || latest(state2).get(key2) !== value) {
+        prepareMapCopy(state2);
+        markChanged(state2);
+        state2.assigned_.set(key2, true);
+        state2.copy_.set(key2, value);
+        state2.assigned_.set(key2, true);
+      }
+      return this;
+    }
+    delete(key2) {
+      if (!this.has(key2)) {
+        return false;
+      }
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      prepareMapCopy(state2);
+      markChanged(state2);
+      if (state2.base_.has(key2)) {
+        state2.assigned_.set(key2, false);
+      } else {
+        state2.assigned_.delete(key2);
+      }
+      state2.copy_.delete(key2);
+      return true;
+    }
+    clear() {
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      if (latest(state2).size) {
+        prepareMapCopy(state2);
+        markChanged(state2);
+        state2.assigned_ = /* @__PURE__ */ new Map();
+        each(state2.base_, (key2) => {
+          state2.assigned_.set(key2, false);
+        });
+        state2.copy_.clear();
+      }
+    }
+    forEach(cb, thisArg) {
+      const state2 = this[DRAFT_STATE];
+      latest(state2).forEach((_value, key2, _map) => {
+        cb.call(thisArg, this.get(key2), key2, this);
+      });
+    }
+    get(key2) {
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      const value = latest(state2).get(key2);
+      if (state2.finalized_ || !isDraftable(value)) {
+        return value;
+      }
+      if (value !== state2.base_.get(key2)) {
+        return value;
+      }
+      const draft = createProxy(value, state2);
+      prepareMapCopy(state2);
+      state2.copy_.set(key2, draft);
+      return draft;
+    }
+    keys() {
+      return latest(this[DRAFT_STATE]).keys();
+    }
+    values() {
+      const iterator = this.keys();
+      return {
+        [Symbol.iterator]: () => this.values(),
+        next: () => {
+          const r2 = iterator.next();
+          if (r2.done)
+            return r2;
+          const value = this.get(r2.value);
+          return {
+            done: false,
+            value
+          };
+        }
+      };
+    }
+    entries() {
+      const iterator = this.keys();
+      return {
+        [Symbol.iterator]: () => this.entries(),
+        next: () => {
+          const r2 = iterator.next();
+          if (r2.done)
+            return r2;
+          const value = this.get(r2.value);
+          return {
+            done: false,
+            value: [r2.value, value]
+          };
+        }
+      };
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  }
+  function proxyMap_(target, parent) {
+    return new DraftMap(target, parent);
+  }
+  function prepareMapCopy(state2) {
+    if (!state2.copy_) {
+      state2.assigned_ = /* @__PURE__ */ new Map();
+      state2.copy_ = new Map(state2.base_);
+    }
+  }
+  class DraftSet extends Set {
+    constructor(target, parent) {
+      super();
+      this[DRAFT_STATE] = {
+        type_: 3,
+        parent_: parent,
+        scope_: parent ? parent.scope_ : getCurrentScope$1(),
+        modified_: false,
+        finalized_: false,
+        copy_: void 0,
+        base_: target,
+        draft_: this,
+        drafts_: /* @__PURE__ */ new Map(),
+        revoked_: false,
+        isManual_: false
+      };
+    }
+    get size() {
+      return latest(this[DRAFT_STATE]).size;
+    }
+    has(value) {
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      if (!state2.copy_) {
+        return state2.base_.has(value);
+      }
+      if (state2.copy_.has(value))
+        return true;
+      if (state2.drafts_.has(value) && state2.copy_.has(state2.drafts_.get(value)))
+        return true;
+      return false;
+    }
+    add(value) {
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      if (!this.has(value)) {
+        prepareSetCopy(state2);
+        markChanged(state2);
+        state2.copy_.add(value);
+      }
+      return this;
+    }
+    delete(value) {
+      if (!this.has(value)) {
+        return false;
+      }
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      prepareSetCopy(state2);
+      markChanged(state2);
+      return state2.copy_.delete(value) || (state2.drafts_.has(value) ? state2.copy_.delete(state2.drafts_.get(value)) : (
+        /* istanbul ignore next */
+        false
+      ));
+    }
+    clear() {
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      if (latest(state2).size) {
+        prepareSetCopy(state2);
+        markChanged(state2);
+        state2.copy_.clear();
+      }
+    }
+    values() {
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      prepareSetCopy(state2);
+      return state2.copy_.values();
+    }
+    entries() {
+      const state2 = this[DRAFT_STATE];
+      assertUnrevoked(state2);
+      prepareSetCopy(state2);
+      return state2.copy_.entries();
+    }
+    keys() {
+      return this.values();
+    }
+    [Symbol.iterator]() {
+      return this.values();
+    }
+    forEach(cb, thisArg) {
+      const iterator = this.values();
+      let result = iterator.next();
+      while (!result.done) {
+        cb.call(thisArg, result.value, result.value, this);
+        result = iterator.next();
+      }
+    }
+  }
+  function proxySet_(target, parent) {
+    return new DraftSet(target, parent);
+  }
+  function prepareSetCopy(state2) {
+    if (!state2.copy_) {
+      state2.copy_ = /* @__PURE__ */ new Set();
+      state2.base_.forEach((value) => {
+        if (isDraftable(value)) {
+          const draft = createProxy(value, state2);
+          state2.drafts_.set(value, draft);
+          state2.copy_.add(draft);
+        } else {
+          state2.copy_.add(value);
+        }
+      });
+    }
+  }
+  function assertUnrevoked(state2) {
+    if (state2.revoked_)
+      die$1(3, JSON.stringify(latest(state2)));
+  }
+  loadPlugin("MapSet", { proxyMap_, proxySet_ });
+}
 var immer = new Immer2();
 var produce = immer.produce;
 immer.produceWithPatches.bind(
@@ -697,13 +949,13 @@ function filter$2(test) {
     });
   };
 }
-var define_process_default$o = { env: {} };
+var define_process_default$p = { env: {} };
 let _editorWindowIsFocused;
 function setEditorWindowIsFocused(editorWindowIsFocused2) {
   _editorWindowIsFocused = editorWindowIsFocused2;
 }
 function editorWindowIsFocused() {
-  if (define_process_default$o.env.VITEST) {
+  if (define_process_default$p.env.VITEST) {
     return true;
   }
   if (!_editorWindowIsFocused) {
@@ -742,7 +994,7 @@ const siteVersion = authStatus.pipe(
   retry$1(3),
   map$1((siteVersion2) => {
     if (isError$3(siteVersion2)) {
-      logError$2("siteVersion", `Failed to get site version: ${siteVersion2}`);
+      logError$1("siteVersion", `Failed to get site version: ${siteVersion2}`);
       return null;
     }
     return siteVersion2;
@@ -753,7 +1005,7 @@ async function currentSiteVersion() {
   const authStatus2 = await firstResultFromOperation(authStatusAuthed);
   const siteVersion2 = await graphqlClient.getSiteVersion();
   if (isError$3(siteVersion2)) {
-    logError$2("siteVersion", `Failed to get site version from ${authStatus2.endpoint}: ${siteVersion2}`);
+    logError$1("siteVersion", `Failed to get site version from ${authStatus2.endpoint}: ${siteVersion2}`);
     return siteVersion2;
   }
   const isDotComUser = isDotCom(authStatus2);
@@ -830,7 +1082,7 @@ function parseDateFromPreReleaseVersion(version2) {
     return void 0;
   }
 }
-var define_process_default$n = { env: {} };
+var define_process_default$o = { env: {} };
 const _ClientConfigSingleton = class _ClientConfigSingleton {
   constructor() {
     // Default values for the legacy GraphQL features API, used when a Sourcegraph instance
@@ -888,7 +1140,7 @@ const _ClientConfigSingleton = class _ClientConfigSingleton {
     return await firstValueFrom$1(this.changes.pipe(skipPendingOperation()), signal2);
   }
   async fetchConfig(signal2) {
-    logDebug$1("ClientConfigSingleton", "refreshing configuration");
+    logDebug("ClientConfigSingleton", "refreshing configuration");
     let omniBoxEnabled = false;
     return graphqlClient.getSiteVersion(signal2).then((siteVersion2) => {
       signal2 == null ? void 0 : signal2.throwIfAborted();
@@ -896,7 +1148,7 @@ const _ClientConfigSingleton = class _ClientConfigSingleton {
         if (isAbortError(siteVersion2)) {
           throw siteVersion2;
         }
-        logError$2(
+        logError$1(
           "ClientConfigSingleton",
           "Failed to determine site version, GraphQL error",
           siteVersion2
@@ -923,7 +1175,7 @@ const _ClientConfigSingleton = class _ClientConfigSingleton {
       return this.fetchConfigEndpoint(signal2);
     }).then(async (clientConfig) => {
       signal2 == null ? void 0 : signal2.throwIfAborted();
-      logDebug$1("ClientConfigSingleton", "refreshed", JSON.stringify(clientConfig));
+      logDebug("ClientConfigSingleton", "refreshed", JSON.stringify(clientConfig));
       return Promise.all([
         graphqlClient.viewerSettings(signal2),
         graphqlClient.codeSearchEnabled(signal2)
@@ -949,7 +1201,7 @@ const _ClientConfigSingleton = class _ClientConfigSingleton {
       });
     }).catch((e) => {
       if (!isAbortError(e)) {
-        logError$2("ClientConfigSingleton", "failed to refresh client config", e);
+        logError$1("ClientConfigSingleton", "failed to refresh client config", e);
       }
       throw e;
     });
@@ -978,7 +1230,7 @@ const _ClientConfigSingleton = class _ClientConfigSingleton {
   async fetchConfigFeaturesLegacy(defaultErrorValue, signal2) {
     const features2 = await graphqlClient.getCodyConfigFeatures(signal2);
     if (features2 instanceof Error) {
-      logError$2("ClientConfigSingleton", "refreshConfig", features2);
+      logError$1("ClientConfigSingleton", "refreshConfig", features2);
       return defaultErrorValue;
     }
     return features2;
@@ -1014,7 +1266,7 @@ const _ClientConfigSingleton = class _ClientConfigSingleton {
 };
 __publicField2(_ClientConfigSingleton, "instance");
 // REFETCH_INTERVAL is only updated via process.env during test execution, otherwise it is 60 seconds.
-__publicField2(_ClientConfigSingleton, "REFETCH_INTERVAL", define_process_default$n.env.CODY_CLIENT_CONFIG_SINGLETON_REFETCH_INTERVAL ? Number.parseInt(define_process_default$n.env.CODY_CLIENT_CONFIG_SINGLETON_REFETCH_INTERVAL, 10) : 60 * 1e3);
+__publicField2(_ClientConfigSingleton, "REFETCH_INTERVAL", define_process_default$o.env.CODY_CLIENT_CONFIG_SINGLETON_REFETCH_INTERVAL ? Number.parseInt(define_process_default$o.env.CODY_CLIENT_CONFIG_SINGLETON_REFETCH_INTERVAL, 10) : 60 * 1e3);
 let ClientConfigSingleton = _ClientConfigSingleton;
 const configOverwrites = authStatus.pipe(
   pick("authenticated", "endpoint", "pendingValidation"),
@@ -1032,7 +1284,7 @@ const configOverwrites = authStatus.pipe(
       ).pipe(
         map$1((result) => {
           if (isError$3(result)) {
-            logError$2(
+            logError$1(
               "configOverwrites",
               `Failed to get Cody LLM configuration from ${authStatus2.endpoint}: ${result}`
             );
@@ -1047,7 +1299,7 @@ const configOverwrites = authStatus.pipe(
   // the operation catches its own errors, so errors will never get here
 );
 configOverwrites.subscribe({});
-var define_process_default$m = { env: {} };
+var define_process_default$n = { env: {} };
 const version$1 = "0.5.1";
 class ResponseError extends Error {
   constructor(error, status_code) {
@@ -1087,8 +1339,8 @@ const checkOk = async (response) => {
 function getPlatform() {
   if (typeof window !== "undefined" && window.navigator) {
     return `${window.navigator.platform.toLowerCase()} Browser/${navigator.userAgent};`;
-  } else if (typeof define_process_default$m !== "undefined") {
-    return `${define_process_default$m.arch} ${define_process_default$m.platform} Node.js/${define_process_default$m.version}`;
+  } else if (typeof define_process_default$n !== "undefined") {
+    return `${define_process_default$n.arch} ${define_process_default$n.platform} Node.js/${define_process_default$n.version}`;
   }
   return "";
 }
@@ -1953,7 +2205,7 @@ let AST = _AST;
 const escape$1 = (s, { windowsPathsNoEscape = false } = {}) => {
   return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
 };
-var define_process_default$l = { env: {} };
+var define_process_default$m = { env: {} };
 const minimatch = (p2, pattern, options = {}) => {
   assertValidPattern(pattern);
   if (!options.nocomment && pattern.charAt(0) === "#") {
@@ -2011,7 +2263,7 @@ const qmarksTestNoExtDot = ([$0]) => {
   const len2 = $0.length;
   return (f) => f.length === len2 && f !== "." && f !== "..";
 };
-const defaultPlatform = typeof define_process_default$l === "object" && define_process_default$l ? typeof define_process_default$l.env === "object" && define_process_default$l.env && define_process_default$l.env.__MINIMATCH_TESTING_PLATFORM__ || define_process_default$l.platform : "posix";
+const defaultPlatform = typeof define_process_default$m === "object" && define_process_default$m ? typeof define_process_default$m.env === "object" && define_process_default$m.env && define_process_default$m.env.__MINIMATCH_TESTING_PLATFORM__ || define_process_default$m.platform : "posix";
 const path = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
@@ -7782,7 +8034,7 @@ const _ContextFiltersProvider = class _ContextFiltersProvider {
       this.setContextFilters(filters);
       return refetchIntervalHint;
     } catch (error) {
-      logError$2("ContextFiltersProvider", "fetchContextFilters", {
+      logError$1("ContextFiltersProvider", "fetchContextFilters", {
         verbose: error
       });
       return TRANSIENT_REFETCH_INTERVAL_HINT;
@@ -7805,7 +8057,7 @@ const _ContextFiltersProvider = class _ContextFiltersProvider {
     this.parsedContextFilters = null;
     this.lastContextFiltersResponse = canonicalizeContextFilters(contextFilters);
     if (!cenv.CODY_TESTING_LOG_SUPRESS_VERBOSE) {
-      logDebug$1("ContextFiltersProvider", "setContextFilters", {
+      logDebug("ContextFiltersProvider", "setContextFilters", {
         verbose: contextFilters
       });
     }
@@ -7894,7 +8146,7 @@ const _ContextFiltersProvider = class _ContextFiltersProvider {
       return maybeError;
     }
     if (!isFileURI(uri)) {
-      logDebug$1("ContextFiltersProvider", "isUriIgnored", `non-file URI ${uri.scheme}`);
+      logDebug("ContextFiltersProvider", "isUriIgnored", `non-file URI ${uri.scheme}`);
       return "non-file-uri";
     }
     if (!_ContextFiltersProvider.repoNameResolver) {
@@ -7935,7 +8187,7 @@ const _ContextFiltersProvider = class _ContextFiltersProvider {
       }
       return patterns.some((pattern) => minimatch(relativePath, pattern, { dot: true }));
     } catch (error) {
-      logDebug$1("ContextFiltersProvider", "isExcludedByPatterns error", { error });
+      logDebug("ContextFiltersProvider", "isExcludedByPatterns error", { error });
       return false;
     }
   }
@@ -8074,6 +8326,9 @@ var ModelUsage = /* @__PURE__ */ ((ModelUsage2) => {
 const ANSWER_TOKENS = 1e3;
 const MAX_CURRENT_FILE_TOKENS = 1e3;
 const SURROUNDING_LINES = 50;
+const NUM_CODE_RESULTS = 12;
+const NUM_TEXT_RESULTS = 3;
+const MAX_BYTES_PER_FILE = 4096;
 function getProviderName(name2) {
   const providerName = name2.toLowerCase();
   switch (providerName) {
@@ -8101,6 +8356,10 @@ function isCustomModel(model2) {
 function modelHasTag(model2, modelTag) {
   return model2.tags.includes(modelTag);
 }
+function toModelRefStr(modelRef) {
+  const { providerId, apiVersionId, modelId } = modelRef;
+  return `${providerId}::${apiVersionId}::${modelId}`;
+}
 function getEnterpriseContextWindow(chatModel, configOverwrites2, configuration) {
   const { chatModelMaxTokens, smartContextWindow } = configOverwrites2;
   let contextWindow2 = {
@@ -8121,7 +8380,7 @@ function applyLocalTokenLimitOverwrite({ providerLimitPrompt }, chatModel, conte
     return { ...contextWindow2, input: providerLimitPrompt };
   }
   if (providerLimitPrompt) {
-    logDebug$1(
+    logDebug(
       "getEnterpriseContextWindow",
       `Invalid token limit configured for ${chatModel}`,
       providerLimitPrompt
@@ -8240,6 +8499,10 @@ function capabilityToUsage(capability) {
       return [];
   }
 }
+function modelTier(model2) {
+  const tierSet = /* @__PURE__ */ new Set([ModelTag.Pro, ModelTag.Enterprise]);
+  return model2.tags.find((tag2) => tierSet.has(tag2)) ?? ModelTag.Free;
+}
 function parseModelRef(ref) {
   try {
     const [providerId, apiVersionId, modelId] = ref.split("::", 3);
@@ -8257,6 +8520,9 @@ function parseModelRef(ref) {
     };
   }
 }
+function toLegacyModel(modelRefOrID) {
+  return parseModelRef(modelRefOrID).modelId || modelRefOrID;
+}
 function getServerModelTags(capabilities, category, status, tier) {
   const tags = [tier];
   if (capabilities.includes("vision")) {
@@ -8277,7 +8543,7 @@ function getServerModelTags(capabilities, category, status, tier) {
   }
   return tags;
 }
-createModel({
+const FIXTURE_MODEL = createModel({
   id: "my-model",
   usage: [ModelUsage.Chat],
   tags: [ModelTag.Enterprise]
@@ -8350,7 +8616,7 @@ class RestClient {
       if (isAbortError(serverSideConfig)) {
         throw serverSideConfig;
       }
-      logError$2("RestClient::getAvailableModels", "failed to fetch available models", {
+      logError$1("RestClient::getAvailableModels", "failed to fetch available models", {
         verbose: serverSideConfig
       });
       return;
@@ -8423,7 +8689,7 @@ function syncModels({
     }),
     distinctUntilChanged$1(),
     tap$2((preferences) => {
-      logDebug$1("ModelsService", "User model preferences changed", JSON.stringify(preferences));
+      logDebug("ModelsService", "User model preferences changed", JSON.stringify(preferences));
     }),
     shareReplay$1()
   );
@@ -8439,7 +8705,7 @@ function syncModels({
       const serverModelsConfig = clientConfig.pipe(
         switchMapReplayOperation((maybeServerSideClientConfig) => {
           if (maybeServerSideClientConfig == null ? void 0 : maybeServerSideClientConfig.modelsAPIEnabled) {
-            logDebug$1("ModelsService", "new models API enabled");
+            logDebug("ModelsService", "new models API enabled");
             return promiseFactoryToObservable(
               (signal2) => fetchServerSideModels_(configWithEndpoint, signal2)
             ).pipe(
@@ -8634,7 +8900,7 @@ function syncModels({
     distinctUntilChanged$1(),
     tap$2((modelsData) => {
       if (modelsData !== pendingOperation && modelsData.primaryModels.length > 0) {
-        logDebug$1(
+        logDebug(
           "ModelsService",
           "ModelsData changed",
           `${modelsData.primaryModels.length} primary models`
@@ -8919,7 +9185,7 @@ class ModelsService {
     if (!resolved.usage.includes(type)) {
       throw new Error(`Model "${resolved.id}" is not compatible with usage type "${type}".`);
     }
-    logDebug$1("ModelsService", `Setting selected ${type} model to ${resolved.id}`);
+    logDebug("ModelsService", `Setting selected ${type} model to ${resolved.id}`);
     if (!this.storage) {
       throw new Error("ModelsService.storage is not set");
     }
@@ -8985,6 +9251,34 @@ class ModelsService {
   }
 }
 const modelsService = new ModelsService();
+class TestLocalStorageForModelPreferences {
+  constructor(data = null) {
+    __publicField2(this, "isEnrolled", /* @__PURE__ */ new Map());
+    this.data = data;
+  }
+  getModelPreferences() {
+    return this.data || {};
+  }
+  async setModelPreferences(preferences) {
+    this.data = preferences;
+  }
+  getEnrollmentHistory(_featureName) {
+    if (!this.isEnrolled.has(_featureName)) {
+      this.isEnrolled.set(_featureName, true);
+      return false;
+    }
+    return true;
+  }
+}
+function mockModelsService({
+  storage = new TestLocalStorageForModelPreferences(),
+  modelsService: modelsService2 = new ModelsService(),
+  authStatus: authStatus2 = AUTH_STATUS_FIXTURE_AUTHED_DOTCOM
+}) {
+  modelsService2.setStorage(storage);
+  mockAuthStatus(authStatus2);
+  return { storage, modelsService: modelsService2 };
+}
 function deepClone(value) {
   return JSON.parse(JSON.stringify(value));
 }
@@ -9118,9 +9412,7 @@ __publicField2(_BotResponseMultiplexer, "DEFAULT_TOPIC", "Assistant");
 __publicField2(_BotResponseMultiplexer, "TOPIC_RE", /<$|<\/?([\dA-Za-z-]?$|[\dA-Za-z-]+>?)/m);
 let BotResponseMultiplexer = _BotResponseMultiplexer;
 const DEFAULT_CHAT_COMPLETION_PARAMETERS = {
-  temperature: 0.2,
-  topK: -1,
-  topP: -1
+  temperature: 0.2
 };
 class ChatClient {
   constructor(completions) {
@@ -9370,6 +9662,23 @@ function envPaths() {
   return { data: "/tmp/data", config: "/tmp/config", log: "/tmp/log" };
 }
 const codyPaths = () => envPaths();
+const EVENT_LINE_PREFIX = "event: ";
+const DATA_LINE_PREFIX = "data: ";
+const EVENTS_SEPARATOR = "\n\n";
+function parseEventType(eventLine) {
+  if (!eventLine.startsWith(EVENT_LINE_PREFIX)) {
+    return new Error(`cannot parse event type: ${eventLine}`);
+  }
+  const eventType = eventLine.slice(EVENT_LINE_PREFIX.length);
+  switch (eventType) {
+    case "completion":
+    case "error":
+    case "done":
+      return eventType;
+    default:
+      return new Error(`unexpected event type: ${eventType}`);
+  }
+}
 function parseJSON(data) {
   try {
     return JSON.parse(data);
@@ -9380,6 +9689,85 @@ function parseJSON(data) {
 function parseCompletionJSON(jsonData) {
   return parseJSON(jsonData);
 }
+function parseEventData(builder, eventType, dataLine) {
+  if (!dataLine.startsWith(DATA_LINE_PREFIX)) {
+    return new Error(`cannot parse event data: ${dataLine}`);
+  }
+  const jsonData = dataLine.slice(DATA_LINE_PREFIX.length);
+  switch (eventType) {
+    case "completion": {
+      const data = parseCompletionJSON(jsonData);
+      if (isError$3(data)) {
+        return data;
+      }
+      let usage = void 0;
+      if (data.usage) {
+        usage = {
+          completionTokens: data.usage.completion_tokens,
+          promptTokens: data.usage.prompt_tokens,
+          totalTokens: data.usage.total_tokens
+        };
+        logInfo(
+          "server-usage",
+          `${JSON.stringify({
+            model: builder.model,
+            output_tokens: data.usage.completion_tokens,
+            input_tokens: data.usage.prompt_tokens,
+            total_tokens: data.usage.total_tokens
+          })}`
+        );
+      }
+      builder.nextThinking(data.delta_thinking);
+      const completion = builder.nextCompletion(data.completion, data.deltaText);
+      const toolCalls = builder.nextToolCalls(data == null ? void 0 : data.delta_tool_calls);
+      const content = [];
+      content.push(...toolCalls);
+      return {
+        type: eventType,
+        completion,
+        stopReason: data.stopReason,
+        content,
+        usage
+      };
+    }
+    case "error": {
+      const data = parseJSON(jsonData);
+      if (isError$3(data)) {
+        return data;
+      }
+      if (typeof data.error === "undefined") {
+        return new Error("invalid error event");
+      }
+      return { type: eventType, error: data.error };
+    }
+    case "done":
+      return { type: eventType };
+  }
+}
+function parseEvent(builder, eventBuffer) {
+  const [eventLine, dataLine] = eventBuffer.split("\n");
+  const eventType = parseEventType(eventLine);
+  if (isError$3(eventType)) {
+    return eventType;
+  }
+  return parseEventData(builder, eventType, dataLine);
+}
+function parseEvents(builder, eventsBuffer) {
+  let eventStartIndex = 0;
+  let eventEndIndex = eventsBuffer.indexOf(EVENTS_SEPARATOR);
+  const events2 = [];
+  while (eventEndIndex >= 0) {
+    const eventBuffer = eventsBuffer.slice(eventStartIndex, eventEndIndex);
+    const event2 = parseEvent(builder, eventBuffer);
+    if (isError$3(event2)) {
+      return event2;
+    }
+    events2.push(event2);
+    eventStartIndex = eventEndIndex + EVENTS_SEPARATOR.length;
+    eventEndIndex = eventsBuffer.indexOf(EVENTS_SEPARATOR, eventStartIndex);
+  }
+  return { events: events2, remainingBuffer: eventsBuffer.slice(eventStartIndex) };
+}
 const defaultTimeoutSeconds = 45;
 class SourcegraphGuardrailsClient {
   async searchAttribution(snippet) {
@@ -9489,6 +9877,10 @@ function populateCurrentEditorDiagnosticsTemplate(diagnostic, uri) {
   const { type, message, text: text2 } = PromptString.fromTextEditorDiagnostic(diagnostic, uri);
   return DIAGNOSTICS_CONTEXT_TEMPLATE.replaceAll("{type}", type).replaceAll("{filePath}", PromptString.fromDisplayPath(uri)).replaceAll("{prefix}", type).replaceAll("{message}", message).replaceAll("{languageID}", PromptString.fromMarkdownCodeBlockLanguageIDForFilename(uri)).replaceAll("{code}", text2);
 }
+const COMMAND_OUTPUT_TEMPLATE = "Here is the output returned from the terminal.\n";
+function populateTerminalOutputContextTemplate(output2) {
+  return COMMAND_OUTPUT_TEMPLATE + output2;
+}
 const SELECTED_CODE_CONTEXT_TEMPLATE = ps`My selected code from codebase file {filePath}:\n\`\`\`\n{code}\`\`\``;
 function populateCurrentSelectedCodeContextTemplate(code18, fileUri, range) {
   return SELECTED_CODE_CONTEXT_TEMPLATE.replace("{code}", code18).replaceAll(
@@ -9496,10 +9888,20 @@ function populateCurrentSelectedCodeContextTemplate(code18, fileUri, range) {
     PromptString.fromDisplayPathLineRange(fileUri, range)
   );
 }
+const DIRECTORY_FILE_LIST_TEMPLATE = "Here is a list of files from the directory contains {fileName} in my codebase: ";
+const ROOT_DIRECTORY_FILE_LIST_TEMPLATE = "Here is a list of files from the root codebase directory: ";
+function populateListOfFilesContextTemplate(fileList, fileUri) {
+  return (fileUri ? DIRECTORY_FILE_LIST_TEMPLATE.replace("{fileName}", displayPath(fileUri)) : ROOT_DIRECTORY_FILE_LIST_TEMPLATE) + fileList;
+}
 function populateContextTemplateFromText(templateText, content, fileUri, range) {
   return templateText.replace("{displayPath}", PromptString.fromDisplayPathLineRange(fileUri, range)).concat(content);
 }
-ps`{fileName} has imported the following: `;
+const FILE_IMPORTS_TEMPLATE = ps`{fileName} has imported the following: `;
+function populateImportListContextTemplate(importList, fileUri) {
+  return FILE_IMPORTS_TEMPLATE.replace("{fileName}", PromptString.fromDisplayPath(fileUri)).concat(
+    importList
+  );
+}
 const CODE_GENERATION_CONTEXT_TEMPLATE = ps`Below is the code from file path {filePath}. Review the code outside the XML tags to detect the functionality, formats, style, patterns, and logics in use. Then, use what you detect and reuse methods/libraries to complete and enclose completed code only inside XML tags precisely without duplicating existing implementations. Here is the code:
 {precedingText}<{outputTag}></{outputTag}>{followingText}
 `;
@@ -9533,7 +9935,7 @@ async function getTokenCounterUtils() {
   const browser2 = detect();
   if (browser2 && browser2.name === "safari") {
     _tokenCounterUtilsPromise = import("./cl100k_base-B4kyDDRQ.mjs").then(async (tokenizer2) => {
-      const tiktoken = await import("./lite-CQAWMpwn.mjs");
+      const tiktoken = await import("./lite-BPYOwOSx.mjs");
       return createTokenCounterUtils(new tiktoken.Tiktoken(tokenizer2.default));
     });
   } else {
@@ -9713,6 +10115,30 @@ async function truncatePromptString(text2, maxTokens) {
   const encoded = await TokenCounterUtils.encode(text2.toString());
   return encoded.length <= maxTokens ? text2 : text2.slice(0, (_a3 = await TokenCounterUtils.decode(encoded.slice(0, maxTokens))) == null ? void 0 : _a3.length).trim();
 }
+function truncateTextNearestLine(text2, maxBytes) {
+  if (text2.length <= maxBytes) {
+    return { truncated: text2 };
+  }
+  const textMaxBytes = text2.slice(0, maxBytes);
+  const textMaxBytesLines = textMaxBytes.split("\n");
+  if (text2.at(maxBytes) === "\n" || text2.at(maxBytes - 1) === "\n") {
+    return {
+      truncated: textMaxBytes,
+      range: {
+        start: { line: 0, character: 0 },
+        end: { line: textMaxBytesLines.length, character: 0 }
+      }
+    };
+  }
+  const truncated = textMaxBytesLines.slice(0, -1).join("\n");
+  return {
+    truncated,
+    range: {
+      start: { line: 0, character: 0 },
+      end: { line: textMaxBytesLines.length - 1, character: 0 }
+    }
+  };
+}
 async function truncatePromptStringStart(text2, maxTokens) {
   const encoded = await TokenCounterUtils.encode(text2.toString());
   if (encoded.length <= maxTokens) {
@@ -9919,7 +10345,7 @@ class CompletionsResponseBuilder {
     this.model = model2;
   }
   /**
-   * Creates a builder from a URL with api-version parameter
+   * Creates a builder from a URL with api-version parameter and optional model
    */
   static fromUrl(url, model2) {
     const apiVersion = Number.parseInt(new URL(url).searchParams.get("api-version") ?? "0", 10);
@@ -10616,7 +11042,7 @@ const getStringFromMaybeBuffer = (x) => {
 };
 const isAsyncIterableIterator = (value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
 const isMultipartBody = (body2) => body2 && typeof body2 === "object" && body2.body && body2[Symbol.toStringTag] === "MultipartBody";
-var define_process_default$k = { env: {} };
+var define_process_default$l = { env: {} };
 var __classPrivateFieldSet$3 = function(receiver, state2, value, kind2, f) {
   if (typeof state2 === "function" ? receiver !== state2 || !f : !state2.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
   return state2.set(receiver, value), value;
@@ -11157,17 +11583,17 @@ const getPlatformProperties = () => {
       "X-Stainless-OS": "Unknown",
       "X-Stainless-Arch": `other:${EdgeRuntime}`,
       "X-Stainless-Runtime": "edge",
-      "X-Stainless-Runtime-Version": define_process_default$k.version
+      "X-Stainless-Runtime-Version": define_process_default$l.version
     };
   }
-  if (Object.prototype.toString.call(typeof define_process_default$k !== "undefined" ? define_process_default$k : 0) === "[object process]") {
+  if (Object.prototype.toString.call(typeof define_process_default$l !== "undefined" ? define_process_default$l : 0) === "[object process]") {
     return {
       "X-Stainless-Lang": "js",
       "X-Stainless-Package-Version": VERSION,
-      "X-Stainless-OS": normalizePlatform(define_process_default$k.platform),
-      "X-Stainless-Arch": normalizeArch(define_process_default$k.arch),
+      "X-Stainless-OS": normalizePlatform(define_process_default$l.platform),
+      "X-Stainless-Arch": normalizeArch(define_process_default$l.arch),
       "X-Stainless-Runtime": "node",
-      "X-Stainless-Runtime-Version": define_process_default$k.version
+      "X-Stainless-Runtime-Version": define_process_default$l.version
     };
   }
   const browserInfo = getBrowserInfo();
@@ -11284,8 +11710,8 @@ const castToError = (err2) => {
 };
 const readEnv = (env2) => {
   var _a3, _b2, _c2, _d2, _e2;
-  if (typeof define_process_default$k !== "undefined") {
-    return ((_b2 = (_a3 = define_process_default$k.env) == null ? void 0 : _a3[env2]) == null ? void 0 : _b2.trim()) ?? void 0;
+  if (typeof define_process_default$l !== "undefined") {
+    return ((_b2 = (_a3 = define_process_default$l.env) == null ? void 0 : _a3[env2]) == null ? void 0 : _b2.trim()) ?? void 0;
   }
   if (typeof Deno !== "undefined") {
     return (_e2 = (_d2 = (_c2 = Deno.env) == null ? void 0 : _c2.get) == null ? void 0 : _d2.call(_c2, env2)) == null ? void 0 : _e2.trim();
@@ -11319,7 +11745,7 @@ function applyHeadersMut(targetHeaders, newHeaders) {
 }
 function debug$1(action, ...args2) {
   var _a3;
-  if (typeof define_process_default$k !== "undefined" && ((_a3 = define_process_default$k == null ? void 0 : define_process_default$k.env) == null ? void 0 : _a3["DEBUG"]) === "true") {
+  if (typeof define_process_default$l !== "undefined" && ((_a3 = define_process_default$l == null ? void 0 : define_process_default$l.env) == null ? void 0 : _a3["DEBUG"]) === "true") {
     console.log(`Anthropic:DEBUG:${action}`, ...args2);
   }
 }
@@ -13278,11 +13704,11 @@ async function useCustomChatClient({
   }
   return false;
 }
-var define_process_default$j = { env: {} };
+var define_process_default$k = { env: {} };
 class SourcegraphCompletionsClient {
   constructor(logger2) {
     __publicField2(this, "errorEncountered", false);
-    __publicField2(this, "isTemperatureZero", define_process_default$j.env.CODY_TEMPERATURE_ZERO === "true");
+    __publicField2(this, "isTemperatureZero", define_process_default$k.env.CODY_TEMPERATURE_ZERO === "true");
     this.logger = logger2;
   }
   async completionsEndpoint() {
@@ -13614,7 +14040,7 @@ function event(featureAction, record, maps) {
   const wrappedRecord = (...args2) => {
     const fn = record(ctx);
     const handleError = (e) => {
-      logError$2("Telemetry Recording", "Failed to record telemetry event", {
+      logError$1("Telemetry Recording", "Failed to record telemetry event", {
         error: e
       });
     };
@@ -15498,7 +15924,7 @@ const getContextForChatMessage = async (message, parentSignal) => {
           try {
             return (_a4 = message.match(new RegExp(pattern))) == null ? void 0 : _a4.length;
           } catch {
-            logDebug$1(
+            logDebug(
               "OpenCtx",
               `getContextForChatMessage Error: matching regex ${pattern} for provider ${p2.providerUri}`
             );
@@ -16156,10 +16582,10 @@ function observeAnnotations(providerClients, params, { logger: logger2, makeRang
     return (((_c2 = a.range) == null ? void 0 : _c2.start.character) ?? 0) - (((_d2 = b.range) == null ? void 0 : _d2.start.character) ?? 0);
   }) : null)), { logger: logger2, emitPartial, errorHook });
 }
-var define_process_default$i = { env: {} };
+var define_process_default$j = { env: {} };
 const perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
 const warned = /* @__PURE__ */ new Set();
-const PROCESS = typeof define_process_default$i === "object" && !!define_process_default$i ? define_process_default$i : {};
+const PROCESS = typeof define_process_default$j === "object" && !!define_process_default$j ? define_process_default$j : {};
 const emitWarning = (msg, type, code18, fn) => {
   typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code18, fn) : console.error(`[${code18}] ${type}: ${msg}`);
 };
@@ -19996,24 +20422,6 @@ const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   __proto__: null,
   createController
 }, Symbol.toStringTag, { value: "Module" }));
-function appendFileSync() {
-  throw new Error("not implemented");
-}
-function existsSync() {
-  throw new Error("not implemented");
-}
-function mkdirSync() {
-  throw new Error("not implemented");
-}
-function rmSync() {
-  throw new Error("not implemented");
-}
-function copySync() {
-  throw new Error("not implemented");
-}
-function statSync() {
-  throw new Error("not implemented");
-}
 var events = { exports: {} };
 var R = typeof Reflect === "object" ? Reflect : null;
 var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args2) {
@@ -25072,6 +25480,8 @@ var merge_1 = merge;
 const merge$1 = /* @__PURE__ */ getDefaultExportFromCjs(merge_1);
 const CODY_ACCESS_TOKEN_SOURCE = "cody.access-token.source";
 const CODY_ACCESS_TOKEN_SECRET = "cody.access-token";
+const CODY_REFRESH_TOKEN_SECRET = "cody.refresh-token";
+const CODY_TOKEN_EXPIRES_AT = "cody.token.expires-at";
 class VSCodeSecretStorage {
   constructor() {
     __publicField2(this, "fsPath", null);
@@ -25084,7 +25494,7 @@ class VSCodeSecretStorage {
     const config = workspace.getConfiguration("cody");
     this.fsPath = config.get("experimental.localTokenPath") || null;
     if (this.fsPath) {
-      logDebug("VSCodeSecretStorage:experimental.localTokenPath", "enabled", {
+      outputChannelLogger.logDebug("VSCodeSecretStorage:experimental.localTokenPath", "enabled", {
         verbose: this.fsPath
       });
     }
@@ -25122,7 +25532,9 @@ class VSCodeSecretStorage {
         await this.secretStorage.store(key2, value);
       }
     } catch (error) {
-      logError$1("VSCodeSecretStorage:store:failed", key2, { verbose: error });
+      outputChannelLogger.logError("VSCodeSecretStorage:store:failed", key2, {
+        verbose: error
+      });
     }
   }
   async getToken(endpoint) {
@@ -25147,6 +25559,21 @@ class VSCodeSecretStorage {
     await this.secretStorage.delete(endpoint);
     await this.secretStorage.delete(CODY_ACCESS_TOKEN_SECRET);
     await this.secretStorage.delete(endpoint + CODY_ACCESS_TOKEN_SOURCE);
+    await this.secretStorage.delete(endpoint + CODY_REFRESH_TOKEN_SECRET);
+    await this.secretStorage.delete(endpoint + CODY_TOKEN_EXPIRES_AT);
+  }
+  async storeRefreshToken(endpoint, refreshToken) {
+    await this.store(endpoint + CODY_REFRESH_TOKEN_SECRET, refreshToken);
+  }
+  async getRefreshToken(endpoint) {
+    return this.get(endpoint + CODY_REFRESH_TOKEN_SECRET);
+  }
+  async storeTokenExpiresAt(endpoint, expiresAt) {
+    await this.store(endpoint + CODY_TOKEN_EXPIRES_AT, expiresAt.toString());
+  }
+  async getTokenExpiresAt(endpoint) {
+    const expiresAtStr = await this.get(endpoint + CODY_TOKEN_EXPIRES_AT);
+    return expiresAtStr ? Number.parseInt(expiresAtStr, 10) : void 0;
   }
   async delete(key2) {
     await this.secretStorage.delete(key2);
@@ -25169,10 +25596,12 @@ async function getAccessTokenFromFsPath(fsPath) {
     if (!json2.token) {
       throw new Error(`Failed to retrieve token from: ${fsPath}`);
     }
-    logDebug("VSCodeSecretStorage:getAccessTokenFromFsPath", "retrieved");
+    outputChannelLogger.logDebug("VSCodeSecretStorage:getAccessTokenFromFsPath", "retrieved");
     return json2.token;
   } catch (error) {
-    logError$1("VSCodeSecretStorage:getAccessTokenFromFsPath", "failed", { verbose: error });
+    outputChannelLogger.logError("VSCodeSecretStorage:getAccessTokenFromFsPath", "failed", {
+      verbose: error
+    });
     return null;
   }
 }
@@ -25673,7 +26102,7 @@ function sanitizeCodebase(codebase) {
   const trailingSlashRegexp = /\/$/;
   return codebase.replace(protocolRegexp, "").trim().replace(trailingSlashRegexp, "");
 }
-var define_process_default$h = { env: {} };
+var define_process_default$i = { env: {} };
 const CODY_OUTPUT_CHANNEL = "Cody by Sourcegraph";
 class OutputChannelManager {
   constructor() {
@@ -25681,7 +26110,8 @@ class OutputChannelManager {
     __publicField2(this, "outputChannels", /* @__PURE__ */ new Map());
   }
   getOutputChannel(feature2) {
-    if (!this.outputChannels.has(feature2) && false) {
+    const shouldCreateChannel = feature2 === "auth";
+    if (!this.outputChannels.has(feature2) && shouldCreateChannel) {
       const channel2 = window$1.createOutputChannel(`Cody ${feature2}`, { log: true });
       this.outputChannels.set(feature2, channel2);
     }
@@ -25706,7 +26136,7 @@ class OutputChannelManager {
         channel2 == null ? void 0 : channel2.debug(text2);
       }
     }
-    const path2 = define_process_default$h.env.CODY_LOG_FILE;
+    const path2 = define_process_default$i.env.CODY_LOG_FILE;
     if (path2) {
       appendFileSync();
     }
@@ -25771,15 +26201,6 @@ class Logger {
   }
 }
 const outputChannelLogger = new Logger();
-function logDebug(filterLabel, text2, ...args2) {
-  outputChannelLogger.logDebug(filterLabel, text2, ...args2);
-}
-function logInfo(filterLabel, text2, ...args2) {
-  outputChannelLogger.logInfo(filterLabel, text2, ...args2);
-}
-function logError$1(filterLabel, text2, ...args2) {
-  outputChannelLogger.logError(filterLabel, text2, ...args2);
-}
 function formatMessage({
   prefix,
   feature: feature2,
@@ -25797,7 +26218,9 @@ function formatMessage({
     const isVerboseLastArg = lastArg && typeof lastArg === "object" && "verbose" in lastArg;
     const argsToLog = isVerboseLastArg ? args2.slice(0, -1) : args2;
     if (argsToLog.length > 0) {
-      messageParts.push(argsToLog.join(" "));
+      messageParts.push(
+        argsToLog.map((arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)).join(" ")
+      );
     }
     if (isVerboseLastArg && debugVerbose) {
       messageParts.push(JSON.stringify(lastArg.verbose, null, 2));
@@ -25837,13 +26260,14 @@ function isRunningInsideAgent() {
 }
 const version = ((_i = (_h = extensions.getExtension("sourcegraph.cody-ai")) == null ? void 0 : _h.packageJSON) == null ? void 0 : _i.version) ?? version$2;
 setExtensionVersion(version);
+var define_process_default$h = { env: {} };
 const HAS_AUTHENTICATED_BEFORE_KEY = "has-authenticated-before";
 class AuthProvider {
   constructor(setAuthStatusObservable$1 = setAuthStatusObservable) {
     __publicField2(this, "status", new MulticastSubject());
     /**
      * Credentials that were already validated with
-     * {@link AuthProvider.validateAndStoreCredentials}.
+     * {@link AuthProvider["validateAndStoreCredentials"]}.
      */
     __publicField2(this, "lastValidated", { credentials: null, auth: null });
     __publicField2(this, "subscriptions", []);
@@ -25887,7 +26311,11 @@ class AuthProvider {
             authStatus2.endpoint
           );
         } catch (error) {
-          logError$1("AuthProvider", "Unexpected error while setting context", error);
+          outputChannelLogger.logError(
+            "AuthProvider",
+            "Unexpected error while setting context",
+            error
+          );
         }
       })
     );
@@ -25896,7 +26324,11 @@ class AuthProvider {
         try {
           this.reportAuthTelemetryEvent(authStatus2);
         } catch (error) {
-          logError$1("AuthProvider", "Unexpected error while reporting auth telemetry", error);
+          outputChannelLogger.logError(
+            "AuthProvider",
+            "Unexpected error while reporting auth telemetry",
+            error
+          );
         }
       })
     );
@@ -25919,6 +26351,42 @@ class AuthProvider {
       })
     );
   }
+  async waitForResolvedConfigEndpointMatch(expectedEndpoint, timeoutMs = 3e3) {
+    const normalized2 = normalizeServerEndpointURL(expectedEndpoint);
+    const startTime = Date.now();
+    try {
+      await Promise.race([
+        firstValueFrom$1(
+          resolvedConfig.pipe(
+            map$1(
+              (config) => config.auth.serverEndpoint ? normalizeServerEndpointURL(config.auth.serverEndpoint) : void 0
+            ),
+            filter$3((endpoint) => endpoint === normalized2),
+            take$2(1)
+          )
+        ),
+        new Promise(
+          (_2, reject) => setTimeout(() => reject(new Error("Timeout waiting for resolvedConfig")), timeoutMs)
+        )
+      ]);
+      outputChannelLogger.logDebug("AuthProvider", "resolvedConfig endpoint matched", {
+        endpoint: normalized2,
+        waitTime: Date.now() - startTime,
+        timestamp: Date.now()
+      });
+    } catch (error) {
+      outputChannelLogger.logDebug(
+        "AuthProvider",
+        "Timeout waiting for resolvedConfig endpoint match",
+        {
+          endpoint: normalized2,
+          waitTime: Date.now() - startTime,
+          error: String(error),
+          timestamp: Date.now()
+        }
+      );
+    }
+  }
   async validateAndStoreCredentials(config, mode) {
     var _a3;
     let credentials;
@@ -25943,12 +26411,21 @@ class AuthProvider {
         localStorage.saveEndpointAndToken(credentials.auth),
         this.serializeUninstallerInfo(authStatus2)
       ]);
+      if (credentials.auth.serverEndpoint && !define_process_default$h.env.VITEST) {
+        await this.waitForResolvedConfigEndpointMatch(credentials.auth.serverEndpoint);
+      }
     } else if (!authStatus2.authenticated && !authStatus2.pendingValidation) {
       const status = authStatus2;
       if (status.endpoint && isInvalidAccessTokenError(status.error)) {
         await localStorage.deleteEndpointAndToken(status.endpoint);
       }
     }
+    if (!authStatus2.authenticated && !authStatus2.pendingValidation) {
+      const status = authStatus2;
+      if ((isInvalidAccessTokenError(status.error) || isOAuthProviderError(status.error)) && status.endpoint) {
+        await localStorage.deleteEndpointAndToken(status.endpoint);
+      }
+    }
     this.lastValidated = { credentials, auth: authStatus2 };
     this.status.next(authStatus2);
     return authStatus2;
@@ -26040,11 +26517,6 @@ class AuthProvider {
   }
 }
 const authProvider = new AuthProvider();
-let runningAuthProgressIndicator = null;
-function closeAuthProgressIndicator() {
-  runningAuthProgressIndicator == null ? void 0 : runningAuthProgressIndicator();
-  runningAuthProgressIndicator = null;
-}
 async function showEnterpriseInstanceUrlFlow(endpoint) {
   const { configuration } = await currentResolvedConfig();
   const auth2 = await resolveAuth(endpoint, configuration, secretStorage);
@@ -26063,7 +26535,7 @@ async function showEnterpriseInstanceUrlFlow(endpoint) {
 async function showSignInMenu() {
   const authStatus2 = currentAuthStatus();
   const mode = authStatus2.authenticated ? "switch" : "signin";
-  logDebug("AuthProvider:signinMenu", mode);
+  outputChannelLogger.logDebug("AuthProvider:signinMenu", mode);
   telemetryRecorder.recordEvent("cody.auth.login", "clicked");
   const item = await showAuthMenu(mode);
   if (!item) {
@@ -26111,7 +26583,7 @@ async function showSignInMenu() {
         );
       }
       await showAuthResultMessage(selectedEndpoint, authStatus3);
-      logDebug("AuthProvider:signinMenu", mode, selectedEndpoint);
+      outputChannelLogger.logDebug("AuthProvider:signinMenu", mode, selectedEndpoint);
     }
   }
 }
@@ -26264,7 +26736,6 @@ async function showAuthFailureMessage(endpoint, authStatus2) {
   }
 }
 async function tokenCallbackHandler(uri) {
-  closeAuthProgressIndicator();
   const params = new URLSearchParams(uri.query);
   const token = params.get("code") || params.get("token");
   const endpoint = currentAuthStatus().endpoint;
@@ -26324,17 +26795,21 @@ async function showSignOutMenu() {
   const { endpoint } = currentAuthStatus();
   if (endpoint) {
     await signOut(endpoint);
-    logDebug("AuthProvider:signoutMenu", endpoint);
+    outputChannelLogger.logDebug("AuthProvider:signoutMenu", endpoint);
   }
 }
 async function signOut(endpoint) {
-  Promise.all([secretStorage.getToken(endpoint), secretStorage.getTokenSource(endpoint)]).then(
-    ([token, tokenSource]) => {
-      if (token && tokenSource === "redirect") {
-        void graphqlClient.DeleteAccessToken(token);
-      }
+  await Promise.all([
+    secretStorage.getToken(endpoint),
+    secretStorage.getRefreshToken(endpoint),
+    secretStorage.getTokenSource(endpoint)
+  ]).then(async ([token, refreshToken, tokenSource]) => {
+    if (token && tokenSource === "redirect") {
+      void graphqlClient.DeleteAccessToken(token);
+    } else if (token && refreshToken && tokenSource === "oauth") {
+      await revokeOAuthTokens(endpoint, refreshToken, token);
     }
-  );
+  });
   authProvider.signout(endpoint);
   await firstResultFromOperation(authStatus.filter((status) => status.authenticated === false));
   await localStorage.deleteEndpointAndToken(endpoint);
@@ -26342,7 +26817,7 @@ async function signOut(endpoint) {
 async function validateCredentials(config) {
   var _a3;
   if (config.auth.error !== void 0) {
-    logDebug(
+    outputChannelLogger.logDebug(
       "auth",
       `Failed to authenticate to ${config.auth.serverEndpoint} due to configuration error`,
       config.auth.error
@@ -26364,7 +26839,7 @@ async function validateCredentials(config) {
   if (!config.auth.credentials && !clientCapabilities().isCodyWeb) {
     return { authenticated: false, endpoint: config.auth.serverEndpoint, pendingValidation: false };
   }
-  logDebug("auth", `Authenticating to ${config.auth.serverEndpoint}...`);
+  outputChannelLogger.logDebug("auth", `Authenticating to ${config.auth.serverEndpoint}...`);
   const apiClientConfig = {
     configuration: {
       customHeaders: config.configuration.customHeaders,
@@ -26377,8 +26852,8 @@ async function validateCredentials(config) {
   try {
     const userInfo = await client.getCurrentUserInfo();
     if (isError$3(userInfo)) {
-      if (isExternalProviderAuthError(userInfo)) {
-        logDebug("auth", userInfo.message);
+      if (isExternalAuthProviderError(userInfo) || isOAuthProviderError(userInfo)) {
+        outputChannelLogger.logDebug("auth", userInfo.message);
         return {
           authenticated: false,
           error: userInfo,
@@ -26388,7 +26863,7 @@ async function validateCredentials(config) {
       }
       const needsAuthChallenge = isNeedsAuthChallengeError(userInfo);
       if (isNetworkLikeError(userInfo) || needsAuthChallenge) {
-        logDebug(
+        outputChannelLogger.logDebug(
           "auth",
           `Failed to authenticate to ${config.auth.serverEndpoint} due to likely network or endpoint availability error`,
           userInfo.message
@@ -26402,7 +26877,7 @@ async function validateCredentials(config) {
       }
     }
     if (!userInfo || isError$3(userInfo)) {
-      logDebug(
+      outputChannelLogger.logDebug(
         "auth",
         `Failed to authenticate to ${config.auth.serverEndpoint} due to invalid credentials or other endpoint error`,
         userInfo == null ? void 0 : userInfo.message
@@ -26414,7 +26889,10 @@ async function validateCredentials(config) {
         pendingValidation: false
       };
     }
-    logDebug("auth", `Authentication succeed to endpoint ${config.auth.serverEndpoint}`);
+    outputChannelLogger.logDebug(
+      "auth",
+      `Authentication succeed to endpoint ${config.auth.serverEndpoint}`
+    );
     return newAuthStatus({
       ...userInfo,
       endpoint: config.auth.serverEndpoint,
@@ -35734,7 +36212,7 @@ class IndentationBasedFoldingRangeProvider {
         result.push(new FoldingRange(start2.startLine, document2.lineCount));
       }
     } catch (error) {
-      logError$2("IndentationBasedFoldingRanges", "error", error);
+      logError$1("IndentationBasedFoldingRanges", "error", error);
     }
     return result;
   }
@@ -35960,7 +36438,7 @@ async function getContextFileFromCurrentFile() {
         source: ContextItemSource.Editor
       };
     } catch (error) {
-      logError$2("getContextFileFromCurrentFile", "failed", { verbose: error });
+      logError$1("getContextFileFromCurrentFile", "failed", { verbose: error });
       return null;
     }
   });
@@ -36207,11 +36685,19 @@ async function gitLocallyModifiedFiles(uri, signal2) {
   var _a3, _b2;
   const repo = vscodeGitAPI == null ? void 0 : vscodeGitAPI.getRepository(uri);
   if (!repo) {
-    logDebug("gitLocallyModifiedFiles", "no git repository found at", uri.toString());
+    outputChannelLogger.logDebug(
+      "gitLocallyModifiedFiles",
+      "no git repository found at",
+      uri.toString()
+    );
     return [];
   }
   if (!((_a3 = repo.state.HEAD) == null ? void 0 : _a3.commit)) {
-    logDebug("gitLocallyModifiedFiles", "HEAD commit was undefined for git repo at", uri.toString());
+    outputChannelLogger.logDebug(
+      "gitLocallyModifiedFiles",
+      "HEAD commit was undefined for git repo at",
+      uri.toString()
+    );
     return [];
   }
   let diffBase = repo.state.HEAD.commit;
@@ -36406,7 +36892,9 @@ class RepoNameResolver {
       }),
       map$1((value) => {
         if (isError$3(value)) {
-          logDebug("RepoNameResolver:getRepoNamesContainingUri", "error", { verbose: value });
+          outputChannelLogger.logDebug("RepoNameResolver:getRepoNamesContainingUri", "error", {
+            verbose: value
+          });
           return [];
         }
         return value;
@@ -36418,7 +36906,7 @@ class RepoNameResolver {
     let remoteUrlsInfo = this.fsPathToRemoteUrlsInfo.get(key2);
     if (!remoteUrlsInfo) {
       remoteUrlsInfo = gitRemoteUrlsForUri(uri, signal2).catch((error) => {
-        logError$2("RepoNameResolver:getRemoteUrlsInfoCached", "error", {
+        logError$1("RepoNameResolver:getRemoteUrlsInfoCached", "error", {
           verbose: error
         });
         return [];
@@ -36448,7 +36936,9 @@ class RepoNameResolver {
         ),
         map$1((value) => {
           if (isError$3(value)) {
-            logDebug("RepoNameResolver:getRepoNameCached", "error", { verbose: value });
+            outputChannelLogger.logDebug("RepoNameResolver:getRepoNameCached", "error", {
+              verbose: value
+            });
             return null;
           }
           return value;
@@ -36495,7 +36985,7 @@ async function getContextFileFromCursor(newCursorPosition) {
         size
       };
     } catch (error) {
-      logError$2("getContextFileFromCursor", "failed", { verbose: error });
+      logError$1("getContextFileFromCursor", "failed", { verbose: error });
       return null;
     }
   });
@@ -36631,7 +37121,7 @@ async function executeDocChatCommand(args2) {
   return wrapInActiveSpan("command.doc", async (span2) => {
     var _a3;
     span2.setAttribute("sampled", true);
-    logDebug$1("executeDocCommand", "executing", { verbose: args2 });
+    logDebug("executeDocCommand", "executing", { verbose: args2 });
     const editor = (args2 == null ? void 0 : args2.uri) ? await window$1.showTextDocument(args2.uri) : (_a3 = getEditor()) == null ? void 0 : _a3.active;
     const document2 = editor == null ? void 0 : editor.document;
     if (!document2) {
@@ -36657,7 +37147,7 @@ async function executeDocCommand(args2) {
   return wrapInActiveSpan("command.doc", async (span2) => {
     var _a3;
     span2.setAttribute("sampled", true);
-    logDebug$1("executeDocCommand", "executing", { verbose: args2 });
+    logDebug("executeDocCommand", "executing", { verbose: args2 });
     let prompt = PromptString.fromDefaultCommands(commands, "doc");
     if (args2 == null ? void 0 : args2.additionalInstruction) {
       span2.addEvent("additionalInstruction");
@@ -36676,7 +37166,7 @@ async function executeDocCommand(args2) {
     if (!(selectionText == null ? void 0 : selectionText.trim())) {
       throw new Error("Cannot document an empty selection.");
     }
-    logDebug$1(
+    logDebug(
       "executeDocCommand",
       `selectionText: ${selectionText ? selectionText.slice(0, 70) + (selectionText.length > 70 ? "..." : "") : "null"}`
     );
@@ -36722,7 +37212,7 @@ async function explainCommand(span2, args2) {
 async function executeExplainCommand(args2) {
   return wrapInActiveSpan("command.explain", async (span2) => {
     span2.setAttribute("sampled", true);
-    logDebug$1("executeExplainCommand", "executing", { args: args2 });
+    logDebug("executeExplainCommand", "executing", { args: args2 });
     const editor = getEditor();
     if (editor.active && await isUriIgnoredByContextFilterWithNotification(editor.active.document.uri, "command")) {
       return;
@@ -36786,7 +37276,7 @@ async function executeSmellCommand(args2) {
     if (editor.active && await isUriIgnoredByContextFilterWithNotification(editor.active.document.uri, "command")) {
       return;
     }
-    logDebug$1("executeSmellCommand", "executing", { args: args2 });
+    logDebug("executeSmellCommand", "executing", { args: args2 });
     telemetryRecorder.recordEvent("cody.command.smell", "executed", {
       metadata: {
         useCodebaseContex: 0
@@ -36915,7 +37405,7 @@ async function getWorkspaceFilesContext(globalPattern, excludePattern, maxResult
         })
       )).filter(isDefined);
     } catch (error) {
-      logError$2("getWorkspaceFilesContext failed", `${error}`);
+      logError$1("getWorkspaceFilesContext failed", `${error}`);
       return [];
     }
   });
@@ -36973,7 +37463,7 @@ async function executeTestEditCommand(args2) {
   return wrapInActiveSpan("command.test", async (span2) => {
     var _a3, _b2;
     span2.setAttribute("sampled", true);
-    logDebug$1("executeTestEditCommand", "executing", { verbose: args2 });
+    logDebug("executeTestEditCommand", "executing", { verbose: args2 });
     const newTestFilePrompt = PromptString.fromDefaultCommands(commands, "test");
     const newTestSuitePrompt = ps`Review the shared code context to identify the testing framework and libraries in use. Then, create a new test suite with multiple new unit tests for my selected code following the same patterns, testing framework, conventions, and libraries as shown in the shared context. Pay attention to the shared context to ensure that your response code does not contain cases that have already been covered. Focus on generating new unit tests for uncovered cases. Respond only with the fully completed code for the new tests without any added comments, fragments, or TODO. The new tests should validate the expected functionality and cover edge cases for the selected code. The goal is to provide me with a new test suite that I can add to the end of the existing test file. Enclose only the new test suite without any import statements or modules in your response. Do not repeat tests from the shared context.`;
     const editor = (_a3 = getEditor()) == null ? void 0 : _a3.active;
@@ -36988,7 +37478,7 @@ async function executeTestEditCommand(args2) {
       throw new Error("Cannot generate unit test on empty selection.");
     }
     const contextFiles = await getContextFilesForUnitTestCommand(uri).catch((error) => {
-      logError$2("executeNewTestCommand", "failed to fetch context", { verbose: error });
+      logError$1("executeNewTestCommand", "failed to fetch context", { verbose: error });
       return [];
     });
     const destinationFile = (_b2 = contextFiles.find(
@@ -37100,7 +37590,7 @@ async function getContextFileFromDirectory(directory) {
         }
       }
     } catch (error) {
-      logError$2("getContextFileFromDirectory", "failed", { verbose: error });
+      logError$1("getContextFileFromDirectory", "failed", { verbose: error });
     }
     return contextFiles;
   });
@@ -37145,7 +37635,7 @@ async function executeTestCaseEditCommand(args2) {
       const files = await getContextFilesForAddingUnitTestCases(document2.uri);
       contextFiles.push(...files);
     } catch (error) {
-      logError$2("executeNewTestCommand", "failed to fetch context", { verbose: error });
+      logError$1("executeNewTestCommand", "failed to fetch context", { verbose: error });
     }
     const startLine = editor.selection.start.line + 1;
     const endLine = Math.max(startLine, editor.selection.end.line - 1);
@@ -37171,7 +37661,7 @@ async function executeExplainOutput(args2) {
   return wrapInActiveSpan("command.terminal", async (span2) => {
     var _a3;
     span2.setAttribute("sampled", true);
-    logDebug$1("executeExplainOutput", "executing", { args: args2 });
+    logDebug("executeExplainOutput", "executing", { args: args2 });
     const requestID = v4();
     const source = "terminal";
     telemetryRecorder.recordEvent("cody.command.terminal", "executed", {
@@ -37264,7 +37754,7 @@ function createOrUpdateTelemetryRecorderProvider(isExtensionModeDevOrTest) {
     resolvedConfig.subscribe(({ configuration, auth: auth2, clientState, isReinstall: isReinstall2 }) => {
       const initialize = telemetryRecorderProvider === void 0;
       if (isExtensionModeDevOrTest) {
-        logDebug(
+        outputChannelLogger.logDebug(
           debugLogLabel,
           "using telemetry recorder for dev mode (whitelisted events only)"
         );
@@ -37294,8 +37784,6 @@ function createOrUpdateTelemetryRecorderProvider(isExtensionModeDevOrTest) {
               }
             }
           );
-        } else if (!configuration.isRunningInsideAgent || configuration.agentHasPersistentStorage) {
-          telemetryRecorder.recordEvent("cody.extension", "savedLogin");
         }
       }
     })
@@ -37645,9 +38133,7 @@ async function resolveRelativeOrAbsoluteUri(baseDirUri, uri, fallbackUri) {
   if (!isFileProvided) {
     return fallbackUri;
   }
-  const rootDir = Uri.parse(path$1.join(...uri.split(separatorsRegex).slice(0, 2)));
-  const hasExistingRoot = await doesFileExist(rootDir);
-  if (hasExistingRoot) {
+  if (path$1.isAbsolute(uri)) {
     return Uri.file(uri);
   }
   if (!baseDirUri) {
@@ -37661,11 +38147,22 @@ async function resolveRelativeOrAbsoluteUri(baseDirUri, uri, fallbackUri) {
   return smartJoinPath(baseDirUri, uri);
 }
 function smartJoinPath(baseDirUri, relativeFileUri) {
+  if (path$1.isAbsolute(relativeFileUri)) {
+    return Uri.file(relativeFileUri);
+  }
   const workspacePath = baseDirUri.path.split(separatorsRegex).filter((segment) => segment.length > 0);
   const filePath = relativeFileUri.split(separatorsRegex).filter((segment) => segment.length > 0);
-  const commonPartLength = filePath.findIndex((segment) => segment === workspacePath.at(-1)) + 1;
-  const hasCommonPart = commonPartLength > 0 && isEqual(workspacePath.slice(-commonPartLength), filePath.slice(0, commonPartLength));
-  const uniqueFilePath = hasCommonPart ? filePath.slice(commonPartLength) : filePath;
+  const maxOverlap = Math.min(workspacePath.length, filePath.length);
+  let overlapLength = 0;
+  for (let k = maxOverlap; k >= 1; k--) {
+    const workspaceSuffix = workspacePath.slice(-k);
+    const filePrefix = filePath.slice(0, k);
+    if (isEqual(workspaceSuffix, filePrefix)) {
+      overlapLength = k;
+      break;
+    }
+  }
+  const uniqueFilePath = overlapLength > 0 ? filePath.slice(overlapLength) : filePath;
   const resultPath = path$1.join(baseDirUri.path, ...uniqueFilePath);
   return Uri.file(resultPath);
 }
@@ -37762,10 +38259,6 @@ async function getSmartApplyModel(authStatus2) {
   if (isInstantModeEnabled) {
     return SMART_APPLY_MODEL_IDENTIFIERS.FireworksQwenCodeDefault;
   }
-  if (isS2(authStatus2)) {
-    const defaultModel = "anthropic::2024-10-22::claude-3-5-sonnet-latest";
-    return defaultModel;
-  }
   return void 0;
 }
 async function handleSmartApply({
@@ -37804,7 +38297,7 @@ async function handleSmartApply({
         id,
         document: document2,
         instruction: PromptString.unsafe_fromUserQuery(instruction || ""),
-        model: await getSmartApplyModel(authStatus2),
+        model: await getSmartApplyModel(),
         replacement: code18,
         isNewFile,
         traceparent
@@ -37827,7 +38320,7 @@ async function handleSmartApply({
       id,
       document: document2,
       instruction: PromptString.unsafe_fromUserQuery(instruction || ""),
-      model: await getSmartApplyModel(authStatus2),
+      model: await getSmartApplyModel(),
       replacement: code18,
       isNewFile,
       traceparent
@@ -37879,7 +38372,7 @@ async function isCodeFromChatCodeBlockAction(newCode) {
   }
   return { ...storedCode, operation: "paste" };
 }
-const LOG_INTERVAL$1 = 30 * 60 * 1e3;
+const LOG_INTERVAL = 30 * 60 * 1e3;
 const RAPID_CHANGE_TIMEOUT = 15;
 const SELECTION_TIMEOUT = 5e3;
 const changeBoundaries = {
@@ -37955,7 +38448,7 @@ const _CharactersLogger = class _CharactersLogger {
     );
     this.windowFocused = window2.state.focused;
     this.activeTextEditor = window2.activeTextEditor;
-    this.nextTimeoutId = setTimeout(() => this.flush(), LOG_INTERVAL$1);
+    this.nextTimeoutId = setTimeout(() => this.flush(), LOG_INTERVAL);
   }
   flush() {
     try {
@@ -37973,7 +38466,7 @@ const _CharactersLogger = class _CharactersLogger {
     } finally {
       this.changeCounters = { ...DEFAULT_COUNTERS };
       if (!this.isDisposed) {
-        this.nextTimeoutId = setTimeout(() => this.flush(), LOG_INTERVAL$1);
+        this.nextTimeoutId = setTimeout(() => this.flush(), LOG_INTERVAL);
       }
     }
   }
@@ -38195,14 +38688,14 @@ class UpstreamHealthProvider {
       });
       if ("error" in upstreamResult) {
         this.lastUpstreamLatency = void 0;
-        logDebug$1("UpstreamHealth", "Failed to ping upstream host", {
+        logDebug("UpstreamHealth", "Failed to ping upstream host", {
           verbose: {
             error: upstreamResult.error
           }
         });
       } else {
         this.lastUpstreamLatency = upstreamResult.latency;
-        logDebug$1(
+        logDebug(
           "UpstreamHealth",
           `Ping took ${Math.round(upstreamResult.latency)}ms ${this.lastGatewayLatency ? `(Gateway: ${Math.round(this.lastGatewayLatency)}ms)` : ""}`,
           {
@@ -38235,63 +38728,6 @@ async function measureLatencyToUri(headers, uri) {
     return { error };
   }
 }
-const LOG_INTERVAL = 30 * 60 * 1e3;
-const AUTOCOMPLETE_STAGE_COUNTER_INITIAL_STATE = {
-  preLastCandidate: 0,
-  preCache: 0,
-  preSmartThrottle: 0,
-  preDebounce: 0,
-  preContextRetrieval: 0,
-  preNetworkRequest: 0,
-  preFinalCancellationCheck: 0,
-  preVisibilityCheck: 0
-};
-class AutocompleteStageCounter {
-  constructor() {
-    __publicField2(this, "nextTimeoutId", null);
-    __publicField2(this, "providerModel", null);
-    __publicField2(this, "currentState", { ...AUTOCOMPLETE_STAGE_COUNTER_INITIAL_STATE });
-    this.nextTimeoutId = setTimeout(() => this.flush(), LOG_INTERVAL);
-  }
-  setProviderModel(providerModel) {
-    if (this.providerModel !== null && this.providerModel !== providerModel) {
-      this.flush();
-    }
-    this.providerModel = providerModel;
-  }
-  //
-  //
-  flush() {
-    this.nextTimeoutId = null;
-    const stateToLog = this.currentState;
-    this.currentState = { ...AUTOCOMPLETE_STAGE_COUNTER_INITIAL_STATE };
-    if (Object.values(stateToLog).some((count) => count > 0)) {
-      telemetryRecorder.recordEvent("cody.completion.stageCounter", "flush", {
-        metadata: stateToLog,
-        privateMetadata: { providerModel: this.providerModel }
-      });
-    }
-    this.nextTimeoutId = setTimeout(() => this.flush(), LOG_INTERVAL);
-  }
-  /**
-   * Records the occurrence of a specific stage in the autocompletion generation pipeline.
-   */
-  record(state2) {
-    if (!this.providerModel) {
-      return;
-    }
-    this.currentState[state2]++;
-  }
-  //
-  // Like the code above, you can reuse the code outside the XML tags to detect the functionality, formats, style, patterns, and logics in use. Then, use what you detect and reuse methods/libraries to complete and enclose completed code only inside XML tags precisely without duplicating existing implementations. Here is the code:
-  dispose() {
-    this.flush();
-    if (this.nextTimeoutId) {
-      clearTimeout(this.nextTimeoutId);
-    }
-  }
-}
-new AutocompleteStageCounter();
 function getLanguageConfig(languageId) {
   switch (languageId) {
     case "astro":
@@ -39040,7 +39476,7 @@ class ProtocolTextDocumentWithUri {
     this.uri = uri;
     this.underlying = underlying ?? { uri: uri.toString() };
     if (this.underlying.uri !== uri.toString()) {
-      logDebug(
+      outputChannelLogger.logDebug(
         "ProtocolTextDocumentWithUri",
         "correcting invariant violation",
         `${this.uri} (this.uri) !== ${this.underlying.uri} (this.underlying.uri)`
@@ -39090,17 +39526,17 @@ class AgentAuthHandler {
       }
       this.startServer(url);
     } catch (error) {
-      logDebug$1("AgentAuthHandler", `Invalid callback URL: ${error}`);
+      logDebug("AgentAuthHandler", `Invalid callback URL: ${error}`);
     }
   }
   startServer(callbackUri) {
     var _a3;
     if (!((_a3 = this.tokenCallbackHandlers) == null ? void 0 : _a3.length)) {
-      logDebug$1("AgentAuthHandler", "Token callback handler is not set.");
+      logDebug("AgentAuthHandler", "Token callback handler is not set.");
       return;
     }
     if (this.server && this.port) {
-      logDebug$1("AgentAuthHandler", "Server already running");
+      logDebug("AgentAuthHandler", "Server already running");
       this.redirectToEndpointLoginPage(callbackUri);
       return;
     }
@@ -39137,17 +39573,17 @@ class AgentAuthHandler {
     server.listen(0, "127.0.0.1", () => {
       this.port = server.address().port;
       this.server = server;
-      logDebug$1("AgentAuthHandler", `Server listening on port ${this.port}`);
+      logDebug("AgentAuthHandler", `Server listening on port ${this.port}`);
       this.redirectToEndpointLoginPage(callbackUri);
       setTimeout(() => this.closeServer(), SIX_MINUTES);
     });
     server.on("error", (error) => {
-      logDebug$1("AgentAuthHandler", `Server error: ${error}`);
+      logDebug("AgentAuthHandler", `Server error: ${error}`);
     });
   }
   closeServer() {
     if (this.server) {
-      logDebug$1("AgentAuthHandler", "Auth server closed");
+      logDebug("AgentAuthHandler", "Auth server closed");
       this.server.close();
     }
     this.server = null;
@@ -39176,8 +39612,14 @@ class AgentAuthHandler {
     } else {
       const params = new URLSearchParams(decodeURIComponent(uri.search));
       const requestFrom = params.get("requestFrom");
+      const user_code = params.get("user_code");
       if (requestFrom) {
         params.set("requestFrom", `${requestFrom}-${this.port}`);
+      }
+      if (user_code) {
+        params.set("user_code", user_code);
+      }
+      if (requestFrom || user_code) {
         uri.search = params.toString();
       }
     }
@@ -39198,7 +39640,7 @@ function getValidCallbackUri(uri) {
     }
     return URI.parse(endpointUri.href);
   } catch (error) {
-    logDebug$1("Invalid URL: ", `${error}`);
+    logDebug("Invalid URL: ", `${error}`);
     return null;
   }
 }
@@ -39274,7 +39716,7 @@ function createFileSystemRuleProvider() {
                   return rules;
                 } catch (error) {
                   if (!(error && typeof error === "object" && "code" in error && error.code === "FileNotFound")) {
-                    logDebug$1(
+                    logDebug(
                       "rules",
                       `Error reading rules for ${searchPath}: ${error}`
                     );
@@ -39355,7 +39797,7 @@ async function listRulesApplyingToRemoteFile(client, repoName, filePath, signal2
     }
     return resp.rules ?? [];
   } catch (error) {
-    logDebug$1(
+    logDebug(
       "rules",
       `Error listing rules for remote file ${filePath} in repository ${repoName}: ${error}`
     );
@@ -39679,7 +40121,7 @@ async function getContextFileFromUri(file, range) {
         size
       };
     } catch (error) {
-      logError$2("getContextFileFromUri", "failed", { verbose: error });
+      logError$1("getContextFileFromUri", "failed", { verbose: error });
       return null;
     }
   });
@@ -39712,7 +40154,7 @@ async function getContextFromRelativePath(path2) {
       size
     };
   } catch (error) {
-    logError$2("getContextFileFromUri", "failed", { verbose: error });
+    logError$1("getContextFileFromUri", "failed", { verbose: error });
     return null;
   }
 }
@@ -40530,7 +40972,7 @@ async function resolveContextMentionProviderContextItem({ provider: providerUri,
     return [];
   }
   if (!item.mention) {
-    logError$2("OpenCtx", "resolving context item is missing mention parameter", item);
+    logError$1("OpenCtx", "resolving context item is missing mention parameter", item);
     return [];
   }
   const mention = {
@@ -40543,15 +40985,16 @@ async function resolveContextMentionProviderContextItem({ provider: providerUri,
   );
   signal2 == null ? void 0 : signal2.throwIfAborted();
   return items.map(
-    (item2) => {
+    (openCtxItem) => {
       var _a3;
-      return ((_a3 = item2.ai) == null ? void 0 : _a3.content) ? {
+      return ((_a3 = openCtxItem.ai) == null ? void 0 : _a3.content) ? {
         type: "openctx",
-        title: item2.title,
-        uri: URI.parse(item2.url || item2.providerUri),
-        providerUri: item2.providerUri,
-        content: item2.ai.content,
-        provider: "openctx"
+        title: openCtxItem.title,
+        uri: URI.parse(openCtxItem.url || openCtxItem.providerUri),
+        providerUri: openCtxItem.providerUri,
+        content: openCtxItem.ai.content,
+        provider: "openctx",
+        source: item.source
       } : null;
     }
   ).filter((context2) => context2 !== null);
@@ -42741,6 +43184,9 @@ const objectivec = [
   "m",
   "mm"
 ];
+const matlab = [
+  "m"
+];
 const ocaml = [
   "ml",
   "eliom",
@@ -43048,6 +43494,7 @@ const extensionMapping = {
   markdown,
   nginx,
   objectivec,
+  matlab,
   ocaml,
   pascal,
   perl,
@@ -43090,17 +43537,25 @@ function getMapping() {
   mapping = /* @__PURE__ */ new Map();
   for (const [language, extensions2] of Object.entries(extensionMapping)) {
     for (const extension of extensions2) {
-      mapping.set(extension, language);
+      mapping.set(extension.toLowerCase(), language);
     }
   }
   return mapping;
 }
 function getLanguageForFileName(filePath) {
   const fileName = path$1.basename(filePath);
-  const extension = fileName.split(".").pop() || fileName;
+  const extension = (fileName.split(".").pop() || fileName).toLowerCase();
   const language = getMapping().get(extension);
   return language || extension;
 }
+function getLanguageForFileNameAndContent(filePath, content) {
+  const fileName = path$1.basename(filePath);
+  const extension = (fileName.split(".").pop() || fileName).toLowerCase();
+  if (extension === "m") {
+    return isMatlabFile(content) ? "matlab" : "objectivec";
+  }
+  return getLanguageForFileName(filePath);
+}
 class DocumentOffsets {
   constructor(document2) {
     __publicField2(this, "lines", []);
@@ -43170,7 +43625,10 @@ class AgentTextDocument {
     __publicField2(this, "isClosed", false);
     __publicField2(this, "eol", EndOfLine.LF);
     this.protocolDocument = protocolDocument;
-    this.languageId = getLanguageForFileName(this.fileName);
+    this.languageId = getLanguageForFileNameAndContent(
+      this.fileName,
+      this.protocolDocument.underlying.content ?? ""
+    );
     this.offsets = new DocumentOffsets(protocolDocument.underlying);
     this.lineCount = this.offsets.lineCount();
   }
@@ -43289,7 +43747,7 @@ class AgentTextEditor {
       if ((_a3 = this.params) == null ? void 0 : _a3.edit) {
         return this.params.edit(this.agentDocument.uri, callback, options);
       }
-      logDebug$1("AgentTextEditor:edit()", "not supported");
+      logDebug("AgentTextEditor:edit()", "not supported");
       return Promise.resolve(false);
     });
     this.agentDocument = agentDocument;
@@ -43929,7 +44387,7 @@ class AgentWorkspaceDocuments {
       if (uri.scheme === "untitled") {
         document2.underlying.content = "";
       } else if (!await doesFileExist(uri)) {
-        logError$2(
+        logError$1(
           "AgentWorkspaceDocuments.openTextDocument()",
           "File does not exist",
           uri.toString()
@@ -43938,7 +44396,7 @@ class AgentWorkspaceDocuments {
         const buffer2 = await fs.readFile(uri.fsPath, "utf8");
         document2.underlying.content = buffer2.toString();
       } else {
-        logError$2("vscode.workspace.openTextDocument", `unable to read non-file URI: ${uri}`);
+        logError$1("vscode.workspace.openTextDocument", `unable to read non-file URI: ${uri}`);
       }
     }
     return Promise.resolve(this.loadAndUpdateDocument(document2));
@@ -45505,14 +45963,14 @@ function copyExtensionRelativeResources(extensionPath, extensionClient) {
         return;
       }
     } catch {
-      logDebug$1("copyExtensionRelativeResources", `Failed to find ${source}, skipping copy`);
+      logDebug("copyExtensionRelativeResources", `Failed to find ${source}, skipping copy`);
       return;
     }
     try {
       mkdirSync(path$1.dirname(target), { recursive: true });
       copySync(source, target);
     } catch (err2) {
-      logDebug$1("copyExtensionRelativeResources", `Failed to copy ${source} to dist ${target}`, err2);
+      logDebug("copyExtensionRelativeResources", `Failed to copy ${source} to dist ${target}`, err2);
     }
   };
   copySources("win-ca-roots.exe");
@@ -45583,7 +46041,7 @@ class Agent extends MessageHandler {
       edit: (uri, callback, options) => {
         var _a3, _b2;
         if (((_b2 = (_a3 = this.clientInfo) == null ? void 0 : _a3.capabilities) == null ? void 0 : _b2.edit) !== "enabled") {
-          logDebug$1("CodyAgent", "client does not support operation: textDocument/edit");
+          logDebug("CodyAgent", "client does not support operation: textDocument/edit");
           return Promise.resolve(false);
         }
         const edits = [];
@@ -45764,7 +46222,6 @@ class Agent extends MessageHandler {
       const textDocument = this.workspace.loadDocument(documentWithUri);
       onDidOpenTextDocument.fire(textDocument);
       this.pushPendingPromise(this.workspace.fireVisibleTextEditorsDidChange());
-      this.workspace.setActiveTextEditor(this.workspace.newTextEditor(textDocument));
     });
     this.registerNotification("textDocument/didChange", async (document2) => {
       this.handleDocumentChange(document2);
@@ -46118,12 +46575,12 @@ class Agent extends MessageHandler {
       var _a3, _b2, _c2;
       const provider = await completionProvider();
       if (!provider) {
-        logError$2("Agent", "autocomplete/execute", "Completion provider is not initialized");
+        logError$1("Agent", "autocomplete/execute", "Completion provider is not initialized");
         return { items: [], inlineCompletionItems: [], decoratedEditItems: [] };
       }
       const uri = typeof params2.uri === "string" ? Uri.parse(params2.uri) : (params2 == null ? void 0 : params2.filePath) ? Uri.file(params2.filePath) : void 0;
       if (!uri) {
-        logError$2(
+        logError$1(
           "Agent",
           "autocomplete/execute",
           `No uri provided for autocomplete request ${JSON.stringify(
@@ -46134,7 +46591,7 @@ class Agent extends MessageHandler {
       }
       const document2 = this.workspace.getDocument(uri);
       if (!document2) {
-        logError$2(
+        logError$1(
           "Agent",
           "autocomplete/execute",
           "No document found for file path",
@@ -46329,7 +46786,7 @@ class Agent extends MessageHandler {
         );
         const document2 = this.workspace.getDocument(uri);
         if (!document2) {
-          logError$2(
+          logError$1(
             "Agent",
             "editTask/getFoldingRanges",
             "No document found for file path",
@@ -46751,7 +47208,7 @@ class Agent extends MessageHandler {
           metadata: metadata2
         });
       }
-      logError$2(
+      logError$1(
         "Agent",
         'client does not support vscode.workspace.applyEdit() yet. If you are a client author, enable this operation by setting the client capability `editWorkspace: "enabled"`',
         new Error().stack
@@ -46840,7 +47297,7 @@ async function explainHistoryCommand(span2, commandsProvider, args2) {
   if (isFailure(historyOptions)) {
     return historyOptions;
   }
-  logDebug$1("explainHistoryCommand", "computed history options", JSON.stringify(historyOptions));
+  logDebug("explainHistoryCommand", "computed history options", JSON.stringify(historyOptions));
   let contextItems = [];
   try {
     contextItems = await commandsProvider.history(historyOptions.uri, historyOptions);
@@ -46868,7 +47325,7 @@ async function explainHistoryCommand(span2, commandsProvider, args2) {
 async function executeExplainHistoryCommand(commandsProvider, args2 = {}) {
   return wrapInActiveSpan("command.explain-history", async (span2) => {
     span2.setAttribute("sampled", true);
-    logDebug$1("executeExplainHistoryCommand", "executing", args2);
+    logDebug("executeExplainHistoryCommand", "executing", args2);
     telemetryRecorder.recordEvent("cody.command.explain-history", "executed", {
       interactionID: args2 == null ? void 0 : args2.requestID,
       privateMetadata: {
@@ -46924,7 +47381,7 @@ function isFailure(object) {
 function handleFailure(span2, result) {
   span2.setAttribute("failure-reason", result.reason);
   if (result.level === "error") {
-    logError$2(
+    logError$1(
       "executeExplainHistoryCommand",
       "error fetching history context",
       result.reason,
@@ -46934,7 +47391,7 @@ function handleFailure(span2, result) {
     window$1.showErrorMessage(errorMessage);
     throw new Error(errorMessage);
   }
-  logDebug$1(
+  logDebug(
     "executeExplainHistoryCommand",
     "failed to explaining history context",
     result.reason,
@@ -47319,7 +47776,7 @@ class CustomCommandsManager {
       const buildWorkspaceCommands = workspace.isTrusted ? this.build(CustomCommandType.Workspace) : Promise.resolve();
       await Promise.all([buildUserCommands, buildWorkspaceCommands]);
     } catch (error) {
-      logError$1("CustomCommandsProvider:refresh", "failed", { verbose: error });
+      outputChannelLogger.logError("CustomCommandsProvider:refresh", "failed", { verbose: error });
     }
     return { commands: this.customCommandsMap };
   }
@@ -47349,7 +47806,7 @@ class CustomCommandsManager {
         );
       }
     } catch (error) {
-      logError$1("CustomCommandsProvider:build", "failed", { verbose: error });
+      outputChannelLogger.logError("CustomCommandsProvider:build", "failed", { verbose: error });
     }
     return this.customCommandsMap;
   }
@@ -47363,7 +47820,7 @@ class CustomCommandsManager {
       return;
     }
     await this.save(newCommand.key, newCommand.prompt, newCommand.type);
-    logDebug("CustomCommandsProvider:newCustomCommandQuickPick:", "saved", {
+    outputChannelLogger.logDebug("CustomCommandsProvider:newCustomCommandQuickPick:", "saved", {
       verbose: newCommand
     });
   }
@@ -47438,7 +47895,7 @@ class CustomCommandsManager {
     }
   }
   showSystemError(title, error) {
-    logDebug("CustomCommandsProvider", title, { verbose: error });
+    outputChannelLogger.logDebug("CustomCommandsProvider", title, { verbose: error });
     void window$1.showErrorMessage(`${title} ${error}`);
   }
   /**
@@ -47890,7 +48347,7 @@ class CommandsProvider {
     if (!isFileURI(uri)) {
       throw new Error("history only supported on local file paths");
     }
-    const { getContextFileFromGitLog } = await import("./git-log-Dihxu1-Z.mjs");
+    const { getContextFileFromGitLog } = await import("./git-log-DjCz8t7A.mjs");
     return getContextFileFromGitLog(uri, options);
   }
   dispose() {
@@ -48077,6 +48534,418 @@ ${authStatus2.endpoint}`;
       return void 0;
   }
 }
+async function abortableDelay(ms, signal2) {
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(() => resolve(false), ms);
+    if (signal2.aborted) {
+      clearTimeout(timeoutId);
+      resolve(true);
+      return;
+    }
+    const onAbort2 = () => {
+      clearTimeout(timeoutId);
+      resolve(true);
+    };
+    signal2.addEventListener("abort", onAbort2);
+  });
+}
+let debugDisableDeviceAuth = false;
+function setDebugDisableDeviceAuth(disabled) {
+  debugDisableDeviceAuth = disabled;
+  outputChannelLogger.logDebug("device-auth", "Debug device auth override", { disabled });
+}
+function getDebugDisableDeviceAuth() {
+  return debugDisableDeviceAuth;
+}
+async function getOIDCConfiguration(endpoint) {
+  if (debugDisableDeviceAuth) {
+    outputChannelLogger.logDebug("device-auth", "Device auth disabled via debug flag", { endpoint });
+    return null;
+  }
+  const config = await getOIDCConfiguration$1(endpoint);
+  if (!config) {
+    outputChannelLogger.logDebug("device-auth", "OIDC configuration not available", { endpoint });
+    return null;
+  }
+  return config;
+}
+async function initiateDeviceAuth(oidcConfig) {
+  if (!(oidcConfig == null ? void 0 : oidcConfig.device_authorization_endpoint)) {
+    return null;
+  }
+  const clientId = getOAuthClientId();
+  try {
+    const response = await fetch(oidcConfig.device_authorization_endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        client_id: clientId,
+        scope: "user:all"
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Device auth initiation failed: ${response.status} ${response.statusText}`);
+    }
+    const deviceAuth = await response.json();
+    outputChannelLogger.logDebug("device-auth", "Device auth initiated", {
+      device_authorization_endpoint: oidcConfig == null ? void 0 : oidcConfig.device_authorization_endpoint,
+      user_code: deviceAuth.user_code,
+      expires_in: deviceAuth.expires_in
+    });
+    return deviceAuth;
+  } catch (error) {
+    outputChannelLogger.logError("device-auth", "Failed to initiate device auth", error);
+    return null;
+  }
+}
+async function pollForToken(oidcConfig, deviceCode, interval2, expiresIn, abortSignal) {
+  const clientId = getOAuthClientId();
+  const startTime = Date.now();
+  const expirationTime = startTime + expiresIn * 1e3;
+  let attempts = 0;
+  const maxAttempts = Math.ceil(expiresIn / interval2);
+  while (Date.now() < expirationTime && attempts < maxAttempts && !abortSignal.aborted) {
+    attempts++;
+    try {
+      const response = await fetch(oidcConfig.token_endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: new URLSearchParams({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: clientId
+        })
+      });
+      if (response.ok) {
+        const tokenResponse = await response.json();
+        outputChannelLogger.logDebug("device-auth", "Token received successfully");
+        return tokenResponse;
+      }
+      if (response.status === 400) {
+        const error = await response.json();
+        if (error.error === "authorization_pending") {
+          outputChannelLogger.logDebug(
+            "device-auth",
+            "Authorization pending, continuing to poll",
+            { attempts }
+          );
+        } else if (error.error === "slow_down") {
+          interval2 = Math.min(interval2 * 2, 60);
+          outputChannelLogger.logDebug("device-auth", "Slowing down polling", {
+            newInterval: interval2
+          });
+        } else if (error.error === "expired_token") {
+          outputChannelLogger.logDebug("device-auth", "Device code expired");
+          return null;
+        } else if (error.error === "access_denied") {
+          outputChannelLogger.logDebug("device-auth", "User denied authorization");
+          return null;
+        } else {
+          outputChannelLogger.logError(
+            "device-auth",
+            "Unknown error during token polling",
+            error
+          );
+          return null;
+        }
+      } else {
+        outputChannelLogger.logError("device-auth", "Unexpected response during token polling", {
+          status: response.status,
+          statusText: response.statusText
+        });
+        return null;
+      }
+    } catch (error) {
+      outputChannelLogger.logError("device-auth", "Error during token polling", error);
+      return null;
+    }
+    const wasCancelled = await abortableDelay(interval2 * 1e3, abortSignal);
+    if (wasCancelled) {
+      return null;
+    }
+  }
+  outputChannelLogger.logDebug("device-auth", "Token polling timed out", { attempts, expiresIn });
+  return null;
+}
+async function startDeviceAuthFlow(uri, onUserCode, abortSignal) {
+  const endpoint = formatURL(uri);
+  if (!endpoint) {
+    return { type: "failed" };
+  }
+  telemetryRecorder.recordEvent("cody.auth.device.initiated", "started");
+  const oidcConfig = await getOIDCConfiguration(endpoint);
+  if (!oidcConfig) {
+    outputChannelLogger.logDebug("device-auth", "Failed to get OIDC configuration", { endpoint });
+    return { type: "failed" };
+  }
+  const deviceAuth = await initiateDeviceAuth(oidcConfig);
+  if (!deviceAuth) {
+    outputChannelLogger.logDebug("device-auth", "Device auth not supported", { endpoint });
+    return { type: "failed" };
+  }
+  const deviceUrl = deviceAuth.verification_uri_complete || `${deviceAuth.verification_uri}?user_code=${encodeURIComponent(deviceAuth.user_code)}`;
+  onUserCode(deviceAuth.user_code, deviceUrl);
+  return window$1.withProgress(
+    {
+      location: ProgressLocation.Notification,
+      title: "Waiting for authorization...",
+      cancellable: true
+    },
+    async (progress, cancellationToken) => {
+      const combinedController = new AbortController();
+      cancellationToken.onCancellationRequested(() => {
+        combinedController.abort();
+        outputChannelLogger.logDebug("device-auth", "Device auth cancelled via notification");
+      });
+      if (abortSignal) {
+        abortSignal.addEventListener("abort", () => {
+          combinedController.abort();
+          outputChannelLogger.logDebug("device-auth", "Device auth aborted via webview");
+        });
+      }
+      const tokenResponse = await pollForToken(
+        oidcConfig,
+        deviceAuth.device_code,
+        deviceAuth.interval,
+        deviceAuth.expires_in,
+        combinedController.signal
+      );
+      if (combinedController.signal.aborted) {
+        telemetryRecorder.recordEvent("cody.auth.device.cancelled", "cancelled");
+        const status = { pendingValidation: false };
+        return Promise.resolve({ type: "cancelled", authStatus: status });
+      }
+      if (!tokenResponse) {
+        telemetryRecorder.recordEvent("cody.auth.device.failed", "failed");
+        return { type: "failed" };
+      }
+      if (tokenResponse.refresh_token) {
+        await secretStorage.storeRefreshToken(endpoint, tokenResponse.refresh_token);
+      }
+      if (tokenResponse.expires_in) {
+        const expiresAt = Date.now() + tokenResponse.expires_in * 1e3;
+        await secretStorage.storeTokenExpiresAt(endpoint, expiresAt);
+      }
+      if (tokenResponse.access_token) {
+        await secretStorage.storeToken(endpoint, tokenResponse.access_token, "oauth");
+      }
+      await secretStorage.store(endpoint + "cody.access-token.source", "oauth");
+      const deviceAuthCredential = new OAuthCredential(endpoint, secretStorage);
+      if (!deviceAuthCredential) {
+        telemetryRecorder.recordEvent("cody.auth.device.failed", "failed");
+        return { type: "failed" };
+      }
+      const authStatus2 = await authProvider.validateAndStoreCredentials(
+        {
+          serverEndpoint: endpoint,
+          credentials: deviceAuthCredential
+        },
+        "store-if-valid"
+      );
+      telemetryRecorder.recordEvent("cody.auth.device.completed", "completed", {
+        metadata: {
+          success: authStatus2.authenticated ? 1 : 0
+        }
+      });
+      return { type: "success", authStatus: authStatus2 };
+    }
+  );
+}
+function registerAuthDebugCommands(disposables) {
+  disposables.push(
+    // Set token expiry for testing refresh logic
+    commands$1.registerCommand("cody.debug.auth.setTokenExpiry", async () => {
+      const authStatus2 = currentAuthStatus();
+      if (!authStatus2.authenticated) {
+        void window$1.showErrorMessage("Not authenticated");
+        return;
+      }
+      const options = [
+        { label: "1 hour ago (expired)", value: Date.now() - 60 * 60 * 1e3 },
+        { label: "10 minutes from now", value: Date.now() + 10 * 60 * 1e3 },
+        { label: "2 minutes from now", value: Date.now() + 2 * 60 * 1e3 },
+        { label: "30 seconds from now", value: Date.now() + 30 * 1e3 },
+        { label: "No expiry (remove)", value: null }
+      ];
+      const selection = await window$1.showQuickPick(options, {
+        title: "Set Token Expiry",
+        placeHolder: "Choose when the token should expire"
+      });
+      if (!selection) return;
+      const endpoint = authStatus2.endpoint;
+      if (selection.value === null) {
+        await secretStorage.delete(endpoint + "cody.token.expires-at");
+        void window$1.showInformationMessage("Token expiry removed");
+      } else {
+        await secretStorage.storeTokenExpiresAt(endpoint, selection.value);
+        const timeStr = new Date(selection.value).toLocaleString();
+        void window$1.showInformationMessage(`Token expiry set to: ${timeStr}`);
+      }
+    }),
+    // Check current token expiry
+    commands$1.registerCommand("cody.debug.auth.checkTokenExpiry", async () => {
+      const authStatus2 = currentAuthStatus();
+      if (!authStatus2.authenticated) {
+        void window$1.showErrorMessage("Not authenticated");
+        return;
+      }
+      const endpoint = authStatus2.endpoint;
+      const expiresAt = await secretStorage.getTokenExpiresAt(endpoint);
+      const refreshToken = await secretStorage.getRefreshToken(endpoint);
+      const tokenSource = await secretStorage.getTokenSource(endpoint);
+      if (!expiresAt) {
+        void window$1.showInformationMessage("No token expiry set");
+        return;
+      }
+      const now = Date.now();
+      const timeUntilExpiry = expiresAt - now;
+      const isExpired = timeUntilExpiry <= 0;
+      const needsRefresh = timeUntilExpiry <= 5 * 60 * 1e3;
+      const expiryTime = new Date(expiresAt).toLocaleString();
+      const status = isExpired ? "🔴 EXPIRED" : needsRefresh ? "🟡 NEEDS REFRESH" : "🟢 VALID";
+      const info2 = [
+        `Status: ${status}`,
+        `Expires: ${expiryTime}`,
+        `Time until expiry: ${Math.round(timeUntilExpiry / 1e3)}s`,
+        `Has refresh token: ${refreshToken ? "Yes" : "No"}`,
+        `Token source: ${tokenSource || "Unknown"}`
+      ].join("\n");
+      void window$1.showInformationMessage(info2, { modal: true });
+    }),
+    // Set invalid token to test error handling
+    commands$1.registerCommand("cody.debug.auth.setInvalidRefreshToken", async () => {
+      const authStatus2 = currentAuthStatus();
+      if (!authStatus2.authenticated) {
+        void window$1.showErrorMessage("Not authenticated");
+        return;
+      }
+      const endpoint = authStatus2.endpoint;
+      await secretStorage.storeRefreshToken(endpoint, "invalid_token_for_testing");
+      void window$1.showInformationMessage(
+        "Invalid refresh token set - auth will fail on next request"
+      );
+    }),
+    // Clear all auth data
+    commands$1.registerCommand("cody.debug.auth.clearAll", async () => {
+      const confirmation = await window$1.showWarningMessage(
+        "This will clear all stored authentication data. Continue?",
+        { modal: true },
+        "Clear All"
+      );
+      if (confirmation !== "Clear All") return;
+      const endpoints = JSON.parse(localStorage.get("CODY_ENDPOINT_HISTORY") || "[]");
+      for (const endpoint of endpoints) {
+        await secretStorage.deleteToken(endpoint);
+      }
+      void window$1.showInformationMessage("All auth data cleared");
+    }),
+    // Show stored auth data (works even when not authenticated)
+    commands$1.registerCommand("cody.debug.auth.showStoredData", async () => {
+      const endpoints = localStorage.getEndpointHistory() || [];
+      if (endpoints.length === 0) {
+        void window$1.showInformationMessage("No stored endpoints found");
+        return;
+      }
+      const results = [];
+      for (const endpoint of endpoints) {
+        const tokenSource = await secretStorage.getTokenSource(endpoint);
+        const refreshToken = await secretStorage.getRefreshToken(endpoint);
+        const expiresAt = await secretStorage.getTokenExpiresAt(endpoint);
+        let token = await secretStorage.getToken(endpoint);
+        let tokenInfo = "None";
+        if (tokenSource === "oauth") {
+          const authStatus2 = currentAuthStatus();
+          if (authStatus2.authenticated && authStatus2.endpoint === endpoint) {
+            tokenInfo = "In memory (HeaderCredential)";
+            try {
+              const config = await import("./index-CQZWUrDD.mjs").then(
+                (m) => m.currentResolvedConfig()
+              );
+              const currentConfig = await config;
+              if (currentConfig.auth.credentials && "getHeaders" in currentConfig.auth.credentials) {
+                const headers = await currentConfig.auth.credentials.getHeaders();
+                const authHeader = headers.Authorization;
+                if (authHeader == null ? void 0 : authHeader.startsWith("Bearer ")) {
+                  token = authHeader.slice(7);
+                  tokenInfo = token;
+                }
+              }
+            } catch {
+            }
+          }
+        } else if (token) {
+          tokenInfo = token;
+        }
+        if (token || refreshToken || tokenSource) {
+          const expiryStr = expiresAt ? new Date(expiresAt).toLocaleString() : "No expiry";
+          results.push(
+            [
+              `Endpoint: ${endpoint}`,
+              `Token: ${tokenInfo}`,
+              `Refresh Token: ${refreshToken || "None"}`,
+              `Token Source: ${tokenSource || "Unknown"}`,
+              `Expires: ${expiryStr}`,
+              "---"
+            ].join("\n")
+          );
+        }
+      }
+      if (results.length === 0) {
+        void window$1.showInformationMessage("No stored tokens found");
+      } else {
+        void window$1.showInformationMessage(
+          `Found ${results.length} stored token(s). Check "Cody auth" output channel for details.`,
+          "Open Output Channel"
+        ).then((action) => {
+          if (action === "Open Output Channel") {
+            commands$1.executeCommand("workbench.action.output.toggleOutput");
+          }
+        });
+      }
+    }),
+    // Show current auth info (masked) - requires being authenticated
+    commands$1.registerCommand("cody.debug.auth.showInfo", async () => {
+      const authStatus2 = currentAuthStatus();
+      if (!authStatus2.authenticated) {
+        void window$1.showInformationMessage(
+          'Not authenticated - use "Show Stored Data" instead'
+        );
+        return;
+      }
+      const endpoint = authStatus2.endpoint;
+      const token = await secretStorage.getToken(endpoint);
+      const refreshToken = await secretStorage.getRefreshToken(endpoint);
+      const expiresAt = await secretStorage.getTokenExpiresAt(endpoint);
+      const tokenSource = await secretStorage.getTokenSource(endpoint);
+      const maskedToken = refreshToken ? `${refreshToken.slice(0, 8)}...${refreshToken.slice(-4)}` : "None";
+      const expiryStr = expiresAt ? new Date(expiresAt).toLocaleString() : "No expiry";
+      const info2 = [
+        `Endpoint: ${endpoint}`,
+        `Username: ${authStatus2.username}`,
+        `Token: ${token || "Unknown"}`,
+        `Token source: ${tokenSource || "Unknown"}`,
+        `Refresh token: ${maskedToken}`,
+        `Expires: ${expiryStr}`,
+        `Auth method: ${refreshToken ? "Device/OAuth" : "Manual token"}`
+      ].join("\n");
+      void window$1.showInformationMessage(info2, { modal: true });
+    }),
+    // Toggle device auth support (for testing fallback)
+    commands$1.registerCommand("cody.debug.auth.toggleDeviceAuth", async () => {
+      const currentState = getDebugDisableDeviceAuth();
+      const newState = !currentState;
+      setDebugDisableDeviceAuth(newState);
+      const status = newState ? "DISABLED" : "ENABLED";
+      const emoji = newState ? "🔴" : "🟢";
+      const fallbackMsg = newState ? " (will fallback to old auth flow)" : "";
+      void window$1.showInformationMessage(`${emoji} Device Auth: ${status}${fallbackMsg}`);
+    })
+  );
+}
 const RRF_K = 60;
 function fuseResults(retrievedSets, rankingIdentities) {
   const resultsByDocument = /* @__PURE__ */ new Map();
@@ -48405,7 +49274,7 @@ class CachedRetriever {
      */
     __publicField2(this, "addDependency", (dep) => {
       if (!this.currentKey) {
-        logError$2(this.constructor.name, "Cannot add dependency outside of retrieval function");
+        logError$1(this.constructor.name, "Cannot add dependency outside of retrieval function");
         return;
       }
       const keys2 = this.dependencies.get(dep);
@@ -150452,7 +151321,7 @@ const _ContextRetrieverDataCollection = class _ContextRetrieverDataCollection {
       case RetrieverIdentifier.JaccardSimilarityRetriever:
         return new JaccardSimilarityRetriever();
       default:
-        logDebug(
+        outputChannelLogger.logDebug(
           "ContextRetrieverDataCollection",
           "createRetriever",
           `Unhandled RetrieverIdentifier: ${config.identifier}`
@@ -154538,15 +155407,24 @@ class AutoeditAnalyticsLogger {
     telemetryParams
   }) {
     autoeditsOutputChannelLogger.logDebug("writeAutoeditEvent", action, ...logDebugArgs);
-    if (action !== "discarded") {
-      telemetryRecorder.recordEvent("cody.autoedit", action, {
-        ...telemetryParams,
-        billingMetadata: action === "accepted" || action === "suggested" ? {
-          product: "cody",
-          category: action === "accepted" ? "core" : "billable"
-        } : void 0
-      });
+    const skippedActions = [
+      "discarded",
+      "invalidTransitionToAccepted",
+      "invalidTransitionToDiscarded",
+      "invalidTransitionToLoaded",
+      "invalidTransitionToRejected",
+      "invalidTransitionToPostProcessed"
+    ];
+    if (skippedActions.includes(action)) {
+      return;
     }
+    telemetryRecorder.recordEvent("cody.autoedit", action, {
+      ...telemetryParams,
+      billingMetadata: action === "accepted" || action === "suggested" ? {
+        product: "cody",
+        category: action === "accepted" ? "core" : "billable"
+      } : void 0
+    });
   }
   /**
    * Rate-limited error logging, capturing exceptions with Sentry and grouping repeated logs.
@@ -171223,7 +172101,7 @@ function migrateAndNotifyForOutdatedModels(model2) {
   if (!model2 || isRunningInsideAgent() || !deprecatedModelSet.has(model2)) {
     return model2;
   }
-  const newModel = "anthropic/claude-3-5-sonnet-20240620";
+  const newModel = "anthropic/claude-sonnet-4-5-20250929";
   if (modelsService.getModelByID(newModel)) {
     showNotificationIfNotShownYet(
       "Claude 2 model support has been removed in favor of the newer Claude 3 models. All chats that used Claude 2 have been upgraded to Claude 3.",
@@ -171259,7 +172137,7 @@ async function getContextFileFromTabs() {
         })
       )).filter(isDefined);
     } catch (error) {
-      logError$2("getContextFileFromTabs", "failed", { verbose: error });
+      logError$1("getContextFileFromTabs", "failed", { verbose: error });
       return [];
     }
   });
@@ -172593,7 +173471,11 @@ const getCommandContextFiles = async (config) => {
     }
     return contextFiles;
   } catch (error) {
-    logDebug("getCommandContextFiles", "Error getting command context files", error);
+    outputChannelLogger.logDebug(
+      "getCommandContextFiles",
+      "Error getting command context files",
+      error
+    );
     return [];
   }
 };
@@ -172603,7 +173485,7 @@ class CommandRunner {
     this.span = span2;
     this.command = command;
     this.args = args2;
-    logDebug("CommandRunner", command.key, { verbose: { command, args: args2 } });
+    outputChannelLogger.logDebug("CommandRunner", command.key, { verbose: { command, args: args2 } });
     command.mode = args2.runInChatMode ? "ask" : command.mode ?? "ask";
     this.command = command;
   }
@@ -172658,7 +173540,7 @@ class CommandRunner {
    */
   async handleChatRequest() {
     this.span.setAttribute("mode", "chat");
-    logDebug("CommandRunner:handleChatRequest", "chat request detecte");
+    outputChannelLogger.logDebug("CommandRunner:handleChatRequest", "chat request detected");
     const prompt = PromptString.unsafe_fromUserQuery(this.command.prompt);
     const contextItems = await this.getContextFiles();
     return {
@@ -172677,7 +173559,7 @@ class CommandRunner {
    */
   async handleEditRequest() {
     this.span.setAttribute("mode", "edit");
-    logDebug("CommandRunner:handleEditRequest", "fixup request detected");
+    outputChannelLogger.logDebug("CommandRunner:handleEditRequest", "fixup request detected");
     const userContextFiles = await this.getContextFiles();
     return {
       type: "edit",
@@ -172750,7 +173632,10 @@ class CommandsController {
       }
       const command = (_b2 = this.provider) == null ? void 0 : _b2.get(commandKey);
       if (!command || command.mode !== "ask" && !this.isEditEnabled) {
-        logDebug("CommandsController:execute", `${commandKey} command not found/supported`);
+        outputChannelLogger.logDebug(
+          "CommandsController:execute",
+          `${commandKey} command not found/supported`
+        );
         return void 0;
       }
       span2.setAttribute("sampled", true);
@@ -172766,7 +173651,7 @@ class CommandsController {
       disposable.dispose();
     }
     this.disposables = [];
-    logDebug("CommandsController:dispose", "disposed");
+    outputChannelLogger.logDebug("CommandsController:dispose", "disposed");
   }
 }
 const controller = new CommandsController();
@@ -172943,14 +173828,14 @@ async function getLocalCommands(input) {
 const TraceSender = {
   send(spanData) {
     void doSendTraceData(spanData).catch((error) => {
-      logError$1("TraceSender", `Error sending trace data: ${error}`);
+      outputChannelLogger.logError("TraceSender", `Error sending trace data: ${error}`);
     });
   }
 };
 async function doSendTraceData(spanData) {
   const { auth: auth2 } = await currentResolvedConfig();
   if (!auth2.credentials) {
-    logError$1("TraceSender", "Cannot send trace data: not authenticated");
+    outputChannelLogger.logError("TraceSender", "Cannot send trace data: not authenticated");
     throw new Error("Not authenticated");
   }
   const traceUrl = new URL("/-/debug/otlp/v1/traces", auth2.serverEndpoint);
@@ -172962,10 +173847,10 @@ async function doSendTraceData(spanData) {
     body: spanData
   });
   if (!response.ok) {
-    logError$1("TraceSender", `Failed to send trace data: ${response.statusText}`);
+    outputChannelLogger.logError("TraceSender", `Failed to send trace data: ${response.statusText}`);
     throw new Error(`Failed to send trace data: ${response.statusText}`);
   }
-  logDebug("TraceSender", "Trace data sent successfully");
+  outputChannelLogger.logDebug("TraceSender", "Trace data sent successfully");
 }
 async function openExternalLinks(uri) {
   try {
@@ -173170,7 +174055,10 @@ async function searchSymf(symf, editor, workspaceRoot, userText, blockOnIndex =
             text2 = await editor.getTextEditorContentForFile(result.file, range);
             text2 = truncateSymfResult(text2);
           } catch (error) {
-            logError$1("ChatController.searchSymf", `Error getting file contents: ${error}`);
+            outputChannelLogger.logError(
+              "ChatController.searchSymf",
+              `Error getting file contents: ${error}`
+            );
             return [];
           }
           const metadata2 = [
@@ -173197,17 +174085,17 @@ async function searchSymf(symf, editor, workspaceRoot, userText, blockOnIndex =
 }
 async function retrieveContextGracefully(promise2, strategy) {
   try {
-    logDebug("ChatController", `resolveContext > ${strategy} (start)`);
+    outputChannelLogger.logDebug("ChatController", `resolveContext > ${strategy} (start)`);
     return await promise2;
   } catch (error) {
     if (isAbortError(error)) {
-      logError$1("ChatController", `resolveContext > ${strategy}' (aborted)`);
+      outputChannelLogger.logError("ChatController", `resolveContext > ${strategy}' (aborted)`);
       throw error;
     }
-    logError$1("ChatController", `resolveContext > ${strategy} (error)`, error);
+    outputChannelLogger.logError("ChatController", `resolveContext > ${strategy} (error)`, error);
     return [];
   } finally {
-    logDebug("ChatController", `resolveContext > ${strategy} (end)`);
+    outputChannelLogger.logDebug("ChatController", `resolveContext > ${strategy} (end)`);
   }
 }
 const maxSymfBytes = 2048;
@@ -173280,7 +174168,11 @@ async function codebaseRootsFromMentions({ repos, trees }, signal2) {
   const localRepoNames = treesToRepoNames.flatMap((t) => t.names);
   let localRepoIDs = localRepoNames.length === 0 ? [] : await graphqlClient.getRepoIds(localRepoNames, localRepoNames.length, signal2);
   if (isError$1(localRepoIDs)) {
-    logError$1("codebaseRootFromMentions", "Failed to get repo IDs from Sourcegraph", localRepoIDs);
+    outputChannelLogger.logError(
+      "codebaseRootFromMentions",
+      "Failed to get repo IDs from Sourcegraph",
+      localRepoIDs
+    );
     localRepoIDs = [];
   }
   const uriToId = {};
@@ -173348,7 +174240,7 @@ class ContextRetriever {
       );
       changedFiles = changedFilesByRoot.flat();
     } catch (error) {
-      logDebug(
+      outputChannelLogger.logDebug(
         "ContextRetriever",
         "Failed to get locally modified files, falling back to indexed context only",
         error
@@ -173371,7 +174263,7 @@ class ContextRetriever {
       return [];
     }
     if (!this.symf) {
-      logDebug("ContextRetriever", "symf not available, skipping live context");
+      outputChannelLogger.logDebug("ContextRetriever", "symf not available, skipping live context");
       return [];
     }
     const results = await this.symf.getLiveResults(originalQuery, rewrittenQuery, files, signal2);
@@ -173389,7 +174281,10 @@ class ContextRetriever {
           text2 = await this.editor.getTextEditorContentForFile(r2.file, range);
           text2 = truncateSymfResult(text2);
         } catch (error) {
-          logError$1("ChatController.searchSymf", `Error getting file contents: ${error}`);
+          outputChannelLogger.logError(
+            "ChatController.searchSymf",
+            `Error getting file contents: ${error}`
+          );
           return [];
         }
         return {
@@ -173494,7 +174389,7 @@ class ContextRetriever {
 }
 function contextSearchResultToContextItem(result) {
   if (result.startLine < 0 || result.endLine < 0) {
-    logDebug(
+    outputChannelLogger.logDebug(
       "ContextRetriever",
       "ignoring server context result with invalid range",
       result.repoName,
@@ -173962,7 +174857,7 @@ class DefaultPrompter {
       reverseTranscript[0] = PromptMixin.mixInto(reverseTranscript[0], chat2.selectedModel, mixins);
       const messagesIgnored = promptBuilder.tryAddMessages(reverseTranscript);
       if (messagesIgnored) {
-        logDebug(
+        outputChannelLogger.logDebug(
           "DefaultPrompter.makePrompt",
           `Ignored ${messagesIgnored} chat messages due to context limit`
         );
@@ -173985,7 +174880,7 @@ class DefaultPrompter {
       const historyContext = await promptBuilder.tryAddContext("history", historyItems.reverse());
       ignoredContext.transcript += historyContext.ignored.length;
       if (ignoredContext.user + ignoredContext.corpus + ignoredContext.transcript > 0) {
-        logDebug(
+        outputChannelLogger.logDebug(
           "DefaultPrompter.makePrompt",
           `Ignored context due to context limit: user=${ignoredContext.user}, corpus=${ignoredContext.corpus}, previous=${ignoredContext.transcript}`
         );
@@ -174390,7 +175285,7 @@ async function getContextFileFromShell(command) {
         }
       ];
     } catch (error) {
-      logError$1("getContextFileFromShell", "failed", { verbose: error });
+      outputChannelLogger.logError("getContextFileFromShell", "failed", { verbose: error });
       const errorContent = `Failed to run ${command} in terminal:
 ${error}`;
       const size = await TokenCounterUtils.countTokens(errorContent);
@@ -180764,14 +181659,14 @@ ${error}` : error;
       this.connections.push(connection);
       this.statusChangeEmitter.fire({ serverName: name2, status: "connecting" });
       transport.onclose = () => {
-        logDebug$1("MCPConnectionManager", `Transport closed for "${name2}"`);
+        logDebug("MCPConnectionManager", `Transport closed for "${name2}"`);
         const conn2 = this.getConnection(name2);
         if (conn2 && conn2.server.status !== "disconnected") {
           this.updateConnectionStatus(conn2, "disconnected", "Transport closed");
         }
       };
       transport.onerror = (error) => {
-        logDebug$1("MCPConnectionManager", `Transport error for "${name2}"`, {
+        logDebug("MCPConnectionManager", `Transport error for "${name2}"`, {
           verbose: { error }
         });
         const conn2 = this.getConnection(name2);
@@ -180781,11 +181676,11 @@ ${error}` : error;
       };
       await transport.start();
       if (config.transportType === "stdio" && transport instanceof StdioClientTransport) {
-        logDebug$1("MCPConnectionManager", `Connecting to stdio server "${name2}"...`, {
+        logDebug("MCPConnectionManager", `Connecting to stdio server "${name2}"...`, {
           verbose: { config }
         });
       } else if (config.transportType === "sse") {
-        logDebug$1("MCPConnectionManager", `Connecting to SSE server "${name2}"...`, {
+        logDebug("MCPConnectionManager", `Connecting to SSE server "${name2}"...`, {
           verbose: { config }
         });
       }
@@ -180794,13 +181689,13 @@ ${error}` : error;
       await client.connect(transport);
       connection.server.status = "connected";
       connection.server.error = "";
-      logDebug$1("MCPConnectionManager", `Connected to MCP server: ${name2}`);
+      logDebug("MCPConnectionManager", `Connected to MCP server: ${name2}`);
       this.statusChangeEmitter.fire({ serverName: name2, status: "connected" });
       this.notifyServerChanged(name2);
       return connection;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logDebug$1("MCPConnectionManager", `Failed to connect to MCP server ${name2}`, {
+      logDebug("MCPConnectionManager", `Failed to connect to MCP server ${name2}`, {
         verbose: { error }
       });
       const conn2 = this.getConnection(name2) ?? connection;
@@ -180809,14 +181704,14 @@ ${error}` : error;
       }
       await Promise.allSettled([
         transport == null ? void 0 : transport.close().catch(
-          (closeError) => logDebug$1(
+          (closeError) => logDebug(
             "MCPConnectionManager",
             `Error closing transport for ${name2} after connection failure`,
             { verbose: { closeError } }
           )
         ),
         client == null ? void 0 : client.close().catch(
-          (closeError) => logDebug$1(
+          (closeError) => logDebug(
             "MCPConnectionManager",
             `Error closing client for ${name2} after connection failure`,
             { verbose: { closeError } }
@@ -180833,9 +181728,9 @@ ${error}` : error;
     this.connections.splice(index2, 1);
     try {
       await Promise.all([connection.transport.close(), connection.client.close()]);
-      logDebug$1("MCPConnectionManager", `Closed connection for ${name2}`);
+      logDebug("MCPConnectionManager", `Closed connection for ${name2}`);
     } catch (error) {
-      logDebug$1("MCPConnectionManager", `Failed to cleanly close connection for ${name2}:`, {
+      logDebug("MCPConnectionManager", `Failed to cleanly close connection for ${name2}:`, {
         verbose: { error }
       });
     }
@@ -180896,7 +181791,7 @@ class MCPServerManager {
           // Add disabled status
         };
       })) || [];
-      logDebug$1("MCPServerManager", `Fetched ${tools.length} tools for ${serverName}`, {
+      logDebug("MCPServerManager", `Fetched ${tools.length} tools for ${serverName}`, {
         verbose: { tools }
       });
       try {
@@ -180908,7 +181803,7 @@ class MCPServerManager {
           CodyToolProvider.updateToolDisabledState(codyToolName, true);
         }
       } catch (error) {
-        logDebug$1(
+        logDebug(
           "MCPServerManager",
           `Failed to register tools with CodyToolProvider: ${error}`,
           {
@@ -180919,12 +181814,12 @@ class MCPServerManager {
       await this.registerAgentTools(serverName, tools);
       return tools;
     } catch (error) {
-      logDebug$1("MCPServerManager", `Failed to fetch tools for ${serverName}:`, {
+      logDebug("MCPServerManager", `Failed to fetch tools for ${serverName}:`, {
         verbose: { error }
       });
       return [];
     } finally {
-      logDebug$1("MCPServerManager", `Tool list retrieval process completed for ${serverName}`);
+      logDebug("MCPServerManager", `Tool list retrieval process completed for ${serverName}`);
       this.connectionManager.notifyToolChanged(serverName);
     }
   }
@@ -180948,17 +181843,17 @@ class MCPServerManager {
         mimeType: r2.mimeType,
         title: `${r2.title}`
       }));
-      logDebug$1("MCPServerManager", `Fetched ${resources.length} resources for ${serverName}`, {
+      logDebug("MCPServerManager", `Fetched ${resources.length} resources for ${serverName}`, {
         verbose: { resources }
       });
       return resources;
     } catch (error) {
-      logDebug$1("MCPServerManager", `Failed to fetch resources for ${serverName}:`, {
+      logDebug("MCPServerManager", `Failed to fetch resources for ${serverName}:`, {
         verbose: { error }
       });
       return [];
     } finally {
-      logDebug$1("MCPServerManager", `Resource list retrieval process completed for ${serverName}`);
+      logDebug("MCPServerManager", `Resource list retrieval process completed for ${serverName}`);
     }
   }
   /**
@@ -180984,7 +181879,7 @@ class MCPServerManager {
         uri: t.uriTemplate
       }));
     } catch (error) {
-      logDebug$1("MCPServerManager", `Failed to fetch resource templates for ${serverName}:`, {
+      logDebug("MCPServerManager", `Failed to fetch resource templates for ${serverName}:`, {
         verbose: { error }
       });
       return [];
@@ -181008,7 +181903,7 @@ class MCPServerManager {
             try {
               return this.executeTool(serverName, tool.name, args2);
             } catch (error) {
-              logDebug$1("MCPServerManager", `Error executing tool ${tool.name}:`, {
+              logDebug("MCPServerManager", `Error executing tool ${tool.name}:`, {
                 verbose: { error }
               });
               return createMCPToolState(
@@ -181034,7 +181929,7 @@ class MCPServerManager {
           });
         }
       } catch (error) {
-        logDebug$1("MCPServerManager", `Error creating agent tool for ${tool.name || ""}`, {
+        logDebug("MCPServerManager", `Error creating agent tool for ${tool.name || ""}`, {
           verbose: { error }
         });
       }
@@ -181043,7 +181938,7 @@ class MCPServerManager {
       [...this.tools.filter((t) => !t.spec.name.startsWith(`${serverName}_`)), ..._agentTools],
       serverName
     );
-    logDebug$1("MCPServerManager", `Created ${_agentTools.length} agent tools from ${serverName}`, {
+    logDebug("MCPServerManager", `Created ${_agentTools.length} agent tools from ${serverName}`, {
       verbose: { _agentTools }
     });
     this.connectionManager.notifyToolChanged(serverName);
@@ -181097,12 +181992,12 @@ class MCPServerManager {
         throw new Error("unexpected response");
       }
       const { context: context2, contents } = transforMCPToolResult(result.content, toolName);
-      logDebug$1("MCPServerManager", `Tool ${toolName} executed successfully`, {
+      logDebug("MCPServerManager", `Tool ${toolName} executed successfully`, {
         verbose: { context: context2, contents }
       });
       return createMCPToolState(serverName, toolName, contents, context2);
     } catch (error) {
-      logDebug$1("MCPServerManager", `Error calling tool ${toolName} on server ${serverName}`, {
+      logDebug("MCPServerManager", `Error calling tool ${toolName} on server ${serverName}`, {
         verbose: error
       });
       return createMCPToolState(
@@ -181140,7 +182035,7 @@ class MCPServerManager {
       );
       return result.content;
     } catch (error) {
-      logDebug$1("MCPServerManager", `Error reading resource ${uri} from server ${serverName}`, {
+      logDebug("MCPServerManager", `Error reading resource ${uri} from server ${serverName}`, {
         verbose: { error }
       });
       throw error;
@@ -181178,7 +182073,7 @@ class MCPServerManager {
       const codyToolName = ToolFactory.getCodyToolName(toolName, serverName);
       CodyToolProvider.updateToolDisabledState(codyToolName, disabled);
     } catch (error) {
-      logDebug$1("MCPServerManager", `Failed to update tool state in CodyToolProvider: ${error}`, {
+      logDebug("MCPServerManager", `Failed to update tool state in CodyToolProvider: ${error}`, {
         verbose: { error }
       });
     }
@@ -181229,7 +182124,7 @@ class MCPServerManager {
           }
         }
       } catch (error) {
-        logDebug$1("MCPServerManager", "Failed to update tool states in CodyToolProvider", {
+        logDebug("MCPServerManager", "Failed to update tool states in CodyToolProvider", {
           verbose: { error }
         });
       }
@@ -181241,7 +182136,7 @@ class MCPServerManager {
     this.toolsChangeNotifications.next({
       serverName: affectedServers.size === 1 ? Array.from(affectedServers)[0] : ""
     });
-    logDebug$1("MCPServerManager", `Loaded ${tools.length} disabled tools`, {
+    logDebug("MCPServerManager", `Loaded ${tools.length} disabled tools`, {
       verbose: { disabled: tools }
     });
   }
@@ -181353,15 +182248,15 @@ const _MCPManager = class _MCPManager {
       this.observeConfigChanges();
       this.setupToolStateListeners();
     } catch (error) {
-      logDebug$1("MCPManager", "Failed to initialize MCP manager", { verbose: { error } });
+      logDebug("MCPManager", "Failed to initialize MCP manager", { verbose: { error } });
       _MCPManager.instance = void 0;
     }
   }
   async handleConnectionStatusChange(event2) {
-    logDebug$1("MCPManager", `Connection status changed for ${event2.serverName}: ${event2.status}`);
+    logDebug("MCPManager", `Connection status changed for ${event2.serverName}: ${event2.status}`);
     if (event2.status === "connected") {
       await this.initializeServerData(event2.serverName).catch((error) => {
-        logDebug$1("MCPManager", `Error initializing server data for ${event2.serverName}`, {
+        logDebug("MCPManager", `Error initializing server data for ${event2.serverName}`, {
           verbose: { error }
         });
       });
@@ -181371,7 +182266,7 @@ const _MCPManager = class _MCPManager {
     this.serverManager.onToolStateChanged(async (event2) => {
       await this.updateToolStateInConfig(event2.serverName, event2.toolName, event2.disabled).catch(
         (e) => {
-          logDebug$1("MCPManager", `Failed to update ${event2.serverName} config`, { verbose: e });
+          logDebug("MCPManager", `Failed to update ${event2.serverName} config`, { verbose: e });
         }
       );
     });
@@ -181380,12 +182275,12 @@ const _MCPManager = class _MCPManager {
     const configWatcher = workspace.onDidChangeConfiguration(async (event2) => {
       if (event2.affectsConfiguration(`${_MCPManager.CONFIG_SECTION}.${_MCPManager.MCP_SERVERS_KEY}`)) {
         if (this.programmaticConfigChangeInProgress) {
-          logDebug$1("MCPManager", "Ignoring programmatic configuration change");
+          logDebug("MCPManager", "Ignoring programmatic configuration change");
           return;
         }
-        logDebug$1("MCPManager", "Configuration change detected");
+        logDebug("MCPManager", "Configuration change detected");
         await this.loadServersFromConfig().catch((e) => {
-          logDebug$1("MCPManager", "Error reloading servers from config", { verbose: e });
+          logDebug("MCPManager", "Error reloading servers from config", { verbose: e });
         });
       }
     });
@@ -181402,7 +182297,7 @@ const _MCPManager = class _MCPManager {
     const result = McpSettingsSchema.safeParse({ mcpServers });
     if (result.success) {
       await this.sync(mcpServers);
-      logDebug$1("MCPManager", "MCP servers initialized successfully from configuration");
+      logDebug("MCPManager", "MCP servers initialized successfully from configuration");
     } else {
       throw new Error("Invalid MCP server configuration: " + result.error.format());
     }
@@ -181411,14 +182306,14 @@ const _MCPManager = class _MCPManager {
    * Sync servers with configuration
    */
   async sync(mcpServers) {
-    logDebug$1("MCPManager", "Syncing MCP servers", { verbose: { mcpServers } });
+    logDebug("MCPManager", "Syncing MCP servers", { verbose: { mcpServers } });
     const currentConnections = this.connectionManager.getAllConnections();
     const currentNames = new Set(currentConnections.map((conn2) => conn2.server.name));
     const newNames = new Set(Object.keys(mcpServers));
     for (const name2 of currentNames) {
       if (!newNames.has(name2)) {
         await this.connectionManager.removeConnection(name2);
-        logDebug$1("MCPManager", `Deleted MCP server: ${name2}`);
+        logDebug("MCPManager", `Deleted MCP server: ${name2}`);
       }
     }
     const allDisabledTools = [];
@@ -181440,7 +182335,7 @@ const _MCPManager = class _MCPManager {
           allDisabledTools.push(...toolsWithPrefix);
         }
       } catch (error) {
-        logDebug$1("MCPManager", `Failed to reconnect MCP server ${name2}`, {
+        logDebug("MCPManager", `Failed to reconnect MCP server ${name2}`, {
           verbose: { error }
         });
       }
@@ -181460,7 +182355,7 @@ const _MCPManager = class _MCPManager {
       const parsedConfig = result.data;
       await this.connectionManager.addConnection(name2, parsedConfig, parsedConfig == null ? void 0 : parsedConfig.disabled);
     } catch (error) {
-      logDebug$1("MCPManager", `Error adding connection for ${name2}`, { verbose: { error } });
+      logDebug("MCPManager", `Error adding connection for ${name2}`, { verbose: { error } });
     }
   }
   /**
@@ -181470,14 +182365,14 @@ const _MCPManager = class _MCPManager {
     const connection = this.connectionManager.getConnection(serverName);
     if (!connection) return;
     try {
-      logDebug$1("MCPManager", `Initializing tools for server: ${serverName}`);
+      logDebug("MCPManager", `Initializing tools for server: ${serverName}`);
       connection.server.tools = await this.serverManager.getToolList(serverName) || [];
-      logDebug$1("MCPManager", `Initialized tools for server: ${serverName}`, {
+      logDebug("MCPManager", `Initialized tools for server: ${serverName}`, {
         verbose: { toolCount: connection.server.tools.length }
       });
       this.connectionManager.notifyServerChanged(serverName);
     } catch (error) {
-      logDebug$1("MCPManager", `Failed to initialize ${serverName}`, { verbose: error });
+      logDebug("MCPManager", `Failed to initialize ${serverName}`, { verbose: error });
     }
   }
   static get tools() {
@@ -181559,7 +182454,7 @@ const _MCPManager = class _MCPManager {
         }
       });
     } catch (error) {
-      logDebug$1("MCPManager", `Failed to update tool state in config: ${error}`, {
+      logDebug("MCPManager", `Failed to update tool state in config: ${error}`, {
         verbose: { error }
       });
       throw error;
@@ -181582,7 +182477,7 @@ const _MCPManager = class _MCPManager {
         mcpServers[(config == null ? void 0 : config.name) ?? name2] = config;
       } else if (operation === "update") {
         if (!mcpServers[name2] || !mcpServers[config == null ? void 0 : config.name]) {
-          logDebug$1("", `MCP server "${name2}" does not exist`);
+          logDebug("", `MCP server "${name2}" does not exist`);
         }
         const mergedConfig = {
           ...mcpServers[name2],
@@ -181601,29 +182496,29 @@ const _MCPManager = class _MCPManager {
         if (mcpServers[name2]) {
           delete mcpServers[name2];
         } else {
-          logDebug$1("MCPManager", `${name2} not found in MCP configuration`);
+          logDebug("MCPManager", `${name2} not found in MCP configuration`);
         }
       }
       await this.updateMcpServerConfig(mcpServers);
       if (operation === "delete") {
         await this.connectionManager.removeConnection(name2);
-        logDebug$1("MCPManager", `Deleted MCP server: ${name2}`);
+        logDebug("MCPManager", `Deleted MCP server: ${name2}`);
       } else if (operation === "update") {
         await this.connectionManager.removeConnection(name2);
         await this.addConnection(name2, mcpServers[name2]);
-        logDebug$1("MCPManager", `Updated ${name2}`, {
+        logDebug("MCPManager", `Updated ${name2}`, {
           verbose: { config: mcpServers[name2] }
         });
       } else if (operation === "add") {
         await this.addConnection(name2, config);
-        logDebug$1("MCPManager", `Added MCP server: ${name2}`, { verbose: { config } });
+        logDebug("MCPManager", `Added MCP server: ${name2}`, { verbose: { config } });
         const connection = this.connectionManager.getConnection(name2);
         if ((connection == null ? void 0 : connection.server.status) === "connected") {
           await this.initializeServerData(name2);
         }
       }
     } catch (error) {
-      logDebug$1("MCPManager", `Failed to ${operation} MCP server: ${name2}`, { verbose: { error } });
+      logDebug("MCPManager", `Failed to ${operation} MCP server: ${name2}`, { verbose: { error } });
       if (operation === "update") {
         window$1.showErrorMessage(
           `Failed to update MCP server: ${error instanceof Error ? error.message : String(error)}`
@@ -181660,15 +182555,15 @@ const _MCPManager = class _MCPManager {
       if (enabled) {
         try {
           await this.addConnection(name2, mcpServers[name2]);
-          logDebug$1("MCPManager", `Enabled and connected to MCP server: ${name2}`);
+          logDebug("MCPManager", `Enabled and connected to MCP server: ${name2}`);
         } catch (error) {
-          logDebug$1("MCPManager", `Enabled MCP server but failed to connect: ${name2}`, {
+          logDebug("MCPManager", `Enabled MCP server but failed to connect: ${name2}`, {
             verbose: { error }
           });
         }
       } else {
         await this.connectionManager.removeConnection(name2);
-        logDebug$1("MCPManager", `Disabled MCP server: ${name2}`);
+        logDebug("MCPManager", `Disabled MCP server: ${name2}`);
       }
     } catch (error) {
       const action = enabled ? "enable" : "disable";
@@ -181729,7 +182624,7 @@ const _MCPManager = class _MCPManager {
         cleanedServers,
         ConfigurationTarget.Global
       );
-      logDebug$1("MCPManager", "Updated MCP servers configuration", {
+      logDebug("MCPManager", "Updated MCP servers configuration", {
         verbose: { serverCount: Object.keys(cleanedServers).length }
       });
     } finally {
@@ -181744,12 +182639,12 @@ const _MCPManager = class _MCPManager {
     }
     this.disposables = [];
     _MCPManager.instance = void 0;
-    logDebug$1("MCPManager", "disposed");
+    logDebug("MCPManager", "disposed");
   }
   static dispose() {
     var _a3;
     (_a3 = _MCPManager.instance) == null ? void 0 : _a3.dispose().catch((error) => {
-      logDebug$1("MCPManager", "Error disposing MCPManager", { verbose: { error } });
+      logDebug("MCPManager", "Error disposing MCPManager", { verbose: { error } });
     });
   }
 };
@@ -181965,7 +182860,7 @@ function getCorpusContextItemsForEditorState() {
             return pendingOperation;
           }
           if (isError$3(remoteReposForAllWorkspaceFolders2)) {
-            logError$2(
+            logError$1(
               "initialContext",
               "Failed to get remote repos for all workspace folders"
             );
@@ -182092,7 +182987,7 @@ const _CodyTool = class _CodyTool {
       }
       return ps`${prompt}\n\t- ${RawTextProcessor.join(examples, ps`\n\t- `)}`;
     } catch (error) {
-      logDebug$1("Cody Tool", `failed to getInstruction for ${tag2}`, { verbose: { error } });
+      logDebug("Cody Tool", `failed to getInstruction for ${tag2}`, { verbose: { error } });
       return ps``;
     }
   }
@@ -182193,7 +183088,7 @@ class CliTool extends CodyTool {
       throw new Error("No commands approved for execution");
     }
     callback.onUpdate(toolID, { content: [...approvedCommands].join(", ") });
-    logDebug$1("CodyTool", `executing ${approvedCommands.size} commands...`);
+    logDebug("CodyTool", `executing ${approvedCommands.size} commands...`);
     return Promise.all([...approvedCommands].map(getContextFileFromShell)).then(
       (results) => results.flat()
     );
@@ -182219,7 +183114,7 @@ class FileTool extends CodyTool {
   async execute(span2, filePaths) {
     span2.addEvent("executeFileTool");
     if (filePaths.length === 0) return [];
-    logDebug$1("CodyTool", `requesting ${filePaths.length} files`);
+    logDebug("CodyTool", `requesting ${filePaths.length} files`);
     return Promise.all(filePaths.map(getContextFromRelativePath)).then((results) => results.filter((item) => item !== null)).catch(() => []);
   }
 }
@@ -182256,7 +183151,7 @@ class SearchTool extends CodyTool {
     if (!repo) {
       return [];
     }
-    logDebug$1("SearchTool", `searching codebase for ${query2}`);
+    logDebug("SearchTool", `searching codebase for ${query2}`);
     const context2 = await this.contextRetriever.retrieveContext(
       toStructuredMentions([repo]),
       PromptString.unsafe_fromLLMResponse(query2),
@@ -182316,11 +183211,11 @@ class OpenCtxTool extends CodyTool {
         );
         results.push(...itemsWithContent.flat());
       }
-      logDebug$1("OpenCtxTool", `${this.provider.title} returned ${results.length} items`, {
+      logDebug("OpenCtxTool", `${this.provider.title} returned ${results.length} items`, {
         verbose: { results, provider: this.provider.title }
       });
     } catch {
-      logDebug$1("CodyTool", `OpenCtx item retrieval failed for ${queries}`);
+      logDebug("CodyTool", `OpenCtx item retrieval failed for ${queries}`);
     }
     return results;
   }
@@ -182365,7 +183260,7 @@ class McpToolImpl extends CodyTool {
   }
   handleMcpToolError(error) {
     const displayToolName = this.toolName || this.tool.name;
-    logDebug$1("CodyToolProvider", `Error executing ${displayToolName}`, {
+    logDebug("CodyToolProvider", `Error executing ${displayToolName}`, {
       verbose: error
     });
     const errorStr = error instanceof Error ? error.message : String(error);
@@ -182675,11 +183570,11 @@ const _CodyToolProvider = class _CodyToolProvider {
    */
   static registerMcpTools(serverName, tools) {
     if (!_CodyToolProvider.instance) {
-      logDebug$1("CodyToolProvider", "Cannot register MCP tools - instance not initialized");
+      logDebug("CodyToolProvider", "Cannot register MCP tools - instance not initialized");
       return [];
     }
     const createdTools = _CodyToolProvider.instance.factory.createMcpTools(tools, serverName);
-    logDebug$1("CodyToolProvider", `Registered ${createdTools.length} MCP tools successfully`);
+    logDebug("CodyToolProvider", `Registered ${createdTools.length} MCP tools successfully`);
     return createdTools;
   }
   /**
@@ -182690,14 +183585,14 @@ const _CodyToolProvider = class _CodyToolProvider {
    */
   static updateToolDisabledState(toolName, disabled) {
     if (!_CodyToolProvider.instance) {
-      logDebug$1("CodyToolProvider", "Cannot update tool state - instance not initialized");
+      logDebug("CodyToolProvider", "Cannot update tool state - instance not initialized");
       return false;
     }
     const result = _CodyToolProvider.instance.factory.updateToolDisabledState(toolName, disabled);
     if (result) {
-      logDebug$1("CodyToolProvider", `Updated tool ${toolName} disabled state to ${disabled}`);
+      logDebug("CodyToolProvider", `Updated tool ${toolName} disabled state to ${disabled}`);
     } else {
-      logDebug$1("CodyToolProvider", `Failed to update tool ${toolName} - not found`);
+      logDebug("CodyToolProvider", `Failed to update tool ${toolName} - not found`);
     }
     return result;
   }
@@ -183069,7 +183964,7 @@ const _DeepCodyAgent = class _DeepCodyAgent {
       return newContext;
     } catch (error) {
       await this.multiplexer.notifyTurnComplete();
-      logDebug$1("Deep Cody", `context review failed: ${error}`, { verbose: { prompt, error } });
+      logDebug("Deep Cody", `context review failed: ${error}`, { verbose: { prompt, error } });
       return [];
     }
   }
@@ -183111,7 +184006,7 @@ const _DeepCodyAgent = class _DeepCodyAgent {
             const file = item.uri.scheme === "file" ? await getContextFromRelativePath(contextName) : item;
             reviewed.push({ ...file || item, source: ContextItemSource.Agentic });
           } catch (error) {
-            logDebug$1("Deep Cody", `failed to get context from ${contextName}`, {
+            logDebug("Deep Cody", `failed to get context from ${contextName}`, {
               verbose: { error, contextName }
             });
           }
@@ -183219,7 +184114,7 @@ class ChatsController {
     this.contextRetriever = contextRetriever;
     this.guardrails = guardrails;
     this.extensionClient = extensionClient;
-    logDebug("ChatsController:constructor", "init");
+    outputChannelLogger.logDebug("ChatsController:constructor", "init");
     this.panel = this.createChatController();
     this.disposables.push(
       subscriptionDisposable(
@@ -183238,7 +184133,7 @@ class ChatsController {
     try {
       await this.getOrCreateEditorChatController(chatID, panel2.title, panel2);
     } catch (error) {
-      logDebug("ChatsController", "restoreToPanel", { error });
+      outputChannelLogger.logDebug("ChatsController", "restoreToPanel", { error });
       await this.getOrCreateEditorChatController(chatID, panel2.title);
       panel2.dispose();
     }
@@ -183289,10 +184184,10 @@ class ChatsController {
     );
     const restoreToEditor = async (chatID, chatQuestion) => {
       try {
-        logDebug("ChatsController", "debouncedRestorePanel");
+        outputChannelLogger.logDebug("ChatsController", "debouncedRestorePanel");
         return await this.getOrCreateEditorChatController(chatID, chatQuestion);
       } catch (error) {
-        logDebug("ChatsController", "debouncedRestorePanel", "failed", error);
+        outputChannelLogger.logDebug("ChatsController", "debouncedRestorePanel", "failed", error);
         return void 0;
       }
     };
@@ -183526,7 +184421,11 @@ class ChatsController {
           }
         });
       } catch (error) {
-        logError$1("ChatsController:exportHistory", "Failed to export chat history", error);
+        outputChannelLogger.logError(
+          "ChatsController:exportHistory",
+          "Failed to export chat history",
+          error
+        );
       }
     }
   }
@@ -183577,7 +184476,7 @@ class ChatsController {
         }
       });
     } catch (error) {
-      logError$1(
+      outputChannelLogger.logError(
         "ChatsController:exportAllChatsUnauthenticated",
         "Failed to export all chat history",
         error
@@ -183877,7 +184776,7 @@ const _GitHubDotComRepoMetadata = class _GitHubDotComRepoMetadata {
       metadata2.isPublic = response.ok;
     } catch (error) {
       if (!isAbortError(error)) {
-        logDebug(
+        outputChannelLogger.logDebug(
           "queryGitHubApi",
           "error querying GitHub API (assuming repository is non-public",
           `${owner2}/${repoName}`,
@@ -183949,11 +184848,7 @@ const publicRepoMetadataIfAllWorkspaceReposArePublic = remoteReposForAllWorkspac
         return allReposArePublic ? { isPublic: true, repoMetadata: repoMetadatas.filter(isDefined) } : NO_PUBLIC_METADATA;
       }),
       catchError$1((error) => {
-        logDebug(
-          "publicRepoMetadataIfAllWorkspaceReposArePublic",
-          "error getting repository metadata",
-          error
-        );
+        outputChannelLogger.logDebug("error getting repository metadata", error);
         return Observable.of(NO_PUBLIC_METADATA);
       })
     );
@@ -183984,7 +184879,7 @@ class OmniboxTelemetry {
   }
   recordChatQuestionExecuted(context2, spans) {
     if (!this.intentInfo) {
-      logError$2(
+      logError$1(
         "AgentTelemetry",
         "failed to log cody.chat-question/executed because intent info was not set"
       );
@@ -184645,7 +185540,7 @@ function validateWithZod(schema2, input, toolName) {
   const parsed = schema2.safeParse(sanitizeToolInput(input));
   if (!parsed.success) {
     const errorMsg = parsed.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
-    logDebug$1("validateWithZod", `Validation error for ${toolName}: ${errorMsg}`);
+    logDebug("validateWithZod", `Validation error for ${toolName}: ${errorMsg}`);
     throw new Error(`${toolName} validation failed: ${errorMsg}`);
   }
   return parsed.data;
@@ -184656,13 +185551,13 @@ function sanitizeToolInput(input) {
       return JSON.parse(input);
     } catch (e) {
       try {
-        logDebug$1("sanitizeToolInput", `Attempting to repair malformed JSON: ${input}`);
+        logDebug("sanitizeToolInput", `Attempting to repair malformed JSON: ${input}`);
         const repairedJson = jsonrepair(input);
         const result = JSON.parse(repairedJson);
-        logDebug$1("sanitizeToolInput", `Successfully repaired JSON: ${repairedJson}`);
+        logDebug("sanitizeToolInput", `Successfully repaired JSON: ${repairedJson}`);
         return result;
       } catch (repairError) {
-        logDebug$1("sanitizeToolInput", `Failed to repair JSON: ${input}`);
+        logDebug("sanitizeToolInput", `Failed to repair JSON: ${input}`);
       }
     }
   }
@@ -185834,7 +186729,7 @@ const fileOps = {
       const doc2 = await workspace.openTextDocument(uri);
       await doc2.save();
     } catch (error) {
-      logDebug$1("file_operations", `Failed to create file ${uri.toString()}: ${error.message}`);
+      logDebug("file_operations", `Failed to create file ${uri.toString()}: ${error.message}`);
       throw error;
     }
   },
@@ -186022,7 +186917,7 @@ async function createFile(uri, fileText) {
     }
     return createEditToolState(toolId, UIToolStatus.Done, uri, output2.join("\n"), "file-view");
   } catch (error) {
-    logDebug$1("text_editor", `Failed to create file ${displayPath(uri)}: ${error.message}`);
+    logDebug("text_editor", `Failed to create file ${displayPath(uri)}: ${error.message}`);
     return createEditToolState(
       toolId,
       UIToolStatus.Error,
@@ -186073,7 +186968,7 @@ async function replaceInFile(uri, oldStr, newStr) {
     const diffMarkdown = diffWithLineNum(content, newContent);
     const output2 = [`Edited ${fileName}`, diffMarkdown];
     const historyUri = uri.with({ scheme: "cody-checkpoint" });
-    logDebug$1("text_editor", "New content created", { uri: historyUri });
+    logDebug("text_editor", "New content created", { uri: historyUri });
     const diagnosticsOnEnd = getErrorDiagnostics(uri);
     if (diagnosticsOnEnd.length) {
       output2.push("[Error detected - Action required]");
@@ -186559,7 +187454,7 @@ class AgenticHandler extends ChatHandler {
     const contextItems = (contextResult == null ? void 0 : contextResult.contextItems) ?? [];
     this.tools = await AgentToolGroup.getToolsByAgentId(this.contextRetriever, span2);
     const startTime = Date.now();
-    logDebug$1("AgenticHandler", `Starting agent session ${sessionID}`);
+    logDebug("AgenticHandler", `Starting agent session ${sessionID}`);
     recorder2.recordChatQuestionExecuted(contextItems, { addMetadata: true, current: span2 });
     try {
       await this.runConversationLoop(chatBuilder, delegate, recorder2, span2, signal2, contextItems);
@@ -186567,8 +187462,8 @@ class AgenticHandler extends ChatHandler {
       this.handleError(sessionID, error, delegate, signal2);
     } finally {
       delegate.postDone();
-      logDebug$1("AgenticHandler", `Ending agent session ${sessionID}`);
-      logDebug$1("AgenticHandler", `Session ${sessionID} duration: ${Date.now() - startTime}ms`);
+      logDebug("AgenticHandler", `Ending agent session ${sessionID}`);
+      logDebug("AgenticHandler", `Session ${sessionID} duration: ${Date.now() - startTime}ms`);
     }
   }
   /**
@@ -186596,13 +187491,13 @@ class AgenticHandler extends ChatHandler {
         );
         if (!(toolCalls == null ? void 0 : toolCalls.size)) {
           chatBuilder.addBotMessage(botResponse, model2);
-          logDebug$1("AgenticHandler", "No tool calls, ending conversation");
+          logDebug("AgenticHandler", "No tool calls, ending conversation");
           break;
         }
         const content = Array.from(toolCalls.values());
         delegate.postMessageInProgress(botResponse);
         const results = await this.executeTools(content, model2).catch(() => {
-          logDebug$1("AgenticHandler", "Error executing tools");
+          logDebug("AgenticHandler", "Error executing tools");
           return [];
         });
         const toolResults = results == null ? void 0 : results.map((result) => result.tool_result).filter(isDefined);
@@ -186617,7 +187512,7 @@ class AgenticHandler extends ChatHandler {
           contextFiles: toolOutputs
         });
         if (turnCount >= this.MAX_TURN - 1) {
-          logDebug$1("AgenticHandler", "Max turns reached, ending conversation");
+          logDebug("AgenticHandler", "Max turns reached, ending conversation");
           break;
         }
         turnCount++;
@@ -186634,7 +187529,7 @@ class AgenticHandler extends ChatHandler {
     var _a3, _b2;
     const prompter2 = new AgenticChatPrompter(this.SYSTEM_PROMPT);
     const prompt = await prompter2.makePrompt(chatBuilder, contextItems);
-    logDebug$1("AgenticHandler", "Prompt created", { verbose: prompt });
+    logDebug("AgenticHandler", "Prompt created", { verbose: prompt });
     const params = {
       maxTokensToSample: 8e3,
       messages: JSON.stringify(prompt),
@@ -186721,7 +187616,7 @@ class AgenticHandler extends ChatHandler {
     var _a3, _b2, _c2;
     const existingCall = toolCalls.get((_a3 = toolCall == null ? void 0 : toolCall.tool_call) == null ? void 0 : _a3.id);
     if (!existingCall) {
-      logDebug$1("AgenticHandler", `Calling ${(_b2 = toolCall == null ? void 0 : toolCall.tool_call) == null ? void 0 : _b2.name}`, { verbose: toolCall });
+      logDebug("AgenticHandler", `Calling ${(_b2 = toolCall == null ? void 0 : toolCall.tool_call) == null ? void 0 : _b2.name}`, { verbose: toolCall });
     }
     const updatedCall = { ...existingCall, ...toolCall };
     toolCalls.set((_c2 = toolCall == null ? void 0 : toolCall.tool_call) == null ? void 0 : _c2.id, updatedCall);
@@ -186731,7 +187626,7 @@ class AgenticHandler extends ChatHandler {
    */
   async executeTools(toolCalls, model2) {
     try {
-      logDebug$1("AgenticHandler", `Executing ${toolCalls.length} tools`);
+      logDebug("AgenticHandler", `Executing ${toolCalls.length} tools`);
       const results = await Promise.allSettled(
         toolCalls.map(async (toolCall) => {
           var _a3, _b2, _c2, _d2;
@@ -186748,12 +187643,12 @@ class AgenticHandler extends ChatHandler {
                 type: "builtin"
               }
             });
-            logDebug$1("AgenticHandler", `Executing ${(_c2 = toolCall.tool_call) == null ? void 0 : _c2.name}`, {
+            logDebug("AgenticHandler", `Executing ${(_c2 = toolCall.tool_call) == null ? void 0 : _c2.name}`, {
               verbose: toolCall
             });
             return await this.executeSingleTool(toolCall, model2);
           } catch (error) {
-            logDebug$1("AgenticHandler", `Error executing tool ${(_d2 = toolCall.tool_call) == null ? void 0 : _d2.name}`, {
+            logDebug("AgenticHandler", `Error executing tool ${(_d2 = toolCall.tool_call) == null ? void 0 : _d2.name}`, {
               verbose: error
             });
             return null;
@@ -186762,7 +187657,7 @@ class AgenticHandler extends ChatHandler {
       );
       return results.filter((result) => result.status === "fulfilled" && result.value).map((result) => result.value);
     } catch (error) {
-      logDebug$1("AgenticHandler", "Error executing tools", { verbose: error });
+      logDebug("AgenticHandler", "Error executing tools", { verbose: error });
       return [];
     }
   }
@@ -186802,7 +187697,7 @@ class AgenticHandler extends ChatHandler {
             type: "builtin"
           }
         });
-        logDebug$1("AgenticHandler", `Error executing tool ${toolCall.tool_call.name}`, {
+        logDebug("AgenticHandler", `Error executing tool ${toolCall.tool_call.name}`, {
           verbose: error
         });
         return null;
@@ -186811,7 +187706,7 @@ class AgenticHandler extends ChatHandler {
         throw new Error(`Tool ${toolCall.tool_call.name} failed`);
       }
       tool_result.tool_result.content = result.content || "Empty result";
-      logDebug$1("AgenticHandler", `Executed ${toolCall.tool_call.name}`, { verbose: result });
+      logDebug("AgenticHandler", `Executed ${toolCall.tool_call.name}`, { verbose: result });
       telemetryRecorder.recordEvent("cody.tool-use", "executed", {
         billingMetadata: {
           product: "cody",
@@ -186846,7 +187741,7 @@ class AgenticHandler extends ChatHandler {
           type: "builtin"
         }
       });
-      logDebug$1("AgenticHandler", `${toolCall.tool_call.name} failed`, { verbose: error });
+      logDebug("AgenticHandler", `${toolCall.tool_call.name} failed`, { verbose: error });
       return {
         tool_result,
         output: {
@@ -186864,7 +187759,7 @@ class AgenticHandler extends ChatHandler {
    * Handle errors with consistent logging and reporting
    */
   handleError(sessionID, error, delegate, signal2) {
-    logDebug$1("AgenticHandler", `Error in agent session ${sessionID}`, {
+    logDebug("AgenticHandler", `Error in agent session ${sessionID}`, {
       verbose: error instanceof Error ? { message: error.message, stack: error.stack } : String(error)
     });
     if (!signal2.aborted) {
@@ -187412,6 +188307,7 @@ class ChatController {
     __publicField2(this, "guardrails");
     __publicField2(this, "lastKnownTokenUsage");
     __publicField2(this, "disposables", []);
+    __publicField2(this, "deviceAuthController", null);
     __publicField2(this, "clientBroadcast", new MulticastSubject());
     __publicField2(this, "initDoer", new InitDoer());
     __publicField2(this, "submitOrEditOperation");
@@ -187595,7 +188491,7 @@ class ChatController {
         case "mcp": {
           const mcpManager = MCPManager.instance;
           if (!mcpManager) {
-            logDebug("ChatController", "MCP Manager is not initialized");
+            outputChannelLogger.logDebug("ChatController", "MCP Manager is not initialized");
             break;
           }
           const serverName = message.name;
@@ -187649,11 +188545,18 @@ class ChatController {
                 break;
               }
               default:
-                logDebug("ChatController", `Unknown MCP operation: ${message.type}`);
+                outputChannelLogger.logDebug(
+                  "ChatController",
+                  `Unknown MCP operation: ${message.type}`
+                );
             }
           } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            logDebug("ChatController", `Failed to ${message.type} server`, errorMessage);
+            outputChannelLogger.logDebug(
+              "ChatController",
+              `Failed to ${message.type} server`,
+              errorMessage
+            );
             void this.postMessage({
               type: "clientAction",
               mcpServerError: {
@@ -187700,6 +188603,49 @@ class ChatController {
                 auth2 = await resolveAuth(endpoint, configuration, secretStorage);
               }
               if (!auth2 || !auth2.credentials) {
+                this.deviceAuthController = new AbortController();
+                const deviceAuthResult = await startDeviceAuthFlow(
+                  endpoint,
+                  (userCode, verificationUri) => {
+                    void this.postMessage({
+                      type: "device-flow-status",
+                      status: "code-ready",
+                      userCode,
+                      verificationUri
+                    });
+                  },
+                  this.deviceAuthController.signal
+                );
+                this.deviceAuthController = null;
+                if (deviceAuthResult.type === "success") {
+                  await this.postMessage({
+                    type: "device-flow-status",
+                    status: "success",
+                    message: "Authentication successful!"
+                  });
+                  await showAuthResultMessage(endpoint, deviceAuthResult.authStatus);
+                  return;
+                }
+                if (deviceAuthResult.type === "cancelled") {
+                  await this.postMessage({
+                    type: "device-flow-status",
+                    status: "cancelled",
+                    message: "Device auth cancelled"
+                  });
+                  return;
+                }
+                if (deviceAuthResult.type === "failed") {
+                  await this.postMessage({
+                    type: "device-flow-status",
+                    status: "error",
+                    message: "Device auth failed"
+                  });
+                  outputChannelLogger.logDebug(
+                    "auth",
+                    "Device auth not available, falling back to traditional auth",
+                    { endpoint }
+                  );
+                }
                 return redirectToEndpointLogin(endpoint);
               }
               await authProvider.validateAndStoreCredentials(auth2, "always-store");
@@ -187723,12 +188669,26 @@ class ChatController {
             await showSignInMenu();
             break;
           }
+          if (message.authKind === "cancel") {
+            if (this.deviceAuthController) {
+              this.deviceAuthController.abort();
+              this.deviceAuthController = null;
+              outputChannelLogger.logDebug(
+                "ChatController",
+                "Device auth cancelled by user"
+              );
+            }
+            break;
+          }
           await commands$1.executeCommand(`cody.auth.${message.authKind}`);
           break;
         }
         case "log": {
-          const logger2 = message.level === "debug" ? logDebug : logError$2;
-          logger2(message.filterLabel, message.message);
+          if (message.level === "debug") {
+            outputChannelLogger.logDebug(message.filterLabel, message.message);
+          } else {
+            outputChannelLogger.logError(message.filterLabel, message.message);
+          }
           break;
         }
         case "devicePixelRatio": {
@@ -187811,7 +188771,7 @@ class ChatController {
       workspaceFolderUris,
       siteHasCodyEnabled
     });
-    logDebug("ChatController", "updateViewConfig", {
+    outputChannelLogger.logDebug("ChatController", "updateViewConfig", {
       verbose: configForWebview
     });
   }
@@ -187820,7 +188780,7 @@ class ChatController {
       type: "clientConfig",
       clientConfig
     });
-    logDebug("ChatController", "updateClientConfig", {
+    outputChannelLogger.logDebug("ChatController", "updateClientConfig", {
       verbose: clientConfig
     });
   }
@@ -187933,6 +188893,7 @@ class ChatController {
     this.postEmptyMessageInProgress(model2);
     let messageInProgress = { speaker: "assistant", model: model2 };
     try {
+      const chatBuilder = this.chatBuilder;
       await agent2.handle(
         {
           requestID,
@@ -187940,7 +188901,7 @@ class ChatController {
           mentions,
           editorState,
           signal: signal2,
-          chatBuilder: this.chatBuilder,
+          chatBuilder,
           span: span2,
           recorder: recorder2,
           model: model2
@@ -187954,7 +188915,7 @@ class ChatController {
             this.postViewTranscript(message);
           },
           postStatuses: (steps) => {
-            this.chatBuilder.setLastMessageProcesses(steps);
+            chatBuilder.setLastMessageProcesses(steps);
             this.postViewTranscript(messageInProgress);
           },
           experimentalPostMessageInProgress: (subMessages) => {
@@ -188264,26 +189225,12 @@ class ChatController {
       revealWebviewViewOrPanel(this._webviewPanelOrView);
     }
   }
-  async handleResubmitLastUserInput() {
-    var _a3;
-    const lastHumanMessage = this.chatBuilder.getLastHumanMessage();
-    const getLastHumanMessageText = (_a3 = lastHumanMessage == null ? void 0 : lastHumanMessage.text) == null ? void 0 : _a3.toString();
-    if (getLastHumanMessageText) {
-      await this.clearAndRestartSession();
-      void this.postMessage({
-        type: "clientAction",
-        appendTextToLastPromptEditor: getLastHumanMessageText
-      });
-    }
-  }
   async handleSmartApplyResult(result) {
     void this.postMessage({
       type: "clientAction",
       smartApplyResult: result
     });
   }
-  fireClientAction() {
-  }
   async handleAttributionSearch(snippet) {
     try {
       const attribution = await this.guardrails.searchAttribution(snippet);
@@ -188378,19 +189325,8 @@ class ChatController {
           }
         }
       } catch (error) {
-        logDebug("ChatController", "setCustomChatTitle", { verbose: error });
+        outputChannelLogger.logDebug("ChatController", "setCustomChatTitle", { verbose: error });
       }
-      telemetryRecorder.recordEvent("cody.chat.customTitle", "generated", {
-        privateMetadata: {
-          requestID,
-          model: model2,
-          traceId: span2.spanContext().traceId
-        },
-        metadata: {
-          titleLength: title.length,
-          inputLength: inputText.length
-        }
-      });
     });
   }
   /**
@@ -188400,13 +189336,15 @@ class ChatController {
     if (isRateLimitError(error)) {
       handleRateLimitError();
     }
-    logDebug("ChatController: postError", error.message);
+    const traceId = isNetworkError(error) ? error.traceId : void 0;
+    const errorMessage = traceId ? `${error.message} (trace ID: ${traceId})` : error.message;
+    outputChannelLogger.logDebug("ChatController: postError", errorMessage);
     if (type === "transcript") {
       this.chatBuilder.addErrorAsBotMessage(error, ChatBuilder.NO_MODEL);
       this.postViewTranscript();
       return;
     }
-    void this.postMessage({ type: "errors", errors: error.message });
+    void this.postMessage({ type: "errors", errors: errorMessage });
     captureException(error);
   }
   /**
@@ -188505,7 +189443,7 @@ class ChatController {
         }
       }
     } catch (error) {
-      logDebug("ChatController", "Failed");
+      outputChannelLogger.logDebug("ChatController", "Failed");
     }
   }
   async duplicateSession(sessionID) {
@@ -188569,7 +189507,7 @@ class ChatController {
    * Revives the chat panel when the extension is reactivated.
    */
   async revive(webviewPanel) {
-    logDebug("ChatController:revive", "registering webview panel");
+    outputChannelLogger.logDebug("ChatController:revive", "registering webview panel");
     await this.registerWebviewPanel(webviewPanel);
   }
   async resolveWebviewView(webviewView, _context, _token) {
@@ -189481,7 +190419,6 @@ const HINT_DECORATIONS = {
 };
 const DOCUMENTABLE_SYMBOL_THROTTLE = 10;
 const GHOST_TEXT_THROTTLE = 250;
-const TELEMETRY_THROTTLE = 30 * 1e3;
 class GhostHintDecorator {
   constructor(options) {
     // permanentDisposables are disposed when this instance is disposed.
@@ -189491,7 +190428,6 @@ class GhostHintDecorator {
     __publicField2(this, "isActive", false);
     __publicField2(this, "activeDecorationRange", null);
     __publicField2(this, "setThrottledGhostText");
-    __publicField2(this, "fireThrottledDisplayEvent");
     __publicField2(this, "getThrottledDocumentableSymbol");
     /** Store the last line that the user typed on, we want to avoid showing the text here */
     __publicField2(this, "lastLineTyped", null);
@@ -189500,14 +190436,6 @@ class GhostHintDecorator {
       leading: false,
       trailing: true
     });
-    this.fireThrottledDisplayEvent = lodashExports.throttle(
-      this._fireDisplayEvent.bind(this),
-      TELEMETRY_THROTTLE,
-      {
-        leading: true,
-        trailing: false
-      }
-    );
     this.getThrottledDocumentableSymbol = lodashExports.throttle(
       this.getDocumentableSymbol.bind(this),
       DOCUMENTABLE_SYMBOL_THROTTLE,
@@ -189617,7 +190545,6 @@ class GhostHintDecorator {
     if (this.hasConflictingDecorations(editor, position)) {
       return;
     }
-    this.fireThrottledDisplayEvent(variant);
     const decorationHint = HINT_DECORATIONS[variant];
     const decorationText = UNICODE_SPACE$1.repeat(textPadding) + decorationHint.text;
     this.activeDecorationRange = new Range(position, position);
@@ -189666,9 +190593,6 @@ class GhostHintDecorator {
       editor.setDecorations(decoration, []);
     });
   }
-  _fireDisplayEvent(variant) {
-    telemetryRecorder.recordEvent("cody.ghostText", "visible", { privateMetadata: { variant } });
-  }
   async updateEnablement(authStatus2) {
     const featureEnablement = await getGhostHintEnablement();
     if (!authStatus2.authenticated || !(featureEnablement.Document || featureEnablement.EditOrChat || featureEnablement.Generate)) {
@@ -189717,7 +190641,7 @@ async function unitTestCommand(span2, args2) {
         );
       }
       const sharedContext = await getContextFilesForUnitTestCommand(document2.uri).catch((error) => {
-        logError$2("executeNewTestCommand", "failed to fetch context", { verbose: error });
+        logError$1("executeNewTestCommand", "failed to fetch context", { verbose: error });
         return [];
       });
       prompt = prompt.replaceAll("<selected>", selectedCodePromptWithExtraFiles(cursorContext, []));
@@ -189730,7 +190654,7 @@ async function unitTestCommand(span2, args2) {
       contextItems.push(cursorContext);
       contextItems.push(...sharedContext);
     } catch (error) {
-      logError$2("testCommand", "failed to fetch context", { verbose: error });
+      logError$1("testCommand", "failed to fetch context", { verbose: error });
     }
   }
   return {
@@ -189747,7 +190671,7 @@ async function executeTestChatCommand(args2) {
     if (editor.active && await isUriIgnoredByContextFilterWithNotification(editor.active.document.uri, "test")) {
       return;
     }
-    logDebug$1("executeTestEditCommand", "executing", { args: args2 });
+    logDebug("executeTestEditCommand", "executing", { args: args2 });
     telemetryRecorder.recordEvent("cody.command.test", "executed", {
       metadata: {
         useCodebaseContex: 0
@@ -190275,7 +191199,7 @@ async function getGitInfoForMentions(settings) {
         );
         return { cwd: dir, defaultBranch: defaultBranch.trim() };
       } catch (error) {
-        logDebug$1("gitMentionsProvider", "getGitInfoForMentions", {
+        logDebug("gitMentionsProvider", "getGitInfoForMentions", {
           dir: dir.toString(),
           error
         });
@@ -190303,13 +191227,13 @@ function parseMentionURI(uri) {
     }
     return data;
   } catch (error) {
-    logDebug$1("gitMentionsProvider", "invalid Git mention URI", uri.toString(), error);
+    logDebug("gitMentionsProvider", "invalid Git mention URI", uri.toString(), error);
     return null;
   }
 }
 async function execFileAsync(program2, args2, { cwd }) {
-  const { promisify } = await import("./util-D8ltdME7.mjs").then((n) => n.u);
-  const { execFile } = await import("./vscode-shim-Csgwpsv8.mjs").then((n) => n.fx);
+  const { promisify } = await import("./util-Ci-ROool.mjs").then((n) => n.u);
+  const { execFile } = await import("./vscode-shim-CdmSM8Q0.mjs").then((n) => n.gz);
   return promisify(execFile)(program2, args2, { cwd });
 }
 var __create = Object.create;
@@ -192544,7 +193468,7 @@ function observeOpenCtxController(context2, createOpenCtxController) {
         });
         return controller2;
       } catch (error) {
-        logDebug("openctx", `Failed to load OpenCtx client: ${error}`);
+        outputChannelLogger.logDebug("openctx", `Failed to load OpenCtx client: ${error}`);
         throw error;
       }
     }),
@@ -192704,7 +193628,7 @@ async function getViewerSettingsProviders() {
     }
     return providers;
   } catch (error) {
-    logError$2("OpenCtx", "failed to fetch viewer settings from Sourcegraph", error);
+    logError$1("OpenCtx", "failed to fetch viewer settings from Sourcegraph", error);
     return void 0;
   }
 }
@@ -193426,7 +194350,7 @@ function matchJavascriptFormatting(incoming, original) {
   return incoming;
 }
 function matchLanguage(incoming, original, uri) {
-  const language = languageFromFilename(uri);
+  const language = languageFromFilenameAndContent(uri, original);
   switch (language) {
     case ProgrammingLanguage.TypeScript:
     case ProgrammingLanguage.JavaScript:
@@ -194304,7 +195228,7 @@ class EditProvider {
           }
           case "error": {
             let err2 = message.error;
-            logError$1("EditProvider:onError", err2.message);
+            outputChannelLogger.logError("EditProvider:onError", err2.message);
             if (isAbortError(err2)) {
               if (session.state === "streaming") {
                 void this.handleResponse(text2, false);
@@ -194685,7 +195609,7 @@ class EditManager {
     } catch (error) {
       const errorObject = error instanceof Error ? error : new Error(typeof error === "string" ? error : String(error));
       this.options.fixupController.error(task.id, errorObject);
-      logError$2("EditManager", "startStreamingEditTask", errorObject);
+      logError$1("EditManager", "startStreamingEditTask", errorObject);
     }
   }
   dispose() {
@@ -195680,9 +196604,9 @@ function getOverriddenModelForIntent(intent, currentModel, authStatus2) {
   }
   switch (intent) {
     case "fix":
-      return "anthropic::2024-10-22::claude-3-5-sonnet-latest";
+      return "anthropic::2024-10-22::claude-sonnet-4-5-latest";
     case "doc":
-      return "anthropic::2024-10-22::claude-3-5-haiku-latest";
+      return "anthropic::2024-10-22::claude-haiku-4-5-latest";
     case "test":
     case "add":
     case "edit":
@@ -196762,7 +197686,7 @@ class FixupController {
   }
   // Apply single fixup from task ID. Public for testing.
   async apply(id) {
-    logDebug("FixupController:apply", "applying", { verbose: { id } });
+    outputChannelLogger.logDebug("FixupController:apply", "applying", { verbose: { id } });
     const task = this.tasks.get(id);
     if (!task) {
       return;
@@ -197005,7 +197929,7 @@ class FixupController {
   }
   // Replace edit returned by Cody at task selection range
   async replaceEdit(edit, diff2, task, options) {
-    logDebug("FixupController:edit", "replacing ");
+    outputChannelLogger.logDebug("FixupController:edit", "replacing ");
     const suitableDiffForEditing = makeDiffEditBuilderCompatible(diff2);
     if (edit instanceof AgentWorkspaceEdit) {
       for (const change of suitableDiffForEditing) {
@@ -197033,7 +197957,7 @@ class FixupController {
   }
   // Insert edit returned by Cody at task selection range
   async insertEdit(edit, document2, task, options) {
-    logDebug("FixupController:edit", "inserting");
+    outputChannelLogger.logDebug("FixupController:edit", "inserting");
     const text2 = task.replacement;
     if (!text2) {
       return false;
@@ -197307,7 +198231,6 @@ const showSetupNotification = async (auth2) => {
     await commands$1.executeCommand("cody.chat.focus");
     return;
   }
-  telemetryRecorder.recordEvent("cody.signInNotification", "shown");
   return showActionNotification({
     message: "Sign in to Cody to get started",
     actions: [
@@ -197511,12 +198434,6 @@ const FeedbackOptionItems = [
       await env.openExternal(Uri.parse(CODY_DOC_URL.href));
     }
   },
-  {
-    label: "$(feedback) Cody Feedback",
-    async onSelect() {
-      await env.openExternal(Uri.parse(CODY_FEEDBACK_URL.href));
-    }
-  },
   {
     label: "$(organization) Cody Discord Channel",
     async onSelect() {
@@ -198575,10 +199492,6 @@ function registerSidebarCommands() {
       logSidebarClick("support");
       void commands$1.executeCommand("vscode.open", CODY_SUPPORT_URL.href);
     }),
-    commands$1.registerCommand("cody.sidebar.feedback", () => {
-      logSidebarClick("feedback");
-      void commands$1.executeCommand("vscode.open", CODY_FEEDBACK_URL.href);
-    }),
     commands$1.registerCommand("cody.sidebar.discord", () => {
       logSidebarClick("discord");
       void commands$1.executeCommand("vscode.open", DISCORD_URL.href);
@@ -198976,7 +199889,7 @@ function interactDefault({
       try {
         (_a3 = error.onShow) == null ? void 0 : _a3.call(error);
       } catch (e) {
-        logError$2("Status Bar Interaction", "Error during show handler");
+        logError$1("Status Bar Interaction", "Error during show handler");
       }
     }
     const createFeatureToggle = featureToggleBuilder(
@@ -199058,17 +199971,7 @@ function interactDefault({
       },
       { label: "feedback & support", kind: QuickPickItemKind.Separator },
       ...SupportOptionItems,
-      ...FeedbackOptionItems,
-      { label: `v${version}`, kind: QuickPickItemKind.Separator },
-      {
-        label: "$(cody-logo) Cody Release Blog",
-        async onSelect() {
-          await commands$1.executeCommand(
-            "vscode.open",
-            getReleaseNotesURLByIDE(version, CodyIDE.VSCode)
-          );
-        }
-      }
+      ...FeedbackOptionItems
     ].filter(Boolean);
     quickPick.title = "Cody Settings";
     quickPick.placeholder = "Choose an option";
@@ -199420,7 +200323,7 @@ async function* getSupercompletions({
     if (!supercompletion) {
       continue;
     }
-    logDebug$1("supercompletions", "candidate", { verbose: supercompletion });
+    logDebug("supercompletions", "candidate", { verbose: supercompletion });
     yield supercompletion;
   }
 }
@@ -199442,7 +200345,7 @@ async function* generateRawChanges(chat2, messages, abortSignal) {
           const summaryMatch = change.match(/<summary>(.*)<\/summary>/s);
           const changeMatch = change.match(/<change>(.*)<\/change>/s);
           if (!summaryMatch || !changeMatch) {
-            logDebug$1("supercompletions", "error", "invalid change block", {
+            logDebug("supercompletions", "error", "invalid change block", {
               verbose: change
             });
             continue;
@@ -199499,7 +200402,7 @@ function parseRawChange(document2, { change, summary }) {
     }
   }
   if (state2 !== "complete") {
-    logDebug$1(
+    logDebug(
       "supercompletions",
       "error",
       "could not find change deliminators",
@@ -199928,7 +200831,7 @@ async function start(context2, platform2) {
   if (secretStorage instanceof VSCodeSecretStorage) {
     secretStorage.setStorage(context2.secrets);
   }
-  setLogger({ logDebug, logError: logError$1, logInfo });
+  setLogger(outputChannelLogger);
   setClientCapabilities({
     configuration: getConfiguration(),
     agentCapabilities: platform2.extensionClient.capabilities
@@ -199959,7 +200862,7 @@ async function start(context2, platform2) {
             isReinstalling,
             onReinstall: async () => {
               if (hasReinstallCleanupRun) return;
-              logDebug("start", "Reinstalling Cody");
+              outputChannelLogger.logDebug("start", "Reinstalling Cody");
               const history = await localStorage.deleteEndpointHistory();
               const additionalEndpointsToClear = [
                 clientConfiguration.overrideServerEndpoint,
@@ -200048,6 +200951,7 @@ const register = async (context2, platform2, isExtensionModeDevOrTest) => {
   }
   if (isExtensionModeDevOrTest) {
     await registerTestCommands(context2, disposables);
+    registerAuthDebugCommands(disposables);
   }
   registerDebugCommands(context2, disposables);
   registerAuthenticationHandlers(disposables);
@@ -200113,11 +201017,6 @@ ${retryMessage}`
           void env.openExternal(Uri.parse(ACCOUNT_LIMITS_INFO_URL.toString()));
         }
       }
-    ),
-    // Walkthrough / Support
-    commands$1.registerCommand(
-      "cody.feedback",
-      () => env.openExternal(Uri.parse(CODY_FEEDBACK_URL.href))
     )
   );
 }
@@ -200133,7 +201032,7 @@ async function registerCodyCommands({
       if (error instanceof Error) {
         console.log(error.stack);
       }
-      logError$1("executeCommand", commandKey, args2, error);
+      outputChannelLogger.logError("executeCommand", commandKey, args2, error);
       return void 0;
     });
   };
@@ -200409,7 +201308,7 @@ function registerAutocomplete(platform2, statusBar, disposables) {
         }),
         catchError$1((error) => {
           finishLoading();
-          logError$1("registerAutocomplete", "Error", error);
+          outputChannelLogger.logError("registerAutocomplete", "Error", error);
           return NEVER$1;
         })
       ).subscribe({})
@@ -200441,7 +201340,10 @@ function registerChat({ context: context2, platform: platform2, chatClient, guar
     window$1.registerWebviewPanelSerializer(CodyChatEditorViewType, {
       async deserializeWebviewPanel(webviewPanel, chatID) {
         if (chatID && webviewPanel.title) {
-          logDebug("main:deserializeWebviewPanel", "reviving last unclosed chat panel");
+          outputChannelLogger.logDebug(
+            "main:deserializeWebviewPanel",
+            "reviving last unclosed chat panel"
+          );
           await chatsController.restoreToPanel(webviewPanel, chatID);
         }
       }
@@ -202168,5 +203070,95 @@ agent.registerNotification("debug/message", (params) => {
 });
 conn.listen();
 export {
-  base64Js as b
+  getCompletionsModelConfig as $,
+  ANSWER_TOKENS as A,
+  BotResponseMultiplexer as B,
+  CompletionStopReason as C,
+  DEFAULT_EVENT_SOURCE as D,
+  EventSourceTelemetryMetadataMapping as E,
+  FIXTURE_MODEL as F,
+  PromptMixin as G,
+  newPromptMixin as H,
+  truncateTextNearestLine as I,
+  truncatePromptStringStart as J,
+  truncatePromptString as K,
+  SourcegraphBrowserCompletionsClient as L,
+  ModelUsage as M,
+  NUM_CODE_RESULTS as N,
+  Ollama$1 as O,
+  ProcessType as P,
+  SourcegraphCompletionsClient as Q,
+  ClientConfigSingleton as R,
+  SourcegraphGuardrailsClient as S,
+  Typewriter as T,
+  RestClient as U,
+  events$1 as V,
+  TokenCounter as W,
+  getTokenCounterUtils as X,
+  TokenCounterUtils as Y,
+  tokensToChars as Z,
+  charsToTokens as _,
+  createModel as a,
+  getSerializedParams as a0,
+  fetchLocalOllamaModels as a1,
+  siteVersion as a2,
+  currentSiteVersion as a3,
+  isValidVersion as a4,
+  checkVersion as a5,
+  configOverwrites as a6,
+  createRuleService as a7,
+  isRulesEnabled as a8,
+  ModelsService as a9,
+  editorWindowIsFocused as aA,
+  modelsService as aa,
+  TestLocalStorageForModelPreferences as ab,
+  mockModelsService as ac,
+  codyPaths as ad,
+  populateCodeContextTemplate as ae,
+  populateCurrentEditorDiagnosticsTemplate as af,
+  populateTerminalOutputContextTemplate as ag,
+  populateCurrentSelectedCodeContextTemplate as ah,
+  populateListOfFilesContextTemplate as ai,
+  populateContextTemplateFromText as aj,
+  populateImportListContextTemplate as ak,
+  populateCodeGenerationContextTemplate as al,
+  getClientPromptString as am,
+  InvisibleStatusBarTag as an,
+  dotcomTokenToGatewayToken as ao,
+  getCodyAuthReferralCode as ap,
+  createSSEIterator as aq,
+  googleChatClient as ar,
+  groqChatClient as as,
+  parseCompletionJSON as at,
+  ContextFiltersProvider as au,
+  getContextForChatMessage as av,
+  Mutable as aw,
+  singletonNotYetSet as ax,
+  setSingleton as ay,
+  setEditorWindowIsFocused as az,
+  base64Js as b,
+  contextFiltersProvider as c,
+  createModelFromServerModel as d,
+  enableMapSet as e,
+  getModelInfo as f,
+  getProviderName as g,
+  handleRateLimitError as h,
+  isCustomModel as i,
+  toModelRefStr as j,
+  ChatClient as k,
+  getDefaultSystemPrompt as l,
+  modelTier as m,
+  getChatPreamble as n,
+  getSimplePreamble as o,
+  parseModelRef as p,
+  errorToChatError as q,
+  parseEvents as r,
+  serializeChatMessage as s,
+  toLegacyModel as t,
+  ollamaChatClient as u,
+  OLLAMA_DEFAULT_URL as v,
+  MAX_BYTES_PER_FILE as w,
+  MAX_CURRENT_FILE_TOKENS as x,
+  NUM_TEXT_RESULTS as y,
+  SURROUNDING_LINES as z
 };