@selesai/code 0.9.10 → 0.9.12

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/model-resolver.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Model resolution, scoping, and initial selection
+ */
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import { type Api, type KnownProvider, type Model } from "@earendil-works/pi-ai";
+import type { ModelRuntime } from "./model-runtime.ts";
+/** Default model IDs for each known provider */
+export declare const defaultModelPerProvider: Record<KnownProvider, string>;
+export interface ScopedModel {
+    model: Model<Api>;
+    /** Thinking level if explicitly specified in pattern (e.g., "model:high"), undefined otherwise */
+    thinkingLevel?: ThinkingLevel;
+}
+/**
+ * Find an exact model reference match.
+ * Supports either a bare model id or a canonical provider/modelId reference.
+ * When matching by bare id, ambiguous matches across providers are rejected.
+ */
+export declare function findExactModelReferenceMatch(modelReference: string, availableModels: Model<Api>[]): Model<Api> | undefined;
+export interface ParsedModelResult {
+    model: Model<Api> | undefined;
+    /** Thinking level if explicitly specified in pattern, undefined otherwise */
+    thinkingLevel?: ThinkingLevel;
+    warning: string | undefined;
+}
+/**
+ * Parse a pattern to extract model and thinking level.
+ * Handles models with colons in their IDs (e.g., OpenRouter's :exacto suffix).
+ *
+ * Algorithm:
+ * 1. Try to match full pattern as a model
+ * 2. If found, return it with "off" thinking level
+ * 3. If not found and has colons, split on last colon:
+ *    - If suffix is valid thinking level, use it and recurse on prefix
+ *    - If suffix is invalid, warn and recurse on prefix with "off"
+ *
+ * @internal Exported for testing
+ */
+export declare function parseModelPattern(pattern: string, availableModels: Model<Api>[], options?: {
+    allowInvalidThinkingLevelFallback?: boolean;
+}): ParsedModelResult;
+/**
+ * Resolve model patterns to actual Model objects with optional thinking levels
+ * Format: "pattern:level" where :level is optional
+ * For each pattern, finds all matching models and picks the best version:
+ * 1. Prefer alias (e.g., claude-sonnet-4-5) over dated versions (claude-sonnet-4-5-20250929)
+ * 2. If no alias, pick the latest dated version
+ *
+ * Supports models with colons in their IDs (e.g., OpenRouter's model:exacto).
+ * The algorithm tries to match the full pattern first, then progressively
+ * strips colon-suffixes to find a match.
+ */
+export interface ModelScopeDiagnostic {
+    type: "warning";
+    message: string;
+    pattern: string;
+}
+export interface ResolveModelScopeResult {
+    scopedModels: ScopedModel[];
+    diagnostics: ModelScopeDiagnostic[];
+}
+export declare function resolveModelScopeWithDiagnostics(patterns: string[], modelRuntime: ModelRuntime): Promise<ResolveModelScopeResult>;
+export declare function resolveModelScope(patterns: string[], modelRuntime: ModelRuntime): Promise<ScopedModel[]>;
+export interface ResolveCliModelResult {
+    model: Model<Api> | undefined;
+    thinkingLevel?: ThinkingLevel;
+    warning: string | undefined;
+    /**
+     * Error message suitable for CLI display.
+     * When set, model will be undefined.
+     */
+    error: string | undefined;
+}
+/**
+ * Resolve a single model from CLI flags.
+ *
+ * Supports:
+ * - --provider <provider> --model <pattern>
+ * - --model <provider>/<pattern>
+ * - Fuzzy matching (same rules as model scoping: exact id, then partial id/name)
+ *
+ * Note: This does not apply the thinking level by itself, but it may *parse* and
+ * return a thinking level from "<pattern>:<thinking>" so the caller can apply it.
+ */
+export declare function resolveCliModel(options: {
+    cliProvider?: string;
+    cliModel?: string;
+    cliThinking?: ThinkingLevel;
+    modelRuntime: ModelRuntime;
+}): ResolveCliModelResult;
+export interface InitialModelResult {
+    model: Model<Api> | undefined;
+    thinkingLevel: ThinkingLevel;
+    fallbackMessage: string | undefined;
+}
+/**
+ * Find the initial model to use based on priority:
+ * 1. CLI args (provider + model)
+ * 2. First model from scoped models (if not continuing/resuming)
+ * 3. Restored from session (if continuing/resuming)
+ * 4. Saved default from settings
+ * 5. First available model with valid API key
+ */
+export declare function findInitialModel(options: {
+    cliProvider?: string;
+    cliModel?: string;
+    scopedModels: ScopedModel[];
+    isContinuing: boolean;
+    defaultProvider?: string;
+    defaultModelId?: string;
+    defaultThinkingLevel?: ThinkingLevel;
+    modelRuntime: ModelRuntime;
+}): Promise<InitialModelResult>;
+/**
+ * Restore model from session, with fallback to available models
+ */
+export declare function restoreModelFromSession(savedProvider: string, savedModelId: string, currentModel: Model<Api> | undefined, shouldPrintMessages: boolean, modelRuntime: ModelRuntime): Promise<{
+    model: Model<Api> | undefined;
+    fallbackMessage: string | undefined;
+}>;
+//# sourceMappingURL=model-resolver.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/model-runtime.d.ts

