@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.1.0

package/vscode/src/vs/platform/agentHost/common/agentMerge.d.ts

@@ -0,0 +1,261 @@
+import { GitHubActor, PullRequestCheck, PullRequestChecks, PullRequestSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/platform/github/common/githubPullRequestService";
+export declare const AgentMergeConfigKey: {
+    readonly Enabled: "agentMerge.enabled";
+    readonly AddressReviews: "agentMerge.addressReviews";
+    readonly FixCI: "agentMerge.fixCI";
+    readonly ResolveConflicts: "agentMerge.resolveConflicts";
+    readonly MergePullRequest: "agentMerge.mergePullRequest";
+    readonly MergeMethod: "agentMerge.mergeMethod";
+    readonly ReplyAttribution: "agentMerge.replyAttribution";
+};
+export declare const AgentMergeSettingId: {
+    readonly Enabled: "chat.agentMerge.enabled";
+    readonly AddressReviews: "chat.agentMerge.addressReviews";
+    readonly FixCI: "chat.agentMerge.fixCI";
+    readonly ResolveConflicts: "chat.agentMerge.resolveConflicts";
+    readonly MergePullRequest: "chat.agentMerge.mergePullRequest";
+    readonly MergeMethod: "chat.agentMerge.mergeMethod";
+    readonly ReplyAttribution: "chat.agentMerge.replyAttribution";
+};
+/**
+ * Settings-editor tag carried by every Agent Merge setting, so the UI can open
+ * settings filtered to exactly this group with `@tag:agentMerge`.
+ */
+export declare const AGENT_MERGE_SETTING_TAG = "agentMerge";
+/**
+ * Work the agent itself can be asked to perform. Merging is deliberately absent:
+ * it is executed by the host, never delegated to a model.
+ */
+export type AgentMergeRepairAction = "addressReviews" | "fixCI" | "resolveConflicts";
+/** A user-authorizable Agent Merge action, including the host-executed merge. */
+export type AgentMergeAction = AgentMergeRepairAction | "mergePullRequest";
+export type AgentMergeMethod = "auto" | "squash" | "merge" | "rebase";
+/**
+ * When Agent Merge may merge the pull request once it is ready.
+ *
+ * `ifUnchanged` is self-demoting rather than evaluated at merge time: the
+ * moment a repair turn lands a commit the session's value is rewritten to
+ * `never`, so the chosen value always reflects what will actually happen.
+ * Re-selecting `ifUnchanged` starts a fresh baseline from that point.
+ */
+export type AgentMergeMergePullRequest = "always" | "ifUnchanged" | "never";
+export declare const agentMergeMergePullRequestValues: readonly AgentMergeMergePullRequest[];
+export interface AgentMergeActions {
+    readonly addressReviews: boolean;
+    readonly fixCI: boolean;
+    readonly resolveConflicts: boolean;
+    readonly mergePullRequest: AgentMergeMergePullRequest;
+}
+export interface AgentMergeConfiguration extends AgentMergeActions {
+    readonly mergeMethod: AgentMergeMethod;
+    readonly replyAttribution: boolean;
+}
+export interface AgentMergeSessionOverrides {
+    readonly addressReviews?: boolean;
+    readonly fixCI?: boolean;
+    readonly resolveConflicts?: boolean;
+    readonly mergePullRequest?: AgentMergeMergePullRequest;
+}
+export interface AgentMergeTarget {
+    readonly branchName: string;
+    readonly pullRequestUrl?: string;
+    readonly enabledAt: string;
+    readonly commentWatermark: string;
+}
+export interface AgentMergeReviewThreadContext {
+    readonly id: string;
+    readonly path?: string;
+    readonly line?: number;
+    /** Authorized comments in the thread, oldest first, so later follow-ups are visible. */
+    readonly comments: readonly AgentMergeFeedbackComment[];
+}
+export interface AgentMergeFeedbackComment {
+    readonly author?: string;
+    readonly body: string;
+}
+export interface AgentMergeInjectedConfiguration {
+    readonly previous: Readonly<Record<string, unknown>>;
+    readonly applied: Readonly<Record<string, unknown>>;
+}
+export interface AgentMergeSessionState {
+    readonly enabled: boolean;
+    readonly overrides?: AgentMergeSessionOverrides;
+    readonly target?: AgentMergeTarget;
+    readonly injectedConfiguration?: AgentMergeInjectedConfiguration;
+    readonly lastPromptFingerprint?: string;
+    readonly lastPromptAt?: string;
+    readonly repeatedPromptCount?: number;
+    readonly totalPromptCount?: number;
+    /**
+     * Local worktree commit observed when the most recent repair turn started.
+     * A different local commit afterwards means that turn produced work, which
+     * is what demotes an `ifUnchanged` session to `never`.
+     *
+     * Deliberately the local commit rather than the pull request's published
+     * head: GitHub reports a push only after some replication delay, and a turn
+     * ends by evaluating immediately, so a published comparison would routinely
+     * read a stale head and merge changes it should have held back.
+     */
+    readonly repairBaseCommit?: string;
+}
+export interface AgentMergeControllerState {
+    readonly target?: AgentMergeTarget;
+    readonly injectedConfiguration?: AgentMergeInjectedConfiguration;
+    readonly lastPromptFingerprint?: string;
+    readonly lastPromptAt?: string;
+    readonly repeatedPromptCount?: number;
+    readonly totalPromptCount?: number;
+    readonly repairBaseCommit?: string;
+}
+export type AgentMergeRequiredChecks = {
+    readonly kind: "ready";
+    readonly failed: readonly PullRequestCheck[];
+    readonly pending: boolean;
+} | {
+    readonly kind: "indeterminate";
+    readonly reason: string;
+};
+export declare const agentMergeRootConfigSchema: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchema<{
+    "agentMerge.enabled": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+    "agentMerge.addressReviews": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+    "agentMerge.fixCI": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+    "agentMerge.resolveConflicts": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+    "agentMerge.mergePullRequest": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<AgentMergeMergePullRequest>;
+    "agentMerge.mergeMethod": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<AgentMergeMethod>;
+    "agentMerge.replyAttribution": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+}>;
+export declare const defaultAgentMergeConfiguration: AgentMergeConfiguration;
+export type AgentMergeGateResult = {
+    readonly kind: "indeterminate";
+    readonly reason: string;
+    readonly cause: string;
+} | {
+    readonly kind: "terminal";
+} | {
+    readonly kind: "noWork";
+    readonly waitingOnChecks: boolean;
+    readonly fingerprint: string;
+} | {
+    readonly kind: "prompt";
+    readonly actions: readonly AgentMergeRepairAction[];
+    readonly fingerprint: string;
+    readonly context: AgentMergePromptContext;
+} | {
+    readonly kind: "merge";
+    readonly fingerprint: string;
+};
+export interface AgentMergePromptContext {
+    readonly pullRequestUrl: string;
+    readonly title: string;
+    readonly headSha: string;
+    readonly baseRef: string;
+    readonly headRef: string;
+    readonly reviewThreads: readonly AgentMergeReviewThreadContext[];
+    readonly reviewSummaries: readonly AgentMergeFeedbackComment[];
+    readonly newComments: readonly AgentMergeFeedbackComment[];
+    readonly failedChecks: readonly string[];
+    readonly behind: boolean;
+    readonly conflicting: boolean;
+    readonly commentWatermark: string;
+}
+export declare function resolveAgentMergeConfiguration(defaults: AgentMergeConfiguration, overrides: AgentMergeSessionOverrides | undefined): AgentMergeConfiguration;
+/**
+ * Maps the configured merge method onto a method the repository actually
+ * allows. `auto` prefers squash, then a merge commit, then rebase; an
+ * explicitly configured method is only used when the repository permits it.
+ */
+export declare function resolveMergeMethod(configured: AgentMergeMethod, allowed: readonly ("MERGE" | "SQUASH" | "REBASE")[]): "MERGE" | "SQUASH" | "REBASE" | undefined;
+/**
+ * Why Agent Merge stopped monitoring a session. Keeping both strings together
+ * lets the controller log a stable English detail while the transcript shows a
+ * localized sentence, without either drifting from the other.
+ */
+export interface AgentMergeDisableReason {
+    /** Stable English detail appended to the host log line. */
+    readonly log: string;
+    /** Localized sentence shown to the user in the session transcript. */
+    readonly notice: string;
+}
+/** Every reason the Agent Merge controller can stop monitoring a session on its own. */
+export declare const agentMergeDisableReasons: {
+    readonly sessionArchived: () => AgentMergeDisableReason;
+    readonly branchChanged: (from: string, to: string) => AgentMergeDisableReason;
+    readonly branchChangedWhileRefreshing: () => AgentMergeDisableReason;
+    readonly differentPullRequest: () => AgentMergeDisableReason;
+    readonly invalidPullRequestUrl: () => AgentMergeDisableReason;
+    readonly differentGitHubHost: () => AgentMergeDisableReason;
+    readonly indeterminate: (minutes: number, reason: string) => AgentMergeDisableReason;
+    readonly pullRequestClosed: () => AgentMergeDisableReason;
+    readonly pullRequestAlreadyMerged: (pullRequestNumber: number, pullRequestUrl: string) => AgentMergeDisableReason;
+    readonly repairBudgetExhausted: () => AgentMergeDisableReason;
+    readonly pullRequestMerged: (pullRequestNumber: number, pullRequestUrl: string) => AgentMergeDisableReason;
+};
+/** The transcript notice shown once Agent Merge starts watching a branch. */
+export declare function agentMergeEnabledNotice(target: Pick<AgentMergeTarget, "branchName" | "pullRequestUrl">, configuration: AgentMergeConfiguration): string;
+/**
+ * Whether a configuration change was made for one session alone, or to the
+ * defaults every session follows.
+ */
+export type AgentMergeConfigurationChangeScope = "session" | "global";
+/**
+ * The transcript notice shown when effective Agent Merge behavior changes. The
+ * scope is named up front because the same change reads very differently
+ * depending on whether it was made for this session or for all of them.
+ */
+export declare function agentMergeConfigurationChangedNotice(previous: AgentMergeConfiguration, current: AgentMergeConfiguration, scope: AgentMergeConfigurationChangeScope): string | undefined;
+/** The transcript notice shown when the user, rather than the controller, disables Agent Merge. */
+export declare function agentMergeDisabledNotice(): string;
+/**
+ * The transcript notice shown when Agent Merge stops merging automatically
+ * because its own repair work changed the pull request.
+ */
+export declare function agentMergeMergePullRequestDemotedNotice(): string;
+export declare function readAgentMergeSessionState(values: Record<string, unknown> | undefined): AgentMergeSessionState | undefined;
+/**
+ * Returns session config values with Agent Merge injected overrides removed,
+ * so callers can read the user's own picker selections while merge is active.
+ */
+export declare function getNonMergeSessionConfigValues(values: Readonly<Record<string, unknown>> | undefined): Readonly<Record<string, unknown>>;
+export declare function isAgentMergeFeedbackAuthor(actor: GitHubActor | undefined): boolean;
+/**
+ * Recorded as the repair baseline when the session worktree cannot be read.
+ * No git object id can equal it, so a session that reached this state always
+ * counts as changed — see {@link shouldStopMergingAfterAgentChanges}.
+ */
+export declare const AGENT_MERGE_UNKNOWN_COMMIT = "unknown";
+/**
+ * Whether a session that only authorized merging while the pull request is
+ * unchanged must stop merging automatically, because a repair turn produced
+ * work since it started.
+ *
+ * Compares local worktree commits, not the pull request's published head: the
+ * commit exists locally the moment the agent makes it, whereas GitHub reports
+ * it only after a replication delay that a turn-completion check would race.
+ *
+ * Fails closed. Once a repair turn has run, a commit that cannot be resolved
+ * counts as a change: a missed automatic merge is cheap, whereas merging
+ * agent-written changes the user wanted to review first is not.
+ *
+ * Callers rewrite the chosen value to `never` rather than gating on this, so
+ * the value always reflects what will actually happen. Clearing
+ * {@link AgentMergeSessionState.repairBaseCommit} at the same time is what lets
+ * a later re-selection start from a fresh baseline.
+ */
+export declare function shouldStopMergingAfterAgentChanges(configuration: AgentMergeConfiguration, agentMerge: AgentMergeSessionState, currentCommit: string | undefined): boolean;
+export declare function isAgentMergeMergePullRequest(value: unknown): value is AgentMergeMergePullRequest;
+export declare function evaluateAgentMerge(snapshot: PullRequestSnapshot, configuration: AgentMergeConfiguration, commentWatermark: string, deferredCheckIds?: ReadonlySet<string>): AgentMergeGateResult;
+/** Fragments the gate must be able to read before it can decide anything. */
+export declare const agentMergeGateFragments: readonly [
+    "core",
+    "topLevelComments",
+    "submittedReviews",
+    "reviewThreads",
+    "checks",
+    "mergeability"
+];
+/**
+ * Returns whether a draft pull request has no pending or failed required checks
+ * and no actionable review feedback, or `undefined` while that state is incomplete.
+ */
+export declare function isAgentMergePullRequestReadyForReview(snapshot: PullRequestSnapshot, commentWatermark: string): boolean | undefined;
+export declare function classifyAgentMergeRequiredChecks(checks: PullRequestChecks): AgentMergeRequiredChecks;

package/vscode/src/vs/platform/agentHost/common/agentMerge.js

@@ -0,0 +1,67 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { createSchema, schemaProperty } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+
+const AgentMergeConfigKey = {
+    Enabled: "agentMerge.enabled",
+    AddressReviews: "agentMerge.addressReviews",
+    FixCI: "agentMerge.fixCI",
+    ResolveConflicts: "agentMerge.resolveConflicts",
+    MergePullRequest: "agentMerge.mergePullRequest",
+    MergeMethod: "agentMerge.mergeMethod",
+    ReplyAttribution: "agentMerge.replyAttribution"
+};
+const AgentMergeSettingId = {
+    Enabled: "chat.agentMerge.enabled",
+    AddressReviews: "chat.agentMerge.addressReviews",
+    FixCI: "chat.agentMerge.fixCI",
+    ResolveConflicts: "chat.agentMerge.resolveConflicts",
+    MergePullRequest: "chat.agentMerge.mergePullRequest",
+    MergeMethod: "chat.agentMerge.mergeMethod",
+    ReplyAttribution: "chat.agentMerge.replyAttribution"
+};
+const AGENT_MERGE_SETTING_TAG = "agentMerge";
+createSchema({
+    [AgentMergeConfigKey.Enabled]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2041, "Agent Merge")),
+        default: false
+    }),
+    [AgentMergeConfigKey.AddressReviews]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2042, "Address Reviews")),
+        default: true
+    }),
+    [AgentMergeConfigKey.FixCI]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2043, "Fix CI Failures")),
+        default: true
+    }),
+    [AgentMergeConfigKey.ResolveConflicts]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2044, "Resolve Conflicts")),
+        default: true
+    }),
+    [AgentMergeConfigKey.MergePullRequest]: schemaProperty({
+        type: "string",
+        title: ( localize(2045, "Merge Pull Request")),
+        enum: ["always", "ifUnchanged", "never"],
+        default: "never"
+    }),
+    [AgentMergeConfigKey.MergeMethod]: schemaProperty({
+        type: "string",
+        title: ( localize(2046, "Merge Method")),
+        enum: ["auto", "squash", "merge", "rebase"],
+        default: "auto"
+    }),
+    [AgentMergeConfigKey.ReplyAttribution]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2047, "Reply Attribution")),
+        default: true
+    })
+});
+
+export { AGENT_MERGE_SETTING_TAG, AgentMergeConfigKey, AgentMergeSettingId };

