oh-my-opencode-slim 0.8.1 → 0.8.2

package/README.md

@@ -2,7 +2,7 @@
   <img src="img/team.png" alt="Pantheon agents" width="420">
   <p><i>Six divine beings emerged from the dawn of code, each an immortal master of their craft await your command to forge order from chaos and build what was once thought impossible.</i></p>
   <p><b>Open Multi Agent Suite</b> · Mix any models · Auto delegate tasks</p>
-  <p><a href="https://moltfounders.com/project/0f5874c7-9291-415b-9622-7509d96a2c73"><img src="https://moltfounders.com/badges/4.png" alt="MoltFounders" height="30"></a></p>
+  <p><a href="https://moltfounders.com/jobs/09d1c6e7-9e0e-4683-8d78-e2376aaa2333"><img src="https://moltfounders.com/badges/4.png" alt="MoltFounders" height="30"></a></p>
 </div>
 
 ---
@@ -259,6 +259,6 @@ MIT
 ---
 
 <!-- MoltFounders Banner -->
-<a href="https://moltfounders.com/project/0f5874c7-9291-415b-9622-7509d96a2c73">
+<a href="https://moltfounders.com/jobs/09d1c6e7-9e0e-4683-8d78-e2376aaa2333">
   <img src="img/moltfounders-banner.png" alt="MoltFounders - The Agent Co-Founder Network">
 </a>

package/dist/agents/orchestrator.d.ts

@@ -3,5 +3,13 @@ export interface AgentDefinition {
     name: string;
     description?: string;
     config: AgentConfig;
+    /** Priority-ordered model entries for runtime fallback resolution. */
+    _modelArray?: Array<{
+        id: string;
+        variant?: string;
+    }>;
 }
