@camerontaylor/paseo-protocol 0.8.0-fork.1

package/dist/provider-config.d.ts

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import type { AgentProvider } from "./agent-types.js";
+export declare const ProviderCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"default">;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"append">;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"replace">;
+    argv: z.ZodArray<z.ZodString>;
+}, z.core.$strip>], "mode">;
+export declare const ProviderRuntimeSettingsSchema: z.ZodObject<{
+    command: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"default">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"append">;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"replace">;
+        argv: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>], "mode">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ProviderPaseoToolsPolicySchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ProviderProfileModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    thinkingOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ProviderOverrideSchema: z.ZodObject<{
+    extends: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        thinkingOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            isDefault: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    additionalModels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        thinkingOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            isDefault: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    paseoTools: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ProviderOverridesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    extends: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        thinkingOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            isDefault: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    additionalModels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        thinkingOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            isDefault: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    paseoTools: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const AgentProviderRuntimeSettingsMapSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    command: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"default">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"append">;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"replace">;
+        argv: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>], "mode">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+export type ProviderCommand = z.infer<typeof ProviderCommandSchema>;
+export type ProviderRuntimeSettings = z.infer<typeof ProviderRuntimeSettingsSchema>;
+export type ProviderPaseoToolsPolicy = z.infer<typeof ProviderPaseoToolsPolicySchema>;
+export type ProviderProfileModel = z.infer<typeof ProviderProfileModelSchema>;
+export type ProviderOverride = z.infer<typeof ProviderOverrideSchema>;
+export type ProviderOverrides = z.infer<typeof ProviderOverridesSchema>;
+export type AgentProviderRuntimeSettingsMap = Partial<Record<AgentProvider, ProviderRuntimeSettings>>;
+//# sourceMappingURL=provider-config.d.ts.map

package/dist/provider-config.js

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import { AgentProviderSchema } from "./provider-manifest.js";
+const ProviderCommandDefaultSchema = z.object({
+    mode: z.literal("default"),
+});
+const ProviderCommandAppendSchema = z.object({
+    mode: z.literal("append"),
+    args: z.array(z.string()).optional(),
+});
+const ProviderCommandReplaceSchema = z.object({
+    mode: z.literal("replace"),
+    argv: z.array(z.string().min(1)).min(1),
+});
+export const ProviderCommandSchema = z.discriminatedUnion("mode", [
+    ProviderCommandDefaultSchema,
+    ProviderCommandAppendSchema,
+    ProviderCommandReplaceSchema,
+]);
+export const ProviderRuntimeSettingsSchema = z.object({
+    command: ProviderCommandSchema.optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    disallowedTools: z.array(z.string()).optional(),
+});
+export const ProviderPaseoToolsPolicySchema = z.object({
+    enabled: z.boolean().optional(),
+    disabledTools: z.array(z.string()).optional(),
+});
+const ProviderProfileThinkingOptionSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    isDefault: z.boolean().optional(),
+});
+export const ProviderProfileModelSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    description: z.string().optional(),
+    isDefault: z.boolean().optional(),
+    thinkingOptions: z.array(ProviderProfileThinkingOptionSchema).optional(),
+});
+export const ProviderOverrideSchema = z.object({
+    extends: z.string().optional(),
+    label: z.string().optional(),
+    description: z.string().optional(),
+    command: z.array(z.string().min(1)).min(1).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    params: z.record(z.string(), z.unknown()).optional(),
+    models: z.array(ProviderProfileModelSchema).optional(),
+    additionalModels: z.array(ProviderProfileModelSchema).optional(),
+    disallowedTools: z.array(z.string()).optional(),
+    paseoTools: ProviderPaseoToolsPolicySchema.optional(),
+    enabled: z.boolean().optional(),
+    order: z.number().optional(),
+});
+const BUILTIN_PROVIDER_IDS = ["claude", "codex", "copilot", "opencode", "pi", "omp"];
+const PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+export const ProviderOverridesSchema = z
+    .record(z.string(), ProviderOverrideSchema)
+    .superRefine((providers, ctx) => {
+    const builtinProviderIdSet = new Set(BUILTIN_PROVIDER_IDS);
+    const validExtendsValues = new Set([...BUILTIN_PROVIDER_IDS, "acp"]);
+    for (const [providerId, provider] of Object.entries(providers)) {
+        if (!PROVIDER_ID_PATTERN.test(providerId)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId],
+                message: `Provider ID "${providerId}" must match ${PROVIDER_ID_PATTERN}.`,
+            });
+        }
+        const isBuiltinProvider = builtinProviderIdSet.has(providerId);
+        if (!isBuiltinProvider && !provider.extends) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId, "extends"],
+                message: `Custom provider "${providerId}" must declare extends.`,
+            });
+        }
+        if (!isBuiltinProvider && !provider.label) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId, "label"],
+                message: `Custom provider "${providerId}" must declare label.`,
+            });
+        }
+        if (provider.extends && !validExtendsValues.has(provider.extends)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId, "extends"],
+                message: `Provider "${providerId}" extends unknown provider "${provider.extends}".`,
+            });
+        }
+        if (provider.extends === "acp" && !provider.command) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId, "command"],
+                message: `Provider "${providerId}" extending "acp" must declare command.`,
+            });
+        }
+    }
+});
+export const AgentProviderRuntimeSettingsMapSchema = z
+    .record(z.string(), ProviderRuntimeSettingsSchema)
+    .superRefine((providers, ctx) => {
+    for (const providerId of Object.keys(providers)) {
+        const parsedProviderId = AgentProviderSchema.safeParse(providerId);
+        if (!parsedProviderId.success) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId],
+                message: `Invalid agent provider "${providerId}".`,
+            });
+        }
+    }
+});
+//# sourceMappingURL=provider-config.js.map

