@op1/fast-mode 0.5.2

package/README.md

@@ -0,0 +1,119 @@
+# @op1/fast-mode
+
+Fast-mode plugin for OpenCode that toggles request priority on demand and applies
+it only when your runtime conditions match (provider, model, and enabled agent).
+
+## What the plugin does
+
+- Exposes `fast_mode` tool actions: `status`, `on`, and `off`.
+- Writes/reads runtime toggles from `.opencode/fast-mode-state.json`.
+- Reads guard configuration from:
+  - `~/.config/opencode/fast-mode.json` (global)
+  - `.opencode/fast-mode.json` (project, overrides global)
+- Applies `options.serviceTier = "priority"` only when a request passes provider,
+  model, and agent allowlists.
+
+## Install
+
+```bash
+bun add @op1/fast-mode
+```
+
+If you install from source workspace, run the local build first:
+
+```bash
+bun run build --cwd packages/fast-mode
+```
+
+## Configure
+
+Add plugin access in `~/.config/opencode/opencode.json`:
+
+```json
+{
+	"plugin": ["@op1/fast-mode"]
+}
+```
+
+If your `opencode.json` already has a plugin list, merge `@op1/fast-mode` into it.
+
+### Fast-mode config file shape
+
+Create or edit `~/.config/opencode/fast-mode.json`:
+
+```json
+{
+	"enabled": true,
+	"providers": {
+		"openai": {
+			"enabled": true,
+			"agents": ["build", "coder"],
+			"models": ["gpt-5.3-codex", "gpt-5.3-codex-mini"]
+		}
+	}
+}
+```
+
+Supported fields:
+
+- `enabled` (boolean): global feature gate for fast-mode.
+- `providers` (record): provider-level config, keyed by provider ID.
+- `providers.<provider>.enabled` (optional boolean): per-provider gate.
+- `providers.<provider>.agents` (optional string[]): agent allowlist.
+- `providers.<provider>.models` (optional string[]): model allowlist.
+
+Project-level `/.opencode/fast-mode.json` config is merged over the global file.
+
+You can also add a `.opencode/fast-mode.json` in a repo to tune behavior per project.
+
+## `/fast` command shim
+
+This plugin is tool-first; `/fast` is typically provided via a local command shim.
+
+Example local command shim file:
+
+`~/.config/opencode/commands/fast.md`
+
+```md
+---
+description: Toggle fast mode state
+agent: build
+---
+
+Use the `fast_mode` tool from this plugin.
+
+- `/fast status [agent|all]`
+- `/fast on [agent]`
+- `/fast off [agent|all]`
+```
+
+The shim keeps behavior consistent with agent commands in OpenCode and lets you
+type concise `/fast ...` actions during a chat session.
+
+## Notes on behavior
+
+- This plugin is **provider-first**: it matches provider ID first, then model and
+  agent allowlists.
+- It is currently **OpenAI-focused** because it writes `serviceTier` in the
+  request options contract used by OpenAI-style providers.
+- It is **model-guarded**: if model/agent/provider checks fail, no request
+  mutation occurs.
+
+## Publishing readiness
+
+Build now emits declarations for npm publishing:
+
+```bash
+bun run build --cwd packages/fast-mode
+```
+
+That script writes:
+
+- `dist/fast-mode.js`
+- declaration files under `dist/` (for example `dist/index.d.ts`)
+
+Keep `dist/` committed for package publishing.
+
+## License
+
+MIT

package/dist/config.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+declare const fastModeConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type FastModeConfigInput = z.input<typeof fastModeConfigSchema>;
+export interface FastModeProviderConfig {
+    enabled: boolean;
+    agents: string[];
+    models: string[];
+}
+export interface FastModeConfig {
+    enabled: boolean;
+    providers: Record<string, FastModeProviderConfig>;
+}
+export declare function parseFastModeConfig(input: unknown): FastModeConfig;
+export declare function mergeFastModeConfigInput(base: FastModeConfigInput, override: FastModeConfigInput | null): FastModeConfigInput;
+export declare function getFastModeConfigPaths(directory: string): {
+    globalPath: string;
+    projectPath: string;
+};
+export declare function loadFastModeConfig(directory: string): Promise<FastModeConfig>;
+export {};

package/dist/fast-mode.js

