dsh-better-copilot 0.1.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.3.0 — builtin review routing and temperature compatibility
+
+- Add volatile `autoReview.enabled`, `autoReview.model` and
+  `autoReview.reasoningEffort` settings. Builtin GitHub Copilot reviews default to
+  `gpt-6.1-terra`; DeepSeek Flash and non-Copilot routes retain their current
+  model. Omitted effort uses the selected model's adapter default.
+- Redispatch detached frozen auxiliary requests through the public LLM
+  waterfall, leaving conversation requests, review policy, permission state,
+  Session metadata and cancellation unchanged; dispose the listener on unload.
+- Remove the builtin Copilot reviewer's sampling parameter unless its model
+  positively advertises support. Map boolean account temperature capability
+  metadata into known/new catalog descriptors and strip explicitly unsupported
+  temperature on ordinary Copilot inference requests without model-name guesses.
+- Compose temperature and Gemini normalization in the existing wire transform;
+  a Gemini guard failure cannot discard a temperature fix. Add routing, effort
+  validation, metadata, protocol, lifecycle and publication regressions.
+
+## 0.2.0 — read-only subagent route badge
+
+- Add a browser client half that shows an addressed subagent's effective model
+  and reasoning effort in the Web session header, beside the title. The label is
+  text only: no selector, no click target, no Host write, because the child's
+  route is fixed at creation and reused on resume.
+- Read the route from the existing `modelSelection` session projection and show
+  an adapter-defaulted effort as `default`. Provider/model/effort ids render
+  verbatim; catalog display names are not available to client plugins.
+- Keep ordinary conversations and the DSH-rendered subagent catalog untouched.
+  Ship the bundle through `./client` and a `dsh.client` declaration, with render
+  tests and the publication allowlist updated.
+
 ## 0.1.1 — DSH 0.2.2-rc.1 compatibility
 
 - Retarget the manifest, peer ranges and development pins to DSH `0.2.2-rc.1`

package/README.md

@@ -12,6 +12,10 @@ One DeepSeek Harness plugin for GitHub Copilot:
   provider for the ordinary `web_search` tool.
 - **Gemini tool-declaration guard** — adds a missing root `properties` bucket to
   tool parameter schemas for configured Copilot routes.
+- **Builtin Auto review overrides** — selects the review model and effort without
+  changing the conversation model or the builtin authorization policy.
+- **Temperature compatibility** — omits unsupported sampling controls on the
+  Copilot wire, including the builtin reviewer's hard-coded zero.
 
 The plugin is a replacement for, and superset of, the earlier separate
 `dsh-copilot-catalog`, `dsh-copilot-search` and `dsh-copilot-tool-schema`
@@ -67,14 +71,55 @@ The bundle patch:
       providers: [github-copilot]
       families: [gemini]
       logFixes: false