package/dist/provider-icon-names.d.ts

@@ -0,0 +1,5 @@
+export declare const BUILTIN_PROVIDER_ICON_NAMES: string[];
+export declare const ACP_PROVIDER_ICON_NAMES: string[];
+export declare const TERMINAL_PROFILE_ICON_NAMES: string[];
+export declare const KNOWN_PROVIDER_ICON_NAMES: string[];
+//# sourceMappingURL=provider-icon-names.d.ts.map

package/dist/provider-icon-names.js

@@ -0,0 +1,54 @@
+export const BUILTIN_PROVIDER_ICON_NAMES = [
+    "claude",
+    "codex",
+    "copilot",
+    "kiro",
+    "minimax",
+    "omp",
+    "opencode",
+    "pi",
+];
+export const ACP_PROVIDER_ICON_NAMES = [
+    "agoragentic-acp",
+    "amp-acp",
+    "auggie",
+    "autohand",
+    "cline",
+    "codebuddy-code",
+    "codewhale",
+    "cortex-code",
+    "corust-agent",
+    "crow-cli",
+    "cursor",
+    "deepagents",
+    "dimcode",
+    "dirac",
+    "factory-droid",
+    "fast-agent",
+    "gemini",
+    "gjc",
+    "glm-acp-agent",
+    "goose",
+    "grok",
+    "junie",
+    "kilo",
+    "kimi",
+    "minimax-code",
+    "minion-code",
+    "mistral-vibe",
+    "nova",
+    "poolside",
+    "qoder",
+    "qwen-code",
+    "sigit",
+    "stakpak",
+    "traecli",
+    "vtcode",
+];
+export const TERMINAL_PROFILE_ICON_NAMES = ["agy"];
+export const KNOWN_PROVIDER_ICON_NAMES = [
+    ...BUILTIN_PROVIDER_ICON_NAMES,
+    ...ACP_PROVIDER_ICON_NAMES,
+    ...TERMINAL_PROFILE_ICON_NAMES,
+];
+//# sourceMappingURL=provider-icon-names.js.map