package/vscode/src/vs/platform/agentHost/common/agentModelByokMeta.d.ts

@@ -0,0 +1,24 @@
+import type { SessionModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { IAgentModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent";
+/**
+ * Well-known key for the renderer LM-service identifier of the BYOK model an
+ * agent-host model is a copy of, carried under a model's open `_meta` bag (see
+ * {@link IAgentModelInfo._meta} / {@link SessionModelInfo._meta}).
+ *
+ * A renderer BYOK model is registered under `<vendor>/<group>/<id>` (or `<vendor>/<id>`
+ * without a configured group) — exactly the id the "Manage Models" view keys visibility
+ * by. That identifier is not otherwise recoverable once the model round-trips the
+ * agent-host bridge, so the renderer attaches it here so the chat model picker can honour
+ * the model's visibility toggle.
+ */
+export declare const BYOK_MODEL_IDENTIFIER_META_KEY = "byokModelIdentifier";
+/**
+ * Builds a `_meta` payload carrying the BYOK model identifier, or `undefined` when there
+ * is none so callers can avoid attaching an empty `_meta` object.
+ */
+export declare function createAgentModelByokMeta(modelIdentifier: string | undefined): Record<string, unknown> | undefined;
+/**
+ * Reads the BYOK model identifier from a model's open `_meta` bag, ignoring unrelated
+ * keys and values of the wrong type.
+ */
+export declare function readAgentModelByokIdentifier(model: IAgentModelInfo | SessionModelInfo): string | undefined;

package/vscode/src/vs/platform/agentHost/common/agentModelByokMeta.js

@@ -0,0 +1,13 @@
+
+
+const BYOK_MODEL_IDENTIFIER_META_KEY = 'byokModelIdentifier';
+function readAgentModelByokIdentifier(model) {
+    const meta = model._meta;
+    if (!meta) {
+        return undefined;
+    }
+    const value = meta[BYOK_MODEL_IDENTIFIER_META_KEY];
+    return typeof value === 'string' ? value : undefined;
+}
+
+export { BYOK_MODEL_IDENTIFIER_META_KEY, readAgentModelByokIdentifier };

package/vscode/src/vs/platform/agentHost/common/agentModelNotices.d.ts

@@ -0,0 +1,22 @@
+import type { IAgentModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent";
+import type { SessionModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+type ModelMessage = {
+    readonly code: string;
+    readonly message: string;
+};
+type ModelNoticeSource = {
+    readonly warningText?: {
+        readonly dataRetention?: string;
+    };
+    readonly infoMessages?: readonly ModelMessage[];
+    readonly warningMessages?: readonly ModelMessage[];
+};
+/** Converts SDK model messages to model-picker metadata. */
+export declare function createAgentModelNoticesMeta(source: ModelNoticeSource): Record<string, unknown> | undefined;
+/** Reads model-picker messages from Agent Host metadata. */
+export declare function readAgentModelNoticesMeta(model: IAgentModelInfo | SessionModelInfo): {
+    warningText: Record<string, string> | undefined;
+    infoText: Record<string, string> | undefined;
+    rowWarning: string | undefined;
+};
+export {};

package/vscode/src/vs/platform/agentHost/common/agentModelNotices.js

@@ -0,0 +1,21 @@
+
+
+function readAgentModelNoticesMeta(model) {
+    const meta = model._meta;
+    return {
+        warningText: asStringDictionary(meta?.warningText),
+        infoText: asStringDictionary(meta?.infoText),
+        rowWarning: typeof meta?.rowWarning === "string" && meta.rowWarning.length > 0 ? meta.rowWarning : undefined
+    };
+}
+function asStringDictionary(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = Object.entries(value).filter(
+        entry => entry[0].length > 0 && typeof entry[1] === "string" && entry[1].length > 0
+    );
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+export { readAgentModelNoticesMeta };

package/vscode/src/vs/platform/agentHost/common/agentModelPricing.d.ts

@@ -0,0 +1,114 @@
+import type { SessionModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { IAgentModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent";
+/**
+ * Well-known model picker metadata carried under a model's open `_meta` bag (see {@link IAgentModelInfo._meta} /
+ * {@link SessionModelInfo._meta}). Agents populate these keys so the chat model picker can render pricing,
+ * capability categories, and promotions.
+ *
+ * All cost values are expressed as credits per 1M tokens — the same unit the model picker hover renders (see
+ * `getModelHoverContent` in `modelPicker/modelPickerHover.ts`). Fields are optional; agents omit what they don't know.
+ */
+export interface IAgentModelPricingMeta {
+    /** Request multiplier (e.g. `1.5` rendered as "1.5x"). */
+    readonly multiplierNumeric?: number;
+    /** Default-tier input cost in credits per 1M tokens. */
+    readonly inputCost?: number;
+    /** Default-tier cached-input (read) cost in credits per 1M tokens. */
+    readonly cacheCost?: number;
+    /** Default-tier cache-write cost in credits per 1M tokens. */
+    readonly cacheWriteCost?: number;
+    /** Default-tier output cost in credits per 1M tokens. */
+    readonly outputCost?: number;
+    /** Long-context-tier input cost in credits per 1M tokens. */
+    readonly longContextInputCost?: number;
+    /** Long-context-tier cached-input (read) cost in credits per 1M tokens. */
+    readonly longContextCacheCost?: number;
+    /** Long-context-tier cache-write cost in credits per 1M tokens. */
+    readonly longContextCacheWriteCost?: number;
+    /** Long-context-tier output cost in credits per 1M tokens. */
+    readonly longContextOutputCost?: number;
+    /** Coarse price bucket (e.g. `low`, `medium`, `high`) for an at-a-glance tag. */
+    readonly priceCategory?: string;
+    /** Capability category (e.g. `lightweight`, `versatile`, `powerful`) shown in the model picker hover. */
+    readonly category?: string;
+    /** Whole-number percentage discount (0-100) for the synthetic `auto` model; shown as a "{n}% discount" detail. */
+    readonly discountPercent?: number;
+    /** Promotional information for the model. A `discountPercent` of `0` is a valid message-only promo. */
+    readonly promo?: {
+        readonly id: string;
+        readonly discountPercent: number;
+        /** ISO 8601 end date; absent for open-ended promotions. */
+        readonly endsAt?: string;
+        readonly message: string;
+        readonly showBanner?: boolean;
+    };
+}
+/**
+ * Reads the well-known {@link IAgentModelPricingMeta} keys from a model's open `_meta` bag, ignoring any unrelated
+ * provider-specific keys and values of the wrong type. Returns an object containing only the keys that were present
+ * with a valid value.
+ */
+export declare function readAgentModelPricingMeta(model: IAgentModelInfo | SessionModelInfo): IAgentModelPricingMeta;
+/**
+ * Builds a `_meta` payload from {@link IAgentModelPricingMeta}, dropping `undefined` entries. Returns `undefined` when
+ * no model picker fields are known so callers can avoid attaching an empty `_meta` object.
+ */
+export declare function createAgentModelPricingMeta(pricing: IAgentModelPricingMeta): Record<string, unknown> | undefined;
+/**
+ * Normalizes a raw CAPI or Copilot SDK billing payload into the camelCase
+ * {@link ICAPIModelBilling} shape that {@link createPricingMetaFromBilling} expects.
+ * Prices are converted from the payload's billing batch to credits per million tokens.
+ */
+export declare function normalizeCAPIBilling(raw: unknown): ICAPIModelBilling | undefined;
+/**
+ * Normalized model billing shape shared by CAPI-backed agents and the Copilot SDK model list.
+ * Raw snake_case and current SDK fields are converted at the read boundary by {@link normalizeCAPIBilling}.
+ */
+export interface ICAPIModelBilling {
+    readonly multiplier?: number;
+    /** Coarse price bucket surfaced as a tag in the model picker hover. */
+    readonly priceCategory?: string;
+    /** Whole-number percentage discount (0-100) for the synthetic `auto` model; rendered as a "{n}% discount" detail. */
+    readonly discountPercent?: number;
+    /** Promotional information for the model. A `discountPercent` of `0` is a valid message-only promo. */
+    readonly promo?: {
+        readonly id: string;
+        readonly discountPercent: number;
+        /** ISO 8601 end date; absent for open-ended promotions. */
+        readonly endsAt?: string;
+        readonly message: string;
+        /** Whether the promo may be surfaced as a chat input banner. Absent means eligible; only `false` suppresses it. */
+        readonly showBanner?: boolean;
+    };
+    readonly tokenPrices?: {
+        readonly contextMax?: number;
+        readonly inputPrice?: number;
+        readonly cachePrice?: number;
+        readonly cacheWritePrice?: number;
+        readonly outputPrice?: number;
+        readonly longContext?: {
+            readonly contextMax?: number;
+            readonly inputPrice?: number;
+            readonly cachePrice?: number;
+            readonly cacheWritePrice?: number;
+            readonly outputPrice?: number;
+        };
+    };
+}
+/**
+ * Converts a CAPI model's billing payload into an {@link IAgentModelPricingMeta} `_meta` bag. Long-context costs are
+ * only emitted when there is an actual surcharge (at least one long-context price differs from the default tier).
+ * When emitting, any missing long-context field falls back to the default-tier value so the hover table renders
+ * complete rows. See {@link hasLongContextSurcharge} for the surcharge detection logic.
+ *
+ * @param billing - The model's billing info, narrowed through {@link ICAPIModelBilling}.
+ * @param priceCategory - An optional override for the price category (e.g. from `modelPickerPriceCategory` on the
+ *   model object itself). Falls back to `billing.priceCategory` when not provided.
+ * @param category - The model's capability category from its top-level `modelPickerCategory` field.
+ */
+export declare function createPricingMetaFromBilling(billing: ICAPIModelBilling | undefined, priceCategory?: string, category?: string): Record<string, unknown> | undefined;
+/**
+ * Whether the model's long-context tier has any cost that differs from its default tier.
+ * Drives the context-size picker default: smaller tier when surcharged, full window when free.
+ */
+export declare function hasLongContextSurcharge(billing: ICAPIModelBilling | undefined): boolean;

package/vscode/src/vs/platform/agentHost/common/agentModelPricing.js

@@ -0,0 +1,56 @@
+
+
+const NUMBER_KEYS = [
+    "multiplierNumeric",
+    "inputCost",
+    "cacheCost",
+    "cacheWriteCost",
+    "outputCost",
+    "longContextInputCost",
+    "longContextCacheCost",
+    "longContextCacheWriteCost",
+    "longContextOutputCost",
+    "discountPercent"
+];
+const COPILOT_MODEL_PICKER_CATEGORY_META_KEY = "copilot.modelPickerCategory";
+function readAgentModelPricingMeta(model) {
+    const meta = model._meta;
+    if (!meta) {
+        return {};
+    }
+    const result = {};
+    for (const key of NUMBER_KEYS) {
+        const value = meta[key];
+        if (typeof value === "number") {
+            result[key] = value;
+        }
+    }
+    if (typeof meta.priceCategory === "string") {
+        result.priceCategory = meta.priceCategory;
+    }
+    if (typeof meta.category === "string") {
+        result.category = meta.category;
+    } else if (typeof meta[COPILOT_MODEL_PICKER_CATEGORY_META_KEY] === "string") {
+        result.category = meta[COPILOT_MODEL_PICKER_CATEGORY_META_KEY];
+    }
+    const rawPromo = meta.promo;
+    if (rawPromo && typeof rawPromo === "object" && !Array.isArray(rawPromo)) {
+        const p = rawPromo;
+        if (typeof p.id === "string" && typeof p.discountPercent === "number" && typeof p.message === "string") {
+            result.promo = {
+                id: p.id,
+                discountPercent: p.discountPercent,
+                message: p.message,
+                ...(typeof p.endsAt === "string" ? {
+                    endsAt: p.endsAt
+                } : {}),
+                ...(typeof p.showBanner === "boolean" ? {
+                    showBanner: p.showBanner
+                } : {})
+            };
+        }
+    }
+    return result;
+}
+
+export { readAgentModelPricingMeta };

package/vscode/src/vs/platform/agentHost/common/agentSdkSetup.d.ts

@@ -0,0 +1,53 @@
+import type { RootState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+export declare const AGENT_SDK_SETUP_DOWNLOAD_REQUEST_KEY = "vscode.agentSdkSetup.downloadRequest";
+/**
+ * Ask an agent to look again at a setup the user completed outside the app
+ * (`claude login`, an exported key) — the only completion signal there is.
+ */
+export declare const AGENT_SDK_SETUP_RELOAD_REQUEST_KEY = "vscode.agentSdkSetup.reloadRequest";
+export declare function agentSdkSetupStatusKey(agent: string): string;
+/**
+ * Whether the agent's SDK can be loaded without a network fetch.
+ *
+ * `downloadOnUse` means the SDK is absent, but this host remembers consent and
+ * will fetch it only when an agent turn needs it.
+ *
+ * Deliberately the *only* thing on the wire: account state is derivable from the
+ * model list, which already flows over AHP — `ready` plus zero models means "no
+ * account" — and publishing it too would be two sources for one truth.
+ */
+export type AgentSdkDownloadStatus = "notDownloaded" | "downloadOnUse" | "downloading" | "ready";
+/**
+ * What an agent declares about its own setup. Capabilities, never UI: no
+ * user-facing strings ride this channel, because localization belongs in the
+ * workbench.
+ */
+export interface IAgentSdkSetupInfo {
+    /** Agent/provider id, e.g. `'claude'`. */
+    readonly agent: string;
+    readonly download: AgentSdkDownloadStatus;
+    /**
+     * Where the user goes to finish setup, for the agents whose setup happens
+     * outside the app (`claude login`, an exported API key).
+     */
+    readonly setupDocsUrl?: string;
+    /**
+     * Display name of the provider this agent can sign in to in-app, e.g.
+     * `'ChatGPT'`; absent means it has no such flow. A proper noun the workbench
+     * cannot invent, so it crosses the wire like `displayName` does and is
+     * interpolated into a localized template rather than shown raw.
+     */
+    readonly signInProviderName?: string;
+}
+/** A request the workbench addresses to one agent, made unique so a repeat press is not swallowed. */
+export interface IAgentSdkSetupRequest {
+    readonly agent: string;
+    readonly request: string;
+}
+export declare function isAgentSdkSetupRequestFor(value: unknown, agent: string): value is IAgentSdkSetupRequest;
+/**
+ * Every agent that has published a setup status, in root-state key order. Agents
+ * that have not published are absent rather than guessed at — there is no honest
+ * default for "we were never told".
+ */
+export declare function readAgentSdkSetupInfos(state: RootState | undefined): readonly IAgentSdkSetupInfo[];