zenox 1.3.0 → 1.4.0

package/README.md

@@ -21,6 +21,7 @@ Zenox supercharges [OpenCode](https://opencode.ai) with specialized AI agents th
 
 - **4 Specialized Agents** — Explorer, Librarian, Oracle, UI Planner
 - **Background Tasks** — Fire multiple agents in parallel
+- **Thinking Mode Variants** — Configure thinking levels (high, xhigh, max) per agent
 - **Keyword Triggers** — `ultrawork`, `deep research`, `explore codebase`
 - **Session History** — Query past sessions to learn from previous work
 - **Code Intelligence** — Search symbols via LSP
@@ -185,6 +186,34 @@ Config saves to `~/.config/opencode/zenox.json`:
 }
 ```
 
+### Thinking Mode Variants
+
+Configure thinking/reasoning levels for models that support extended thinking (like Claude, GPT with reasoning, etc.):
+
+```json
+{
+  "agents": {
+    "oracle": { 
+      "model": "anthropic/claude-opus-4-5",
+      "variant": "high"
+    },
+    "ui-planner": { 
+      "model": "openai/gpt-5.2-codex",
+      "variant": "xhigh"
+    }
+  }
+}
+```
+
+Available variants (model-dependent):
+- `low` — Minimal thinking
+- `medium` — Balanced thinking
+- `high` — Extended thinking
+- `xhigh` — Extra high thinking
+- `max` — Maximum reasoning depth
+
+Variants are applied safely — if an agent doesn't exist or the model doesn't support the variant, it gracefully falls back.
+
 ### Disable Agents or MCPs
 
 ```json

package/dist/agents/types.d.ts

@@ -3,5 +3,6 @@ export type AgentFactory = (model?: string) => AgentConfig;
 export type BuiltinAgentName = "explorer" | "librarian" | "oracle" | "ui-planner";
 export type AgentOverrideConfig = Partial<AgentConfig> & {
     prompt_append?: string;
+    variant?: string;
 };
 export type AgentOverrides = Partial<Record<BuiltinAgentName, AgentOverrideConfig>>;

package/dist/background/manager.d.ts

