@coool/opencode-adaptive 0.0.0-stage → 1.0.1

package/dist/health/resource-health/types.js

@@ -0,0 +1,44 @@
+/**
+ * Resource health types (ADP-007, ADP-012, ADP-021).
+ *
+ * A resource is identified at the narrowest scope the evidence supports:
+ * provider → account → model → variant. Health states are a closed set and
+ * every transition between them is defined by the pure transition layer; the
+ * registry never invents states. The circuit breaker (ADP-019) is an
+ * orthogonal axis stored per resource record.
+ */
+import { DEFAULT_BREAKER_CONFIG, } from "../circuit-breaker/types.js";
+export const RESOURCE_SCOPES = [
+    "provider",
+    "account",
+    "model",
+    "variant",
+];
+export const HEALTH_STATES = [
+    "healthy",
+    "draining",
+    "degraded",
+    "rate_limited",
+    "quota_exhausted",
+    "unavailable",
+];
+export const DEFAULT_HEALTH_CONFIG = {
+    breaker: DEFAULT_BREAKER_CONFIG,
+    defaultRateLimitWindowMs: 30_000,
+    defaultQuotaWindowMs: 15 * 60_000,
+};
+/**
+ * Why an assessment blocks new work. Ordered from hardest to softest fact:
+ * hard resource states (unavailable, quota, rate limit) are direct evidence;
+ * breaker reasons are inferred from failure counts; draining is a policy
+ * request, not a health fact.
+ */
+export const BLOCKED_REASONS = [
+    "unavailable",
+    "quota-exhausted",
+    "rate-limited",
+    "breaker-open",
+    "probe-in-flight",
+    "draining",
+];
+//# sourceMappingURL=types.js.map