package/dist/provider-manifest.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { AgentMode } from "./agent-types.js";
+export type AgentModeColorTier = "safe" | "moderate" | "dangerous" | "planning" | `#${string}`;
+export type AgentModeIcon = string;
+export interface AgentModeVisuals {
+    icon: AgentModeIcon;
+    colorTier: AgentModeColorTier;
+}
+export type AgentProviderModeDefinition = Omit<AgentMode, "icon" | "colorTier"> & AgentModeVisuals & {
+    isUnattended?: boolean;
+};
+export interface AgentProviderDefinition {
+    id: string;
+    label: string;
+    description: string;
+    /** Builtin provider this definition extends, when it comes from a custom provider account. */
+    baseProviderId?: string;
+    enabledByDefault?: boolean;
+    defaultModeId: string | null;
+    modes: AgentProviderModeDefinition[];
+    voice?: {
+        enabled: boolean;
+        defaultModeId: string;
+        defaultModel?: string;
+    };
+}
+export declare const OMP_MODES: AgentProviderModeDefinition[];
+export declare const AGENT_PROVIDER_DEFINITIONS: AgentProviderDefinition[];
+export declare const DEV_AGENT_PROVIDER_DEFINITIONS: AgentProviderDefinition[];
+export declare function getAgentProviderDefinition(provider: string, definitions?: AgentProviderDefinition[]): AgentProviderDefinition;
+export declare const BUILTIN_PROVIDER_IDS: string[];
+export declare const AGENT_PROVIDER_IDS: string[];
+export declare const AgentProviderSchema: z.ZodString;
+export declare function isValidAgentProvider(value: string, validIds?: Iterable<string>): boolean;
+export declare function getUnattendedModeId(provider: string, definitions?: AgentProviderDefinition[]): string | undefined;
+export declare function getModeVisuals(provider: string, modeId: string, definitions: AgentProviderDefinition[]): AgentModeVisuals | undefined;
+//# sourceMappingURL=provider-manifest.d.ts.map

package/dist/provider-manifest.js