@@ -15,7 +15,7 @@ export declare class BackgroundManager {
     private mainSessionID;
     private toastManager;
     setToastManager(manager: TaskToastManager): void;
-    setMainSession(sessionID: string): void;
+    setMainSession(sessionID: string | undefined): void;
     getMainSession(): string | undefined;
     private generateTaskId;
     launch(client: OpencodeClient, input: LaunchInput): Promise<BackgroundTask>;

package/dist/config/schema.d.ts

@@ -6,14 +6,17 @@ export declare const AgentNameSchema: z.ZodEnum<["explorer", "librarian", "oracl
 export type AgentName = z.infer<typeof AgentNameSchema>;
 /**
  * Configuration for overriding an agent's settings
- * Only model override is supported - keeps it simple
+ * Supports model and variant overrides for thinking modes
  */
 export declare const AgentOverrideConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     model?: string | undefined;
+    variant?: string | undefined;
 }, {
     model?: string | undefined;
+    variant?: string | undefined;
 }>;
 export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
 /**
@@ -22,57 +25,77 @@ export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
 export declare const AgentOverridesSchema: z.ZodObject<{
     explorer: z.ZodOptional<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
+        variant?: string | undefined;
     }, {
         model?: string | undefined;
+        variant?: string | undefined;
     }>>;
     librarian: z.ZodOptional<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
+        variant?: string | undefined;
     }, {
         model?: string | undefined;
+        variant?: string | undefined;
     }>>;
     oracle: z.ZodOptional<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
+        variant?: string | undefined;
     }, {
         model?: string | undefined;
+        variant?: string | undefined;
     }>>;
     "ui-planner": z.ZodOptional<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
+        variant?: string | undefined;
     }, {
         model?: string | undefined;
+        variant?: string | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     explorer?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     librarian?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     oracle?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     "ui-planner"?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
 }, {
     explorer?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     librarian?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     oracle?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     "ui-planner"?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
 }>;
 export type AgentOverrides = z.infer<typeof AgentOverridesSchema>;
@@ -84,57 +107,77 @@ export declare const ZenoxConfigSchema: z.ZodObject<{
     agents: z.ZodOptional<z.ZodObject<{
         explorer: z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             model?: string | undefined;
+            variant?: string | undefined;
         }, {
             model?: string | undefined;
+            variant?: string | undefined;
         }>>;
         librarian: z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             model?: string | undefined;
+            variant?: string | undefined;
         }, {
             model?: string | undefined;
+            variant?: string | undefined;
         }>>;
         oracle: z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             model?: string | undefined;
+            variant?: string | undefined;
         }, {
             model?: string | undefined;
+            variant?: string | undefined;
         }>>;
         "ui-planner": z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             model?: string | undefined;
+            variant?: string | undefined;
         }, {
             model?: string | undefined;
+            variant?: string | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         explorer?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         librarian?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         oracle?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         "ui-planner"?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
     }, {
         explorer?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         librarian?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         oracle?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         "ui-planner"?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
     }>>;
     disabled_agents: z.ZodOptional<z.ZodArray<z.ZodEnum<["explorer", "librarian", "oracle", "ui-planner"]>, "many">>;
@@ -144,15 +187,19 @@ export declare const ZenoxConfigSchema: z.ZodObject<{
     agents?: {
         explorer?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         librarian?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         oracle?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         "ui-planner"?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
     } | undefined;
     disabled_agents?: ("explorer" | "librarian" | "oracle" | "ui-planner")[] | undefined;
@@ -162,15 +209,19 @@ export declare const ZenoxConfigSchema: z.ZodObject<{
     agents?: {
         explorer?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         librarian?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         oracle?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         "ui-planner"?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
     } | undefined;
     disabled_agents?: ("explorer" | "librarian" | "oracle" | "ui-planner")[] | undefined;

package/dist/index.js

@@ -4812,7 +4812,8 @@ var AgentNameSchema = exports_external.enum([
   "ui-planner"
 ]);
 var AgentOverrideConfigSchema = exports_external.object({
-  model: exports_external.string().optional()
+  model: exports_external.string().optional(),
+  variant: exports_external.string().optional()
 });
 var AgentOverridesSchema = exports_external.object({
   explorer: AgentOverrideConfigSchema.optional(),
@@ -4969,24 +4970,34 @@ class BackgroundManager {
         agent: task.agent
       }).catch(() => {});
     }
-    client.session.prompt({
-      path: { id: sessionID },
-      body: {
-        agent: input.agent,
-        tools: { task: false },
-        parts: [{ type: "text", text: input.prompt }]
-      }
-    }).catch((err) => {
-      const existingTask = this.tasks.get(task.id);
-      if (existingTask) {
-        existingTask.status = "failed";
-        existingTask.error = err.message ?? "Unknown error";
-        existingTask.completedAt = new Date;
-        if (this.toastManager) {
-          this.toastManager.showFailureToast(task.id, existingTask.error).catch(() => {});
+    const sendPrompt = async (retryWithoutAgent = false) => {
+      try {
+        await client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            ...retryWithoutAgent ? {} : { agent: input.agent },
+            tools: { task: false },
+            parts: [{ type: "text", text: input.prompt }]
+          }
+        });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (!retryWithoutAgent && (errorMsg.includes("agent.name") || errorMsg.includes("undefined is not an object"))) {
+          console.warn(`[zenox] Agent "${input.agent}" not found. Retrying with default agent.`);
+          return sendPrompt(true);
+        }
+        const existingTask = this.tasks.get(task.id);
+        if (existingTask) {
+          existingTask.status = "failed";
+          existingTask.error = errorMsg;
+          existingTask.completedAt = new Date;
+          if (this.toastManager) {
+            this.toastManager.showFailureToast(task.id, existingTask.error).catch(() => {});
+          }
         }
       }
-    });
+    };
+    sendPrompt().catch(() => {});
     return task;
   }
   getTask(taskId) {
@@ -18203,6 +18214,45 @@ Shows which LSP servers are running and their status.`,
     lsp_status: lspStatus
   };
 }
+// src/shared/agent-variant.ts
+function resolveAgentVariant(config2, agentName) {
+  if (!agentName)
+    return;
+  const agentOverrides = config2.agents;
+  return agentOverrides?.[agentName]?.variant;
+}
+function applyAgentVariant(config2, agentName, message) {
+  const variant = resolveAgentVariant(config2, agentName);
+  if (variant !== undefined && message.variant === undefined) {
+    message.variant = variant;
+  }
+}
+// src/shared/first-message-variant.ts
+function createFirstMessageVariantGate() {
+  const pending = new Set;
+  return {
+    markSessionCreated(info) {
+      if (info?.id && !info.parentID) {
+        pending.add(info.id);
+      }
+    },
+    shouldOverride(sessionID) {
+      if (!sessionID)
+        return false;
+      return pending.has(sessionID);
+    },
+    markApplied(sessionID) {
+      if (!sessionID)
+        return;
+      pending.delete(sessionID);
+    },
+    clear(sessionID) {
+      if (!sessionID)
+        return;
+      pending.delete(sessionID);
+    }
+  };
+}
 // src/index.ts
 var ZenoxPlugin = async (ctx) => {
   const pluginConfig = loadPluginConfig(ctx.directory);
@@ -18217,6 +18267,7 @@ var ZenoxPlugin = async (ctx) => {
   const todoEnforcerHook = createTodoEnforcerHook(ctx);
   const sessionTools = createSessionTools(ctx.client);
   const codeIntelligenceTools = createCodeIntelligenceTools(ctx.client);
+  const firstMessageVariantGate = createFirstMessageVariantGate();
   const applyModelOverride = (agentName, baseAgent) => {
     const override = pluginConfig.agents?.[agentName];
     if (override?.model) {
@@ -18231,6 +18282,16 @@ var ZenoxPlugin = async (ctx) => {
       ...codeIntelligenceTools
     },
     "chat.message": async (input, output) => {
+      const message = output.message;
+      if (firstMessageVariantGate.shouldOverride(input.sessionID)) {
+        const variant = resolveAgentVariant(pluginConfig, input.agent);
+        if (variant !== undefined) {
+          message.variant = variant;
+        }
+        firstMessageVariantGate.markApplied(input.sessionID);
+      } else {
+        applyAgentVariant(pluginConfig, input.agent, message);
+      }
       await keywordDetectorHook["chat.message"]?.(input, output);
     },
     event: async (input) => {
@@ -18239,10 +18300,19 @@ var ZenoxPlugin = async (ctx) => {
       if (event.type === "session.created") {
         const props = event.properties;
         const sessionInfo = props?.info;
+        firstMessageVariantGate.markSessionCreated(sessionInfo);
         if (sessionInfo?.id && !sessionInfo?.parentID) {
           backgroundManager.setMainSession(sessionInfo.id);
         }
       }
+      if (event.type === "session.deleted") {
+        const props = event.properties;
+        const sessionID = props?.info?.id;
+        firstMessageVariantGate.clear(sessionID);
+        if (sessionID && sessionID === backgroundManager.getMainSession()) {
+          backgroundManager.setMainSession(undefined);
+        }
+      }
       if (event.type === "session.idle") {
         const props = event.properties;
         const sessionID = props?.sessionID;
@@ -18252,14 +18322,24 @@ var ZenoxPlugin = async (ctx) => {
         if (notification) {
           const mainSessionID = backgroundManager.getMainSession();
           if (mainSessionID) {
-            await ctx.client.session.prompt({
-              path: { id: mainSessionID },
-              body: {
-                noReply: !notification.allComplete,
-                agent: notification.parentAgent,
-                parts: [{ type: "text", text: notification.message }]
+            const sendNotification = async (omitAgent = false) => {
+              try {
+                await ctx.client.session.prompt({
+                  path: { id: mainSessionID },
+                  body: {
+                    noReply: !notification.allComplete,
+                    ...omitAgent ? {} : { agent: notification.parentAgent },
+                    parts: [{ type: "text", text: notification.message }]
+                  }
+                });
+              } catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                if (!omitAgent && (errorMsg.includes("agent.name") || errorMsg.includes("undefined"))) {
+                  return sendNotification(true);
+                }
               }
-            });
+            };
+            await sendNotification();
           }
           return;
         }

package/dist/shared/agent-variant.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Agent Variant Handling
+ *
+ * Safely resolves and applies agent variants for thinking modes.
+ * Defensive implementation to prevent "undefined is not an object" errors.
+ */
+import type { ZenoxConfig } from "../config";
+/**
+ * Safely resolve agent variant from config
+ * Returns undefined if agent doesn't exist or has no variant configured
+ */
+export declare function resolveAgentVariant(config: ZenoxConfig, agentName?: string): string | undefined;
+/**
+ * Apply agent variant to message if configured
+ * Safe for undefined agents - simply does nothing
+ */
+export declare function applyAgentVariant(config: ZenoxConfig, agentName: string | undefined, message: {
+    variant?: string;
+}): void;

package/dist/shared/first-message-variant.d.ts

@@ -0,0 +1,34 @@
+/**
+ * First Message Variant Gate
+ *
+ * Tracks new sessions to apply variants only on the first message.
+ * Prevents variants from being applied to forked/child sessions.
+ */
+type SessionInfo = {
+    id?: string;
+    parentID?: string;
+};
+/**
+ * Creates a gate that tracks which sessions need variant applied on first message
+ */
+export declare function createFirstMessageVariantGate(): {
+    /**
+     * Mark a newly created session as pending variant application
+     * Only marks non-child sessions (no parentID)
+     */
+    markSessionCreated(info?: SessionInfo): void;
+    /**
+     * Check if this session should have variant overridden
+     */
+    shouldOverride(sessionID?: string): boolean;
+    /**
+     * Mark variant as applied for this session
+     */
+    markApplied(sessionID?: string): void;
+    /**
+     * Clear session from tracking (on session delete)
+     */
+    clear(sessionID?: string): void;
+};
+export type FirstMessageVariantGate = ReturnType<typeof createFirstMessageVariantGate>;
+export {};

package/dist/shared/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shared utilities for zenox plugin
+ */
+export { resolveAgentVariant, applyAgentVariant } from "./agent-variant";
+export { createFirstMessageVariantGate, type FirstMessageVariantGate, } from "./first-message-variant";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zenox",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "OpenCode plugin with specialized agents (explorer, librarian, oracle, ui-planner), background tasks for parallel execution, and smart orchestration",
   "author": "Ayush",
   "license": "MIT",
@@ -44,6 +44,8 @@
     "code-intelligence",
     "lsp",
     "todo-enforcer",
+    "thinking-modes",
+    "variants",
     "ai",
     "llm",
     "cli"