@getpaseo/server 0.1.85 → 0.1.86

package/dist/scripts/supervisor-entrypoint.js

@@ -7,6 +7,7 @@ import { loadPersistedConfig } from "../src/server/persisted-config.js";
 import { runSupervisor } from "./supervisor.js";
 import { resolveSupervisorLogFile } from "./supervisor-log-config.js";
 import { applySherpaLoaderEnv } from "../src/server/speech/providers/local/sherpa/sherpa-runtime-env.js";
+process.title = "Paseo Supervisor";
 function parseConfig(argv) {
     let devMode = false;
     const workerArgs = [];

package/dist/server/server/agent/agent-metadata-generator.d.ts

@@ -1,7 +1,9 @@
 import type { Logger } from "pino";
 import type { AgentManager } from "./agent-manager.js";
 import { generateStructuredAgentResponseWithFallback } from "./agent-response-loop.js";
+import { type StructuredGenerationDaemonConfig } from "./structured-generation-providers.js";
 import type { WorkspaceGitService } from "../workspace-git-service.js";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
 export interface AgentMetadataGeneratorDeps {
     generateStructuredAgentResponseWithFallback?: typeof generateStructuredAgentResponseWithFallback;
 }
@@ -10,6 +12,13 @@ export interface AgentMetadataGenerationOptions {
     agentId: string;
     cwd: string;
     workspaceGitService?: Pick<WorkspaceGitService, "resolveRepoRoot">;
+    providerSnapshotManager?: Pick<ProviderSnapshotManager, "listProviders">;
+    daemonConfig?: StructuredGenerationDaemonConfig | null;
+    currentSelection?: {
+        provider?: string | null;
+        model?: string | null;
+        thinkingOptionId?: string | null;
+    };
     initialPrompt?: string | null;
     explicitTitle?: string | null;
     paseoHome?: string;

package/dist/server/server/agent/agent-metadata-generator.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "./agent-response-loop.js";
+import { StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "./agent-response-loop.js";
+import { resolveStructuredGenerationProviders, } from "./structured-generation-providers.js";
 import { MAX_AUTO_AGENT_TITLE_CHARS } from "@getpaseo/protocol/agent-title-limits";
 import { buildMetadataPrompt } from "../../utils/build-metadata-prompt.js";
 function hasExplicitTitle(title) {
@@ -60,6 +61,14 @@ export async function generateAndApplyAgentMetadata(options) {
         generateStructuredAgentResponseWithFallback;
     let result;
     try {
+        const providers = options.providerSnapshotManager
+            ? await resolveStructuredGenerationProviders({
+                cwd: options.cwd,
+                providerSnapshotManager: options.providerSnapshotManager,
+                daemonConfig: options.daemonConfig,
+                currentSelection: options.currentSelection,
+            })
+            : [];
         result = await generator({
             manager: options.agentManager,
             cwd: options.cwd,
@@ -70,7 +79,7 @@ export async function generateAndApplyAgentMetadata(options) {
             schema,
             schemaName: "AgentMetadata",
             maxRetries: 2,
-            providers: DEFAULT_STRUCTURED_GENERATION_PROVIDERS,
+            providers,
             persistSession: false,
             logger: options.logger,
             agentConfigOverrides: {

package/dist/server/server/agent/agent-response-loop.d.ts

@@ -60,7 +60,7 @@ export interface StructuredAgentGenerationWithFallbackOptions<T> {
     logger?: StructuredGenerationLogger;
     runner?: <TResult>(options: StructuredAgentGenerationOptions<TResult>) => Promise<TResult>;
 }
-export declare const DEFAULT_STRUCTURED_GENERATION_PROVIDERS: readonly StructuredGenerationProvider[];
+export { DEFAULT_STRUCTURED_GENERATION_PROVIDERS } from "./structured-generation-providers.js";
 export declare function getStructuredAgentResponse<T>(options: StructuredAgentResponseOptions<T>): Promise<T>;
 export declare function generateStructuredAgentResponse<T>(options: StructuredAgentGenerationOptions<T>): Promise<T>;
 export declare function generateStructuredAgentResponseWithFallback<T>(options: StructuredAgentGenerationWithFallbackOptions<T>): Promise<T>;

package/dist/server/server/agent/agent-response-loop.js

@@ -1,6 +1,5 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
 import Ajv from "ajv";
-import { getAgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
 export class StructuredAgentResponseError extends Error {
     constructor(message, options) {
         super(message);
@@ -27,12 +26,8 @@ export class StructuredAgentFallbackError extends Error {
         this.attempts = attempts;
     }
 }
-export const DEFAULT_STRUCTURED_GENERATION_PROVIDERS = [
-    { provider: "claude", model: "haiku" },
-    { provider: "codex", model: "gpt-5.4-mini", thinkingOptionId: "low" },
-    { provider: "opencode", model: "opencode/minimax-m2.5-free" },
-    { provider: "opencode", model: "opencode/nemotron-3-super-free" },
-];
+// Re-export from the legacy module path so existing server consumers keep working.
+export { DEFAULT_STRUCTURED_GENERATION_PROVIDERS } from "./structured-generation-providers.js";
 function isZodSchema(value) {
     return typeof value?.safeParse === "function";
 }
@@ -229,12 +224,7 @@ export async function getStructuredAgentResponse(options) {
 }
 export async function generateStructuredAgentResponse(options) {
     const { manager, agentConfig, agentId, persistSession, prompt, schema, maxRetries, schemaName } = options;
-    const modeId = agentConfig.modeId ??
-        getAgentProviderDefinition(agentConfig.provider).defaultModeId ??
-        undefined;
-    const agent = await manager.createAgent({ ...agentConfig, modeId }, agentId, {
-        persistSession,
-    });
+    const agent = await manager.createAgent(agentConfig, agentId, { persistSession });
     try {
         const caller = async (nextPrompt) => {
             const result = await manager.runAgent(agent.id, nextPrompt);

package/dist/server/server/agent/create-agent/create.d.ts

@@ -4,6 +4,7 @@ import type { WorkspaceGitService } from "../../workspace-git-service.js";
 import type { AgentWorktreeSetupContinuation, CreatePaseoWorktreeWorkflowFn } from "../../worktree-session.js";
 import type { AgentAttachment, FirstAgentContext, GitSetupOptions } from "../../messages.js";
 import type { AgentManager, ManagedAgent } from "../agent-manager.js";
+import type { StructuredGenerationDaemonConfig } from "../structured-generation-providers.js";
 import type { AgentSessionConfig } from "../agent-sdk-types.js";
 import type { AgentStorage } from "../agent-storage.js";
 import type { ProviderSnapshotManager } from "../provider-snapshot-manager.js";
@@ -22,6 +23,7 @@ interface CreateAgentCommandDependencies {
     workspaceGitService?: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees" | "resolveRepoRoot">;
     terminalManager?: TerminalManager | null;
     providerSnapshotManager: ProviderSnapshotManager;
+    daemonConfig?: StructuredGenerationDaemonConfig | null;
     createPaseoWorktree?: CreatePaseoWorktreeWorkflowFn;
 }
 export interface CreateAgentFromSessionInput {

package/dist/server/server/agent/create-agent/create.js

@@ -121,6 +121,13 @@ async function sendInitialPrompt(dependencies, resolved, snapshot) {
         agentId: snapshot.id,
         cwd: snapshot.cwd,
         workspaceGitService: dependencies.workspaceGitService,
+        providerSnapshotManager: dependencies.providerSnapshotManager,
+        daemonConfig: dependencies.daemonConfig,
+        currentSelection: {
+            provider: snapshot.provider,
+            model: snapshot.runtimeInfo?.model ?? resolved.config.model,
+            thinkingOptionId: snapshot.runtimeInfo?.thinkingOptionId ?? resolved.config.thinkingOptionId ?? null,
+        },
         initialPrompt: resolved.metadataInitialPrompt,
         explicitTitle: resolved.explicitTitle,
         paseoHome: dependencies.paseoHome,

package/dist/server/server/agent/import-sessions.d.ts

@@ -4,6 +4,7 @@ import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
 import type { AgentManager, ManagedAgent } from "./agent-manager.js";
 import type { AgentStorage } from "./agent-storage.js";
 import { scheduleAgentMetadataGeneration } from "./agent-metadata-generator.js";
+import type { StructuredGenerationDaemonConfig } from "./structured-generation-providers.js";
 import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "@getpaseo/protocol/messages";
 import type { WorkspaceGitService } from "../workspace-git-service.js";
 type ImportAgentRequestMessage = z.infer<typeof ImportAgentRequestMessageSchema>;
@@ -33,6 +34,8 @@ export interface ImportProviderSessionInput {
     agentManager: AgentManager;
     agentStorage: AgentStorage;
     workspaceGitService?: Pick<WorkspaceGitService, "resolveRepoRoot">;
+    providerSnapshotManager?: Pick<ProviderSnapshotManager, "listProviders">;
+    daemonConfig?: StructuredGenerationDaemonConfig | null;
     paseoHome?: string;
     logger: Logger;
     deps?: {

package/dist/server/server/agent/import-sessions.js

@@ -94,6 +94,8 @@ export async function importProviderSession(input) {
         snapshot,
         agentManager: input.agentManager,
         workspaceGitService: input.workspaceGitService,
+        providerSnapshotManager: input.providerSnapshotManager,
+        daemonConfig: input.daemonConfig,
         paseoHome: input.paseoHome,
         logger: input.logger,
         scheduleAgentMetadataGeneration: input.deps?.scheduleAgentMetadataGeneration ?? scheduleAgentMetadataGeneration,
@@ -129,6 +131,15 @@ async function applyImportedAgentTitle(input) {
         agentId: input.snapshot.id,
         cwd: input.snapshot.cwd,
         workspaceGitService: input.workspaceGitService,
+        providerSnapshotManager: input.providerSnapshotManager,
+        daemonConfig: input.daemonConfig,
+        currentSelection: {
+            provider: input.snapshot.provider,
+            model: input.snapshot.runtimeInfo?.model ?? input.snapshot.config.model,
+            thinkingOptionId: input.snapshot.runtimeInfo?.thinkingOptionId ??
+                input.snapshot.config.thinkingOptionId ??
+                null,
+        },
         initialPrompt,
         explicitTitle,
         paseoHome: input.paseoHome,

package/dist/server/server/agent/providers/claude/agent.d.ts

@@ -1,7 +1,7 @@
 import { type AgentDefinition, type SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { Logger } from "pino";
 import { type ClaudeQueryFactory } from "./query.js";
-import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentLaunchContext, type AgentMetadata, type AgentModelDefinition, type AgentPersistenceHandle, type AgentSession, type AgentSessionConfig, type AgentTimelineItem, type ListModelsOptions, type ListPersistedAgentsOptions, type PersistedAgentDescriptor } from "../../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMetadata, type AgentModelDefinition, type AgentPersistenceHandle, type AgentSession, type AgentSessionConfig, type AgentTimelineItem, type ListModelsOptions, type ListPersistedAgentsOptions, type PersistedAgentDescriptor } from "../../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 export declare function normalizeClaudeAskUserQuestionUpdatedInput(updatedInput: AgentMetadata | undefined, fallbackInput: AgentMetadata | undefined): AgentMetadata;
 interface EventIdentifiers {
@@ -36,6 +36,7 @@ export declare class ClaudeAgentClient implements AgentClient {
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext, options?: AgentCreateSessionOptions): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
+    listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     listPersistedAgents(options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
     isAvailable(): Promise<boolean>;
     getDiagnostic(): Promise<{

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

@@ -8,6 +8,7 @@ import { mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserConte
 import { getClaudeModelsWithSettings, normalizeClaudeRuntimeModelId } from "./models.js";
 import { parsePartialJsonObject } from "./partial-json.js";
 import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
+import { buildClaudeFeatures, claudeModelSupportsFastMode } from "./feature-definitions.js";
 import { buildBinaryDiagnosticRows, formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "../provider-runner.js";
 import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
@@ -215,8 +216,21 @@ function summarizeClaudeOptionsForLog(options) {
             ? options.pathToClaudeCodeExecutable
             : null,
         persistSession: typeof options.persistSession === "boolean" ? options.persistSession : null,
+        fastMode: readClaudeFastModeSetting(options.settings),
     };
 }
+function readClaudeFastModeSetting(settings) {
+    if (!settings || typeof settings === "string") {
+        return null;
+    }
+    return typeof settings.fastMode === "boolean" ? settings.fastMode : null;
+}
+function mergeClaudeSettings(settings, updates) {
+    if (!settings || typeof settings === "string") {
+        return settings ?? updates;
+    }
+    return { ...settings, ...updates };
+}
 function isToolResultTextBlock(value) {
     return (!!value &&
         typeof value === "object" &&
@@ -951,6 +965,13 @@ export class ClaudeAgentClient {
         // Claude exposes a global catalog here; cwd/force are intentionally irrelevant.
         return await getClaudeModelsWithSettings(this.logger);
     }
+    async listFeatures(config) {
+        const claudeConfig = this.assertConfig(config);
+        return buildClaudeFeatures({
+            modelId: claudeConfig.model,
+            fastModeEnabled: claudeConfig.featureValues?.fast_mode === true,
+        });
+    }
     async listPersistedAgents(options) {
         const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
         const projectsRoot = path.join(configDir, "projects");
@@ -1273,6 +1294,12 @@ class ClaudeAgentSession {
     get id() {
         return this.claudeSessionId;
     }
+    get features() {
+        return buildClaudeFeatures({
+            modelId: this.config.model,
+            fastModeEnabled: this.config.featureValues?.fast_mode === true,
+        });
+    }
     async getRuntimeInfo() {
         if (this.cachedRuntimeInfo) {
             return { ...this.cachedRuntimeInfo };
@@ -1444,6 +1471,9 @@ class ClaudeAgentSession {
         const activeQuery = await this.ensureQuery();
         await activeQuery.setModel(normalizedModelId ?? undefined);
         this.config.model = normalizedModelId ?? undefined;
+        if (!claudeModelSupportsFastMode(this.config.model) && this.config.featureValues?.fast_mode) {
+            await this.applyFastModeFeature(false, activeQuery);
+        }
         this.lastOptionsModel = normalizedModelId ?? this.lastOptionsModel;
         this.lastRuntimeModel = null;
         this.cachedRuntimeInfo = null;
@@ -1465,6 +1495,27 @@ class ClaudeAgentSession {
         }
         this.queryRestartNeeded = true;
     }
+    async setFeature(featureId, value) {
+        if (featureId !== "fast_mode") {
+            throw new Error(`Unknown Claude feature: ${featureId}`);
+        }
+        const enabled = Boolean(value);
+        if (enabled && !claudeModelSupportsFastMode(this.config.model)) {
+            throw new Error(`Claude fast mode is not available for model '${this.config.model ?? "default"}'`);
+        }
+        await this.applyFastModeFeature(enabled);
+    }
+    async applyFastModeFeature(enabled, query) {
+        this.config.featureValues = {
+            ...this.config.featureValues,
+            fast_mode: enabled,
+        };
+        const activeQuery = query ?? this.query;
+        if (activeQuery) {
+            await activeQuery.applyFlagSettings({ fastMode: enabled });
+        }
+        this.cachedRuntimeInfo = null;
+    }
     getPendingPermissions() {
         return Array.from(this.pendingPermissions.values()).map((entry) => entry.request);
     }
@@ -1920,6 +1971,10 @@ class ClaudeAgentSession {
             launchEnv: this.launchEnv,
             queryFactory: this.queryFactory,
         });
+        const fastMode = this.resolveFastModeSetting();
+        if (fastMode !== null) {
+            await this.query.applyFlagSettings({ fastMode });
+        }
         // Do not kick off background control-plane queries here. Methods like
         // supportedCommands()/setPermissionMode() may execute immediately after
         // ensureQuery() (for listCommands()/setMode()), and sharing the same query
@@ -1991,6 +2046,7 @@ class ClaudeAgentSession {
         const { thinking, effort } = this.resolveThinkingConfig();
         const appendedSystemPrompt = this.buildAppendedSystemPrompt();
         const extraClaudeOptions = this.config.extra?.claude;
+        const fastModeOptions = this.buildFastModeOptions(extraClaudeOptions);
         const sdkEnv = this.buildSdkEnv(extraClaudeOptions);
         assertClaudeAutoModeEligible(this.currentMode, sdkEnv);
         const claudeBinary = await this.resolveBinary();
@@ -2039,6 +2095,7 @@ class ClaudeAgentSession {
             ...(thinking ? { thinking } : {}),
             ...(effort ? { effort } : {}),
             ...extraClaudeOptions,
+            ...fastModeOptions,
             ...(this.persistSession === undefined ? {} : { persistSession: this.persistSession }),
             env: sdkEnv,
         };
@@ -2060,6 +2117,19 @@ class ClaudeAgentSession {
         }
         return base;
     }
+    buildFastModeOptions(extraClaudeOptions) {
+        const fastMode = this.resolveFastModeSetting();
+        if (fastMode === null) {
+            return {};
+        }
+        return { settings: mergeClaudeSettings(extraClaudeOptions?.settings, { fastMode }) };
+    }
+    resolveFastModeSetting() {
+        if (!claudeModelSupportsFastMode(this.config.model)) {
+            return null;
+        }
+        return this.config.featureValues?.fast_mode === true;
+    }
     normalizeMcpServers(servers) {
         const result = {};
         for (const [name, config] of Object.entries(servers)) {

package/dist/server/server/agent/providers/claude/feature-definitions.d.ts

@@ -0,0 +1,8 @@
+import type { AgentFeature, AgentFeatureToggle } from "../../agent-sdk-types.js";
+export declare const CLAUDE_FAST_MODE_FEATURE: Omit<AgentFeatureToggle, "value">;
+export declare function claudeModelSupportsFastMode(modelId: string | null | undefined): boolean;
+export declare function buildClaudeFeatures(input: {
+    modelId: string | null | undefined;
+    fastModeEnabled: boolean;
+}): AgentFeature[];
+//# sourceMappingURL=feature-definitions.d.ts.map

package/dist/server/server/agent/providers/claude/feature-definitions.js

@@ -0,0 +1,36 @@
+const CLAUDE_FAST_MODE_SUPPORTED_MODEL_PREFIXES = [
+    "claude-opus-4-8",
+    "claude-opus-4-7",
+    "claude-opus-4-6",
+];
+export const CLAUDE_FAST_MODE_FEATURE = {
+    type: "toggle",
+    id: "fast_mode",
+    label: "Fast",
+    description: "Lower latency Opus responses at higher token cost",
+    tooltip: "Toggle fast mode",
+    icon: "zap",
+};
+function normalizeClaudeModelId(modelId) {
+    const normalized = typeof modelId === "string" ? modelId.trim() : "";
+    return normalized.length > 0 ? normalized : null;
+}
+export function claudeModelSupportsFastMode(modelId) {
+    const normalizedModelId = normalizeClaudeModelId(modelId);
+    if (!normalizedModelId) {
+        return false;
+    }
+    return CLAUDE_FAST_MODE_SUPPORTED_MODEL_PREFIXES.some((prefix) => normalizedModelId === prefix || normalizedModelId.startsWith(`${prefix}[`));
+}
+export function buildClaudeFeatures(input) {
+    if (!claudeModelSupportsFastMode(input.modelId)) {
+        return [];
+    }
+    return [
+        {
+            ...CLAUDE_FAST_MODE_FEATURE,
+            value: input.fastModeEnabled,
+        },
+    ];
+}
+//# sourceMappingURL=feature-definitions.js.map

package/dist/server/server/agent/providers/tool-call-detail-primitives.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { extractCodexShellOutput, flattenReadContent as flattenToolReadContent, nonEmptyString, truncateDiffText, } from "./tool-call-mapper-utils.js";
+import { extractCodexShellOutput, flattenReadContent as flattenToolReadContent, nonEmptyString, stripReadLineNumberGutter, truncateDiffText, } from "./tool-call-mapper-utils.js";
 export const CommandValueSchema = z.union([z.string(), z.array(z.string())]);
 export const ToolShellInputSchema = z
     .union([
@@ -628,11 +628,14 @@ export function toReadToolDetail(input, output, options) {
     if (!filePath) {
         return undefined;
     }
+    const stripped = output?.content ? stripReadLineNumberGutter(output.content) : undefined;
+    const content = stripped?.content ?? output?.content;
+    const offset = input?.offset ?? stripped?.startLine;
     return {
         type: "read",
         filePath,
-        ...(output?.content ? { content: output.content } : {}),
-        ...(input?.offset !== undefined ? { offset: input.offset } : {}),
+        ...(content ? { content } : {}),
+        ...(offset !== undefined ? { offset } : {}),
         ...(input?.limit !== undefined ? { limit: input.limit } : {}),
     };
 }

package/dist/server/server/agent/providers/tool-call-mapper-utils.d.ts

@@ -9,6 +9,11 @@ export declare function nonEmptyString(value: unknown): string | undefined;
 export declare function extractCodexShellOutput(value: string | undefined): string | undefined;
 export declare function extractCodexTerminalSessionId(value: string | undefined): string | undefined;
 export declare function flattenReadContent<Chunk extends ReadChunkLike>(value: string | Chunk | Chunk[] | undefined): string | undefined;
+export interface StrippedReadContent {
+    content: string;
+    startLine?: number;
+}
+export declare function stripReadLineNumberGutter(content: string | undefined): StrippedReadContent | undefined;
 export declare function truncateDiffText(text: string | undefined, maxChars?: number): string | undefined;
 export declare function coerceToolCallId(params: {
     providerPrefix: string;

package/dist/server/server/agent/providers/tool-call-mapper-utils.js

@@ -112,6 +112,68 @@ export function flattenReadContent(value) {
     }
     return (nonEmptyString(value.text) ?? nonEmptyString(value.content) ?? nonEmptyString(value.output));
 }
+// Claude's Read tool returns `cat -n`-style content: each line prefixed with a
+// right-aligned line number and a tab (`␣␣␣1\timport ...`). Other providers
+// return raw source. We strip the gutter here so `read.content` is uniformly
+// raw source across providers, and surface the first line number as `offset`
+// so the client can rebuild the gutter itself. Guarded tightly (first line must
+// match, near-total match ratio, strictly sequential numbering) so real source
+// is never mistaken for a gutter.
+const READ_GUTTER_LINE = /^\s*(\d+)\t(.*)$/;
+export function stripReadLineNumberGutter(content) {
+    const text = nonEmptyString(content);
+    if (!text) {
+        return undefined;
+    }
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const stripped = [];
+    let nonEmpty = 0;
+    let matched = 0;
+    let startLine;
+    let prevNumber;
+    let sequential = true;
+    let firstNonEmptyMatched = false;
+    let sawNonEmpty = false;
+    for (const line of lines) {
+        if (line.length === 0) {
+            stripped.push(line);
+            continue;
+        }
+        nonEmpty += 1;
+        const match = line.match(READ_GUTTER_LINE);
+        if (!match) {
+            if (!sawNonEmpty) {
+                return undefined;
+            }
+            stripped.push(line);
+            sawNonEmpty = true;
+            continue;
+        }
+        if (!sawNonEmpty) {
+            firstNonEmptyMatched = true;
+        }
+        sawNonEmpty = true;
+        matched += 1;
+        const lineNumber = Number.parseInt(match[1], 10);
+        if (startLine === undefined) {
+            startLine = lineNumber;
+        }
+        if (prevNumber !== undefined && lineNumber !== prevNumber + 1) {
+            sequential = false;
+        }
+        prevNumber = lineNumber;
+        stripped.push(match[2]);
+    }
+    if (!firstNonEmptyMatched || !sequential || nonEmpty === 0) {
+        return undefined;
+    }
+    // Sequential numbering from the first line is already a strong signal; the
+    // ratio only rejects source that has a couple of coincidental matches.
+    if (matched / nonEmpty < 0.5) {
+        return undefined;
+    }
+    return { content: stripped.join("\n"), startLine };
+}
 export function truncateDiffText(text, maxChars = 12000) {
     if (typeof text !== "string") {
         return undefined;

package/dist/server/server/agent/structured-generation-providers.d.ts

@@ -0,0 +1,29 @@
+import type { AgentProvider } from "./agent-sdk-types.js";
+import type { StructuredGenerationProvider } from "./agent-response-loop.js";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
+export interface StructuredGenerationDaemonConfig {
+    metadataGeneration?: {
+        providers?: Array<{
+            provider: string;
+            model?: string;
+            thinkingOptionId?: string;
+        }>;
+    };
+}
+export interface StructuredGenerationProviderIdentifier {
+    modelSubstring: string;
+    thinkingOptionId?: string;
+}
+export declare const DEFAULT_STRUCTURED_GENERATION_PROVIDERS: readonly StructuredGenerationProviderIdentifier[];
+export interface ResolveStructuredGenerationProvidersOptions {
+    cwd: string;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "listProviders">;
+    daemonConfig?: StructuredGenerationDaemonConfig | null;
+    currentSelection?: {
+        provider?: AgentProvider | null;
+        model?: string | null;
+        thinkingOptionId?: string | null;
+    };
+}
+export declare function resolveStructuredGenerationProviders(options: ResolveStructuredGenerationProvidersOptions): Promise<StructuredGenerationProvider[]>;
+//# sourceMappingURL=structured-generation-providers.d.ts.map