@@ -0,0 +1,82 @@
+import { type Api, type AssistantMessage, type AssistantMessageEventStream, type AuthCheck, type AuthInteraction, type AuthResult, type AuthType, type Context, type Credential, type CredentialInfo, type CredentialStore, type Model, type Models, type ModelsApiStreamOptions, type ModelsRefreshOptions, type ModelsRefreshResult, type ModelsSimpleStreamOptions, type ModelsStore, type Provider } from "@earendil-works/pi-ai";
+import { type AuthStatus, type CompatibilityRequestConfig, type ProviderConfigInput } from "./provider-composer.ts";
+export interface CreateModelRuntimeOptions {
+    /** Credential storage. Defaults to the file at authPath. */
+    credentials?: CredentialStore;
+    authPath?: string;
+    modelsPath?: string | null;
+    modelsStore?: ModelsStore;
+    modelsStorePath?: string;
+    /** Allow create() to refresh model catalogs over the network. Defaults to false. */
+    allowModelNetwork?: boolean;
+    /** Timeout for the create-time network model refresh. */
+    modelRefreshTimeoutMs?: number;
+    catalogBaseUrl?: string;
+}
+export interface ModelRuntimeAuthOverrides {
+    apiKey?: string;
+    env?: Record<string, string>;
+}
+/** Configured pi-ai Models collection used by coding-agent and SDK consumers. */
+export declare class ModelRuntime implements Models {
+    private readonly models;
+    private readonly credentials;
+    private readonly defaultBuiltins;
+    private readonly builtins;
+    private readonly nativeExtensionProviders;
+    private readonly extensionProviders;
+    private readonly compositionErrors;
+    private readonly modelsPath;
+    private readonly modelNetworkEnabled;
+    private config;
+    private snapshot;
+    private availabilityRefresh;
+    private availabilityError;
+    private constructor();
+    static create(options?: CreateModelRuntimeOptions): Promise<ModelRuntime>;
+    private configureRadiusProviders;
+    private providerIds;
+    private recomposeProvider;
+    private rebuildProviders;
+    private updateModelSnapshot;
+    private runAvailabilityRefresh;
+    private queueAvailabilityRefresh;
+    /** Coalesce concurrent readers onto the pending refresh. */
+    private refreshAvailability;
+    /** Mutations must not observe an in-flight refresh started before them. */
+    private forceRefreshAvailability;
+    getProviders(): readonly Provider[];
+    getProvider(providerId: string): Provider | undefined;
+    getModels(providerId?: string): readonly Model<Api>[];
+    getModel(providerId: string, modelId: string): Model<Api> | undefined;
+    checkAuth(providerId: string): Promise<AuthCheck | undefined>;
+    getAvailable(providerId?: string): Promise<readonly Model<Api>[]>;
+    getAvailableSnapshot(): readonly Model<Api>[];
+    getError(): string | undefined;
+    getRegisteredProviderConfig(providerId: string): ProviderConfigInput | undefined;
+    getRegisteredProviderIds(): readonly string[];
+    getRegisteredNativeProvider(providerId: string): Provider | undefined;
+    /** @internal Compatibility fallback for ModelRegistry when provider auth is unconfigured. */
+    getCompatibilityRequestConfig(model: Model<Api>): CompatibilityRequestConfig;
+    isUsingOAuth(providerId: string): boolean;
+    hasConfiguredAuth(providerId: string): boolean;
+    getAuth(providerId: string, overrides?: ModelRuntimeAuthOverrides): Promise<AuthResult | undefined>;
+    getAuth(model: Model<Api>, overrides?: ModelRuntimeAuthOverrides): Promise<AuthResult | undefined>;
+    setRuntimeApiKey(providerId: string, apiKey: string, refreshOptions?: ModelsRefreshOptions): Promise<void>;
+    removeRuntimeApiKey(providerId: string): Promise<void>;
+    listCredentials(): Promise<readonly CredentialInfo[]>;
+    getProviderAuthStatus(providerId: string): AuthStatus;
+    private prepareRequest;
+    stream<TApi extends Api>(model: Model<TApi>, context: Context, options?: ModelsApiStreamOptions<TApi>): AssistantMessageEventStream;
+    complete<TApi extends Api>(model: Model<TApi>, context: Context, options?: ModelsApiStreamOptions<TApi>): Promise<AssistantMessage>;
+    streamSimple(model: Model<Api>, context: Context, options?: ModelsSimpleStreamOptions): AssistantMessageEventStream;
+    completeSimple(model: Model<Api>, context: Context, options?: ModelsSimpleStreamOptions): Promise<AssistantMessage>;
+    login(providerId: string, type: AuthType, interaction: AuthInteraction): Promise<Credential>;
+    logout(providerId: string): Promise<void>;
+    reloadConfig(): Promise<void>;
+    refresh(options?: ModelsRefreshOptions): Promise<ModelsRefreshResult>;
+    registerNativeProvider(provider: Provider): void;
+    registerProvider(providerId: string, config: ProviderConfigInput): void;
+    unregisterProvider(providerId: string): void;
+}
+//# sourceMappingURL=model-runtime.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/models-store.d.ts

