@getpaseo/server 0.1.99 → 0.1.100

package/dist/server/server/agent/provider-registry.js

@@ -51,6 +51,7 @@ const PROVIDER_CLIENT_FACTORIES = {
         providerParams: options?.providerParams ?? {
             sessionDir: "~/.omp/agent/sessions",
         },
+        commandsRpcType: "get_available_commands",
     }),
     mock: (logger) => new MockLoadTestAgentClient(logger),
     "mock-slow": () => new MockSlowProviderClient(),

package/dist/server/server/agent/providers/acp-agent.d.ts

@@ -3,7 +3,7 @@ import type { ProcessTerminator } from "../../../utils/tree-kill.js";
 import type { ReadableStream as NodeReadableStream, WritableStream as NodeWritableStream } from "node:stream/web";
 import { ClientSideConnection, type Client as ACPClient, type CreateTerminalRequest, type InitializeResponse, type KillTerminalRequest, type LoadSessionResponse, type NewSessionResponse, type ReadTextFileRequest, type RequestPermissionRequest, type RequestPermissionResponse, type ResumeSessionResponse, type SessionConfigOption, type SessionMode, type SessionModelState, type SessionNotification, type TerminalOutputRequest, type TerminalOutputResponse, type ToolCallContent, type ToolCallLocation, type ToolCallStatus, type ToolKind, type Usage, type WaitForTerminalExitRequest, type WriteTextFileRequest, type Stream as ACPStream } from "@agentclientprotocol/sdk";
 import type { Logger } from "pino";
