@agentstorm/platform-protocol 0.2.5

package/dist/provider-manifest.js

@@ -0,0 +1,254 @@
+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",
+    },
+];
+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/schedule/cadence.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert an exact rolling interval to an equivalent five-field cron cadence.
+ * Returns null when cron's calendar boundaries would change the interval.
+ */
+export declare function everyMsToFiveFieldCron(everyMs: number): string | null;
+//# sourceMappingURL=cadence.d.ts.map

package/dist/schedule/cadence.js

@@ -0,0 +1,28 @@
+/**
+ * Convert an exact rolling interval to an equivalent five-field cron cadence.
+ * Returns null when cron's calendar boundaries would change the interval.
+ */
+export function everyMsToFiveFieldCron(everyMs) {
+    const minutes = everyMs / 60000;
+    if (!Number.isInteger(minutes) || minutes <= 0) {
+        return null;
+    }
+    if (minutes < 60 && 60 % minutes === 0) {
+        return `*/${minutes} * * * *`;
+    }
+    if (minutes === 60) {
+        return "0 * * * *";
+    }
+    if (minutes % 60 !== 0) {
+        return null;
+    }
+    const hours = minutes / 60;
+    if (hours < 24 && 24 % hours === 0) {
+        return `0 */${hours} * * *`;
+    }
+    if (hours === 24) {
+        return "0 0 * * *";
+    }
+    return null;
+}
+//# sourceMappingURL=cadence.js.map

package/dist/schedule/cron-expression.d.ts

@@ -0,0 +1,13 @@
+export interface CronFieldMatcher {
+    matches(value: number): boolean;
+}
+export interface ParsedCronExpression {
+    minute: CronFieldMatcher;
+    hour: CronFieldMatcher;
+    dayOfMonth: CronFieldMatcher;
+    month: CronFieldMatcher;
+    dayOfWeek: CronFieldMatcher;
+}
+export declare function parseCronExpression(expression: string): ParsedCronExpression;
+export declare function validateCronExpression(expression: string): string | null;
+//# sourceMappingURL=cron-expression.d.ts.map

package/dist/schedule/cron-expression.js

@@ -0,0 +1,97 @@
+const CRON_FIELD_BOUNDS = [
+    { min: 0, max: 59, name: "minute" },
+    { min: 0, max: 23, name: "hour" },
+    { min: 1, max: 31, name: "day-of-month" },
+    { min: 1, max: 12, name: "month" },
+    { min: 0, max: 6, name: "day-of-week" },
+];
+function createRange(start, end, step) {
+    const values = [];
+    for (let value = start; value <= end; value += step) {
+        values.push(value);
+    }
+    return values;
+}
+function parseStepPart(part, bounds) {
+    const stepParts = part.split("/");
+    if (stepParts.length > 2) {
+        throw new Error(`Invalid cron ${bounds.name} step`);
+    }
+    const [base, stepSource] = stepParts;
+    const normalizedStep = stepSource?.trim();
+    const step = normalizedStep === undefined ? 1 : Number.parseInt(normalizedStep, 10);
+    if (!Number.isInteger(step) ||
+        step <= 0 ||
+        (normalizedStep !== undefined && String(step) !== normalizedStep)) {
+        throw new Error(`Invalid cron ${bounds.name} step`);
+    }
+    return { base, step };
+}
+function parseField(source, bounds) {
+    const trimmed = source.trim();
+    if (!trimmed) {
+        throw new Error(`Invalid cron ${bounds.name} field`);
+    }
+    const allowed = new Set();
+    for (const rawPart of trimmed.split(",")) {
+        const part = rawPart.trim();
+        if (!part) {
+            throw new Error(`Invalid cron ${bounds.name} field`);
+        }
+        const { base, step } = parseStepPart(part, bounds);
+        if (base === "*") {
+            for (const value of createRange(bounds.min, bounds.max, step)) {
+                allowed.add(value);
+            }
+            continue;
+        }
+        const rangeMatch = base.match(/^(\d+)-(\d+)$/);
+        if (rangeMatch) {
+            const start = Number.parseInt(rangeMatch[1], 10);
+            const end = Number.parseInt(rangeMatch[2], 10);
+            if (start > end || start < bounds.min || end > bounds.max) {
+                throw new Error(`Invalid cron ${bounds.name} range`);
+            }
+            for (const value of createRange(start, end, step)) {
+                allowed.add(value);
+            }
+            continue;
+        }
+        if (!/^\d+$/.test(base)) {
+            throw new Error(`Invalid cron ${bounds.name} value`);
+        }
+        const value = Number.parseInt(base, 10);
+        if (!Number.isInteger(value) || value < bounds.min || value > bounds.max) {
+            throw new Error(`Invalid cron ${bounds.name} value`);
+        }
+        allowed.add(value);
+    }
+    return {
+        matches(value) {
+            return allowed.has(value);
+        },
+    };
+}
+export function parseCronExpression(expression) {
+    const parts = expression.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error("Cron expressions must have 5 fields");
+    }
+    return {
+        minute: parseField(parts[0], CRON_FIELD_BOUNDS[0]),
+        hour: parseField(parts[1], CRON_FIELD_BOUNDS[1]),
+        dayOfMonth: parseField(parts[2], CRON_FIELD_BOUNDS[2]),
+        month: parseField(parts[3], CRON_FIELD_BOUNDS[3]),
+        dayOfWeek: parseField(parts[4], CRON_FIELD_BOUNDS[4]),
+    };
+}
+export function validateCronExpression(expression) {
+    try {
+        parseCronExpression(expression);
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : "Invalid cron expression";
+    }
+}
+//# sourceMappingURL=cron-expression.js.map