@@ -0,0 +1,17 @@
+import type { ModelsStore, ModelsStoreEntry } from "@earendil-works/pi-ai";
+export declare class InMemoryCodingAgentModelsStore implements ModelsStore {
+    private readonly entries;
+    read(providerId: string): Promise<ModelsStoreEntry | undefined>;
+    write(providerId: string, entry: ModelsStoreEntry): Promise<void>;
+    delete(providerId: string): Promise<void>;
+}
+/** Locked JSON-backed storage for dynamically refreshed provider catalogs. */
+export declare class FileModelsStore implements ModelsStore {
+    private readonly storage;
+    constructor(path?: string);
+    private parse;
+    read(providerId: string): Promise<ModelsStoreEntry | undefined>;
+    write(providerId: string, entry: ModelsStoreEntry): Promise<void>;
+    delete(providerId: string): Promise<void>;
+}
+//# sourceMappingURL=models-store.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/output-guard.d.ts

@@ -0,0 +1,7 @@
+export declare function takeOverStdout(): void;
+export declare function restoreStdout(): void;
+export declare function isStdoutTakenOver(): boolean;
+export declare function writeRawStdout(text: string): void;
+export declare function waitForRawStdoutBackpressure(): Promise<void>;
+export declare function flushRawStdout(): Promise<void>;
+//# sourceMappingURL=output-guard.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/package-manager.d.ts