package/dist/health/resource-health/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/health/resource-health/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,sBAAsB,GAGvB,MAAM,6BAA6B,CAAA;AAGpC,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,UAAU;IACV,SAAS;IACT,OAAO;IACP,SAAS;CAC2B,CAAA;AAiBtC,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,SAAS;IACT,UAAU;IACV,UAAU;IACV,cAAc;IACd,iBAAiB;IACjB,aAAa;CACuB,CAAA;AA6DtC,MAAM,CAAC,MAAM,qBAAqB,GAAyB;IACzD,OAAO,EAAE,sBAAsB;IAC/B,wBAAwB,EAAE,MAAM;IAChC,oBAAoB,EAAE,EAAE,GAAG,MAAM;CAClC,CAAA;AAKD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,aAAa;IACb,iBAAiB;IACjB,cAAc;IACd,cAAc;IACd,iBAAiB;IACjB,UAAU;CAC0B,CAAA","sourcesContent":["/**\n * Resource health types (ADP-007, ADP-012, ADP-021).\n *\n * A resource is identified at the narrowest scope the evidence supports:\n * provider → account → model → variant. Health states are a closed set and\n * every transition between them is defined by the pure transition layer; the\n * registry never invents states. The circuit breaker (ADP-019) is an\n * orthogonal axis stored per resource record.\n */\nimport {\n  DEFAULT_BREAKER_CONFIG,\n  type BreakerConfig,\n  type BreakerRecord,\n} from \"../circuit-breaker/types.js\"\nimport type { FailureCategory } from \"../classifier/types.js\"\n\nexport const RESOURCE_SCOPES = [\n  \"provider\",\n  \"account\",\n  \"model\",\n  \"variant\",\n] as const satisfies readonly string[]\n\nexport type ResourceScope = (typeof RESOURCE_SCOPES)[number]\n\n/**\n * Hierarchical resource identity. The scope is derived from the most specific\n * field present, so callers attribute evidence at exactly the level they can\n * prove (e.g. a provider-wide outage without a model id stays at provider\n * scope; a per-variant failure quarantines only that variant).\n */\nexport interface ResourceKey {\n  readonly providerID: string\n  readonly accountID?: string | undefined\n  readonly modelID?: string | undefined\n  readonly variantID?: string | undefined\n}\n\nexport const HEALTH_STATES = [\n  \"healthy\",\n  \"draining\",\n  \"degraded\",\n  \"rate_limited\",\n  \"quota_exhausted\",\n  \"unavailable\",\n] as const satisfies readonly string[]\n\nexport type HealthState = (typeof HEALTH_STATES)[number]\n\n/**\n * A time-bounded window during which the current state is known to hold\n * (e.g. until a Retry-After delay or a quota reset elapses). Absent when no\n * reset time is known — recovery then relies on probes, observed successes,\n * or explicit resets.\n */\nexport interface ResourceWindow {\n  readonly kind: \"rate-limit\" | \"quota\"\n  readonly until: number\n}\n\nexport interface ResourceRecord {\n  readonly key: ResourceKey\n  readonly health: HealthState\n  readonly breaker: BreakerRecord\n  readonly window?: ResourceWindow | undefined\n  readonly updatedAt: number\n}\n\n/**\n * Health evidence events. `failure` carries an already-classified category\n * (from the error classifier, ADP-009) plus the classification's\n * definitiveness and parsed retry delay. `capacity` carries a CapacitySensor\n * reading (ADP-020) — `exhausted: false` is positive evidence of capacity.\n * `reset` is the manual Control-mode recovery op.\n */\nexport type HealthEvent =\n  | {\n      readonly kind: \"failure\"\n      readonly key: ResourceKey\n      readonly category: FailureCategory\n      readonly definitive: boolean\n      readonly retryAfterMs?: number | undefined\n    }\n  | { readonly kind: \"success\"; readonly key: ResourceKey }\n  | { readonly kind: \"drain\"; readonly key: ResourceKey }\n  | {\n      readonly kind: \"capacity\"\n      readonly key: ResourceKey\n      readonly exhausted: boolean\n      readonly retryAfterMs?: number | undefined\n    }\n  | { readonly kind: \"reset\"; readonly key: ResourceKey }\n\nexport interface ResourceHealthConfig {\n  readonly breaker: BreakerConfig\n  /** Window applied to rate-limited evidence that carries no Retry-After. */\n  readonly defaultRateLimitWindowMs: number\n  /**\n   * Window applied to quota exhaustion that carries no reset delay. Without\n   * one the state would be permanent (it is persisted and rehydrated), so an\n   * unknown reset re-admits the resource after this window and lets fresh\n   * evidence re-mark it (ADP-012).\n   */\n  readonly defaultQuotaWindowMs: number\n}\n\nexport const DEFAULT_HEALTH_CONFIG: ResourceHealthConfig = {\n  breaker: DEFAULT_BREAKER_CONFIG,\n  defaultRateLimitWindowMs: 30_000,\n  defaultQuotaWindowMs: 15 * 60_000,\n}\n\n/** Injected monotonic clock, milliseconds. */\nexport type Clock = () => number\n\n/**\n * Why an assessment blocks new work. Ordered from hardest to softest fact:\n * hard resource states (unavailable, quota, rate limit) are direct evidence;\n * breaker reasons are inferred from failure counts; draining is a policy\n * request, not a health fact.\n */\nexport const BLOCKED_REASONS = [\n  \"unavailable\",\n  \"quota-exhausted\",\n  \"rate-limited\",\n  \"breaker-open\",\n  \"probe-in-flight\",\n  \"draining\",\n] as const satisfies readonly string[]\n\nexport type BlockedReason = (typeof BLOCKED_REASONS)[number]\n\n/** Opaque single-probe admission token; validated on report. */\nexport interface ProbeTicket {\n  readonly id: string\n  readonly key: ResourceKey\n}\n\nexport type ProbeOutcome =\n  { readonly success: true } | { readonly success: false; readonly category: FailureCategory }\n\n/**\n * Result of assessing whether a resource may take new work right now. The\n * `blocked` variant reports the winning blocker's key (which may be a wider\n * scope than the assessed key) and, when known, when the block can lift.\n */\nexport type Assessment =\n  | { readonly kind: \"available\" }\n  | { readonly kind: \"probe\"; readonly ticket: ProbeTicket }\n  | {\n      readonly kind: \"blocked\"\n      readonly reason: BlockedReason\n      readonly key: ResourceKey\n      readonly retryAtMs?: number\n    }\n"]}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "@opencode/plugin";
+export { PLUGIN_ID } from "./plugin-id.js";
+/**
+ * Entry point wired into OpenCode via `opencode.json(c)`. Setup glues the
+ * adapter touchpoints (session hooks, event subscription, storage) to the
+ * supervisor and returns a cleanup that disposes every registration.
+ * All supervision errors are fail-open (ADP-031): the supervisor's public
+ * entry points never throw; the event pump's stream errors are logged.
+ */
+declare const _default: Plugin.Plugin;
+export default _default;

package/dist/index.js