-export declare function createOrchestratorAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;
+export declare function createOrchestratorAgent(model?: string | Array<string | {
+    id: string;
+    variant?: string;
+}>, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/cli/index.js

@@ -13704,7 +13704,16 @@ var FallbackChainsSchema = exports_external.object({
   fixer: AgentModelChainSchema.optional()
 }).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = exports_external.object({
-  model: exports_external.string().optional(),
+  model: exports_external.union([
+    exports_external.string(),
+    exports_external.array(exports_external.union([
+      exports_external.string(),
+      exports_external.object({
+        id: exports_external.string(),
+        variant: exports_external.string().optional()
+      })
+    ]))
+  ]).optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
   variant: exports_external.string().optional().catch(undefined),
   skills: exports_external.array(exports_external.string()).optional(),

package/dist/config/constants.d.ts

@@ -4,7 +4,7 @@ export declare const ORCHESTRATOR_NAME: "orchestrator";
 export declare const ALL_AGENT_NAMES: readonly ["orchestrator", "explorer", "librarian", "oracle", "designer", "fixer"];
 export type AgentName = (typeof ALL_AGENT_NAMES)[number];
 export declare const SUBAGENT_DELEGATION_RULES: Record<AgentName, readonly string[]>;
-export declare const DEFAULT_MODELS: Record<AgentName, string>;
+export declare const DEFAULT_MODELS: Record<AgentName, string | undefined>;
 export declare const POLL_INTERVAL_MS = 500;
 export declare const POLL_INTERVAL_SLOW_MS = 1000;
 export declare const POLL_INTERVAL_BACKGROUND_MS = 2000;

package/dist/config/loader.d.ts

@@ -17,11 +17,14 @@ export declare function loadPluginConfig(directory: string): PluginConfig;
 /**
  * Load custom prompt for an agent from the prompts directory.
  * Checks for {agent}.md (replaces default) and {agent}_append.md (appends to default).
+ * If preset is provided and safe for paths, it first checks {preset}/ subdirectory,
+ * then falls back to the root prompts directory.
  *
  * @param agentName - Name of the agent (e.g., "orchestrator", "explorer")
+ * @param preset - Optional preset name for preset-scoped prompt lookup
  * @returns Object with prompt and/or appendPrompt if files exist
  */
-export declare function loadAgentPrompt(agentName: string): {
+export declare function loadAgentPrompt(agentName: string, preset?: string): {
     prompt?: string;
     appendPrompt?: string;
 };

package/dist/config/schema.d.ts

@@ -50,7 +50,10 @@ export type ManualAgentPlan = z.infer<typeof ManualAgentPlanSchema>;
 export type ManualPlan = z.infer<typeof ManualPlanSchema>;
 export type FallbackAgentName = (typeof FALLBACK_AGENT_NAMES)[number];
 export declare const AgentOverrideConfigSchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
     temperature: z.ZodOptional<z.ZodNumber>;
     variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -77,8 +80,16 @@ export declare const TmuxConfigSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
 export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
+/** Normalized model entry with optional per-model variant. */
+export type ModelEntry = {
+    id: string;
+    variant?: string;
+};
 export declare const PresetSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
     temperature: z.ZodOptional<z.ZodNumber>;
     variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -155,14 +166,20 @@ export declare const PluginConfigSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strict>>;
     presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
-        model: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
         temperature: z.ZodOptional<z.ZodNumber>;
         variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>>;
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        model: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>]>>;
         temperature: z.ZodOptional<z.ZodNumber>;
         variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         skills: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/hooks/chat-headers.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput, ProviderContext } from '@opencode-ai/plugin';
+import type { Model, UserMessage } from '@opencode-ai/sdk';
+interface ChatHeadersInput {
+    sessionID: string;
+    model: Model;
+    provider: ProviderContext;
+    message: UserMessage;
+}
+interface ChatHeadersOutput {
+    headers: Record<string, string>;
+}
+export declare function __resetInternalMarkerCacheForTesting(): void;
+export declare function createChatHeadersHook(ctx: PluginInput): {
+    'chat.headers': (input: ChatHeadersInput, output: ChatHeadersOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/delegate-task-retry/index.d.ts

@@ -1,4 +1,4 @@
-export type { DelegateTaskErrorPattern, DetectedError } from './patterns';
-export { DELEGATE_TASK_ERROR_PATTERNS, detectDelegateTaskError } from './patterns';
 export { buildRetryGuidance } from './guidance';
 export { createDelegateTaskRetryHook } from './hook';
+export type { DelegateTaskErrorPattern, DetectedError } from './patterns';
+export { DELEGATE_TASK_ERROR_PATTERNS, detectDelegateTaskError, } from './patterns';

package/dist/hooks/index.d.ts

@@ -1,5 +1,6 @@
 export type { AutoUpdateCheckerOptions } from './auto-update-checker';
 export { createAutoUpdateCheckerHook } from './auto-update-checker';
+export { createChatHeadersHook } from './chat-headers';
 export { createDelegateTaskRetryHook } from './delegate-task-retry';
 export { createJsonErrorRecoveryHook } from './json-error-recovery';
 export { createPhaseReminderHook } from './phase-reminder';

package/dist/hooks/phase-reminder/index.d.ts

@@ -1,3 +1,4 @@
+export declare const PHASE_REMINDER = "<reminder>Recall Workflow Rules:\nUnderstand \u2192 find the best path (delegate based on rules and parallelize independent work) \u2192 execute \u2192 verify.\nIf delegating, launch the specialist in the same turn you mention it.</reminder>";
 interface MessageInfo {
     role: string;
     agent?: string;

package/dist/index.js

@@ -3376,7 +3376,7 @@ var SUBAGENT_DELEGATION_RULES = {
   oracle: []
 };
 var DEFAULT_MODELS = {
-  orchestrator: "kimi-for-coding/k2p5",
+  orchestrator: undefined,
   oracle: "openai/gpt-5.2-codex",
   librarian: "openai/gpt-5.1-codex-mini",
   explorer: "openai/gpt-5.1-codex-mini",
@@ -17014,7 +17014,16 @@ var FallbackChainsSchema = exports_external.object({
   fixer: AgentModelChainSchema.optional()
 }).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = exports_external.object({
-  model: exports_external.string().optional(),
+  model: exports_external.union([
+    exports_external.string(),
+    exports_external.array(exports_external.union([
+      exports_external.string(),
+      exports_external.object({
+        id: exports_external.string(),
+        variant: exports_external.string().optional()
+      })
+    ]))
+  ]).optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
   variant: exports_external.string().optional().catch(undefined),
   skills: exports_external.array(exports_external.string()).optional(),
@@ -17138,25 +17147,27 @@ function loadPluginConfig(directory) {
   }
   return config2;
 }
-function loadAgentPrompt(agentName) {
+function loadAgentPrompt(agentName, preset) {
+  const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : undefined;
   const promptsDir = path.join(getUserConfigDir(), "opencode", PROMPTS_DIR_NAME);
+  const promptSearchDirs = presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
   const result = {};
-  const promptPath = path.join(promptsDir, `${agentName}.md`);
-  if (fs.existsSync(promptPath)) {
-    try {
-      result.prompt = fs.readFileSync(promptPath, "utf-8");
-    } catch (error48) {
-      console.warn(`[oh-my-opencode-slim] Error reading prompt file ${promptPath}:`, error48 instanceof Error ? error48.message : String(error48));
-    }
-  }
-  const appendPromptPath = path.join(promptsDir, `${agentName}_append.md`);
-  if (fs.existsSync(appendPromptPath)) {
-    try {
-      result.appendPrompt = fs.readFileSync(appendPromptPath, "utf-8");
-    } catch (error48) {
-      console.warn(`[oh-my-opencode-slim] Error reading append prompt file ${appendPromptPath}:`, error48 instanceof Error ? error48.message : String(error48));
+  const readFirstPrompt = (fileName, errorPrefix) => {
+    for (const dir of promptSearchDirs) {
+      const promptPath = path.join(dir, fileName);
+      if (!fs.existsSync(promptPath)) {
+        continue;
+      }
+      try {
+        return fs.readFileSync(promptPath, "utf-8");
+      } catch (error48) {
+        console.warn(`[oh-my-opencode-slim] ${errorPrefix} ${promptPath}:`, error48 instanceof Error ? error48.message : String(error48));
+      }
     }
-  }
+    return;
+  };
+  result.prompt = readFirstPrompt(`${agentName}.md`, "Error reading prompt file");
+  result.appendPrompt = readFirstPrompt(`${agentName}_append.md`, "Error reading append prompt file");
   return result;
 }
 // src/config/utils.ts
@@ -17580,21 +17591,32 @@ function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
 
 ${customAppendPrompt}`;
   }
-  return {
+  const definition = {
     name: "orchestrator",
     description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
     config: {
-      model,
       temperature: 0.1,
       prompt
     }
   };
+  if (Array.isArray(model)) {
+    definition._modelArray = model.map((m) => typeof m === "string" ? { id: m } : m);
+  } else if (typeof model === "string" && model) {
+    definition.config.model = model;
+  }
+  return definition;
 }
 
 // src/agents/index.ts
 function applyOverrides(agent, override) {
-  if (override.model)
-    agent.config.model = override.model;
+  if (override.model) {
+    if (Array.isArray(override.model)) {
+      agent._modelArray = override.model.map((m) => typeof m === "string" ? { id: m } : m);
+      agent.config.model = undefined;
+    } else {
+      agent.config.model = override.model;
+    }
+  }
   if (override.variant)
     agent.config.variant = override.variant;
   if (override.temperature !== undefined)
@@ -17625,12 +17647,20 @@ var SUBAGENT_FACTORIES = {
 function createAgents(config2) {
   const getModelForAgent = (name) => {
     if (name === "fixer" && !getAgentOverride(config2, "fixer")?.model) {
-      return getAgentOverride(config2, "librarian")?.model ?? DEFAULT_MODELS.librarian;
+      const librarianOverride = getAgentOverride(config2, "librarian")?.model;
+      let librarianModel;
+      if (Array.isArray(librarianOverride)) {
+        const first = librarianOverride[0];
+        librarianModel = typeof first === "string" ? first : first?.id;
+      } else {
+        librarianModel = librarianOverride;
+      }
+      return librarianModel ?? DEFAULT_MODELS.librarian;
     }
     return DEFAULT_MODELS[name];
   };
   const protoSubAgents = Object.entries(SUBAGENT_FACTORIES).map(([name, factory]) => {
-    const customPrompts = loadAgentPrompt(name);
+    const customPrompts = loadAgentPrompt(name, config2?.preset);
     return factory(getModelForAgent(name), customPrompts.prompt, customPrompts.appendPrompt);
   });
   const allSubAgents = protoSubAgents.map((agent) => {
@@ -17641,13 +17671,13 @@ function createAgents(config2) {
     applyDefaultPermissions(agent, override?.skills);
     return agent;
   });
-  const orchestratorModel = getAgentOverride(config2, "orchestrator")?.model ?? DEFAULT_MODELS.orchestrator;
-  const orchestratorPrompts = loadAgentPrompt("orchestrator");
+  const orchestratorOverride = getAgentOverride(config2, "orchestrator");
+  const orchestratorModel = orchestratorOverride?.model ?? DEFAULT_MODELS.orchestrator;
+  const orchestratorPrompts = loadAgentPrompt("orchestrator", config2?.preset);
   const orchestrator = createOrchestratorAgent(orchestratorModel, orchestratorPrompts.prompt, orchestratorPrompts.appendPrompt);
-  const oOverride = getAgentOverride(config2, "orchestrator");
-  applyDefaultPermissions(orchestrator, oOverride?.skills);
-  if (oOverride) {
-    applyOverrides(orchestrator, oOverride);
+  applyDefaultPermissions(orchestrator, orchestratorOverride?.skills);
+  if (orchestratorOverride) {
+    applyOverrides(orchestrator, orchestratorOverride);
   }
   return [orchestrator, ...allSubAgents];
 }
@@ -17709,6 +17739,27 @@ function applyAgentVariant(variant, body) {
   }
   return { ...body, variant };
 }
+// src/utils/internal-initiator.ts
+var SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function createInternalAgentTextPart(text) {
+  return {
+    type: "text",
+    text: `${text}
+${SLIM_INTERNAL_INITIATOR_MARKER}`
+  };
+}
+function hasInternalInitiatorMarker(part) {
+  if (!isRecord(part) || part.type !== "text") {
+    return false;
+  }
+  if (typeof part.text !== "string") {
+    return false;
+  }
+  return part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER);
+}
 // src/utils/tmux.ts
 var {spawn } = globalThis.Bun;
 var tmuxPath = null;
@@ -18119,7 +18170,15 @@ class BackgroundTaskManager {
     const primary = this.config?.agents?.[agentName]?.model;
     const chain = [];
     const seen = new Set;
-    for (const model of [primary, ...configuredChain]) {
+    let primaryIds;
+    if (Array.isArray(primary)) {
+      primaryIds = primary.map((m) => typeof m === "string" ? m : m.id);
+    } else if (typeof primary === "string") {
+      primaryIds = [primary];
+    } else {
+      primaryIds = [];
+    }
+    for (const model of [...primaryIds, ...configuredChain]) {
       if (!model || seen.has(model))
         continue;
       seen.add(model);
@@ -18341,7 +18400,7 @@ class BackgroundTaskManager {
     await this.client.session.prompt({
       path: { id: task.parentSessionId },
       body: {
-        parts: [{ type: "text", text: message }]
+        parts: [createInternalAgentTextPart(message)]
       }
     });
   }
@@ -18971,6 +19030,56 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
     body: { title, message, variant, duration: duration3 }
   }).catch(() => {});
 }
+// src/hooks/chat-headers.ts
+var INTERNAL_MARKER_CACHE_LIMIT = 1000;
+var internalMarkerCache = new Map;
+function getProviderID(input) {
+  return input.provider.info?.id || input.model.providerID;
+}
+function isCopilotProvider(providerID) {
+  return providerID === "github-copilot" || providerID === "github-copilot-enterprise";
+}
+async function hasInternalMarker(client, sessionID, messageID) {
+  const cacheKey = `${sessionID}:${messageID}`;
+  const cached2 = internalMarkerCache.get(cacheKey);
+  if (cached2 !== undefined) {
+    return cached2;
+  }
+  try {
+    const response = await client.session.message({
+      path: { id: sessionID, messageID }
+    });
+    const hasMarker = (response.data?.parts ?? []).some(hasInternalInitiatorMarker);
+    if (hasMarker) {
+      if (internalMarkerCache.size >= INTERNAL_MARKER_CACHE_LIMIT) {
+        internalMarkerCache.clear();
+      }
+      internalMarkerCache.set(cacheKey, true);
+    }
+    return hasMarker;
+  } catch {
+    return false;
+  }
+}
+function createChatHeadersHook(ctx) {
+  return {
+    "chat.headers": async (input, output) => {
+      if (!isCopilotProvider(getProviderID(input))) {
+        return;
+      }
+      if (input.model.api.npm === "@ai-sdk/github-copilot") {
+        return;
+      }
+      if (!input.message.id || input.message.role !== "user") {
+        return;
+      }
+      if (!await hasInternalMarker(ctx.client, input.sessionID, input.message.id)) {
+        return;
+      }
+      output.headers["x-initiator"] = "agent";
+    }
+  };
+}
 // src/hooks/delegate-task-retry/patterns.ts
 var DELEGATE_TASK_ERROR_PATTERNS = [
   {
@@ -19030,6 +19139,7 @@ function detectDelegateTaskError(output) {
   }
   return null;
 }
+
 // src/hooks/delegate-task-retry/guidance.ts
 function extractAvailableList(output) {
   const match = output.match(/Allowed agents:\s*(.+)$/m);
@@ -19161,6 +19271,9 @@ function createPhaseReminderHook() {
         return;
       }
       const originalText = lastUserMessage.parts[textPartIndex].text ?? "";
+      if (originalText.includes(SLIM_INTERNAL_INITIATOR_MARKER)) {
+        return;
+      }
       lastUserMessage.parts[textPartIndex].text = `${PHASE_REMINDER}
 
 ---
@@ -33415,7 +33528,14 @@ var lsp_rename = tool({
 // src/index.ts
 var OhMyOpenCodeLite = async (ctx) => {
   const config3 = loadPluginConfig(ctx.directory);
+  const agentDefs = createAgents(config3);
   const agents = getAgentConfigs(config3);
+  const modelArrayMap = {};
+  for (const agentDef of agentDefs) {
+    if (agentDef._modelArray && agentDef._modelArray.length > 0) {
+      modelArrayMap[agentDef.name] = agentDef._modelArray;
+    }
+  }
   const tmuxConfig = {
     enabled: config3.tmux?.enabled ?? false,
     layout: config3.tmux?.layout ?? "main-vertical",
@@ -33439,6 +33559,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   });
   const phaseReminderHook = createPhaseReminderHook();
   const postReadNudgeHook = createPostReadNudgeHook();
+  const chatHeadersHook = createChatHeadersHook(ctx);
   const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
   const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
   return {
@@ -33463,6 +33584,40 @@ var OhMyOpenCodeLite = async (ctx) => {
         Object.assign(opencodeConfig.agent, agents);
       }
       const configAgent = opencodeConfig.agent;
+      if (Object.keys(modelArrayMap).length > 0) {
+        const providerConfig = opencodeConfig.provider ?? {};
+        const configuredProviders = Object.keys(providerConfig);
+        for (const [agentName, modelArray] of Object.entries(modelArrayMap)) {
+          let resolved = false;
+          for (const modelEntry of modelArray) {
+            const slashIdx = modelEntry.id.indexOf("/");
+            if (slashIdx === -1)
+              continue;
+            const providerID = modelEntry.id.slice(0, slashIdx);
+            if (configuredProviders.includes(providerID)) {
+              const entry = configAgent[agentName];
+              if (entry) {
+                entry.model = modelEntry.id;
+                if (modelEntry.variant) {
+                  entry.variant = modelEntry.variant;
+                }
+              }
+              log("[plugin] resolved model fallback", {
+                agent: agentName,
+                model: modelEntry.id,
+                variant: modelEntry.variant
+              });
+              resolved = true;
+              break;
+            }
+          }
+          if (!resolved) {
+            log("[plugin] no provider match for model array", {
+              agent: agentName
+            });
+          }
+        }
+      }
       const configMcp = opencodeConfig.mcp;
       if (!configMcp) {
         opencodeConfig.mcp = { ...mcps };
@@ -33499,6 +33654,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       await backgroundManager.handleSessionDeleted(input.event);
       await tmuxSessionManager.onSessionDeleted(input.event);
     },
+    "chat.headers": chatHeadersHook["chat.headers"],
     "experimental.chat.messages.transform": phaseReminderHook["experimental.chat.messages.transform"],
     "tool.execute.after": async (input, output) => {
       await delegateTaskRetryHook["tool.execute.after"](input, output);

package/dist/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from './agent-variant';
 export * from './env';
+export * from './internal-initiator';
 export { log } from './logger';
 export * from './polling';
 export * from './tmux';

package/dist/utils/internal-initiator.d.ts

@@ -0,0 +1,6 @@
+export declare const SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
+export declare function createInternalAgentTextPart(text: string): {
+    type: 'text';
+    text: string;
+};
+export declare function hasInternalInitiatorMarker(part: unknown): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",