@@ -0,0 +1,210 @@
+import type { SettingsManager } from "./settings-manager.ts";
+export interface PathMetadata {
+    source: string;
+    scope: SourceScope;
+    origin: "package" | "top-level";
+    baseDir?: string;
+}
+export interface ResolvedResource {
+    path: string;
+    enabled: boolean;
+    metadata: PathMetadata;
+}
+export interface ResolvedPaths {
+    extensions: ResolvedResource[];
+    skills: ResolvedResource[];
+    prompts: ResolvedResource[];
+    themes: ResolvedResource[];
+}
+export type MissingSourceAction = "install" | "skip" | "error";
+export interface ProgressEvent {
+    type: "start" | "progress" | "complete" | "error";
+    action: "install" | "remove" | "update" | "clone" | "pull";
+    source: string;
+    message?: string;
+}
+export type ProgressCallback = (event: ProgressEvent) => void;
+export interface PackageUpdate {
+    source: string;
+    displayName: string;
+    type: "npm" | "git";
+    scope: Exclude<SourceScope, "temporary">;
+}
+export interface ConfiguredPackage {
+    source: string;
+    scope: "user" | "project";
+    filtered: boolean;
+    installedPath?: string;
+}
+export interface PackageManager {
+    resolve(onMissing?: (source: string) => Promise<MissingSourceAction>): Promise<ResolvedPaths>;
+    install(source: string, options?: {
+        local?: boolean;
+    }): Promise<void>;
+    installAndPersist(source: string, options?: {
+        local?: boolean;
+    }): Promise<void>;
+    remove(source: string, options?: {
+        local?: boolean;
+    }): Promise<void>;
+    removeAndPersist(source: string, options?: {
+        local?: boolean;
+    }): Promise<boolean>;
+    update(source?: string): Promise<void>;
+    listConfiguredPackages(): ConfiguredPackage[];
+    resolveExtensionSources(sources: string[], options?: {
+        local?: boolean;
+        temporary?: boolean;
+    }): Promise<ResolvedPaths>;
+    addSourceToSettings(source: string, options?: {
+        local?: boolean;
+    }): boolean;
+    removeSourceFromSettings(source: string, options?: {
+        local?: boolean;
+    }): boolean;
+    setProgressCallback(callback: ProgressCallback | undefined): void;
+    getInstalledPath(source: string, scope: "user" | "project"): string | undefined;
+}
+interface PackageManagerOptions {
+    cwd: string;
+    agentDir: string;
+    settingsManager: SettingsManager;
+}
+type SourceScope = "user" | "project" | "temporary";
+export declare function getExtensionTempFolder(agentDir: string): string;
+export declare class DefaultPackageManager implements PackageManager {
+    private cwd;
+    private agentDir;
+    private settingsManager;
+    private globalNpmRoot;
+    private globalNpmRootCommandKey;
+    private progressCallback;
+    constructor(options: PackageManagerOptions);
+    setProgressCallback(callback: ProgressCallback | undefined): void;
+    addSourceToSettings(source: string, options?: {
+        local?: boolean;
+    }): boolean;
+    removeSourceFromSettings(source: string, options?: {
+        local?: boolean;
+    }): boolean;
+    getInstalledPath(source: string, scope: "user" | "project"): string | undefined;
+    private emitProgress;
+    private withProgress;
+    resolve(onMissing?: (source: string) => Promise<MissingSourceAction>): Promise<ResolvedPaths>;
+    resolveExtensionSources(sources: string[], options?: {
+        local?: boolean;
+        temporary?: boolean;
+    }): Promise<ResolvedPaths>;
+    listConfiguredPackages(): ConfiguredPackage[];
+    install(source: string, options?: {
+        local?: boolean;
+    }): Promise<void>;
+    installAndPersist(source: string, options?: {
+        local?: boolean;
+    }): Promise<void>;
+    remove(source: string, options?: {
+        local?: boolean;
+    }): Promise<void>;
+    removeAndPersist(source: string, options?: {
+        local?: boolean;
+    }): Promise<boolean>;
+    update(source?: string): Promise<void>;
+    private updateConfiguredSources;
+    private shouldUpdateNpmSource;
+    private updateNpmBatch;
+    private installNpmBatch;
+    checkForAvailableUpdates(): Promise<PackageUpdate[]>;
+    private resolvePackageSources;
+    private findAutoloadDeltaBase;
+    private resolveLocalExtensionSource;
+    private installParsedSource;
+    private getPackageSourceString;
+    private getSourceMatchKeyForInput;
+    private getSourceMatchKeyForSettings;
+    private buildNoMatchingPackageMessage;
+    private findSuggestedConfiguredSource;
+    private packageSourcesMatch;
+    private normalizePackageSourceForSettings;
+    private parseSource;
+    private installedNpmMatchesConfiguredVersion;
+    private npmHasAvailableUpdate;
+    private getInstalledNpmVersion;
+    private getLatestNpmVersion;
+    private gitHasAvailableUpdate;
+    private getRemoteGitHead;
+    private getLocalGitUpdateTarget;
+    private getGitUpstreamRef;
+    private runGitRemoteCommand;
+    private runWithConcurrency;
+    /**
+     * Get a unique identity for a package, ignoring version/ref.
+     * Used to detect when the same package is in both global and project settings.
+     * For git packages, uses normalized host/path to ensure SSH and HTTPS URLs
+     * for the same repository are treated as identical.
+     */
+    private getPackageIdentity;
+    /**
+     * Dedupe packages: if same package identity appears in both global and project,
+     * keep only the project one (project wins). A project entry with autoload=false
+     * is a delta over the global entry, so both are kept (delta first).
+     */
+    private dedupePackages;
+    private parseNpmSpec;
+    private assertProjectTrustedForScope;
+    private getNpmCommand;
+    private getPackageManagerName;
+    private runNpmCommand;
+    private getGitDependencyInstallArgs;
+    private runNpmCommandSync;
+    private getNpmInstallArgs;
+    private installNpm;
+    private uninstallNpm;
+    private installGit;
+    private updateGit;
+    private ensureGitRef;
+    private refreshTemporaryGitSource;
+    private removeGit;
+    private pruneEmptyGitParents;
+    private ensureNpmProject;
+    private ensureGitIgnore;
+    private getNpmInstallRoot;
+    private getGlobalNpmRoot;
+    private getPnpmGlobalPackagePath;
+    private getManagedNpmInstallPath;
+    private getLegacyGlobalNpmInstallPath;
+    private getNpmInstallPath;
+    private getGitInstallPath;
+    private getGitInstallRoot;
+    private getTemporaryDir;
+    private resolveManagedPath;
+    private getBaseDirForScope;
+    private resolvePath;
+    private resolvePathFromBase;
+    private collectPackageResources;
+    private collectDefaultResources;
+    private applyPackageFilter;
+    private applyPackageDeltaFilter;
+    /**
+     * Collect all files from a package for a resource type, applying manifest patterns.
+     * Returns { allFiles, enabledByManifest } where enabledByManifest is the set of files
+     * that pass the manifest's own patterns.
+     */
+    private collectManifestFiles;
+    private readPiManifest;
+    private addManifestEntries;
+    private collectFilesFromManifestEntries;
+    private resolveLocalEntries;
+    private addAutoDiscoveredResources;
+    private collectFilesFromPaths;
+    private getTargetMap;
+    private addResource;
+    private createAccumulator;
+    private toResolvedPaths;
+    private spawnCommand;
+    private spawnCaptureCommand;
+    private runCommandCapture;
+    private runCommand;
+    private runCommandSync;
+}
+export {};
+//# sourceMappingURL=package-manager.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/project-trust.d.ts