@@ -0,0 +1,105 @@
+import { Plugin } from "@opencode/plugin";
+import { isCodexHeaderName } from "./adapters/codex-capacity/index.js";
+import { escalationTool, registerSessionHooks, subscribeSessions, tierTool, } from "./adapters/opencode/index.js";
+import { PLUGIN_ID } from "./plugin-id.js";
+import { adaptiveRpc } from "./rpc/definition.js";
+import { adaptiveRpcHandlers } from "./rpc/handlers.js";
+import { Supervisor, logFailOpen } from "./supervisor/index.js";
+export { PLUGIN_ID } from "./plugin-id.js";
+/**
+ * Entry point wired into OpenCode via `opencode.json(c)`. Setup glues the
+ * adapter touchpoints (session hooks, event subscription, storage) to the
+ * supervisor and returns a cleanup that disposes every registration.
+ * All supervision errors are fail-open (ADP-031): the supervisor's public
+ * entry points never throw; the event pump's stream errors are logged.
+ */
+export default Plugin.define({
+    id: PLUGIN_ID,
+    async setup(context) {
+        const supervisor = new Supervisor({
+            session: context.session,
+            model: context.model,
+            storage: context.storage,
+            clock: () => Date.now(),
+        });
+        const hooks = await registerSessionHooks(context.session, {
+            onRetry: async (input) => {
+                await supervisor.handleRetry(input);
+            },
+            onModelRequest: async (report) => {
+                await supervisor.handleReport(report);
+            },
+            onHttpResponse: async (report) => {
+                await supervisor.handleReport(report);
+            },
+            onIdle: async (report) => {
+                await supervisor.handleReport(report);
+            },
+            onPrompt: async (report) => {
+                await supervisor.handleReport(report);
+            },
+        }, { capture: isCodexHeaderName });
+        const subscription = subscribeSessions(context.event, (report) => {
+            void supervisor.handleReport(report);
+        }, (error) => {
+            logFailOpen("events", error);
+        });
+        // Every disposal settles independently: a failing dispose is logged, never
+        // allowed to mask the other disposals or (during rollback) the original
+        // setup error. Disposals are awaited so a late rejection cannot land after
+        // the host considers the plugin gone.
+        const disposals = [];
+        const settled = async (name, dispose) => {
+            try {
+                await dispose();
+            }
+            catch (error) {
+                logFailOpen(name, error);
+            }
+        };
+        const settledAll = async () => {
+            for (const { name, dispose } of disposals) {
+                await settled(name, dispose);
+            }
+        };
+        for (const [index, hookRegistration] of hooks.entries()) {
+            disposals.push({ name: `hook ${String(index)}`, dispose: () => hookRegistration.dispose() });
+        }
+        disposals.push({
+            name: "events",
+            dispose: () => {
+                subscription.dispose();
+            },
+        });
+        // The typed escalation tool (T-18, ADP-015): the agent's self-report
+        // surface for stronger capability, applied at the next safe boundary.
+        // The tier tool (ADP-055): the agent declares the task's tier; the
+        // declaration steers the session's next admissions until cleared.
+        // Typed RPC (ADP-034/036): the only channel to the control surfaces.
+        // The settings-changed emitter resolves the registration lazily: handlers
+        // only run after `register` resolves, so the holder is always populated.
+        const rpcHolder = {};
+        const emit = (...args) => 
+        // The correlated tuple pairing is checked by the handler types; the
+        // registration forwards it to the host emitter untouched.
+        rpcHolder.registration?.events.emit(...args);
+        try {
+            const toolRegistration = await context.tool.transform((editor) => {
+                editor.add(escalationTool((sessionID, reason, evidence) => supervisor.noteEscalationRequest(sessionID, reason, evidence)));
+                editor.add(tierTool((sessionID, tier) => supervisor.noteTierRequest(sessionID, tier)));
+            });
+            disposals.push({ name: "tools", dispose: () => toolRegistration.dispose() });
+            const rpcRegistration = await context.rpc.register(adaptiveRpc, adaptiveRpcHandlers(supervisor, emit));
+            rpcHolder.registration = rpcRegistration;
+            disposals.push({ name: "rpc", dispose: () => rpcRegistration.dispose() });
+        }
+        catch (error) {
+            // Roll back everything already registered so a failure at the tool or
+            // rpc stage does not leak live hooks and the event pump.
+            await settledAll();
+            throw error;
+        }
+        return () => settledAll();
+    },
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { Plugin } from \"@opencode/plugin\"\nimport { isCodexHeaderName } from \"./adapters/codex-capacity/index.js\"\nimport {\n  escalationTool,\n  registerSessionHooks,\n  subscribeSessions,\n  tierTool,\n} from \"./adapters/opencode/index.js\"\nimport { PLUGIN_ID } from \"./plugin-id.js\"\nimport { adaptiveRpc } from \"./rpc/definition.js\"\nimport { adaptiveRpcHandlers } from \"./rpc/handlers.js\"\nimport type { RpcRegistration } from \"@opencode/plugin/promise/rpc\"\nimport type { AdaptiveRpcEmit } from \"./rpc/handlers.js\"\nimport { Supervisor, logFailOpen } from \"./supervisor/index.js\"\n\nexport { PLUGIN_ID } from \"./plugin-id.js\"\n\n/**\n * Entry point wired into OpenCode via `opencode.json(c)`. Setup glues the\n * adapter touchpoints (session hooks, event subscription, storage) to the\n * supervisor and returns a cleanup that disposes every registration.\n * All supervision errors are fail-open (ADP-031): the supervisor's public\n * entry points never throw; the event pump's stream errors are logged.\n */\nexport default Plugin.define({\n  id: PLUGIN_ID,\n  async setup(context) {\n    const supervisor = new Supervisor({\n      session: context.session,\n      model: context.model,\n      storage: context.storage,\n      clock: () => Date.now(),\n    })\n    const hooks = await registerSessionHooks(\n      context.session,\n      {\n        onRetry: async (input) => {\n          await supervisor.handleRetry(input)\n        },\n        onModelRequest: async (report) => {\n          await supervisor.handleReport(report)\n        },\n        onHttpResponse: async (report) => {\n          await supervisor.handleReport(report)\n        },\n        onIdle: async (report) => {\n          await supervisor.handleReport(report)\n        },\n        onPrompt: async (report) => {\n          await supervisor.handleReport(report)\n        },\n      },\n      { capture: isCodexHeaderName },\n    )\n    const subscription = subscribeSessions(\n      context.event,\n      (report) => {\n        void supervisor.handleReport(report)\n      },\n      (error) => {\n        logFailOpen(\"events\", error)\n      },\n    )\n    // Every disposal settles independently: a failing dispose is logged, never\n    // allowed to mask the other disposals or (during rollback) the original\n    // setup error. Disposals are awaited so a late rejection cannot land after\n    // the host considers the plugin gone.\n    const disposals: { name: string; dispose: () => void | Promise<void> }[] = []\n    const settled = async (name: string, dispose: () => void | Promise<void>): Promise<void> => {\n      try {\n        await dispose()\n      } catch (error) {\n        logFailOpen(name, error)\n      }\n    }\n    const settledAll = async (): Promise<void> => {\n      for (const { name, dispose } of disposals) {\n        await settled(name, dispose)\n      }\n    }\n    for (const [index, hookRegistration] of hooks.entries()) {\n      disposals.push({ name: `hook ${String(index)}`, dispose: () => hookRegistration.dispose() })\n    }\n    disposals.push({\n      name: \"events\",\n      dispose: () => {\n        subscription.dispose()\n      },\n    })\n    // The typed escalation tool (T-18, ADP-015): the agent's self-report\n    // surface for stronger capability, applied at the next safe boundary.\n    // The tier tool (ADP-055): the agent declares the task's tier; the\n    // declaration steers the session's next admissions until cleared.\n    // Typed RPC (ADP-034/036): the only channel to the control surfaces.\n    // The settings-changed emitter resolves the registration lazily: handlers\n    // only run after `register` resolves, so the holder is always populated.\n    const rpcHolder: { registration?: RpcRegistration<typeof adaptiveRpc> } = {}\n    const emit: AdaptiveRpcEmit = (...args) =>\n      // The correlated tuple pairing is checked by the handler types; the\n      // registration forwards it to the host emitter untouched.\n      rpcHolder.registration?.events.emit(...args)\n    try {\n      const toolRegistration = await context.tool.transform((editor) => {\n        editor.add(\n          escalationTool((sessionID, reason, evidence) =>\n            supervisor.noteEscalationRequest(sessionID, reason, evidence),\n          ),\n        )\n        editor.add(tierTool((sessionID, tier) => supervisor.noteTierRequest(sessionID, tier)))\n      })\n      disposals.push({ name: \"tools\", dispose: () => toolRegistration.dispose() })\n      const rpcRegistration = await context.rpc.register(\n        adaptiveRpc,\n        adaptiveRpcHandlers(supervisor, emit),\n      )\n      rpcHolder.registration = rpcRegistration\n      disposals.push({ name: \"rpc\", dispose: () => rpcRegistration.dispose() })\n    } catch (error) {\n      // Roll back everything already registered so a failure at the tool or\n      // rpc stage does not leak live hooks and the event pump.\n      await settledAll()\n      throw error\n    }\n    return () => settledAll()\n  },\n})\n"]}