+    autoReview:
+      enabled: true
+      # Optional: leave unset for Terra on Copilot, current model otherwise
+      # model: gpt-6.1-terra
+      # reasoningEffort: high
 ```
 
 `providers` is the pi-ai adapter's own schema, reused unchanged, so every
 provider setting behaves exactly as it does with the stock adapter. `search`
-configures the web-search provider; `toolSchema` configures the Gemini guard.
+configures the web-search provider; `toolSchema` configures the Gemini guard;
+`autoReview` configures the builtin review request only.
 
 Loader patches replace a row's `config` wholesale, not key by key: an override
-must restate `providers`, `search` and `toolSchema` together.
+must restate every non-default group it needs together. Omitted `search`,
+`toolSchema` and `autoReview` groups resolve their defaults.
+
+## Builtin Auto review
+
+`autoReview` applies only to requests marked `purpose: auto-review` by the builtin
+experimental Auto review plugin. It does not enable Auto review, select a
+permission preset, replace its policy or change normal conversation/subagent
+requests.
+
+- With no `autoReview.model`, GitHub Copilot reviews use `gpt-6.1-terra`.
+  DeepSeek Flash (`deepseek-v4-flash`) stays on Flash; other non-Copilot providers
+  retain their current model.
+- `autoReview.model` selects an exact model id on the current provider;
+  `autoReview.reasoningEffort` selects that model's exact effort id. Explicit
+  settings win over defaults, including on DeepSeek. Omitted effort uses the
+  selected model's adapter default, not the main agent's effort. A model change
+  drops any prior model's effort. Unsupported explicit efforts fail normally
+  before provider I/O, without clamping or silently switching models.
+- Settings are volatile: edits apply to the next review, not an in-flight review.
+  `autoReview.enabled: false` restores the builtin request's model and effort.
+
+The builtin reviewer hard-codes `temperature: 0`. Copilot review requests omit
+this parameter unless the selected catalog model positively advertises
+`compat.supportsTemperature: true`, so older GPT metadata lacking a temperature
+flag does not cause an unsupported-parameter error. This conservative rule is
+limited to the reviewer-owned control; it does not discard explicit sampling
+settings on ordinary requests with unknown support.
+
+For ordinary Copilot inference, account discovery maps boolean
+`capabilities.supports.temperature` into `compat.supportsTemperature`. The
+existing trusted wire transform strips `temperature` only for exact catalog
+models declaring `false`; supported and unknown metadata preserve the original
+body. No model-name or reasoning-capability heuristics are used. Temperature
+normalization remains active with wire identity disabled, and a Gemini guard
+failure cannot undo a successful temperature fix.
 
 ## Wire identity
 
@@ -99,7 +144,27 @@ dispatches. Inside the same refcounted, trusted-path-checked interceptor that
 carries the wire identity, it adds an empty root `properties` bucket to object
 tool schemas that lack one for a configured Copilot route and model family, and
 leaves every other byte of the request untouched. It never replaces an adapter or
-another plugin's settings, and a guard failure dispatches the original body.
+another plugin's settings, and a guard failure preserves the body after any
+successful temperature normalization.
+
+## Subagent model badge (Web)
+
+The package now carries a small browser client half. When a subagent
+conversation is open in the Web GUI, the session header shows the child's
+effective route as muted text next to the title — for example
+`gpt-6.1-sol · high`. The label is read-only: the plugin renders no selector and
+writes nothing back, because the Host fixes a child's provider, model and
+reasoning effort when the subagent is created and reuses the recorded route on
+resume. An adapter-defaulted effort appears as `default`, and the tooltip and
+accessible name say that the route is fixed.
+
+The badge reads the child Session's `modelSelection` projection; it adds no Host
+service, configuration field or RPC. Ids are shown exactly as the Host records
+them, because catalog display names are not exposed to third-party client
+plugins. Ordinary conversations are unchanged, and the subagent catalog
+dropdown is untouched: DSH renders those rows in its own client package rather
+than through an extension slot. The browser half is published as `./client`
+and declared through `dsh.client`; no additional wiring is needed.
 
 ## Migration from the three predecessor packages
 

package/dist/auto-review.d.ts

@@ -0,0 +1,24 @@
+import { type GenerateOptions } from '@deepseek-ai/dsh-llm';
+import { type ModelCatalog, type PluginContext } from './catalog-types.js';
+import type { AutoReviewSettings } from './config.js';
+/** GitHub Copilot's default builtin authorization reviewer. */
+export declare const DEFAULT_REVIEW_MODEL = "gpt-6.1-terra";
+/** One live configuration snapshot for a review request. */
+export interface AutoReviewOverrides {
+    enabled: boolean;
+    model?: string;
+    reasoningEffort?: string;
+}
+/**
+ * Select only an auxiliary builtin review route. Never modify loop requests or
+ * caller-owned inputs, including the frozen request the builtin reviewer sends.
+ * Changing model drops a previous model's effort unless explicitly overridden.
+ */
+export declare function configureAutoReview(options: GenerateOptions<string>, settings: AutoReviewOverrides, catalog?: ModelCatalog): GenerateOptions<string>;
+/**
+ * The waterfall's next() accepts no replacement request. Redispatch a detached
+ * auxiliary request through the public LLM service instead, marking that exact
+ * object so the nested waterfall delegates once without rereading live settings.
+ * Cordis owns listener disposal; no review policy, permission or Session changes.
+ */
+export declare function installAutoReviewRouting(ctx: PluginContext, config: AutoReviewSettings, catalog: ModelCatalog): void;

package/dist/auto-review.js

@@ -0,0 +1,57 @@
+import { isAgentLoopRequest } from '@deepseek-ai/dsh-llm';
+import { asRecord } from './catalog-types.js';
+/** GitHub Copilot's default builtin authorization reviewer. */
+export const DEFAULT_REVIEW_MODEL = 'gpt-6.1-terra';
+/**
+ * Select only an auxiliary builtin review route. Never modify loop requests or
+ * caller-owned inputs, including the frozen request the builtin reviewer sends.
+ * Changing model drops a previous model's effort unless explicitly overridden.
+ */
+export function configureAutoReview(options, settings, catalog = {}) {
+    if (!settings.enabled || options.purpose !== 'auto-review' || isAgentLoopRequest(options))
+        return options;
+    const model = settings.model ?? (options.provider === 'github-copilot' && options.model !== 'deepseek-v4-flash'
+        ? DEFAULT_REVIEW_MODEL : options.model);
+    const reasoningEffort = settings.reasoningEffort ?? (model === options.model ? options.reasoningEffort : undefined);
+    const descriptor = Object.hasOwn(catalog, model) ? catalog[model] : undefined;
+    // The builtin's hard-coded zero is not a user inference setting. Require
+    // positive support for reviewer sampling; old SDK GPT catalogs omit this flag.
+    const omitTemperature = options.provider === 'github-copilot' && options.temperature !== undefined
+        && !(descriptor?.provider === 'github-copilot' && asRecord(descriptor.compat)?.supportsTemperature === true);
+    if (model === options.model && reasoningEffort === options.reasoningEffort && !omitTemperature)
+        return options;
+    const { reasoningEffort: _previous, temperature, ...rest } = options;
+    return Object.freeze({
+        ...rest, model,
+        ...(reasoningEffort === undefined ? {} : { reasoningEffort: reasoningEffort }),
+        ...(omitTemperature || temperature === undefined ? {} : { temperature }),
+    });
+}
+/**
+ * The waterfall's next() accepts no replacement request. Redispatch a detached
+ * auxiliary request through the public LLM service instead, marking that exact
+ * object so the nested waterfall delegates once without rereading live settings.
+ * Cordis owns listener disposal; no review policy, permission or Session changes.
+ */
+export function installAutoReviewRouting(ctx, config, catalog) {
+    const routed = new WeakSet();
+    ctx.on('llm/stream', function (options, next) {
+        if (routed.has(options) || options.purpose !== 'auto-review' || isAgentLoopRequest(options))
+            return next();
+        const enabled = config.enabled.get();
+        if (!enabled)
+            return next();
+        const model = config.model.get();
+        const reasoningEffort = config.reasoningEffort.get();
+        const selected = configureAutoReview(options, {
+            enabled,
+            ...(model === undefined ? {} : { model }),
+            ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+        }, catalog);
+        if (selected === options)
+            return next();
+        routed.add(selected);
+        // Purpose typing is owned by the optional builtin package, not a hard peer.
+        return this.stream(selected);
+    });
+}

package/dist/catalog.js

@@ -1,4 +1,5 @@
 import { asRecord } from './catalog-types.js';
+import { withCopilotTemperatureSupport } from './temperature.js';
 export const DEFAULT_COPILOT_BASE_URL = 'https://api.individual.githubcopilot.com';
 // Provider identity defaults match the supported pi-ai Copilot OAuth client.
 // These are protocol defaults, not metadata borrowed from a particular model.
@@ -165,7 +166,7 @@ export function selectAccountModels(response, catalog, { baseUrl = DEFAULT_COPIL
         // Own-property lookup prevents Object.prototype members becoming descriptors.
         const model = own(catalog, item.id) ?? createNewModel({ ...item, id: item.id }, headers, baseUrl);
         if (model) {
-            models[item.id] = model;
+            models[item.id] = withCopilotTemperatureSupport(model, supports?.temperature);
             unsupported.delete(item.id);
         }
         else {

package/dist/client.js

@@ -0,0 +1,98 @@
+"use strict";
+/// <reference path="./client.types.d.ts" />
+/* Read-only subagent route badge for the Web conversation header.
+ * The Host fixes a subagent's provider, model and reasoning effort when the
+ * child is created, so this client half only presents them. It never renders a
+ * selection control and writes nothing back to the Session.
+ */
+window.__ModuleLoader__.load({
+    id: 'dsh-better-copilot',
+    factory(require) {
+        const React = require('react');
+        const h = React.createElement;
+        const NS = 'better-copilot.subagent';
+        const SLOT = 'conversation.session.header.actions';
+        const ID = 'better-copilot-subagent-model';
+        const en = {
+            'badge.defaultEffort': 'default',
+            'badge.fixed': "Model and effort are fixed for this subagent's lifetime.",
+            'badge.aria': 'Subagent model {model} from {provider}, reasoning effort {effort}. {fixed}',
+        };
+        const zh = {
+            'badge.defaultEffort': '默认',
+            'badge.fixed': '该子智能体的模型与推理强度在创建时已固定。',
+            'badge.aria': '子智能体模型 {model}（{provider}），推理强度 {effort}。{fixed}',
+        };
+        /** Validate one projected selection; anything malformed is not rendered. */
+        function readSelection(value) {
+            if (typeof value !== 'object' || value === null)
+                return null;
+            const candidate = value;
+            const provider = typeof candidate.provider === 'string' ? candidate.provider : '';
+            const model = typeof candidate.model === 'string' ? candidate.model : '';
+            if (provider === '' || model === '')
+                return null;
+            const reasoningEffort = typeof candidate.reasoningEffort === 'string' && candidate.reasoningEffort !== ''
+                ? candidate.reasoningEffort
+                : undefined;
+            return reasoningEffort === undefined ? { provider, model } : { provider, model, reasoningEffort };
+        }
+        /** Read the effective selection from the modelSelection wire view. */
+        function selectedOf(view) {
+            if (typeof view !== 'object' || view === null)
+                return null;
+            const projected = view;
+            return readSelection(projected.next) ?? readSelection(projected.lastUsed);
+        }
+        /** Compose the visible label, tooltip and accessible name for one route. */
+        function subagentBadge(selection, t) {
+            const explicit = selection.reasoningEffort;
+            const effort = explicit === undefined ? t('badge.defaultEffort') : explicit;
+            const route = explicit === undefined
+                ? `${selection.provider}/${selection.model}`
+                : `${selection.provider}/${selection.model} · ${explicit}`;
+            return {
+                label: `${selection.model} · ${effort}`,
+                title: `${route} — ${t('badge.fixed')}`,
+                aria: t('badge.aria', {
+                    provider: selection.provider,
+                    model: selection.model,
+                    effort,
+                    fixed: t('badge.fixed'),
+                }),
+            };
+        }
+        const badgeStyle = {
+            display: 'inline-block',
+            maxWidth: '26ch',
+            overflow: 'hidden',
+            color: 'var(--dsw-alias-label-tertiary)',
+            fontSize: '12px',
+            lineHeight: '18px',
+            whiteSpace: 'nowrap',
+            textOverflow: 'ellipsis',
+            verticalAlign: 'middle',
+            cursor: 'default',
+        };
+        /** Read-only header cell: visible only for an addressed subagent's own route. */
+        function SubagentModelBadge({ sessionId, useSessions, useProjection, t }) {
+            const subagent = useSessions((state) => state.byId[sessionId]?.origin === 'subagent');
+            const view = useProjection('modelSelection');
+            if (!subagent)
+                return null;
+            const selection = selectedOf(view);
+            if (selection === null)
+                return null;
+            const badge = subagentBadge(selection, t);
+            return h('span', { style: badgeStyle, title: badge.title, 'aria-label': badge.aria }, badge.label);
+        }
+        function apply(ctx) {
+            ctx.effect(() => ctx.locale.register(NS, { en, zh }));
+            ctx.slots.inject(SLOT, () => ctx.slots.register({ name: SLOT, id: ID, order: 15, locale: NS }, SubagentModelBadge));
+        }
+        return {
+            inject: ['slots', 'locale'],
+            apply,
+        };
+    },
+});

package/dist/config.d.ts

@@ -30,11 +30,18 @@ export interface GuardConfigValue {
     families: Volatile<string[]>;
     logFixes: Volatile<boolean>;
 }
+/** Builtin Auto review routing; omitted leaves retain the model's adapter defaults. */
+export interface AutoReviewSettings {
+    enabled: Volatile<boolean>;
+    model: Volatile<string | undefined>;
+    reasoningEffort: Volatile<string | undefined>;
+}
 /** The one configuration object every capability reads from. */
 export interface BetterCopilotConfig {
     providers: ProvidersValue;
     search: SearchSettings;
     toolSchema: GuardConfigValue;
+    autoReview: AutoReviewSettings;
 }
 /** User-facing configuration: plain values, before volatile resolution. */
 export interface BetterCopilotConfigInput {
@@ -58,6 +65,11 @@ export interface BetterCopilotConfigInput {
         families?: string[];
         logFixes?: boolean;
     };
+    autoReview?: {
+        enabled?: boolean;
+        model?: string;
+        reasoningEffort?: string;
+    };
 }
 /**
  * The merged Config schema as the plugin and the Loader see it: callable, with a
@@ -115,6 +127,16 @@ export declare const GuardConfig: z<Schemastery.ObjectS<NoInfer<{
     families: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
     logFixes: z<boolean, boolean, "volatile-defined">;
 }>>, "plain">;
+/** Only the builtin reviewer is affected; exact model/effort ids are validated by LLM dispatch. */
+export declare const AutoReviewConfig: z<Schemastery.ObjectS<NoInfer<{
+    enabled: z<boolean, boolean, "volatile-defined">;
+    model: z<string, string, "volatile">;
+    reasoningEffort: z<string, string, "volatile">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    enabled: z<boolean, boolean, "volatile-defined">;
+    model: z<string, string, "volatile">;
+    reasoningEffort: z<string, string, "volatile">;
+}>>, "plain">;
 /**
  * The merged plugin's single configuration object: the adapter's provider map
  * plus one group per additional capability.

package/dist/config.js

@@ -23,6 +23,12 @@ export const GuardConfig = z.object({
     families: z.array(z.string()).default(['gemini']).volatile(),
     logFixes: z.boolean().default(false).volatile(),
 });
+/** Only the builtin reviewer is affected; exact model/effort ids are validated by LLM dispatch. */
+export const AutoReviewConfig = z.object({
+    enabled: z.boolean().default(true).volatile(),
+    model: z.string().min(1).volatile(),
+    reasoningEffort: z.string().min(1).volatile(),
+});
 /**
  * Reuse the pi-ai adapter's own provider profile schema instead of restating it.
  * A restated schema would silently drift from the adapter's defaults, validation
@@ -47,5 +53,6 @@ export function createConfig(originalConfig) {
         providers: providerProfileSchema(originalConfig),
         search: SearchConfig,
         toolSchema: GuardConfig,
+        autoReview: AutoReviewConfig,
     });
 }

package/dist/index.d.ts

@@ -7,6 +7,9 @@ export declare const apply: (ctx: PluginContext, config: BetterCopilotConfig) =>
 /** Preserved predecessor entry point: one read-only discovery with the merged runtime. */
 export declare const syncCopilotCatalog: (credentials?: CredentialReader, authOptions?: CopilotAuthOptions) => Promise<SyncResult>;
 export { DEFAULT_SEARCH_MODEL } from './config.js';
+export { configureAutoReview, DEFAULT_REVIEW_MODEL } from './auto-review.js';
+export type { AutoReviewOverrides } from './auto-review.js';
+export { normalizeCopilotTemperature } from './temperature.js';
 export { liveCost, selectAccountModels } from './catalog.js';
 export { DiscoveryError } from './discovery.js';
 export { createCopilotWireIdentity, installCopilotIdentityHeaders, installCopilotRequestTransform, isCopilotRequestPath, isTrustedCopilotUrl, rewriteCopilotRequestHeaders, wireIdentityMode, } from './identity.js';
@@ -16,7 +19,7 @@ export { COPILOT_SEARCH_PROVIDER_ID, CopilotSearchProvider } from './provider.js
 export { matchesRoute, normalizeToolSchemas, TOOL_SCHEMA_SKIPPED } from './schema.js';
 export { loadRuntime } from './runtime.js';
 export type { BetterCopilotRuntime, RuntimeOptions } from './runtime.js';
-export type { BetterCopilotConfig, BetterCopilotConfigSchema } from './config.js';
+export type { AutoReviewSettings, BetterCopilotConfig, BetterCopilotConfigSchema } from './config.js';
 export type { BetterCopilotDependencies, BetterCopilotPlugin } from './plugin.js';
 export type { AccountModelOptions } from './catalog.js';
 export type { NormalizeResult } from './schema.js';

package/dist/index.js

@@ -9,6 +9,8 @@ export const apply = (ctx, config) => plugin.apply(ctx, config);
 /** Preserved predecessor entry point: one read-only discovery with the merged runtime. */
 export const syncCopilotCatalog = (credentials, authOptions) => plugin.sync(credentials, authOptions);
 export { DEFAULT_SEARCH_MODEL } from './config.js';
+export { configureAutoReview, DEFAULT_REVIEW_MODEL } from './auto-review.js';
+export { normalizeCopilotTemperature } from './temperature.js';
 export { liveCost, selectAccountModels } from './catalog.js';
 export { DiscoveryError } from './discovery.js';
 export { createCopilotWireIdentity, installCopilotIdentityHeaders, installCopilotRequestTransform, isCopilotRequestPath, isTrustedCopilotUrl, rewriteCopilotRequestHeaders, wireIdentityMode, } from './identity.js';

package/dist/plugin.js

@@ -6,6 +6,8 @@ import { createCopilotWireIdentity, installCopilotIdentityHeaders, installCopilo
 import { CopilotSearchProvider } from './provider.js';
 import { TOOL_SCHEMA_SKIPPED } from './schema.js';
 import { guardCopilotRequestBody } from './guard.js';
+import { installAutoReviewRouting } from './auto-review.js';
+import { normalizeCopilotTemperature } from './temperature.js';
 export const name = 'better-copilot';
 /** Search and guard are optional capabilities; the adapter requires these two. */
 export const inject = ['llm', 'credentials'];
@@ -96,21 +98,28 @@ export function createPlugin(dependencies) {
             //    the defect. It is installed even when wire identity is opted out.
             contain('tool-schema guard', 'Gemini tool-schema normalization', () => {
                 const transform = ({ body }) => {
+                    let normalized;
+                    try {
+                        normalized = normalizeCopilotTemperature(body, dependencies.catalog);
+                    }
+                    catch {
+                        log('warn', 'better-copilot: skipped temperature normalization after an internal error');
+                    }
                     try {
                         const settings = guardSettings(config.toolSchema);
-                        const result = guardCopilotRequestBody(body, settings);
+                        const result = guardCopilotRequestBody(normalized ?? body, settings);
                         if (settings.logFixes) {
                             if (result.fixed.length > 0)
                                 log('info', 'better-copilot: added a properties bucket to %d tool schema(s) on the Copilot wire', result.fixed.length);
                             if (result.skipped.length > 0)
                                 log('warn', 'better-copilot: %s left %d tool schema(s) unchanged: %s', TOOL_SCHEMA_SKIPPED, result.skipped.length, JSON.stringify(result.skipped));
                         }
-                        return result.body;
+                        return result.body ?? normalized;
                     }
                     catch {
-                        // The request is delegated byte-identical; a guard failure never fails a call.
+                        // Guard failure never fails a call or discards a temperature fix.
                         log('warn', 'better-copilot: skipped one request after an internal error');
-                        return undefined;
+                        return normalized;
                     }
                 };
                 ctx.effect(() => installCopilotRequestTransform(transform), 'copilot: tool-schema wire normalization');
@@ -144,7 +153,11 @@ export function createPlugin(dependencies) {
                     });
                 });
             });
-            // 4. Catalog discovery, then the adapter itself. Only this step is fatal:
+            // 4. Builtin authorization reviewer routing, independently contained.
+            contain('auto-review routing', 'builtin review model overrides', () => {
+                installAutoReviewRouting(ctx, config.autoReview, dependencies.catalog);
+            });
+            // 5. Catalog discovery, then the adapter itself. Only this step is fatal:
             // without the adapter there is no Copilot inference route at all.
             try {
                 const credentials = ctx.get('credentials');

package/dist/temperature.d.ts

@@ -0,0 +1,19 @@
+import type { Api, Model } from '@earendil-works/pi-ai';
+import { type ModelCatalog } from './catalog-types.js';
+/**
+ * Apply only an explicit boolean from capabilities.supports.temperature.
+ * OpenAI compat schemas do not yet declare this field, but the wire boundary
+ * reads the same metadata used natively by pi-ai's Anthropic serializer.
+ * Preserve descriptor identity when discovery has nothing new to say.
+ */
+export declare function withCopilotTemperatureSupport<T extends Model<Api>>(model: T, support: unknown): T;
+/**
+ * Omit an unsupported temperature after SDK serialization, for every request
+ * purpose (including auxiliary review). IDs are opaque and reasoning capability
+ * says nothing about temperature: only an exact catalog descriptor with explicit
+ * false compatibility metadata is sufficient to remove the field.
+ *
+ * Install through the existing trusted Copilot request transform, not as a
+ * separate interceptor. Undefined means the original body stays byte-identical.
+ */
+export declare function normalizeCopilotTemperature(body: string, catalog: ModelCatalog): string | undefined;

package/dist/temperature.js

@@ -0,0 +1,39 @@
+import { asRecord } from './catalog-types.js';
+/**
+ * Apply only an explicit boolean from capabilities.supports.temperature.
+ * OpenAI compat schemas do not yet declare this field, but the wire boundary
+ * reads the same metadata used natively by pi-ai's Anthropic serializer.
+ * Preserve descriptor identity when discovery has nothing new to say.
+ */
+export function withCopilotTemperatureSupport(model, support) {
+    if (typeof support !== 'boolean' || asRecord(model.compat)?.supportsTemperature === support)
+        return model;
+    return { ...model, compat: { ...model.compat, supportsTemperature: support } };
+}
+/**
+ * Omit an unsupported temperature after SDK serialization, for every request
+ * purpose (including auxiliary review). IDs are opaque and reasoning capability
+ * says nothing about temperature: only an exact catalog descriptor with explicit
+ * false compatibility metadata is sufficient to remove the field.
+ *
+ * Install through the existing trusted Copilot request transform, not as a
+ * separate interceptor. Undefined means the original body stays byte-identical.
+ */
+export function normalizeCopilotTemperature(body, catalog) {
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return undefined;
+    }
+    const request = asRecord(parsed);
+    if (!request || typeof request.model !== 'string' || !Object.hasOwn(request, 'temperature') ||
+        !Object.hasOwn(catalog, request.model))
+        return undefined;
+    const model = catalog[request.model];
+    if (model?.provider !== 'github-copilot' || asRecord(model.compat)?.supportsTemperature !== false)
+        return undefined;
+    delete request.temperature;
+    return JSON.stringify(request);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-better-copilot",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Account-aware GitHub Copilot model discovery, Copilot-compatible wire identity, native Responses web search and a Copilot Gemini tool-declaration guard in one DeepSeek Harness plugin.",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,6 +30,7 @@
       "types": "./dist/guard.d.ts",
       "import": "./dist/guard.js"
     },
+    "./client": "./dist/client.js",
     "./package.json": "./package.json"
   },
   "files": [
@@ -72,6 +73,7 @@
     "@deepseek-ai/cordis": "~4.1.0",
     "@deepseek-ai/dsh-credentials": "0.2.2-rc.1",
     "@deepseek-ai/dsh-launch-environment": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-llm": "0.2.2-rc.1",
     "@deepseek-ai/dsh-llm-pi-ai": "0.2.2-rc.1",
     "@deepseek-ai/dsh-system-prompt": "0.2.2-rc.1",
     "@deepseek-ai/dsh-web": "0.2.2-rc.1",
@@ -83,24 +85,33 @@
     "@deepseek-ai/dsh-agent": "0.2.2-rc.1",
     "@deepseek-ai/dsh-credentials": "0.2.2-rc.1",
     "@deepseek-ai/dsh-launch-environment": "0.2.2-rc.1",
+    "@deepseek-ai/dsh-llm": "0.2.2-rc.1",
     "@deepseek-ai/dsh-llm-pi-ai": "0.2.2-rc.1",
     "@deepseek-ai/dsh-scope": "0.2.2-rc.1",
     "@deepseek-ai/dsh-session": "0.2.2-rc.1",
     "@deepseek-ai/dsh-system-prompt": "0.2.2-rc.1",
     "@deepseek-ai/dsh-web": "0.2.2-rc.1",
     "@deepseek-ai/schemastery": "3.19.0",
-    "@earendil-works/pi-ai": "1.3.0"
+    "@earendil-works/pi-ai": "1.3.0",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0"
   },
   "dsh": {
     "manifestVersion": 1,
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p test/tsconfig.json",
-    "test": "pnpm run build && node --import tsx --test test/catalog.test.ts test/discovery.test.ts test/identity.test.ts test/secrets.test.ts test/catalog-plugin.test.ts test/config.test.ts test/composition.test.ts test/auth.test.ts test/refresh.test.ts test/provider.test.ts test/responses.test.ts test/search-plugin.test.ts test/schema.test.ts test/guard.test.ts test/guard-plugin.test.ts test/patch.test.ts",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.client.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p test/tsconfig.json && tsc -p tsconfig.client.json --noEmit",
+    "test": "pnpm run build && node --import tsx --test test/catalog.test.ts test/discovery.test.ts test/identity.test.ts test/secrets.test.ts test/catalog-plugin.test.ts test/config.test.ts test/composition.test.ts test/auth.test.ts test/refresh.test.ts test/provider.test.ts test/responses.test.ts test/search-plugin.test.ts test/schema.test.ts test/guard.test.ts test/guard-plugin.test.ts test/patch.test.ts test/client.render.test.ts test/temperature.test.ts test/auto-review.test.ts",
     "test:integration": "pnpm run build && node --import tsx --test test/integration/nested-layout.test.ts test/integration/catalog-runtime.test.ts test/integration/enterprise.test.ts test/integration/identity-wire.test.ts test/integration/search-runtime.test.ts test/integration/guard-runtime.test.ts test/integration/wire.test.ts",
     "test:types": "pnpm run build && tsc -p test/types/tsconfig.json",
     "test:pack": "pnpm run build && tsx ../../scripts/check-pack.ts .",