-import { type AgentCapabilityFlags, type AgentClient, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentUsage, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentUsage, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 export declare function summarizeACPRequestError(error: unknown): {
     message: string;
@@ -24,6 +24,7 @@ interface ACPAgentClientOptions {
     modelTransformer?: (models: AgentModelDefinition[]) => AgentModelDefinition[];
     sessionResponseTransformer?: (response: SessionStateResponse) => SessionStateResponse;
     configOptionsTransformer?: (configOptions: SessionConfigOption[]) => SessionConfigOption[];
+    configFeatureOptions?: ACPConfigFeatureOption[];
     modeIdTransformer?: (modeId: string) => string | null;
     toolSnapshotTransformer?: (snapshot: ACPToolSnapshot) => ACPToolSnapshot;
     providerModeWriter?: (context: ACPProviderModeWriterContext) => Promise<ACPProviderModeWriteResult>;
@@ -43,6 +44,7 @@ interface ACPAgentSessionOptions {
     modelTransformer?: (models: AgentModelDefinition[]) => AgentModelDefinition[];
     sessionResponseTransformer?: (response: SessionStateResponse) => SessionStateResponse;
     configOptionsTransformer?: (configOptions: SessionConfigOption[]) => SessionConfigOption[];
+    configFeatureOptions?: ACPConfigFeatureOption[];
     modeIdTransformer?: (modeId: string) => string | null;
     toolSnapshotTransformer?: (snapshot: ACPToolSnapshot) => ACPToolSnapshot;
     providerModeWriter?: (context: ACPProviderModeWriterContext) => Promise<ACPProviderModeWriteResult>;
@@ -76,6 +78,16 @@ interface TerminalExit {
     exitCode?: number | null;
     signal?: string | null;
 }
+export interface ACPConfigFeatureOption {
+    id: string;
+    configId: string;
+    category: string;
+    label: string;
+    description?: string;
+    tooltip?: string;
+    icon?: string;
+    emptyOptionLabel?: string;
+}
 type SelectConfigOption = Extract<SessionConfigOption, {
     type: "select";
 }>;
@@ -134,6 +146,7 @@ export declare function deriveModesFromACP(fallbackModes: AgentMode[], modeState
     currentModeId: string | null;
 };
 export declare function deriveModelDefinitionsFromACP(provider: string, models: SessionModelState | null | undefined, configOptions?: SessionConfigOption[] | null): AgentModelDefinition[];
+export declare function deriveFeaturesFromACP(configOptions: SessionConfigOption[] | null | undefined, featureOptions: ACPConfigFeatureOption[]): AgentFeature[];
 export declare class ACPAgentClient implements AgentClient {
     readonly provider: string;
     readonly capabilities: AgentCapabilityFlags;
@@ -144,6 +157,7 @@ export declare class ACPAgentClient implements AgentClient {
     private readonly modelTransformer?;
     private readonly sessionResponseTransformer?;
     private readonly configOptionsTransformer?;
+    private readonly configFeatureOptions;
     private readonly modeIdTransformer?;
     private readonly toolSnapshotTransformer?;
     private readonly providerModeWriter?;
@@ -156,6 +170,7 @@ export declare class ACPAgentClient implements AgentClient {
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
+    listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;
@@ -182,6 +197,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     protected readonly modelTransformer?: (models: AgentModelDefinition[]) => AgentModelDefinition[];
     private readonly sessionResponseTransformer?;
     private readonly configOptionsTransformer?;
+    private readonly configFeatureOptions;
     private readonly modeIdTransformer?;
     private readonly toolSnapshotTransformer?;
     private readonly providerModeWriter?;
@@ -236,6 +252,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     getRuntimeInfo(): Promise<AgentRuntimeInfo>;
     getAvailableModes(): Promise<AgentMode[]>;
     getCurrentMode(): Promise<string | null>;
+    get features(): AgentFeature[];
     private ensureCommandsReadyDeferred;
     private settleCommandsReady;
     private waitForCommandsReady;
@@ -246,6 +263,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     setModel(modelId: string | null): Promise<void>;
     private setModelWithSelection;
     setThinkingOption(thinkingOptionId: string | null): Promise<void>;
+    setFeature(featureId: string, value: unknown): Promise<void>;
     private applyConfigOptionResponse;
     getPendingPermissions(): AgentPermissionRequest[];
     respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<void>;

package/dist/server/server/agent/providers/acp-agent.js

@@ -257,6 +257,26 @@ export function deriveModelDefinitionsFromACP(provider, models, configOptions) {
         metadata: option.metadata,
     }));
 }
+export function deriveFeaturesFromACP(configOptions, featureOptions) {
+    return featureOptions.flatMap((featureOption) => {
+        const option = findSelectConfigFeatureOption(configOptions, featureOption);
+        if (!option) {
+            return [];
+        }
+        return [
+            {
+                type: "select",
+                id: featureOption.id,
+                label: featureOption.label,
+                description: featureOption.description,
+                tooltip: featureOption.tooltip,
+                icon: featureOption.icon,
+                value: option.currentValue ?? null,
+                options: deriveConfigFeatureSelectOptions(option, featureOption),
+            },
+        ];
+    });
+}
 export class ACPAgentClient {
     constructor(options) {
         this.provider = options.provider;
@@ -272,6 +292,7 @@ export class ACPAgentClient {
         this.modelTransformer = options.modelTransformer;
         this.sessionResponseTransformer = options.sessionResponseTransformer;
         this.configOptionsTransformer = options.configOptionsTransformer;
+        this.configFeatureOptions = options.configFeatureOptions ?? [];
         this.modeIdTransformer = options.modeIdTransformer;
         this.toolSnapshotTransformer = options.toolSnapshotTransformer;
         this.providerModeWriter = options.providerModeWriter;
@@ -291,6 +312,7 @@ export class ACPAgentClient {
             modelTransformer: this.modelTransformer,
             sessionResponseTransformer: this.sessionResponseTransformer,
             configOptionsTransformer: this.configOptionsTransformer,
+            configFeatureOptions: this.configFeatureOptions,
             modeIdTransformer: this.modeIdTransformer,
             toolSnapshotTransformer: this.toolSnapshotTransformer,
             providerModeWriter: this.providerModeWriter,
@@ -329,6 +351,7 @@ export class ACPAgentClient {
             modelTransformer: this.modelTransformer,
             sessionResponseTransformer: this.sessionResponseTransformer,
             configOptionsTransformer: this.configOptionsTransformer,
+            configFeatureOptions: this.configFeatureOptions,
             modeIdTransformer: this.modeIdTransformer,
             toolSnapshotTransformer: this.toolSnapshotTransformer,
             providerModeWriter: this.providerModeWriter,
@@ -364,6 +387,24 @@ export class ACPAgentClient {
             await this.closeProbe(probe);
         }
     }
+    async listFeatures(config) {
+        if (this.configFeatureOptions.length === 0) {
+            return [];
+        }
+        this.assertProvider(config);
+        const probe = await this.spawnProcess(PROBE_ENV);
+        try {
+            const response = await this.runACPRequest(() => probe.connection.newSession({
+                cwd: config.cwd,
+                mcpServers: [],
+            }));
+            const transformed = this.transformSessionResponse(response);
+            return deriveFeaturesFromACP(transformed.configOptions, this.configFeatureOptions);
+        }
+        finally {
+            await this.closeProbe(probe);
+        }
+    }
     async listImportableSessions(options) {
         const probe = await this.spawnProcess(PROBE_ENV);
         try {
@@ -582,6 +623,7 @@ export class ACPAgentSession {
         this.modelTransformer = options.modelTransformer;
         this.sessionResponseTransformer = options.sessionResponseTransformer;
         this.configOptionsTransformer = options.configOptionsTransformer;
+        this.configFeatureOptions = options.configFeatureOptions ?? [];
         this.modeIdTransformer = options.modeIdTransformer;
         this.toolSnapshotTransformer = options.toolSnapshotTransformer;
         this.providerModeWriter = options.providerModeWriter;
@@ -739,6 +781,9 @@ export class ACPAgentSession {
     async getCurrentMode() {
         return this.currentMode;
     }
+    get features() {
+        return deriveFeaturesFromACP(this.configOptions, this.configFeatureOptions);
+    }
     ensureCommandsReadyDeferred() {
         if (this.commandsReadyDeferred || this.commandsReadySettled || this.cachedCommands.length > 0) {
             return;
@@ -1015,6 +1060,37 @@ export class ACPAgentSession {
             thinkingOptionId: this.thinkingOptionId,
         });
     }
+    async setFeature(featureId, value) {
+        if (!this.connection || !this.sessionId) {
+            throw new Error("ACP session not initialized");
+        }
+        const featureOption = this.configFeatureOptions.find((option) => option.id === featureId);
+        if (!featureOption) {
+            throw new Error(`Unknown ${this.provider} feature: ${featureId}`);
+        }
+        const option = findSelectConfigFeatureOption(this.configOptions, featureOption);
+        if (!option) {
+            throw new Error(`${this.provider} does not expose ACP feature '${featureId}'`);
+        }
+        const requestedValue = normalizeConfigFeatureValue(value);
+        const choice = findSelectConfigChoice({ option, value: requestedValue });
+        if (!choice) {
+            throw new Error(`${this.provider} feature '${featureId}' does not include option '${requestedValue}'`);
+        }
+        const response = await this.connection.setSessionConfigOption({
+            sessionId: this.sessionId,
+            configId: option.id,
+            value: requestedValue,
+        });
+        const currentValue = this.applyConfigOptionResponse({
+            response,
+            configId: option.id,
+            category: featureOption.category,
+            requestedValue,
+            label: featureOption.label,
+        });
+        this.config.featureValues = { ...this.config.featureValues, [featureId]: currentValue };
+    }
     applyConfigOptionResponse({ response, configId, category, requestedValue, label, }) {
         this.configOptions = this.transformConfigOptions(response.configOptions);
         const responseOption = findSelectConfigOption({
@@ -1386,6 +1462,13 @@ export class ACPAgentSession {
         if (this.config.thinkingOptionId && this.config.thinkingOptionId !== this.thinkingOptionId) {
             await this.setThinkingOption(this.config.thinkingOptionId);
         }
+        const configuredFeatureValues = this.config.featureValues ?? {};
+        for (const featureOption of this.configFeatureOptions) {
+            if (!Object.prototype.hasOwnProperty.call(configuredFeatureValues, featureOption.id)) {
+                continue;
+            }
+            await this.setFeature(featureOption.id, configuredFeatureValues[featureOption.id]);
+        }
     }
     warnInvalidSelection(value, message) {
         this.logger.warn({ value }, message);
@@ -1671,6 +1754,12 @@ function findSelectConfigOption({ configOptions, category, id, }) {
     const option = configOptions?.find((entry) => entry.type === "select" && entry.category === category && (!id || entry.id === id));
     return option ?? null;
 }
+function findSelectConfigFeatureOption(configOptions, featureOption) {
+    const option = configOptions?.find((entry) => entry.type === "select" &&
+        entry.id === featureOption.configId &&
+        entry.category === featureOption.category);
+    return option ?? null;
+}
 function findSelectConfigChoice({ option, value, }) {
     if (!option) {
         return null;
@@ -1690,6 +1779,34 @@ function flattenSelectOptions(options) {
     }
     return flattened;
 }
+function deriveConfigFeatureSelectOptions(option, featureOption) {
+    return flattenSelectOptions(option.options).map((choice) => ({
+        id: choice.value,
+        label: normalizeConfigFeatureOptionLabel(choice, featureOption),
+        description: choice.description ?? undefined,
+        isDefault: choice.value === option.currentValue,
+        metadata: choice.group ? { group: choice.group } : undefined,
+    }));
+}
+function normalizeConfigFeatureOptionLabel(choice, featureOption) {
+    const name = choice.name.trim();
+    if (name) {
+        return name;
+    }
+    if (choice.value === "" && featureOption.emptyOptionLabel) {
+        return featureOption.emptyOptionLabel;
+    }
+    return choice.value;
+}
+function normalizeConfigFeatureValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === null) {
+        return "";
+    }
+    throw new Error(`ACP feature value must be a string`);
+}
 function deriveSelectorOptions(configOptions, category) {
     const option = findSelectConfigOption({ configOptions, category });
     if (!option) {

package/dist/server/server/agent/providers/claude/agent.js

@@ -1252,23 +1252,6 @@ function readLegacyResultUsageTokens(usage) {
     const usageRecord = toObjectRecord(usage);
     return usageRecord ? readUsageTokenTotal(usageRecord) : undefined;
 }
-function readCurrentContextUsage(value) {
-    const record = toObjectRecord(value);
-    if (!record) {
-        return undefined;
-    }
-    const totalTokens = record.totalTokens;
-    if (typeof totalTokens !== "number" || !Number.isFinite(totalTokens) || totalTokens < 0) {
-        return undefined;
-    }
-    const maxTokens = record.maxTokens;
-    return {
-        totalTokens,
-        ...(typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0
-            ? { maxTokens }
-            : {}),
-    };
-}
 function isClaudeSubagentToolName(name) {
     return name === "Task" || name === "Agent";
 }
@@ -1280,6 +1263,7 @@ class ClaudeContextUsageState {
     beginTurn() {
         this.streamRequestInputTokens = undefined;
         this.streamRequestOutputTokens = undefined;
+        this.compactedContextWindowUsedTokens = undefined;
     }
     setInitialContextWindowMaxTokens(contextWindowMaxTokens) {
         this.contextWindowMaxTokens = contextWindowMaxTokens;
@@ -1291,11 +1275,6 @@ class ClaudeContextUsageState {
         }
         return this.contextWindowMaxTokens;
     }
-    recordCurrentContextUsage(usage) {
-        if (usage?.maxTokens !== undefined) {
-            this.contextWindowMaxTokens = usage.maxTokens;
-        }
-    }
     buildStreamUsageEvent(event) {
         const streamEvent = toObjectRecord(event);
         if (!streamEvent) {
@@ -1326,7 +1305,7 @@ class ClaudeContextUsageState {
         }
         return this.createUsageUpdatedEvent(usedTokens);
     }
-    buildResultUsage(message, modelUsage, currentContextUsage) {
+    buildResultUsage(message, modelUsage) {
         try {
             if (!message.usage) {
                 return undefined;
@@ -1338,7 +1317,6 @@ class ClaudeContextUsageState {
                 totalCostUsd: message.total_cost_usd,
             };
             const modelContextWindowMaxTokens = this.recordModelUsage(modelUsage ?? message.modelUsage);
-            this.recordCurrentContextUsage(currentContextUsage);
             if (this.contextWindowMaxTokens !== undefined) {
                 usage.contextWindowMaxTokens = this.contextWindowMaxTokens;
             }
@@ -1347,13 +1325,14 @@ class ClaudeContextUsageState {
             }
             const activeResultUsageTokens = readActiveUsageTokens(message.usage) ??
                 (this.completedResultTurns === 0 ? readLegacyResultUsageTokens(message.usage) : undefined);
-            const usedTokens = currentContextUsage?.totalTokens ?? this.streamUsedTokens() ?? activeResultUsageTokens;
+            const usedTokens = this.streamUsedTokens() ?? activeResultUsageTokens ?? this.compactedContextWindowUsedTokens;
             if (usedTokens !== undefined) {
                 usage.contextWindowUsedTokens = usedTokens;
             }
             return usage;
         }
         finally {
+            this.compactedContextWindowUsedTokens = undefined;
             this.completedResultTurns += 1;
         }
     }
@@ -1362,7 +1341,8 @@ class ClaudeContextUsageState {
             typeof this.streamRequestOutputTokens !== "number") {
             return undefined;
         }
-        return this.streamRequestInputTokens + this.streamRequestOutputTokens;
+        const usedTokens = this.streamRequestInputTokens + this.streamRequestOutputTokens;
+        return usedTokens > 0 ? usedTokens : undefined;
     }
     createUsageUpdatedEvent(contextWindowUsedTokens) {
         const usage = {
@@ -1377,6 +1357,23 @@ class ClaudeContextUsageState {
             usage,
         };
     }
+    buildCompactionUsageEvent(postTokens) {
+        this.streamRequestInputTokens = undefined;
+        this.streamRequestOutputTokens = undefined;
+        this.compactedContextWindowUsedTokens = postTokens;
+        const usage = {};
+        if (this.contextWindowMaxTokens !== undefined) {
+            usage.contextWindowMaxTokens = this.contextWindowMaxTokens;
+        }
+        if (postTokens !== undefined) {
+            usage.contextWindowUsedTokens = postTokens;
+        }
+        return {
+            type: "usage_updated",
+            provider: "claude",
+            usage,
+        };
+    }
 }
 class ClaudeAgentSession {
     constructor(config, options) {
@@ -2659,7 +2656,7 @@ class ClaudeAgentSession {
             if (await this.handleMissingResumedConversation(message, activeQuery)) {
                 return true;
             }
-            await this.routeSdkMessageFromPump(message, activeQuery);
+            await this.routeSdkMessageFromPump(message);
             return false;
         };
         const drainActiveQuery = async () => {
@@ -2727,7 +2724,7 @@ class ClaudeAgentSession {
             message.type === "tool_progress" ||
             (message.type === "system" && message.subtype === "task_notification"));
     }
-    async routeSdkMessageFromPump(message, activeQuery) {
+    async routeSdkMessageFromPump(message) {
         if (this.shouldSuppressStaleResult(message)) {
             return;
         }
@@ -2750,7 +2747,7 @@ class ClaudeAgentSession {
             identifiers,
             rawEvent: message,
         }, "provider.claude.parsed_event");
-        const events = await this.buildPumpedMessageEvents(message, activeQuery, identifiers.messageId, turnId);
+        const events = await this.buildPumpedMessageEvents(message, identifiers.messageId, turnId);
         if (events.length === 0) {
             return;
         }
@@ -2773,14 +2770,10 @@ class ClaudeAgentSession {
         }
         this.dispatchEvents(events);
     }
-    async buildPumpedMessageEvents(message, activeQuery, messageIdHint, turnId) {
-        const currentContextUsage = message.type === "result" && message.subtype === "success"
-            ? await this.queryCurrentContextUsage(activeQuery)
-            : undefined;
+    async buildPumpedMessageEvents(message, messageIdHint, turnId) {
         const messageEvents = this.translateMessageToEvents(message, {
             suppressAssistantText: true,
             suppressReasoning: true,
-            currentContextUsage,
         });
         const assistantTimelineEvents = this.timelineAssembler
             .consume({
@@ -2795,16 +2788,6 @@ class ClaudeAgentSession {
         }));
         return [...messageEvents, ...assistantTimelineEvents];
     }
-    async queryCurrentContextUsage(activeQuery) {
-        try {
-            const usage = await withTimeout(activeQuery.getContextUsage(), 3000, "timeout");
-            return readCurrentContextUsage(usage);
-        }
-        catch (error) {
-            this.logger.debug({ err: error }, "Claude context usage query failed");
-            return undefined;
-        }
-    }
     async handleMissingResumedConversation(message, activeQuery) {
         const staleResumeError = this.readMissingResumedConversationError(message);
         if (!staleResumeError) {
@@ -2895,9 +2878,7 @@ class ClaudeAgentSession {
                 this.appendStreamEventEvents(message, events, options);
                 break;
             case "result":
-                this.appendResultEvents(message, events, {
-                    currentContextUsage: options?.currentContextUsage,
-                });
+                this.appendResultEvents(message, events);
                 break;
             default:
                 break;
@@ -2963,6 +2944,7 @@ class ClaudeAgentSession {
                 },
                 provider: "claude",
             });
+            events.push(this.contextUsage.buildCompactionUsageEvent(compactMetadata?.postTokens));
             return;
         }
         if (message.subtype === "task_notification") {
@@ -3067,8 +3049,8 @@ class ClaudeAgentSession {
             events.push({ type: "timeline", item, provider: "claude" });
         }
     }
-    appendResultEvents(message, events, options) {
-        const usage = this.convertUsage(message, message.modelUsage, options?.currentContextUsage);
+    appendResultEvents(message, events) {
+        const usage = this.convertUsage(message, message.modelUsage);
         if (message.subtype === "success") {
             // Built-in slash commands (e.g. /voice, /usage, "Unknown command: …")
             // run client-side in the Claude CLI with no model turn — output_tokens
@@ -3212,8 +3194,8 @@ class ClaudeAgentSession {
         }
         return null;
     }
-    convertUsage(message, modelUsage, currentContextUsage) {
-        return this.contextUsage.buildResultUsage(message, modelUsage, currentContextUsage);
+    convertUsage(message, modelUsage) {
+        return this.contextUsage.buildResultUsage(message, modelUsage);
     }
     enqueueTimeline(item) {
         this.pushEvent({ type: "timeline", item, provider: "claude" });
@@ -3899,7 +3881,9 @@ function readCompactionMetadata(source) {
         const trigger = typeof metadata.trigger === "string" ? metadata.trigger : undefined;
         const preTokensRaw = metadata.preTokens ?? metadata.pre_tokens;
         const preTokens = typeof preTokensRaw === "number" ? preTokensRaw : undefined;
-        return { trigger, preTokens };
+        const postTokensRaw = metadata.postTokens ?? metadata.post_tokens;
+        const postTokens = typeof postTokensRaw === "number" ? postTokensRaw : undefined;
+        return { trigger, preTokens, postTokens };
     }
     return null;
 }

package/dist/server/server/agent/providers/copilot-acp-agent.d.ts

@@ -2,8 +2,9 @@ import type { Logger } from "pino";
 import type { SessionConfigOption } from "@agentclientprotocol/sdk";
 import type { AgentMode } from "../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
-import { ACPAgentClient, type ACPBeforeModeWriteResult, type ACPProviderModeWriteResult, type ACPProviderModeWriterContext, type SessionStateResponse } from "./acp-agent.js";
+import { ACPAgentClient, type ACPConfigFeatureOption, type ACPBeforeModeWriteResult, type ACPProviderModeWriteResult, type ACPProviderModeWriterContext, type SessionStateResponse } from "./acp-agent.js";
 export declare const COPILOT_ALLOW_ALL_MODE_ID = "allow-all";
+export declare const COPILOT_AGENT_FEATURE_OPTION: ACPConfigFeatureOption;
 export declare const COPILOT_MODES: AgentMode[];
 interface CopilotACPAgentClientOptions {
     logger: Logger;

package/dist/server/server/agent/providers/copilot-acp-agent.js

@@ -20,6 +20,15 @@ export const COPILOT_ALLOW_ALL_MODE_ID = "allow-all";
 const COPILOT_ALLOW_ALL_CONFIG_ID = "allow_all";
 const COPILOT_ALLOW_ALL_ON = "on";
 const COPILOT_ALLOW_ALL_OFF = "off";
+export const COPILOT_AGENT_FEATURE_OPTION = {
+    id: "agent",
+    configId: "agent",
+    category: "_agent",
+    label: "Agent",
+    description: "Use a Copilot custom agent profile",
+    tooltip: "Select Copilot agent",
+    emptyOptionLabel: "Default",
+};
 export const COPILOT_MODES = [
     {
         id: COPILOT_AGENT_MODE_ID,
@@ -47,6 +56,7 @@ export class CopilotACPAgentClient extends ACPAgentClient {
             defaultModes: COPILOT_MODES,
             sessionResponseTransformer: transformCopilotSessionResponse,
             configOptionsTransformer: transformCopilotConfigOptions,
+            configFeatureOptions: [COPILOT_AGENT_FEATURE_OPTION],
             modeIdTransformer: transformCopilotModeId,
             providerModeWriter: writeCopilotProviderMode,
             beforeModeWriter: beforeCopilotModeWriter,

package/dist/server/server/agent/providers/opencode/server-manager.d.ts

@@ -16,10 +16,10 @@ export interface OpenCodeServerManagerLike {
         port: number;
         url: string;
     }>;
-    acquire(options: {
-        force: boolean;
-        env?: Record<string, string>;
-    }): Promise<OpenCodeServerAcquisition>;
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
+    shutdown(): Promise<void>;
 }
 export interface OpenCodeServerGeneration {
     process: ChildProcess;
@@ -27,7 +27,11 @@ export interface OpenCodeServerGeneration {
     url: string;
     refCount: number;
     retired: boolean;
+    ready: Promise<void>;
     managedProcessId?: string;
+    managedProcessRecord?: Promise<{
+        id: string;
+    } | null>;
 }
 export type OpenCodePortAllocator = () => Promise<number>;
 export type OpenCodeCommandPrefixResolver = () => Promise<{
@@ -50,7 +54,7 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     private currentServer;
     private retiredServers;
     private startPromise;
-    private forcedRefreshPromise;
+    private newServerPromise;
     private readonly logger;
     private readonly runtimeSettings?;
     private readonly runtimeSettingsKey;
@@ -66,21 +70,20 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
         port: number;
         url: string;
     }>;
-    acquire(options: {
-        force: boolean;
-        env?: Record<string, string>;
-    }): Promise<OpenCodeServerAcquisition>;
+    acquireCurrent(): Promise<OpenCodeServerAcquisition>;
+    acquireNew(): Promise<OpenCodeServerAcquisition>;
+    acquireDedicated(env: Record<string, string>): Promise<OpenCodeServerAcquisition>;
     private acquireServer;
-    private getForcedRefreshServer;
+    private getNewServer;
     private getCurrentServer;
     private rotateCurrentServer;
-    private startDedicatedServer;
     private startServer;
     shutdown(): Promise<void>;
     private cleanupRetiredServers;
     private killServer;
     private recordManagedServerProcess;
     private removeManagedProcessRecordWhenResolved;
+    private removeManagedServerRecord;
     private removeManagedProcessId;
 }
 //# sourceMappingURL=server-manager.d.ts.map