package/dist/plugin-id.d.ts

@@ -0,0 +1,2 @@
+/** The plugin identity shared by the server, TUI, and GUI entries. */
+export declare const PLUGIN_ID = "coool.adaptive";

package/dist/plugin-id.js

@@ -0,0 +1,3 @@
+/** The plugin identity shared by the server, TUI, and GUI entries. */
+export const PLUGIN_ID = "coool.adaptive";
+//# sourceMappingURL=plugin-id.js.map

package/dist/plugin-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-id.js","sourceRoot":"","sources":["../src/plugin-id.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,MAAM,CAAC,MAAM,SAAS,GAAG,gBAAgB,CAAA","sourcesContent":["/** The plugin identity shared by the server, TUI, and GUI entries. */\nexport const PLUGIN_ID = \"coool.adaptive\"\n"]}

package/dist/rpc/definition.d.ts

@@ -0,0 +1,123 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { OperatingMode } from "../core/scheduler/types.js";
+import type { SettingsPatch, SettingsV1 } from "../state/settings/index.js";
+import type { PatchResult } from "../state/settings/types.js";
+import type { SessionModeSetResult } from "../state/session-modes/index.js";
+import type { TierRequestSetResult } from "./handlers.js";
+import type { TierName } from "../core/tier-policy/types.js";
+import type { Receipt } from "../state/receipts/types.js";
+import type { StatusSnapshot } from "./status.js";
+export declare const ADAPTIVE_RPC_ID = "coool.adaptive";
+export declare const adaptiveRpc: {
+    readonly id: "coool.adaptive";
+    readonly methods: {
+        readonly "settings.get": {
+            readonly errors: {
+                internal: StandardSchemaV1<undefined, undefined>;
+            };
+            readonly input: StandardSchemaV1<undefined, undefined>;
+            readonly output: StandardSchemaV1<SettingsV1, SettingsV1>;
+        };
+        readonly "settings.set": {
+            readonly errors: {
+                internal: StandardSchemaV1<undefined, undefined>;
+            };
+            readonly input: StandardSchemaV1<SettingsPatch, SettingsPatch>;
+            readonly output: StandardSchemaV1<PatchResult, PatchResult>;
+        };
+        readonly "status.get": {
+            readonly errors: {
+                internal: StandardSchemaV1<undefined, undefined>;
+            };
+            readonly input: StandardSchemaV1<undefined, undefined>;
+            readonly output: StandardSchemaV1<StatusSnapshot, StatusSnapshot>;
+        };
+        readonly "receipts.list": {
+            readonly errors: {
+                internal: StandardSchemaV1<undefined, undefined>;
+            };
+            readonly input: StandardSchemaV1<undefined, undefined>;
+            readonly output: StandardSchemaV1<Receipt[], Receipt[]>;
+        };
+        readonly "session-mode.get": {
+            readonly errors: {
+                internal: StandardSchemaV1<undefined, undefined>;
+            };
+            readonly input: StandardSchemaV1<{
+                sessionID: string;
+            }, {
+                sessionID: string;
+            }>;
+            readonly output: StandardSchemaV1<{
+                mode: OperatingMode | null;
+            }, {
+                mode: OperatingMode | null;
+            }>;
+        };
+        readonly "session-mode.set": {
+            readonly errors: {
+                internal: StandardSchemaV1<undefined, undefined>;
+            };
+            readonly input: StandardSchemaV1<{
+                sessionID: string;
+                mode: OperatingMode | null;
+            }, {
+                sessionID: string;
+                mode: OperatingMode | null;
+            }>;
+            readonly output: StandardSchemaV1<SessionModeSetResult, SessionModeSetResult>;
+        };
+        readonly "tier-request.get": {
+            readonly errors: {
+                internal: StandardSchemaV1<undefined, undefined>;
+            };
+            readonly input: StandardSchemaV1<{
+                sessionID: string;
+            }, {
+                sessionID: string;
+            }>;
+            readonly output: StandardSchemaV1<{
+                tier: TierName | null;
+            }, {
+                tier: TierName | null;
+            }>;
+        };
+        readonly "tier-request.set": {
+            readonly errors: {
+                internal: StandardSchemaV1<undefined, undefined>;
+            };
+            readonly input: StandardSchemaV1<{
+                sessionID: string;
+                tier: string | null;
+            }, {
+                sessionID: string;
+                tier: string | null;
+            }>;
+            readonly output: StandardSchemaV1<TierRequestSetResult, TierRequestSetResult>;
+        };
+    };
+    readonly events: {
+        readonly "settings-changed": {
+            readonly schema: StandardSchemaV1<{
+                version: number;
+            }, {
+                version: number;
+            }>;
+        };
+        readonly "session-mode-changed": {
+            readonly schema: StandardSchemaV1<{
+                sessionID: string;
+            }, {
+                sessionID: string;
+            }>;
+        };
+        readonly "tier-request-changed": {
+            readonly schema: StandardSchemaV1<{
+                sessionID: string;
+            }, {
+                sessionID: string;
+            }>;
+        };
+    };
+};
+export type AdaptiveRpc = typeof adaptiveRpc;