@@ -0,0 +1,335 @@
+// @bun
+// src/plugin.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+
+// src/normalize.ts
+function normalizeProviderID(value) {
+  return value.trim().toLowerCase();
+}
+function normalizeAgentName(value) {
+  return value.trim().toLowerCase();
+}
+function normalizeModelID(value) {
+  return value.trim();
+}
+function normalizeAllowlist(values, normalize) {
+  if (!values || values.length === 0)
+    return [];
+  const deduped = new Set;
+  for (const value of values) {
+    const normalized = normalize(value);
+    if (normalized.length > 0)
+      deduped.add(normalized);
+  }
+  return [...deduped];
+}
+
+// src/config.ts
+var providerConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  agents: z.array(z.string()).optional(),
+  models: z.array(z.string()).optional()
+});
+var fastModeConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  providers: z.record(z.string(), providerConfigSchema).optional()
+});
+var fastModeConfigDefaults = {
+  enabled: false,
+  providers: {}
+};
+function parseFastModeConfig(input) {
+  const parsed = fastModeConfigSchema.parse(input);
+  const providers = {};
+  for (const [providerID, providerConfig] of Object.entries(parsed.providers ?? {})) {
+    const normalizedProviderID = normalizeProviderID(providerID);
+    if (normalizedProviderID.length === 0)
+      continue;
+    providers[normalizedProviderID] = {
+      enabled: providerConfig.enabled ?? true,
+      agents: normalizeAllowlist(providerConfig.agents, normalizeAgentName),
+      models: normalizeAllowlist(providerConfig.models, normalizeModelID)
+    };
+  }
+  return {
+    enabled: parsed.enabled ?? fastModeConfigDefaults.enabled,
+    providers
+  };
+}
+async function readConfigFile(path) {
+  const file = Bun.file(path);
+  if (!await file.exists())
+    return null;
+  try {
+    return await file.json();
+  } catch {
+    return "invalid";
+  }
+}
+function mergeProviderRecords(base, override) {
+  const merged = {
+    ...base
+  };
+  for (const [providerID, providerConfig] of Object.entries(override)) {
+    merged[providerID] = {
+      ...merged[providerID] ?? {},
+      ...providerConfig
+    };
+  }
+  return merged;
+}
+function mergeFastModeConfigInput(base, override) {
+  if (!override)
+    return base;
+  return {
+    ...base,
+    ...override,
+    providers: mergeProviderRecords(base.providers ?? {}, override.providers ?? {})
+  };
+}
+function getFastModeConfigPaths(directory) {
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  const configRoot = typeof xdgConfigHome === "string" && xdgConfigHome.length > 0 ? xdgConfigHome : join(homedir(), ".config");
+  return {
+    globalPath: join(configRoot, "opencode", "fast-mode.json"),
+    projectPath: join(directory, ".opencode", "fast-mode.json")
+  };
+}
+async function loadFastModeConfig(directory) {
+  const { globalPath, projectPath } = getFastModeConfigPaths(directory);
+  const [globalConfig, projectConfig] = await Promise.all([
+    readConfigFile(globalPath),
+    readConfigFile(projectPath)
+  ]);
+  if (globalConfig === "invalid" || projectConfig === "invalid") {
+    return {
+      enabled: false,
+      providers: {}
+    };
+  }
+  try {
+    return parseFastModeConfig(mergeFastModeConfigInput(mergeFastModeConfigInput(fastModeConfigDefaults, globalConfig), projectConfig));
+  } catch {
+    return {
+      enabled: false,
+      providers: {}
+    };
+  }
+}
+
+// src/state.ts
+import { join as join2 } from "path";
+import { z as z2 } from "zod";
+var fastModeStateSchema = z2.object({
+  agents: z2.record(z2.string(), z2.boolean()).optional()
+});
+var fastModeStateDefaults = {
+  agents: {}
+};
+function parseFastModeState(input) {
+  const parsed = fastModeStateSchema.parse(input);
+  const agents = {};
+  for (const [agentName, enabled] of Object.entries(parsed.agents ?? {})) {
+    if (!enabled)
+      continue;
+    const normalized = normalizeAgentName(agentName);
+    if (normalized.length === 0)
+      continue;
+    agents[normalized] = true;
+  }
+  return { agents };
+}
+function getFastModeStatePath(directory) {
+  return join2(directory, ".opencode", "fast-mode-state.json");
+}
+async function loadFastModeState(directory) {
+  const file = Bun.file(getFastModeStatePath(directory));
+  if (!await file.exists()) {
+    return { agents: { ...fastModeStateDefaults.agents } };
+  }
+  try {
+    return parseFastModeState(await file.json());
+  } catch {
+    return { agents: { ...fastModeStateDefaults.agents } };
+  }
+}
+async function saveFastModeState(directory, state) {
+  const normalized = parseFastModeState(state);
+  await Bun.write(getFastModeStatePath(directory), `${JSON.stringify(normalized, null, 2)}
+`);
+}
+function isAgentFastModeEnabled(state, agentName) {
+  const normalized = normalizeAgentName(agentName);
+  if (normalized.length === 0)
+    return false;
+  return state.agents[normalized] === true;
+}
+function setAgentFastModeEnabled(state, agentName, enabled) {
+  const normalized = normalizeAgentName(agentName);
+  if (normalized.length === 0) {
+    throw new Error("Agent name is required for fast mode state updates.");
+  }
+  if (enabled) {
+    return {
+      agents: {
+        ...state.agents,
+        [normalized]: true
+      }
+    };
+  }
+  const nextAgents = { ...state.agents };
+  delete nextAgents[normalized];
+  return { agents: nextAgents };
+}
+function disableAllAgentFastMode() {
+  return { agents: {} };
+}
+function getEnabledAgents(state) {
+  return Object.keys(state.agents).filter((agentName) => state.agents[agentName]).sort();
+}
+
+// src/runtime.ts
+function shouldApplyFastMode(input) {
+  if (!input.config.enabled)
+    return false;
+  const providerID = normalizeProviderID(input.request.providerID);
+  if (providerID.length === 0)
+    return false;
+  const providerConfig = input.config.providers[providerID];
+  if (!providerConfig || !providerConfig.enabled)
+    return false;
+  const modelID = normalizeModelID(input.request.modelID);
+  if (modelID.length === 0 || !providerConfig.models.includes(modelID)) {
+    return false;
+  }
+  const agentName = normalizeAgentName(input.request.agentName);
+  if (agentName.length === 0 || !providerConfig.agents.includes(agentName)) {
+    return false;
+  }
+  return isAgentFastModeEnabled(input.state, agentName);
+}
+function applyFastModeServiceTier(output) {
+  output.options.serviceTier = "priority";
+}
+
+// src/plugin.ts
+function resolveToolTarget(input) {
+  const target = input.target ?? input.fallbackAgent;
+  const normalized = normalizeAgentName(target);
+  if (normalized.length === 0) {
+    throw new Error("Target agent is required.");
+  }
+  return normalized;
+}
+function formatToolStatus(input) {
+  const enabledAgents = getEnabledAgents(input.state);
+  if (input.target && input.target !== "all") {
+    return JSON.stringify({
+      action: "status",
+      configEnabled: input.configEnabled,
+      target: input.target,
+      enabled: isAgentFastModeEnabled(input.state, input.target)
+    }, null, 2);
+  }
+  return JSON.stringify({
+    action: "status",
+    configEnabled: input.configEnabled,
+    currentAgent: input.currentAgent,
+    currentAgentEnabled: isAgentFastModeEnabled(input.state, input.currentAgent),
+    enabledAgents
+  }, null, 2);
+}
+var FastModePlugin = async (ctx) => {
+  const workspaceRoot = ctx.directory;
+  let memoizedState = null;
+  async function readState() {
+    if (memoizedState)
+      return memoizedState;
+    memoizedState = await loadFastModeState(workspaceRoot);
+    return memoizedState;
+  }
+  async function writeState(nextState) {
+    memoizedState = nextState;
+    await saveFastModeState(workspaceRoot, nextState);
+  }
+  const fast_mode = tool({
+    description: "Toggle or inspect fast mode state by agent for provider/model guarded request mutation.",
+    args: {
+      action: tool.schema.enum(["status", "on", "off"]).describe("Choose status, on, or off."),
+      target: tool.schema.string().optional().describe("Optional agent name. Defaults to current agent for on/off. Supports 'all' for status/off.")
+    },
+    async execute(args, toolCtx) {
+      const config = await loadFastModeConfig(workspaceRoot);
+      const state = await readState();
+      const target = args.target ? normalizeAgentName(args.target) : undefined;
+      if (args.action === "status") {
+        return formatToolStatus({
+          configEnabled: config.enabled,
+          target,
+          currentAgent: toolCtx.agent,
+          state
+        });
+      }
+      if (args.action === "off" && target === "all") {
+        const cleared = disableAllAgentFastMode();
+        await writeState(cleared);
+        return formatToolStatus({
+          configEnabled: config.enabled,
+          target: "all",
+          currentAgent: toolCtx.agent,
+          state: cleared
+        });
+      }
+      if (args.action === "on" && target === "all") {
+        return "fast_mode refused: target 'all' is only valid for status/off.";
+      }
+      const resolvedTarget = resolveToolTarget({
+        target,
+        fallbackAgent: toolCtx.agent
+      });
+      const nextState = setAgentFastModeEnabled(state, resolvedTarget, args.action === "on");
+      await writeState(nextState);
+      return JSON.stringify({
+        action: args.action,
+        target: resolvedTarget,
+        enabled: isAgentFastModeEnabled(nextState, resolvedTarget),
+        enabledAgents: getEnabledAgents(nextState)
+      }, null, 2);
+    }
+  });
+  const chatParamsHook = async (input, output) => {
+    const providerID = input.provider?.info?.id ?? input.model?.providerID ?? undefined;
+    if (!providerID)
+      return;
+    const [config, state] = await Promise.all([
+      loadFastModeConfig(workspaceRoot),
+      readState()
+    ]);
+    if (!shouldApplyFastMode({
+      config,
+      state,
+      request: {
+        providerID,
+        modelID: input.model.id,
+        agentName: input.agent
+      }
+    })) {
+      return;
+    }
+    applyFastModeServiceTier(output);
+  };
+  return {
+    name: "@op1/fast-mode",
+    tool: { fast_mode },
+    "chat.params": chatParamsHook
+  };
+};
+export {
+  FastModePlugin as default,
+  FastModePlugin
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { FastModePlugin, FastModePlugin as default } from "./plugin.js";

package/dist/normalize.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeProviderID(value: string): string;
+export declare function normalizeAgentName(value: string): string;
+export declare function normalizeModelID(value: string): string;
+export declare function normalizeAllowlist(values: string[] | undefined, normalize: (value: string) => string): string[];

package/dist/plugin.d.ts

@@ -0,0 +1,3 @@
+import { type Plugin } from "@opencode-ai/plugin";
+export declare const FastModePlugin: Plugin;
+export default FastModePlugin;

package/dist/runtime.d.ts

@@ -0,0 +1,15 @@
+import type { FastModeConfig } from "./config.js";
+import { type FastModeState } from "./state.js";
+export interface FastModeRequest {
+    providerID: string;
+    modelID: string;
+    agentName: string;
+}
+export declare function shouldApplyFastMode(input: {
+    config: FastModeConfig;
+    state: FastModeState;
+    request: FastModeRequest;
+}): boolean;
+export declare function applyFastModeServiceTier(output: {
+    options: Record<string, unknown>;
+}): void;

package/dist/state.d.ts

@@ -0,0 +1,11 @@
+export interface FastModeState {
+    agents: Record<string, boolean>;
+}
+export declare function parseFastModeState(input: unknown): FastModeState;
+export declare function getFastModeStatePath(directory: string): string;
+export declare function loadFastModeState(directory: string): Promise<FastModeState>;
+export declare function saveFastModeState(directory: string, state: FastModeState): Promise<void>;
+export declare function isAgentFastModeEnabled(state: FastModeState, agentName: string): boolean;
+export declare function setAgentFastModeEnabled(state: FastModeState, agentName: string, enabled: boolean): FastModeState;
+export declare function disableAllAgentFastMode(): FastModeState;
+export declare function getEnabledAgents(state: FastModeState): string[];

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@op1/fast-mode",
+	"version": "0.5.2",
+	"description": "Fast mode plugin for OpenCode that enables priority service tier for approved provider/model/agent requests",
+	"type": "module",
+	"main": "dist/fast-mode.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/fast-mode.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"scripts": {
+		"build": "bun build src/index.ts --outfile dist/fast-mode.js --target bun --format esm --external @opencode-ai/plugin --external zod && tsc --emitDeclarationOnly --declaration --declarationMap false --outDir dist",
+		"typecheck": "tsc --noEmit",
+		"dev": "bun run build --watch"
+	},
+	"files": [
+		"dist"
+	],
+	"dependencies": {
+		"@opencode-ai/plugin": "^1.0.0",
+		"zod": "^4.0.0"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.1.0",
+		"typescript": "^5.7.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/op1/op1.git",
+		"directory": "packages/fast-mode"
+	},
+	"license": "MIT",
+	"keywords": [
+		"opencode",
+		"plugin",
+		"fast-mode",
+		"priority"
+	]
+}