@@ -0,0 +1,15 @@
+import type { LoadExtensionsResult, ProjectTrustContext } from "./extensions/types.ts";
+import type { DefaultProjectTrust } from "./settings-manager.ts";
+import { type ProjectTrustStore } from "./trust-manager.ts";
+export type AppMode = "interactive" | "print" | "json" | "rpc";
+export interface ResolveProjectTrustedOptions {
+    cwd: string;
+    trustStore: ProjectTrustStore;
+    trustOverride?: boolean;
+    defaultProjectTrust?: DefaultProjectTrust;
+    extensionsResult?: LoadExtensionsResult;
+    projectTrustContext: ProjectTrustContext;
+    onExtensionError?: (message: string) => void;
+}
+export declare function resolveProjectTrusted(options: ResolveProjectTrustedOptions): Promise<boolean>;
+//# sourceMappingURL=project-trust.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/prompt-templates.d.ts

@@ -0,0 +1,54 @@
+import { type SourceInfo } from "./source-info.ts";
+/**
+ * Represents a prompt template loaded from a markdown file
+ */
+export interface PromptTemplate {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    content: string;
+    sourceInfo: SourceInfo;
+    filePath: string;
+}
+/**
+ * Parse command arguments respecting quoted strings (bash-style)
+ * Returns array of arguments
+ */
+export declare function parseCommandArgs(argsString: string): string[];
+/**
+ * Substitute argument placeholders in template content
+ * Supports:
+ * - $1, $2, ... for positional args
+ * - $@ and $ARGUMENTS for all args
+ * - ${N:-default} for positional arg N with default when missing/empty
+ * - ${@:-default} and ${ARGUMENTS:-default} for all args with a default when empty
+ * - ${@:N} for args from Nth onwards (bash-style slicing)
+ * - ${@:N:L} for L args starting from Nth
+ *
+ * Note: Replacement happens on the template string only. Argument and default values
+ * containing patterns like $1, $@, or $ARGUMENTS are NOT recursively substituted.
+ */
+export declare function substituteArgs(content: string, args: string[]): string;
+export interface LoadPromptTemplatesOptions {
+    /** Working directory for project-local templates. */
+    cwd: string;
+    /** Agent config directory for global templates. */
+    agentDir: string;
+    /** Explicit prompt template paths (files or directories). */
+    promptPaths: string[];
+    /** Include default prompt directories. */
+    includeDefaults: boolean;
+}
+/**
+ * Load all prompt templates from:
+ * 1. Global: agentDir/prompts/
+ * 2. Project: cwd/{CONFIG_DIR_NAME}/prompts/
+ * 3. Explicit prompt paths
+ */
+export declare function loadPromptTemplates(options: LoadPromptTemplatesOptions): PromptTemplate[];
+/**
+ * Expand a prompt template if it matches a template name.
+ * Returns the expanded content or the original text if not a template.
+ */
+export declare function expandPromptTemplate(text: string, templates: PromptTemplate[]): string;
+//# sourceMappingURL=prompt-templates.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/provider-attribution.d.ts