package/dist/rpc/definition.js

@@ -0,0 +1,130 @@
+/**
+ * Typed RPC definition (ADP-034/036): the only channel between the server
+ * plugin and the TUI/GUI surfaces. Surfaces hold no local settings state —
+ * they fetch snapshots, patch settings, and re-fetch on the `settings-changed`
+ * event (the server is the single source of truth). Session-mode overrides
+ * follow the same contract via `session-mode.get/set` and the
+ * `session-mode-changed` event (ADP-054); sticky per-session tier requests
+ * follow it via `tier-request.get/set` and `tier-request-changed` (ADP-055).
+ *
+ * Schema note: input schemas gate the wire shape (non-object patches are
+ * rejected as rpc.invalid_input); deeper validation happens in the handlers
+ * via the state parsers (`applyPatch` reports per-field errors instead), and
+ * output schemas are passthroughs over trusted server-side data.
+ *
+ * Every method declares one `internal` error with no data: handler failures
+ * are returned through the call context's error factory instead of thrown —
+ * a plain throw becomes a server defect and the client sees only the generic
+ * `rpc.internal` message (verified on the sibling @coool plugins).
+ */
+import { Rpc } from "@opencode/schema/rpc";
+import { MAX_SESSION_ID_LENGTH } from "../state/session-modes/types.js";
+export const ADAPTIVE_RPC_ID = "coool.adaptive";
+const RPC_VENDOR = "coool.adaptive";
+const INTERNAL_ERROR = { internal: voidSchema() };
+/**
+ * Identity schema: the wire value passes through unchanged; the type
+ * parameters carry the transport contract. `gate` optionally rejects values
+ * before they reach a handler; the failure message names the expectation so a
+ * rejected call is diagnosable from the wire error alone.
+ */
+function schema(gate, expectation) {
+    return {
+        "~standard": {
+            version: 1,
+            vendor: RPC_VENDOR,
+            validate: (value) => gate(value) ? { value: value } : { issues: [{ message: expectation }] },
+        },
+    };
+}
+function voidSchema() {
+    return {
+        "~standard": {
+            version: 1,
+            vendor: RPC_VENDOR,
+            validate: (value) => value === undefined
+                ? { value: undefined }
+                : { issues: [{ message: "unexpected input: no input expected" }] },
+        },
+    };
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isString = (value) => typeof value === "string";
+/**
+ * `{ sessionID: string }` wire shape. Bounds checked here too: a session id
+ * beyond the bound cannot be a real host identifier and an empty string is
+ * never one, so neither reaches a handler or a store lookup.
+ */
+const hasSessionID = (value) => {
+    if (!(isRecord(value) && isString(value["sessionID"])))
+        return false;
+    const sessionID = value["sessionID"];
+    // A session id beyond the bound cannot be a real host identifier and an
+    // empty string is never one; neither reaches a handler or a store lookup.
+    return sessionID.length > 0 && sessionID.length <= MAX_SESSION_ID_LENGTH;
+};
+/** `{ sessionID: string, mode: OperatingMode | null }` wire shape. */
+const isSessionModeSet = (value) => isRecord(value) &&
+    isString(value["sessionID"]) &&
+    (value["mode"] === null || isString(value["mode"]));
+/** `{ sessionID: string, tier: string | null }` wire shape. */
+const isTierRequestSet = (value) => isRecord(value) &&
+    isString(value["sessionID"]) &&
+    (value["tier"] === null || isString(value["tier"]));
+export const adaptiveRpc = Rpc.define({
+    id: ADAPTIVE_RPC_ID,
+    methods: {
+        "settings.get": {
+            errors: INTERNAL_ERROR,
+            input: voidSchema(),
+            output: schema(isRecord, "output must be an object"),
+        },
+        "settings.set": {
+            errors: INTERNAL_ERROR,
+            input: schema(isRecord, "input must be an object"),
+            output: schema(isRecord, "output must be an object"),
+        },
+        "status.get": {
+            errors: INTERNAL_ERROR,
+            input: voidSchema(),
+            output: schema(isRecord, "output must be an object"),
+        },
+        "receipts.list": {
+            errors: INTERNAL_ERROR,
+            input: voidSchema(),
+            output: schema(Array.isArray, "output must be an array"),
+        },
+        "session-mode.get": {
+            errors: INTERNAL_ERROR,
+            input: schema(hasSessionID, "input must be an object with a sessionID string"),
+            output: schema(isRecord, "output must be an object"),
+        },
+        "session-mode.set": {
+            errors: INTERNAL_ERROR,
+            input: schema(isSessionModeSet, "input must be an object with a sessionID string and a mode string or null"),
+            output: schema(isRecord, "output must be an object"),
+        },
+        "tier-request.get": {
+            errors: INTERNAL_ERROR,
+            input: schema(hasSessionID, "input must be an object with a sessionID string"),
+            output: schema(isRecord, "output must be an object"),
+        },
+        "tier-request.set": {
+            errors: INTERNAL_ERROR,
+            input: schema(isTierRequestSet, "input must be an object with a sessionID string and a tier string or null"),
+            output: schema(isRecord, "output must be an object"),
+        },
+    },
+    events: {
+        "settings-changed": {
+            schema: schema(isRecord, "event data must be an object"),
+        },
+        "session-mode-changed": {
+            schema: schema(hasSessionID, "event data must be an object with a sessionID string"),
+        },
+        "tier-request-changed": {
+            schema: schema(hasSessionID, "event data must be an object with a sessionID string"),
+        },
+    },
+});
+//# sourceMappingURL=definition.js.map

package/dist/rpc/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../src/rpc/definition.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Typed RPC definition (ADP-034/036): the only channel between the server\n * plugin and the TUI/GUI surfaces. Surfaces hold no local settings state —\n * they fetch snapshots, patch settings, and re-fetch on the `settings-changed`\n * event (the server is the single source of truth). Session-mode overrides\n * follow the same contract via `session-mode.get/set` and the\n * `session-mode-changed` event (ADP-054); sticky per-session tier requests\n * follow it via `tier-request.get/set` and `tier-request-changed` (ADP-055).\n *\n * Schema note: input schemas gate the wire shape (non-object patches are\n * rejected as rpc.invalid_input); deeper validation happens in the handlers\n * via the state parsers (`applyPatch` reports per-field errors instead), and\n * output schemas are passthroughs over trusted server-side data.\n *\n * Every method declares one `internal` error with no data: handler failures\n * are returned through the call context's error factory instead of thrown —\n * a plain throw becomes a server defect and the client sees only the generic\n * `rpc.internal` message (verified on the sibling @coool plugins).\n */\nimport { Rpc } from \"@opencode/schema/rpc\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\nimport type { OperatingMode } from \"../core/scheduler/types.js\"\nimport type { SettingsPatch, SettingsV1 } from \"../state/settings/index.js\"\nimport type { PatchResult } from \"../state/settings/types.js\"\nimport type { SessionModeSetResult } from \"../state/session-modes/index.js\"\nimport type { TierRequestSetResult } from \"./handlers.js\"\nimport type { TierName } from \"../core/tier-policy/types.js\"\nimport { MAX_SESSION_ID_LENGTH } from \"../state/session-modes/types.js\"\nimport type { Receipt } from \"../state/receipts/types.js\"\nimport type { StatusSnapshot } from \"./status.js\"\n\nexport const ADAPTIVE_RPC_ID = \"coool.adaptive\"\nconst RPC_VENDOR = \"coool.adaptive\"\n\nconst INTERNAL_ERROR = { internal: voidSchema() }\n\n/**\n * Identity schema: the wire value passes through unchanged; the type\n * parameters carry the transport contract. `gate` optionally rejects values\n * before they reach a handler; the failure message names the expectation so a\n * rejected call is diagnosable from the wire error alone.\n */\nfunction schema<T>(gate: (value: unknown) => boolean, expectation: string): StandardSchemaV1<T, T> {\n  return {\n    \"~standard\": {\n      version: 1,\n      vendor: RPC_VENDOR,\n      validate: (value) =>\n        gate(value) ? { value: value as T } : { issues: [{ message: expectation }] },\n    },\n  }\n}\n\nfunction voidSchema(): StandardSchemaV1<undefined, undefined> {\n  return {\n    \"~standard\": {\n      version: 1,\n      vendor: RPC_VENDOR,\n      validate: (value) =>\n        value === undefined\n          ? { value: undefined }\n          : { issues: [{ message: \"unexpected input: no input expected\" }] },\n    },\n  }\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n\nconst isString = (value: unknown): value is string => typeof value === \"string\"\n\n/**\n * `{ sessionID: string }` wire shape. Bounds checked here too: a session id\n * beyond the bound cannot be a real host identifier and an empty string is\n * never one, so neither reaches a handler or a store lookup.\n */\nconst hasSessionID = (value: unknown): boolean => {\n  if (!(isRecord(value) && isString(value[\"sessionID\"]))) return false\n  const sessionID = value[\"sessionID\"]\n  // A session id beyond the bound cannot be a real host identifier and an\n  // empty string is never one; neither reaches a handler or a store lookup.\n  return sessionID.length > 0 && sessionID.length <= MAX_SESSION_ID_LENGTH\n}\n\n/** `{ sessionID: string, mode: OperatingMode | null }` wire shape. */\nconst isSessionModeSet = (value: unknown): boolean =>\n  isRecord(value) &&\n  isString(value[\"sessionID\"]) &&\n  (value[\"mode\"] === null || isString(value[\"mode\"]))\n\n/** `{ sessionID: string, tier: string | null }` wire shape. */\nconst isTierRequestSet = (value: unknown): boolean =>\n  isRecord(value) &&\n  isString(value[\"sessionID\"]) &&\n  (value[\"tier\"] === null || isString(value[\"tier\"]))\n\nexport const adaptiveRpc = Rpc.define({\n  id: ADAPTIVE_RPC_ID,\n  methods: {\n    \"settings.get\": {\n      errors: INTERNAL_ERROR,\n      input: voidSchema(),\n      output: schema<SettingsV1>(isRecord, \"output must be an object\"),\n    },\n    \"settings.set\": {\n      errors: INTERNAL_ERROR,\n      input: schema<SettingsPatch>(isRecord, \"input must be an object\"),\n      output: schema<PatchResult>(isRecord, \"output must be an object\"),\n    },\n    \"status.get\": {\n      errors: INTERNAL_ERROR,\n      input: voidSchema(),\n      output: schema<StatusSnapshot>(isRecord, \"output must be an object\"),\n    },\n    \"receipts.list\": {\n      errors: INTERNAL_ERROR,\n      input: voidSchema(),\n      output: schema<Receipt[]>(Array.isArray, \"output must be an array\"),\n    },\n    \"session-mode.get\": {\n      errors: INTERNAL_ERROR,\n      input: schema<{ sessionID: string }>(\n        hasSessionID,\n        \"input must be an object with a sessionID string\",\n      ),\n      output: schema<{ mode: OperatingMode | null }>(isRecord, \"output must be an object\"),\n    },\n    \"session-mode.set\": {\n      errors: INTERNAL_ERROR,\n      input: schema<{ sessionID: string; mode: OperatingMode | null }>(\n        isSessionModeSet,\n        \"input must be an object with a sessionID string and a mode string or null\",\n      ),\n      output: schema<SessionModeSetResult>(isRecord, \"output must be an object\"),\n    },\n    \"tier-request.get\": {\n      errors: INTERNAL_ERROR,\n      input: schema<{ sessionID: string }>(\n        hasSessionID,\n        \"input must be an object with a sessionID string\",\n      ),\n      output: schema<{ tier: TierName | null }>(isRecord, \"output must be an object\"),\n    },\n    \"tier-request.set\": {\n      errors: INTERNAL_ERROR,\n      input: schema<{ sessionID: string; tier: string | null }>(\n        isTierRequestSet,\n        \"input must be an object with a sessionID string and a tier string or null\",\n      ),\n      output: schema<TierRequestSetResult>(isRecord, \"output must be an object\"),\n    },\n  },\n  events: {\n    \"settings-changed\": {\n      schema: schema<{ version: number }>(isRecord, \"event data must be an object\"),\n    },\n    \"session-mode-changed\": {\n      schema: schema<{ sessionID: string }>(\n        hasSessionID,\n        \"event data must be an object with a sessionID string\",\n      ),\n    },\n    \"tier-request-changed\": {\n      schema: schema<{ sessionID: string }>(\n        hasSessionID,\n        \"event data must be an object with a sessionID string\",\n      ),\n    },\n  },\n})\n\nexport type AdaptiveRpc = typeof adaptiveRpc\n"]}

package/dist/rpc/handlers.d.ts

@@ -0,0 +1,53 @@
+import type { OperatingMode } from "../core/scheduler/types.js";
+import type { TierName } from "../core/tier-policy/types.js";
+import type { PatchResult } from "../state/settings/types.js";
+import type { SettingsPatch, SettingsV1 } from "../state/settings/index.js";
+import type { Rpc } from "@opencode/schema/rpc";
+import type { Receipt } from "../state/receipts/types.js";
+import type { StatusSnapshot } from "./status.js";
+import type { AdaptiveRpc } from "./definition.js";
+export interface AdaptiveRpcSource {
+    settings(): Promise<SettingsV1>;
+    updateSettings(patch: SettingsPatch): Promise<PatchResult>;
+    status(): Promise<StatusSnapshot>;
+    receipts(): Promise<Receipt[]>;
+    getSessionMode(sessionID: string): Promise<OperatingMode | null>;
+    setSessionMode(sessionID: string, mode: OperatingMode | null): Promise<void>;
+    getTierRequest(sessionID: string): Promise<TierName | null>;
+    noteTierRequest(sessionID: string, tier: string): boolean;
+    setTierRequest(sessionID: string, tier: TierName | null): Promise<void>;
+}
+export type SettingsChangedEmit = (name: "settings-changed", data: {
+    version: number;
+}) => unknown;
+/**
+ * Correlated emit: each call site pairs the event name with its own payload
+ * shape — an invalid pairing is a type error, and the registration site can
+ * forward the tuple to the host emitter untouched.
+ */
+export type AdaptiveRpcEmit = (...args: ["settings-changed", {
+    version: number;
+}] | ["session-mode-changed", {
+    sessionID: string;
+}] | ["tier-request-changed", {
+    sessionID: string;
+}]) => unknown;
+/** A successful tier-request write; mirrors the SessionModeSetResult convention. */
+export type TierRequestSetResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly errors: readonly string[];
+};
+type Methods = AdaptiveRpc["methods"];
+type MethodName = Extract<keyof Methods, string>;
+/** The subset of the host's RpcCallContext the handlers use (no plugin import). */
+export interface AdaptiveRpcCallContext<Name extends MethodName> {
+    readonly error: Rpc.ErrorFactory<Methods[Name]>;
+}
+type HandlerErrorOf<Name extends MethodName> = Rpc.HandlerError<Methods[Name]>;
+type HandlerOf<Name extends MethodName> = (input: Rpc.Output<Methods[Name]["input"]>, context: AdaptiveRpcCallContext<Name>) => Promise<Rpc.HandlerOutput<Methods[Name]["output"]> | HandlerErrorOf<Name>>;
+export declare function adaptiveRpcHandlers(source: AdaptiveRpcSource, emit?: AdaptiveRpcEmit): {
+    [Name in MethodName]: HandlerOf<Name>;
+};
+export {};