@khalilgharbaoui/opencode-claude-code-plugin 0.20.0 → 0.22.0

package/dist/index.js

@@ -1248,6 +1248,102 @@ function resolveDisallowedTools(options) {
   if (options.disableWebSearch) push("WebSearch");
   return out;
 }
+function resolveProxyOpencodeToolDefs(options) {
+  const requested = options.requested ?? [];
+  if (requested.length === 0) return [];
+  const items = options.items;
+  if (!items) {
+    log.warn(
+      "proxyOpencodeTools is set but opencode's tool registry did not answer; forwarding nothing this spawn",
+      { requested: requested.map(String) }
+    );
+    return [];
+  }
+  const byLowerId = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = item.id.toLowerCase();
+    if (!byLowerId.has(key)) byLowerId.set(key, item);
+  }
+  const taken = options.taken ?? /* @__PURE__ */ new Set();
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const unknown = [];
+  const collided = [];
+  for (const raw of requested) {
+    const name = String(raw).trim();
+    if (!name) continue;
+    const item = byLowerId.get(name.toLowerCase());
+    if (!item) {
+      unknown.push(name);
+      continue;
+    }
+    if (taken.has(item.id)) {
+      collided.push(item.id);
+      continue;
+    }
+    if (seen.has(item.id)) continue;
+    seen.add(item.id);
+    out.push({
+      name: item.id,
+      description: typeof item.description === "string" ? item.description : "",
+      inputSchema: item.parameters && typeof item.parameters === "object" ? item.parameters : { type: "object", properties: {} }
+    });
+  }
+  if (unknown.length > 0) {
+    log.warn("ignoring unknown proxyOpencodeTools entries", {
+      unknown,
+      known: [...byLowerId.values()].map((item) => item.id).join(", ")
+    });
+  }
+  if (collided.length > 0) {
+    log.warn(
+      "proxyOpencodeTools entry dropped: a proxy tool already holds that name, and it keeps it",
+      { collided }
+    );
+  }
+  return out;
+}
+function resolveMcpProxyToolDefs(options) {
+  const empty = { defs: [], coveredServers: /* @__PURE__ */ new Set() };
+  const serverNames = options.serverNames ?? [];
+  if (serverNames.length === 0) return empty;
+  const tools = options.tools;
+  if (!tools || tools.length === 0) return empty;
+  const serversByLengthDesc = [...serverNames].sort((a, b) => b.length - a.length);
+  const taken = options.taken ?? /* @__PURE__ */ new Set();
+  const defs = [];
+  const coveredServers = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const collided = [];
+  for (const tool of tools) {
+    if (tool?.type !== void 0 && tool.type !== "function") continue;
+    const name = typeof tool?.name === "string" ? tool.name.trim() : "";
+    if (!name) continue;
+    const matchedServer = serversByLengthDesc.find(
+      (server2) => name === server2 || name.startsWith(`${server2}_`)
+    );
+    if (!matchedServer) continue;
+    if (seen.has(name)) continue;
+    if (taken.has(name)) {
+      collided.push(name);
+      continue;
+    }
+    seen.add(name);
+    coveredServers.add(matchedServer);
+    defs.push({
+      name,
+      description: typeof tool.description === "string" ? tool.description : "",
+      inputSchema: tool.inputSchema && typeof tool.inputSchema === "object" ? tool.inputSchema : { type: "object", properties: {} }
+    });
+  }
+  if (collided.length > 0) {
+    log.warn(
+      "MCP tool not routed through the proxy: another proxy tool already holds that name, and it keeps it",
+      { collided }
+    );
+  }
+  return { defs, coveredServers };
+}
 function readBody(req) {
   return new Promise((resolve5, reject) => {
     const chunks = [];
@@ -1336,6 +1432,14 @@ function writeJson(res, body) {
 
 // src/proxy-broker.ts
 import { EventEmitter as EventEmitter2 } from "events";
+var PROXY_STALL_WARNING_MS = 5 * 6e4;
+var PROXY_DEADLINE_WARNING_FRACTION = 0.6;
+var PROXY_DEADLINE_WARNING_MIN_MS = 6e4;
+function clearPendingTimers(pending) {
+  if (pending.timer) clearTimeout(pending.timer);
+  if (pending.stallTimer) clearInterval(pending.stallTimer);
+  if (pending.deadlineWarnTimer) clearTimeout(pending.deadlineWarnTimer);
+}
 var pendingByCallId = /* @__PURE__ */ new Map();
 var callIdsBySession = /* @__PURE__ */ new Map();
 var emitter = new EventEmitter2();
@@ -1361,10 +1465,10 @@ function onPendingProxyCall(sessionKey2, handler) {
   emitter.on(name, handler);
   return () => emitter.off(name, handler);
 }
-function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
+function queuePendingProxyCall(sessionKey2, call, timeoutOverrides, stallWarningMs = PROXY_STALL_WARNING_MS, deadlineWarningMinMs = PROXY_DEADLINE_WARNING_MIN_MS) {
   const previous = pendingByCallId.get(call.id);
   if (previous) {
-    if (previous.timer) clearTimeout(previous.timer);
+    clearPendingTimers(previous);
     previous.reject(
       new Error(`Replaced pending proxy call ${call.id} with a fresh one`)
     );
@@ -1381,6 +1485,7 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
     if (!current) return;
     pendingByCallId.delete(call.id);
     indexRemove(current.sessionKey, call.id);
+    clearPendingTimers(current);
     current.reject(buildProxyTimeoutError(call.toolName, deadlineMs));
     log.notice("timed out pending proxy call", {
       sessionKey: current.sessionKey,
@@ -1389,6 +1494,38 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
       deadlineMs
     });
   }, deadlineMs) : null;
+  const stallTimer = deadlineMs === PROXY_NO_DEADLINE_MS && stallWarningMs > 0 ? setInterval(() => {
+    const current = pendingByCallId.get(call.id);
+    if (!current) return;
+    log.warn("proxy call still waiting, no deadline", {
+      sessionKey: current.sessionKey,
+      toolCallId: current.toolCallId,
+      toolName: current.toolName,
+      waitedMs: Date.now() - current.createdAt,
+      emitted: current.emitted === true,
+      channelClosed: current.channel?.closed === true,
+      note: "nothing will time this out; it ends when opencode returns a result, you abort, you send another message, or the claude process goes"
+    });
+  }, stallWarningMs) : null;
+  stallTimer?.unref?.();
+  const warnAtMs = Math.floor(deadlineMs * PROXY_DEADLINE_WARNING_FRACTION);
+  const deadlineWarnTimer = deadlineMs >= deadlineWarningMinMs && deadlineMs > 0 && warnAtMs > 0 ? setTimeout(() => {
+    const current = pendingByCallId.get(call.id);
+    if (!current) return;
+    const waitedMs = Date.now() - current.createdAt;
+    log.warn("proxy call still waiting, deadline approaching", {
+      sessionKey: current.sessionKey,
+      toolCallId: current.toolCallId,
+      toolName: current.toolName,
+      waitedMs,
+      deadlineMs,
+      remainingMs: Math.max(0, deadlineMs - waitedMs),
+      emitted: current.emitted === true,
+      channelClosed: current.channel?.closed === true,
+      note: "it will be rejected when the deadline passes; raise this tool's proxyToolTimeoutMs if the work is legitimately this long"
+    });
+  }, warnAtMs) : null;
+  deadlineWarnTimer?.unref?.();
   const pending = {
     sessionKey: sessionKey2,
     toolCallId: call.id,
@@ -1398,6 +1535,8 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
     createdAt: Date.now(),
     deadlineMs,
     timer,
+    stallTimer,
+    deadlineWarnTimer,
     resolve: call.resolve,
     reject: call.reject
   };
@@ -1448,7 +1587,7 @@ function resolvePendingProxyCallById(toolCallId, result) {
   if (!pending) return false;
   pendingByCallId.delete(toolCallId);
   indexRemove(pending.sessionKey, toolCallId);
-  if (pending.timer) clearTimeout(pending.timer);
+  clearPendingTimers(pending);
   pending.resolve(result);
   log.info("resolved pending proxy call", {
     sessionKey: pending.sessionKey,
@@ -1462,7 +1601,7 @@ function rejectPendingProxyCallById(toolCallId, error) {
   if (!pending) return false;
   pendingByCallId.delete(toolCallId);
   indexRemove(pending.sessionKey, toolCallId);
-  if (pending.timer) clearTimeout(pending.timer);
+  clearPendingTimers(pending);
   pending.reject(error);
   log.notice("rejected pending proxy call", {
     sessionKey: pending.sessionKey,
@@ -3840,6 +3979,35 @@ function filterSideQuestionHistory(prompt) {
     (message) => message.role === "assistant" ? { ...message, content: stripPluginNotes(message.content) } : message
   );
 }
+var DCP_REMINDER_BLOCK = /<dcp-system-reminder\b[^>]*>[\s\S]*?<\/dcp-system-reminder>/gi;
+function stripContextReminderBlocks(text) {
+  if (!text.includes("<dcp-system-reminder")) return text;
+  return text.replace(DCP_REMINDER_BLOCK, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function shouldStripContextReminders(options) {
+  if (options.enabled !== true) return false;
+  const namesCompress = (list2) => (list2 ?? []).some((name) => String(name).trim().toLowerCase() === "compress");
+  return !namesCompress(options.proxyTools) && !namesCompress(options.proxyOpencodeTools);
+}
+function stripContextReminders(prompt) {
+  let removed = 0;
+  const countIn = (text) => (text.match(DCP_REMINDER_BLOCK) ?? []).length;
+  const out = prompt.map((message) => {
+    if (message.role !== "user" && message.role !== "assistant") return message;
+    if (!Array.isArray(message.content)) return message;
+    let touched = false;
+    const parts = message.content.map((part) => {
+      if (!part || part.type !== "text" || typeof part.text !== "string") return part;
+      const hits = countIn(part.text);
+      if (hits === 0) return part;
+      removed += hits;
+      touched = true;
+      return { ...part, text: stripContextReminderBlocks(part.text) };
+    });
+    return touched ? { ...message, content: parts } : message;
+  });
+  return removed > 0 ? { prompt: out, removed } : { prompt, removed: 0 };
+}
 var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
   "image/jpeg",
   "image/png",
@@ -4039,6 +4207,15 @@ function getClaudeUserMessage(prompt, includeHistoryContext = false, opts = {})
   const compactionMode = opts.compactionMode === true;
   const cliToolCallIds = opts.cliToolCallIds;
   const content = [];
+  if (opts.stripContextReminders) {
+    const stripped = stripContextReminders(prompt);
+    if (stripped.removed > 0) {
+      log.info("stripped unsatisfiable context reminders", {
+        blocks: stripped.removed
+      });
+      prompt = stripped.prompt;
+    }
+  }
   const pushToolResult = (part) => {
     const id = part.toolCallId;
     const text = getToolResultText(part);
@@ -5592,6 +5769,14 @@ You are running via the Claude Code CLI (not a direct API call). This affects co
 - Everything outside the summary is gone after the reset \u2014 tool output, files you read, and the earlier conversation are not replayed. Write the summary as the authoritative record.
 - The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
 - DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
+var CLAUDE_CLI_OPENCODE_COMPRESS_NOTE = `## Runtime environment: Claude Code CLI
+
+You are running via the Claude Code CLI (not a direct API call). This affects context management:
+
+- To compress context, call \`mcp__opencode_proxy__compress\`. Use that exact full name. It runs opencode's own \`compress\` tool, which is what a "MAX CONTEXT LIMIT REACHED" reminder is asking you to do.
+- It compresses opencode's stored conversation, NOT this Claude Code session. Your current session keeps the context it already has, so do not assume earlier detail is gone after the call.
+- The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
+- DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
 function extractSystemMessages(prompt) {
   const out = [];
   for (const msg of prompt) {
@@ -5618,7 +5803,7 @@ ${options.compressionSummary.trim()}`
     );
   }
   parts.push(
-    options.compressEnabled ? CLAUDE_CLI_COMPRESS_NOTE : CLAUDE_CLI_CONTEXT_NOTE
+    options.compressEnabled ? CLAUDE_CLI_COMPRESS_NOTE : options.opencodeCompressEnabled ? CLAUDE_CLI_OPENCODE_COMPRESS_NOTE : CLAUDE_CLI_CONTEXT_NOTE
   );
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
@@ -5798,43 +5983,46 @@ var ClaudeCodeLanguageModel = class {
     return picked.length > 0 ? picked : null;
   }
   /**
-   * Resolve ProxyToolDef[] for opencode's MCP-bridged tools so they go
+   * Resolve ProxyToolDef[] for opencode's MCP-backed tools so they go
    * through the in-process proxy instead of being bridged into Claude CLI's
-   * `--mcp-config`. Direct bridging causes double execution because both
-   * Claude CLI's own MCP child and opencode hold their own connection to
-   * the same server; routing through the proxy keeps a single execution
-   * site (opencode). Returns null when the feature is disabled, the SDK
-   * client is unavailable, or no MCP servers are configured.
+   * `--mcp-config`. Routing through the proxy keeps a single execution site
+   * (opencode), so the call is permission-prompted and rendered as an
+   * opencode tool call.
+   *
+   * Opt-in (`proxyOpencodeMcpTools: true`) and off by default. It used to
+   * default to true while finding nothing, because it discovered tools via
+   * `client.tool.list()`, which enumerates opencode's `ToolRegistry` and not
+   * the MCP tools merged into the model's tool set afterwards. Discovery now
+   * reads that merged set, the `tools` array opencode passes `doStream`, so
+   * the option does what it says. Turning it on by default at the same time
+   * would have silently moved every existing user's MCP traffic off the
+   * working direct bridge, so the default went to false instead: today's
+   * behaviour is preserved exactly and crossing over is the operator's call.
+   *
+   * Returns null when the feature is off or nothing matched, which leaves
+   * every server on the direct bridge.
    */
-  async resolvedProxyMcpTools(allEnabledServerNames) {
-    if (this.config.proxyOpencodeMcpTools === false) return null;
+  resolvedProxyMcpTools(allEnabledServerNames, modelTools, taken) {
+    if (this.config.proxyOpencodeMcpTools !== true) return null;
     if (this.config.bridgeOpencodeMcp === false) return null;
     if (allEnabledServerNames.length === 0) return null;
-    const items = await fetchOpencodeToolList(
-      this.config.provider,
-      this.modelId,
-      this.config.cwd
-    );
-    if (!items || items.length === 0) return null;
-    const serversByLengthDesc = [...allEnabledServerNames].sort(
-      (a, b) => b.length - a.length
-    );
-    const out = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const item of items) {
-      const matchedServer = serversByLengthDesc.find(
-        (name) => item.id === name || item.id.startsWith(`${name}_`)
+    const resolution = resolveMcpProxyToolDefs({
+      serverNames: allEnabledServerNames,
+      tools: modelTools,
+      taken
+    });
+    if (resolution.defs.length === 0) {
+      log.warn(
+        "proxyOpencodeMcpTools is on but no MCP tool was found in opencode's tool set; those servers stay on the direct bridge this spawn",
+        { servers: allEnabledServerNames, modelTools: modelTools?.length ?? 0 }
       );
-      if (!matchedServer) continue;
-      if (seen.has(item.id)) continue;
-      seen.add(item.id);
-      out.push({
-        name: item.id,
-        description: item.description ?? "",
-        inputSchema: item.parameters && typeof item.parameters === "object" ? item.parameters : { type: "object", properties: {} }
-      });
+      return null;
     }
-    return out.length > 0 ? out : null;
+    log.debug("routing opencode MCP tools through the proxy", {
+      servers: [...resolution.coveredServers],
+      tools: resolution.defs.map((def) => def.name)
+    });
+    return resolution;
   }
   /**
    * Live tool info derived from a single `client.tool.list()` fetch:
@@ -5865,9 +6053,22 @@ var ClaudeCodeLanguageModel = class {
       resolved: items !== void 0,
       taskDescription: items?.find((item) => item.id === "task")?.description,
       questionDescription: question?.description,
-      hasQuestion: !!question
+      hasQuestion: !!question,
+      items
     };
   }
+  /**
+   * Whether dcp-style context reminders should be stripped from this turn's
+   * messages. Config-only and synchronous, so it can be answered before the
+   * spawn block resolves anything: `userMsg` is built well ahead of it.
+   */
+  stripContextRemindersEnabled() {
+    return shouldStripContextReminders({
+      enabled: this.config.stripContextReminders,
+      proxyTools: this.config.proxyTools,
+      proxyOpencodeTools: this.config.proxyOpencodeTools
+    });
+  }
   /** Share one lazy registry request within a turn without making it stale. */
   createLiveToolInfoLoader() {
     let pending;
@@ -5903,10 +6104,10 @@ var ClaudeCodeLanguageModel = class {
    * Create a proxy MCP server for a single active Claude process/session.
    * The process lifecycle owns the server lifecycle via session-manager.
    */
-  async ensureProxyServer(tools, sessionKeyForCalls) {
+  async ensureProxyServer(tools, sessionKeyForCalls, interceptCompress) {
     const timeoutOverrides = this.config.proxyToolTimeoutMs;
     const interceptors = /* @__PURE__ */ new Map();
-    if (tools.some((t) => t.name === "compress")) {
+    if (interceptCompress && tools.some((t) => t.name === "compress")) {
       interceptors.set("compress", (input) => {
         const summary = typeof input.summary === "string" ? input.summary.trim() : "";
         if (!summary) {
@@ -6284,7 +6485,7 @@ var ClaudeCodeLanguageModel = class {
     );
     const sk = effortSessionKey(baseKey, reasoningEffort);
     const compactionMode = this.isCompactionCall(options);
-    if (scope === "tools" && (this.resolvedProxyTools() || this.config.proxyOpencodeMcpTools !== false && this.config.bridgeOpencodeMcp !== false)) {
+    if (scope === "tools" && (this.resolvedProxyTools() || this.config.proxyOpencodeMcpTools === true && this.config.bridgeOpencodeMcp !== false)) {
       return this.doGenerateViaStream(options);
     }
     if (compactionMode) {
@@ -6347,7 +6548,8 @@ var ClaudeCodeLanguageModel = class {
     // at all: every tool result reaching it belongs to opencode and must be
     // rendered as text rather than an orphaned `tool_result` (issue #29).
     getClaudeUserMessage(options.prompt, includeHistoryContext, {
-      cliToolCallIds: /* @__PURE__ */ new Set()
+      cliToolCallIds: /* @__PURE__ */ new Set(),
+      stripContextReminders: this.stripContextRemindersEnabled()
     });
     const [runtimeStatus, cliVersion, planModeQuestionActive] = await Promise.all([
       getRuntimeMcpStatus(),
@@ -6866,7 +7068,8 @@ ${plan}
     const previousPendingProxyCalls = compactionMode ? [] : getPendingProxyCalls(sk);
     const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(options.prompt, includeHistoryContext, {
       compactionMode,
-      cliToolCallIds: new Set(previousPendingProxyCalls.map((c) => c.toolCallId))
+      cliToolCallIds: new Set(previousPendingProxyCalls.map((c) => c.toolCallId)),
+      stripContextReminders: this.stripContextRemindersEnabled()
     });
     const resolvedProxy = compactionMode ? null : this.resolvedProxyTools();
     const loadLiveToolInfo = this.createLiveToolInfoLoader();
@@ -7028,13 +7231,21 @@ ${plan}
                 void 0,
                 runtimeStatus
               );
-              const proxyMcpTools = await self.resolvedProxyMcpTools(
-                discovery.allEnabledServerNames
+              const mcpResolution = self.resolvedProxyMcpTools(
+                discovery.allEnabledServerNames,
+                options.tools,
+                new Set((resolvedProxy ?? []).map((def) => def.name))
               );
-              const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
+              const proxyMcpTools = mcpResolution?.defs ?? null;
+              const excludeServers = mcpResolution ? mcpResolution.coveredServers : void 0;
               const taskProxyEnabled = resolvedProxy?.some((t) => t.name === "task") ?? false;
               const questionProxyEnabled = resolvedProxy?.some((t) => t.name === "question") ?? false;
-              const liveToolInfo = taskProxyEnabled || questionProxyEnabled ? await loadLiveToolInfo() : {
+              const opencodeToolsRequested = (self.config.proxyOpencodeTools?.length ?? 0) > 0;
+              log.debug("opencode tool forwarding gate", {
+                requested: self.config.proxyOpencodeTools ?? null,
+                opencodeToolsRequested
+              });
+              const liveToolInfo = taskProxyEnabled || questionProxyEnabled || opencodeToolsRequested ? await loadLiveToolInfo() : {
                 resolved: false,
                 taskDescription: void 0,
                 questionDescription: void 0,
@@ -7070,13 +7281,33 @@ ${plan}
                   kept: liveToolInfo.hasQuestion
                 });
               }
+              const opencodeToolDefs = resolveProxyOpencodeToolDefs({
+                requested: self.config.proxyOpencodeTools,
+                items: liveToolInfo.items,
+                taken: new Set(
+                  [...enrichedProxy ?? [], ...proxyMcpTools ?? []].map(
+                    (t) => t.name
+                  )
+                )
+              });
+              if (opencodeToolDefs.length > 0) {
+                log.info("forwarding opencode tools through the proxy", {
+                  tools: opencodeToolDefs.map((t) => t.name)
+                });
+              }
               const combinedList = [
                 ...enrichedProxy ?? [],
-                ...proxyMcpTools ?? []
+                ...proxyMcpTools ?? [],
+                ...opencodeToolDefs
               ];
               const combinedProxyTools = combinedList.length > 0 ? combinedList : null;
+              const pluginCompressEnabled = enrichedProxy?.some((t) => t.name === "compress") ?? false;
               if (!proxyServer && combinedProxyTools) {
-                proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
+                proxyServer = await self.ensureProxyServer(
+                  combinedProxyTools,
+                  sk,
+                  pluginCompressEnabled
+                );
               }
               const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
               const allDisallowed = resolveDisallowedTools({
@@ -7099,7 +7330,10 @@ ${plan}
                   ...questionProxyActive ? [QUESTION_PROXY_HINT] : []
                 ],
                 {
-                  compressEnabled: enrichedProxy?.some((t) => t.name === "compress") ?? false,
+                  compressEnabled: pluginCompressEnabled,
+                  opencodeCompressEnabled: opencodeToolDefs.some(
+                    (t) => t.name === "compress"
+                  ),
                   compressionSummary: getCompressionSummary(sk)
                 }
               );
@@ -8923,12 +9157,14 @@ function createClaudeCode(settings = {}) {
       controlRequestToolBehaviors: settings.controlRequestToolBehaviors,
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
+      proxyOpencodeTools: settings.proxyOpencodeTools,
+      stripContextReminders: settings.stripContextReminders === true,
       extraDisallowedTools: settings.extraDisallowedTools,
       proxyToolTimeoutMs: settings.proxyToolTimeoutMs,
       planModeQuestion: settings.planModeQuestion ?? false,
       webSearch: settings.webSearch,
       hotReloadMcp: settings.hotReloadMcp ?? true,
-      proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true,
+      proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools === true,
       multiStepContinuation: settings.multiStepContinuation ?? true,
       autoContinueIncompleteTurns: settings.autoContinueIncompleteTurns ?? "smart",
       compactionModel: settings.compactionModel,