@@ -0,0 +1,4 @@
+import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
+import type { SettingsManager } from "./settings-manager.ts";
+export declare function mergeProviderAttributionHeaders(model: Model<Api>, settingsManager: SettingsManager, sessionId: string | undefined, ...headerSources: Array<ProviderHeaders | undefined>): ProviderHeaders | undefined;
+//# sourceMappingURL=provider-attribution.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/provider-composer.d.ts

@@ -0,0 +1,55 @@
+import { type Api, type AssistantMessageEventStream, type Context, type Model, type OAuthCredentials, type OAuthLoginCallbacks, type Provider, type ProviderHeaders, type RefreshModelsContext, type SimpleStreamOptions } from "@earendil-works/pi-ai";
+import type { ModelConfig, ModelsJsonProvider } from "./model-config.ts";
+import { clearConfigValueCache } from "./resolve-config-value.ts";
+export interface ExtensionOAuthConfig {
+    name: string;
+    /** @deprecated Retained for extension source compatibility; ignored by canonical auth flows. */
+    usesCallbackServer?: boolean;
+    login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
+    refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+    getApiKey(credentials: OAuthCredentials): string;
+    modifyModels?(models: Model<Api>[], credentials: OAuthCredentials): Model<Api>[];
+}
+/** Input type for the extension registerProvider API. */
+export interface ProviderConfigInput {
+    name?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    api?: Api;
+    streamSimple?: (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+    headers?: Record<string, string>;
+    authHeader?: boolean;
+    oauth?: ExtensionOAuthConfig;
+    models?: Array<{
+        id: string;
+        name: string;
+        api?: Api;
+        baseUrl?: string;
+        reasoning: boolean;
+        thinkingLevelMap?: Model<Api>["thinkingLevelMap"];
+        input: ("text" | "image")[];
+        cost: Model<Api>["cost"];
+        contextWindow: number;
+        maxTokens: number;
+        headers?: Record<string, string>;
+        compat?: Model<Api>["compat"];
+    }>;
+    refreshModels?(context: RefreshModelsContext): Promise<NonNullable<ProviderConfigInput["models"]>>;
+}
+export type AuthStatus = {
+    configured: boolean;
+    source?: "stored" | "runtime" | "environment" | "fallback" | "models_json_key" | "models_json_command";
+    label?: string;
+};
+export declare const clearApiKeyCache: typeof clearConfigValueCache;
+export declare function validateExtensionProvider(providerId: string, base: Provider | undefined, modelsConfig: ModelsJsonProvider | undefined, extension: ProviderConfigInput): void;
+/** Compose built-in, models.json, and extension layers without reading credentials. */
+export declare function composeModelProvider(providerId: string, base: Provider | undefined, modelConfig: ModelConfig, extension: ProviderConfigInput | undefined): Provider;
+export declare function resolveConfiguredModelHeaders(model: Model<Api>, config: ModelsJsonProvider | undefined, extension: ProviderConfigInput | undefined, env?: Record<string, string>): Record<string, string> | undefined;
+export interface CompatibilityRequestConfig {
+    headers?: ProviderHeaders;
+    authHeader: boolean;
+}
+export declare function resolveCompatibilityRequestConfig(model: Model<Api>, config: ModelsJsonProvider | undefined, extension: ProviderConfigInput | undefined): CompatibilityRequestConfig;
+export declare function configuredRequestAuthStatus(config: ModelsJsonProvider | undefined, extension: ProviderConfigInput | undefined): AuthStatus | undefined;
+//# sourceMappingURL=provider-composer.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/radius.d.ts

@@ -0,0 +1,2 @@
+export declare const RADIUS_PROVIDER_ID = "radius";
+//# sourceMappingURL=radius.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/remote-catalog-provider.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from "@earendil-works/pi-ai";
+export declare const REMOTE_CATALOG_REFRESH_INTERVAL_MS: number;
+/** Add a persisted pi.dev catalog overlay to a static built-in provider. */
+export declare function withRemoteCatalog(provider: Provider, catalogBaseUrl?: string, localCatalogUrl?: URL): Provider;
+//# sourceMappingURL=remote-catalog-provider.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/core/resolve-config-value.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Resolve configuration values that may be shell commands, environment variables, or literals.
+ * Used by auth-storage.ts and model-registry.ts.
+ */
+export declare function getConfigValueEnvVarName(config: string): string | undefined;
+export declare function getConfigValueEnvVarNames(config: string): string[];
+export declare function getMissingConfigValueEnvVarNames(config: string, env?: Record<string, string>): string[];
+export declare function isCommandConfigValue(config: string): boolean;
+export declare function isConfigValueConfigured(config: string, env?: Record<string, string>): boolean;
+/**
+ * Resolve a config value (API key, header value, etc.) to an actual value.
+ * - If starts with "!", executes the rest as a shell command and uses stdout (cached)
+ * - Interpolates "$ENV_VAR" or "${ENV_VAR}" references with the named environment variable
+ * - In non-command values, "$$" escapes a literal "$" and "$!" escapes a literal "!"
+ * - Otherwise treats the value as a literal
+ */
+export declare function resolveConfigValue(config: string, env?: Record<string, string>): string | undefined;
+/**
+ * Resolve all header values using the same resolution logic as API keys.
+ */
+export declare function resolveConfigValueUncached(config: string, env?: Record<string, string>): string | undefined;
+export declare function resolveConfigValueOrThrow(config: string, description: string, env?: Record<string, string>): string;
+/**
+ * Resolve all header values using the same resolution logic as API keys.
+ */
+export declare function resolveHeaders(headers: Record<string, string> | undefined, env?: Record<string, string>): Record<string, string> | undefined;
+export declare function resolveHeadersOrThrow(headers: Record<string, string> | undefined, description: string, env?: Record<string, string>): Record<string, string> | undefined;
+/** Clear the config value command cache. Exported for testing. */
+export declare function clearConfigValueCache(): void;
+//# sourceMappingURL=resolve-config-value.d.ts.map