@@ -0,0 +1,261 @@
+import { z } from "zod";
+const CLAUDE_MODES = [
+    {
+        id: "plan",
+        label: "Plan Mode",
+        description: "Analyze the codebase without executing tools or edits",
+        icon: "ShieldEllipsis",
+        colorTier: "planning",
+    },
+    {
+        id: "default",
+        label: "Always Ask",
+        description: "Prompts for permission the first time a tool is used",
+        icon: "Shield",
+        colorTier: "safe",
+    },
+    {
+        id: "acceptEdits",
+        label: "Accept File Edits",
+        description: "Automatically approves edit-focused tools without prompting",
+        icon: "ShieldPlus",
+        colorTier: "moderate",
+    },
+    {
+        id: "auto",
+        label: "Auto mode",
+        description: "Uses a model classifier to review permission prompts automatically",
+        icon: "ShieldCheck",
+        colorTier: "moderate",
+    },
+    {
+        id: "bypassPermissions",
+        label: "Bypass",
+        description: "Skip all permission prompts (use with caution)",
+        icon: "ShieldOff",
+        colorTier: "dangerous",
+        isUnattended: true,
+    },
+];
+const CODEX_MODES = [
+    {
+        id: "auto",
+        label: "Default Permissions",
+        description: "Edit files and run commands with Codex's default approval flow.",
+        icon: "Shield",
+        colorTier: "moderate",
+    },
+    {
+        id: "auto-review",
+        label: "Auto-review",
+        description: "Same workspace-write permissions as Default, but eligible `on-request` approvals are routed through the auto-reviewer subagent.",
+        icon: "ShieldCheck",
+        colorTier: "moderate",
+    },
+    {
+        id: "full-access",
+        label: "Full Access",
+        description: "Edit files, run commands, and access the network without additional prompts.",
+        icon: "ShieldOff",
+        colorTier: "dangerous",
+        isUnattended: true,
+    },
+];
+const COPILOT_MODES = [
+    {
+        id: "https://agentclientprotocol.com/protocol/session-modes#agent",
+        label: "Agent",
+        description: "Default agent mode for conversational interactions",
+        icon: "Shield",
+        colorTier: "moderate",
+    },
+    {
+        id: "https://agentclientprotocol.com/protocol/session-modes#plan",
+        label: "Plan",
+        description: "Plan mode for creating and executing multi-step plans",
+        icon: "ShieldEllipsis",
+        colorTier: "planning",
+    },
+    {
+        id: "allow-all",
+        label: "Allow All",
+        description: "Automatically approves all Copilot tool, path, and URL requests.",
+        icon: "ShieldOff",
+        colorTier: "dangerous",
+        isUnattended: true,
+    },
+];
+const OPENCODE_MODES = [
+    {
+        id: "build",
+        label: "Build",
+        description: "Allows edits and tool execution for implementation work",
+        icon: "Shield",
+        colorTier: "moderate",
+    },
+    {
+        id: "plan",
+        label: "Plan",
+        description: "Read-only planning mode that avoids file edits",
+        icon: "ShieldEllipsis",
+        colorTier: "planning",
+    },
+];
+export const OMP_MODES = [
+    {
+        id: "full",
+        label: "Full Access",
+        description: "Launches OMP with yolo approval mode so tools run without prompts.",
+        icon: "ShieldOff",
+        colorTier: "dangerous",
+        isUnattended: true,
+    },
+    {
+        id: "write",
+        label: "Write Approval",
+        description: "Launches OMP with write approval mode — reads are free, writes require approval.",
+        icon: "ShieldAlert",
+        colorTier: "moderate",
+    },
+    {
+        id: "ask",
+        label: "Always Ask",
+        description: "Launches OMP with always-ask approval mode for write and exec tools.",
+        icon: "ShieldCheck",
+        colorTier: "safe",
+    },
+];
+const MOCK_LOAD_TEST_MODES = [
+    {
+        id: "load-test",
+        label: "Load Test",
+        description: "Streams repeated markdown, reasoning, and tool calls for app stress testing",
+        icon: "ShieldOff",
+        colorTier: "dangerous",
+    },
+    {
+        id: "approval-test",
+        label: "Approval Test",
+        description: "Alternate development-only permission mode for preference tests",
+        icon: "ShieldCheck",
+        colorTier: "safe",
+    },
+];
+const MOCK_SLOW_MODES = [
+    {
+        id: "default",
+        label: "Default",
+        description: "Dev-only mode for the mock slow provider",
+        icon: "ShieldOff",
+        colorTier: "dangerous",
+    },
+];
+export const AGENT_PROVIDER_DEFINITIONS = [
+    {
+        id: "claude",
+        label: "Claude",
+        description: "Anthropic's multi-tool assistant with MCP support, streaming, and deep reasoning",
+        defaultModeId: "auto",
+        modes: CLAUDE_MODES,
+        voice: {
+            enabled: true,
+            defaultModeId: "default",
+            defaultModel: "haiku",
+        },
+    },
+    {
+        id: "codex",
+        label: "Codex",
+        description: "OpenAI's Codex workspace agent with sandbox controls and optional network access",
+        defaultModeId: "auto-review",
+        modes: CODEX_MODES,
+        voice: {
+            enabled: true,
+            defaultModeId: "auto",
+            defaultModel: "gpt-5.4-mini",
+        },
+    },
+    {
+        id: "copilot",
+        label: "Copilot",
+        description: "GitHub Copilot via Agent Client Protocol with dynamic modes and session support",
+        defaultModeId: "https://agentclientprotocol.com/protocol/session-modes#agent",
+        modes: COPILOT_MODES,
+    },
+    {
+        id: "opencode",
+        label: "OpenCode",
+        description: "Open-source coding assistant with multi-provider model support",
+        // No static default: OpenCode users can rename or delete any agent,
+        // including "build". Leaving this unset means the daemon and OpenCode
+        // itself decide (see normalizeOpenCodeModeId in opencode-agent.ts).
+        defaultModeId: null,
+        modes: OPENCODE_MODES,
+        voice: {
+            enabled: true,
+            defaultModeId: "build",
+        },
+    },
+    {
+        id: "pi",
+        label: "Pi",
+        description: "Minimal terminal-based coding agent with multi-provider LLM support",
+        defaultModeId: null,
+        modes: [],
+    },
+    {
+        id: "omp",
+        label: "Oh My Pi",
+        description: "Multi-provider coding agent with native approvals, host tools, and subagents",
+        enabledByDefault: false,
+        defaultModeId: "full",
+        modes: OMP_MODES,
+    },
+];
+export const DEV_AGENT_PROVIDER_DEFINITIONS = [
+    {
+        id: "mock",
+        label: "Mock Load Test",
+        description: "Development-only provider that emits synthetic agent traffic for performance tests",
+        defaultModeId: "load-test",
+        modes: MOCK_LOAD_TEST_MODES,
+    },
+    {
+        id: "mock-slow",
+        label: "Mock Slow Provider",
+        description: "Dev-only: hangs during model discovery to test loading and timeout UI",
+        defaultModeId: "default",
+        modes: MOCK_SLOW_MODES,
+    },
+];
+export function getAgentProviderDefinition(provider, definitions = [
+    ...AGENT_PROVIDER_DEFINITIONS,
+    ...DEV_AGENT_PROVIDER_DEFINITIONS,
+]) {
+    const definition = definitions.find((entry) => entry.id === provider);
+    if (!definition) {
+        throw new Error(`Unknown agent provider: ${provider}`);
+    }
+    return definition;
+}
+export const BUILTIN_PROVIDER_IDS = AGENT_PROVIDER_DEFINITIONS.map((d) => d.id);
+export const AGENT_PROVIDER_IDS = BUILTIN_PROVIDER_IDS;
+export const AgentProviderSchema = z.string();
+export function isValidAgentProvider(value, validIds = BUILTIN_PROVIDER_IDS) {
+    return Array.isArray(validIds) ? validIds.includes(value) : new Set(validIds).has(value);
+}
+export function getUnattendedModeId(provider, definitions = [
+    ...AGENT_PROVIDER_DEFINITIONS,
+    ...DEV_AGENT_PROVIDER_DEFINITIONS,
+]) {
+    const definition = definitions.find((entry) => entry.id === provider);
+    return definition?.modes.find((mode) => mode.isUnattended)?.id;
+}
+export function getModeVisuals(provider, modeId, definitions) {
+    const definition = definitions.find((entry) => entry.id === provider);
+    const mode = definition?.modes.find((m) => m.id === modeId);
+    if (!mode)
+        return undefined;
+    return { icon: mode.icon, colorTier: mode.colorTier };
+}
+//# sourceMappingURL=provider-manifest.js.map

package/dist/provider-snapshot-codec.d.ts

@@ -0,0 +1,18 @@
+import type { AgentModelDefinition, AgentSelectOption, ProviderSnapshotEntry } from "./agent-types.js";
+export interface CompactProviderSnapshotModel extends Omit<AgentModelDefinition, "provider" | "thinkingOptions"> {
+    thinkingSet?: number;
+}
+export interface CompactProviderSnapshotEntry extends Omit<ProviderSnapshotEntry, "models"> {
+    models?: CompactProviderSnapshotModel[];
+}
+export interface ProviderSnapshotThinkingSet {
+    options: AgentSelectOption[];
+    defaultOptionId?: string;
+}
+export interface CompactProviderSnapshot {
+    entries: CompactProviderSnapshotEntry[];
+    thinkingSets: ProviderSnapshotThinkingSet[];
+}
+export declare function compactProviderSnapshot(entries: ProviderSnapshotEntry[]): CompactProviderSnapshot;
+export declare function expandProviderSnapshot(snapshot: CompactProviderSnapshot): ProviderSnapshotEntry[];
+//# sourceMappingURL=provider-snapshot-codec.d.ts.map