@oh-my-pi/pi-coding-agent 16.1.15 → 16.1.16

package/src/eval/py/prelude.py

@@ -115,103 +115,6 @@ if "__omp_prelude_loaded__" not in globals():
         _emit_status("write", path=str(p), chars=len(content))
         return p
 
-    def append(path: str | Path, content: str) -> Path:
-        """Append to file."""
-        p = _resolve_omp_path(path)
-        p.parent.mkdir(parents=True, exist_ok=True)
-        with p.open("a", encoding="utf-8") as f:
-            f.write(content)
-        _emit_status("append", path=str(p), chars=len(content))
-        return p
-
-    def sort(text: str, *, reverse: bool = False, unique: bool = False) -> str:
-        """Sort lines of text."""
-        lines = text.splitlines()
-        if unique:
-            lines = list(dict.fromkeys(lines))
-        lines = sorted(lines, reverse=reverse)
-        out = "\n".join(lines)
-        _emit_status("sort", lines=len(lines), unique=unique, reverse=reverse)
-        return out
-
-    def uniq(text: str, *, count: bool = False) -> str | list[tuple[int, str]]:
-        """Remove duplicate adjacent lines (like uniq)."""
-        lines = text.splitlines()
-        if not lines:
-            _emit_status("uniq", groups=0)
-            return [] if count else ""
-        groups: list[tuple[int, str]] = []
-        current = lines[0]
-        current_count = 1
-        for line in lines[1:]:
-            if line == current:
-                current_count += 1
-                continue
-            groups.append((current_count, current))
-            current = line
-            current_count = 1
-        groups.append((current_count, current))
-        _emit_status("uniq", groups=len(groups), count_mode=count)
-        if count:
-            return groups
-        return "\n".join(line for _, line in groups)
-
-    def counter(
-        items: str | list,
-        *,
-        limit: int | None = None,
-        reverse: bool = True,
-    ) -> list[tuple[int, str]]:
-        """Count occurrences and sort by frequency. Like sort | uniq -c | sort -rn.
-        
-        items: text (splits into lines) or list of strings
-        reverse: True for descending (most common first), False for ascending
-        Returns: [(count, item), ...] sorted by count
-        """
-        from collections import Counter
-        if isinstance(items, str):
-            items = items.splitlines()
-        counts = Counter(items)
-        sorted_items = sorted(counts.items(), key=lambda x: (x[1], x[0]), reverse=reverse)
-        if limit is not None:
-            sorted_items = sorted_items[:limit]
-        result = [(count, item) for item, count in sorted_items]
-        _emit_status("counter", unique=len(counts), total=sum(counts.values()), top=result[:10])
-        return result
-    def tree(path: str | Path = ".", *, max_depth: int = 3, show_hidden: bool = False) -> str:
-        """Return directory tree."""
-        base = Path(path)
-        lines = []
-        def walk(p: Path, prefix: str, depth: int):
-            if depth > max_depth:
-                return
-            items = sorted(p.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower()))
-            items = [i for i in items if show_hidden or not i.name.startswith(".")]
-            for i, item in enumerate(items):
-                is_last = i == len(items) - 1
-                connector = "└── " if is_last else "├── "
-                suffix = "/" if item.is_dir() else ""
-                lines.append(f"{prefix}{connector}{item.name}{suffix}")
-                if item.is_dir():
-                    ext = "    " if is_last else "│   "
-                    walk(item, prefix + ext, depth + 1)
-        lines.append(str(base) + "/")
-        walk(base, "", 1)
-        out = "\n".join(lines)
-        _emit_status("tree", path=str(base), entries=len(lines) - 1, preview=out[:1000])
-        return out
-
-    def diff(a: str | Path, b: str | Path) -> str:
-        """Compare two files, return unified diff."""
-        import difflib
-        path_a, path_b = Path(a), Path(b)
-        lines_a = path_a.read_text(encoding="utf-8").splitlines(keepends=True)
-        lines_b = path_b.read_text(encoding="utf-8").splitlines(keepends=True)
-        result = difflib.unified_diff(lines_a, lines_b, fromfile=str(path_a), tofile=str(path_b))
-        out = "".join(result)
-        _emit_status("diff", file_a=str(path_a), file_b=str(path_b), identical=not out, preview=out[:500])
-        return out
-
     def output(
         *ids: str,
         format: str = "raw",
@@ -520,37 +423,66 @@ if "__omp_prelude_loaded__" not in globals():
         text = res.get("text") if isinstance(res, dict) else res
         return json.loads(text) if schema is not None else text
 
-    def agent(prompt, *, agent_type="task", model=None, label=None, schema=None, return_handle=False):
+    def agent(prompt, *, agent="task", model=None, label=None, schema=None, isolated=None, apply=None, merge=None, handle=False):
         """Run a subagent and return its final output.
 
-        `agent_type` selects the subagent definition (default "task"). Pass
+        `agent` selects the subagent definition (default "task"). Pass
         `model` to override that agent's model, `label` for the output artifact
         id, and `schema` to request structured JSON output; when `schema` is
         supplied the parsed object is returned. Share background by writing a
         local:// file and referencing it in the prompt.
 
-        Set `return_handle=True` to receive a DAG node dict instead of bare
+        Pass `isolated=True` to run the subagent inside an isolation worktree
+        (copy-on-write of the parent repo) so parallel `agent()` spawns can
+        edit overlapping files safely. Strict opt-in, mirroring the `task`
+        tool: the default is non-isolated regardless of `task.isolation.mode`.
+        `isolated=True` while the setting is `"none"` errors out instead of
+        silently downgrading.
+
+        When isolated, `apply=False` keeps captured changes inside the
+        worktree and surfaces the root patch path, branch name, and nested
+        repository patches through the DAG node dict (combine with
+        `handle=True` to receive them — see below; the bare return type
+        stays bytes/string/parsed object and has nowhere to expose artifacts).
+        `merge=False` forces patch mode even when `task.isolation.merge` is
+        `"branch"`, avoiding the per-call git lock + repo mutation that branch
+        mode performs.
+
+        Set `handle=True` to receive a DAG node dict instead of bare
         text: ``{"text", "output", "handle", "id", "agent"}`` where ``handle``
         is the spawned agent's recoverable ``agent://<id>`` URI. A downstream
         ``pipeline``/``parallel`` stage embeds that ``handle`` (or ``output``)
         in its prompt so a large transcript flows through the graph by
         reference, never re-inlined. When ``schema`` is also set the parsed
-        object lands under ``"data"``. If the bridge returns no recoverable id
-        the node still resolves with ``handle=None`` — the helper never throws.
+        object lands under ``"data"``. When the spawn ran isolated the node
+        also carries ``"isolated"`` and, when present, ``"patch_path"``,
+        ``"branch_name"``, ``"nested_patches"``, ``"changes_applied"``
+        (``True``/``False``/``None`` — ``None`` means ``apply=False``), and
+        ``"isolation_summary"``. If
+        the bridge returns no recoverable id the node still resolves with
+        ``handle=None`` — the helper never throws.
         """
         args = {"prompt": prompt}
-        if agent_type is not None:
-            args["agentType"] = agent_type
+        if agent is not None:
+            args["agent"] = agent
         if model is not None:
             args["model"] = model
         if label is not None:
             args["label"] = label
         if schema is not None:
             args["schema"] = schema
+        if isolated is not None:
+            args["isolated"] = bool(isolated)
+        if apply is not None:
+            args["apply"] = bool(apply)
+        if merge is not None:
+            args["merge"] = bool(merge)
+        if handle:
+            args["handle"] = True
         res = _bridge_call("__agent__", args)
         text = res.get("text") if isinstance(res, dict) else res
         parsed = json.loads(text) if schema is not None else text
-        if not return_handle:
+        if not handle:
             return parsed
         details = res.get("details") if isinstance(res, dict) else None
         if not isinstance(details, dict) or details.get("id") is None:
@@ -564,6 +496,16 @@ if "__omp_prelude_loaded__" not in globals():
         }
         if schema is not None:
             node["data"] = parsed
+        for src_key, dst_key in (
+            ("isolated", "isolated"),
+            ("patchPath", "patch_path"),
+            ("branchName", "branch_name"),
+            ("nestedPatches", "nested_patches"),
+            ("changesApplied", "changes_applied"),
+            ("isolationSummary", "isolation_summary"),
+        ):
+            if src_key in details:
+                node[dst_key] = details[src_key]
         return node
 
     def _concurrency_limit():

package/src/eval/py/runner.py

@@ -557,12 +557,6 @@ def _magic_run(args: str) -> None:
 def _magic_cell_bash(args: str, body: str) -> int:
     return _run_shell_body(body, shell_arg="/bin/bash")
 
-
-@cell_magic("sh")
-def _magic_cell_sh(args: str, body: str) -> int:
-    return _run_shell_body(body, shell_arg="/bin/sh")
-
-
 @cell_magic("capture")
 def _magic_cell_capture(args: str, body: str) -> str:
     """Capture stdout/stderr of body; bind to ``args`` (a name) if provided."""

package/src/eval/rb/prelude.rb

@@ -2,7 +2,7 @@
 # OMP Ruby prelude helpers (loaded once into the runner's TOPLEVEL_BINDING).
 #
 # Mirrors eval/py/prelude.py: defines the cross-runtime helper surface
-# (display/read/write/append/tree/diff/env/output, the `tool` bridge proxy,
+# (display/read/write/env/output, the `tool` bridge proxy,
 # completion/agent/parallel/pipeline/log/phase/budget). Host-side helpers reach
 # the coding-agent over the same loopback HTTP tool bridge the Python prelude
 # uses (PI_TOOL_BRIDGE_URL/TOKEN/SESSION). Path helpers honor PI_EVAL_LOCAL_ROOTS
@@ -112,191 +112,6 @@ unless defined?($__omp_prelude_loaded) && $__omp_prelude_loaded
     resolved.to_s
   end
 
-  def append(path, content)
-    resolved = __omp_resolve_path(path)
-    require "fileutils"
-    FileUtils.mkdir_p(File.dirname(resolved.to_s))
-    File.open(resolved.to_s, "a") { |f| f.write(content.to_s) }
-    __omp_emit_status("append", "path" => resolved.to_s, "chars" => content.to_s.length)
-    resolved.to_s
-  end
-
-  def tree(path = ".", max_depth: 3, show_hidden: false)
-    base = path.to_s
-    lines = []
-    walk = lambda do |dir, prefix, depth|
-      return if depth > max_depth
-      entries = (Dir.children(dir) rescue [])
-      entries = entries.reject { |e| e.start_with?(".") } unless show_hidden
-      entries = entries.sort_by { |e| [File.directory?(File.join(dir, e)) ? 0 : 1, e.downcase] }
-      entries.each_with_index do |name, i|
-        full = File.join(dir, name)
-        is_last = i == entries.length - 1
-        is_dir = File.directory?(full)
-        lines << "#{prefix}#{is_last ? "└── " : "├── "}#{name}#{is_dir ? "/" : ""}"
-        walk.call(full, prefix + (is_last ? "    " : "│   "), depth + 1) if is_dir
-      end
-    end
-    lines << "#{base}/"
-    walk.call(base, "", 1)
-    out = lines.join("\n")
-    __omp_emit_status("tree", "path" => base, "entries" => lines.length - 1, "preview" => __omp_scrub(out[0, 1000].to_s))
-    out
-  end
-
-  def diff(a, b)
-    pa = a.to_s
-    pb = b.to_s
-    lines_a = File.read(pa, encoding: Encoding::UTF_8).lines
-    lines_b = File.read(pb, encoding: Encoding::UTF_8).lines
-    out = __omp_unified_diff(lines_a, lines_b, pa, pb)
-    __omp_emit_status("diff", "file_a" => pa, "file_b" => pb, "identical" => out.empty?, "preview" => __omp_scrub(out[0, 500].to_s))
-    out
-  end
-
-  # LCS-based op list ([:equal/:delete/:insert, aIndex, bIndex]) per consumed line.
-  def __omp_diff_ops(a, b)
-    n = a.length
-    m = b.length
-    if n * m > 4_000_000
-      # Too large for the DP table — fall back to a coarse all-delete/all-insert.
-      ops = []
-      n.times { |i| ops << [:delete, i, 0] }
-      m.times { |j| ops << [:insert, n, j] }
-      return ops
-    end
-    dp = Array.new(n + 1) { Array.new(m + 1, 0) }
-    (n - 1).downto(0) do |i|
-      row = dp[i]
-      nrow = dp[i + 1]
-      (m - 1).downto(0) do |j|
-        row[j] = a[i] == b[j] ? nrow[j + 1] + 1 : (nrow[j] >= row[j + 1] ? nrow[j] : row[j + 1])
-      end
-    end
-    ops = []
-    i = 0
-    j = 0
-    while i < n && j < m
-      if a[i] == b[j]
-        ops << [:equal, i, j]; i += 1; j += 1
-      elsif dp[i + 1][j] >= dp[i][j + 1]
-        ops << [:delete, i, j]; i += 1
-      else
-        ops << [:insert, i, j]; j += 1
-      end
-    end
-    ops << [:delete, i, j].tap { i += 1 } while i < n
-    ops << [:insert, i, j].tap { j += 1 } while j < m
-    ops
-  end
-
-  def __omp_unified_diff(a, b, from_file, to_file, context = 3)
-    ops = __omp_diff_ops(a, b)
-    return "" unless ops.any? { |tag, _, _| tag != :equal }
-
-    entries = ops.map do |tag, ai, bi|
-      { tag: tag, ai: ai, bi: bi, text: (tag == :insert ? b[bi] : a[ai]) }
-    end
-    changed = entries.each_index.select { |k| entries[k][:tag] != :equal }
-
-    groups = []
-    start = nil
-    prev = nil
-    changed.each do |k|
-      if start.nil?
-        start = k
-        prev = k
-      elsif k - prev <= (2 * context) + 1
-        prev = k
-      else
-        groups << [start, prev]
-        start = k
-        prev = k
-      end
-    end
-    groups << [start, prev] unless start.nil?
-
-    out = +""
-    out << "--- #{from_file}\n"
-    out << "+++ #{to_file}\n"
-    groups.each do |gs, ge|
-      lo = [gs - context, 0].max
-      hi = [ge + context, entries.length - 1].min
-      slice = entries[lo..hi]
-      a_start = nil
-      a_count = 0
-      b_start = nil
-      b_count = 0
-      slice.each do |e|
-        if e[:tag] != :insert
-          a_start ||= e[:ai]
-          a_count += 1
-        end
-        if e[:tag] != :delete
-          b_start ||= e[:bi]
-          b_count += 1
-        end
-      end
-      out << "@@ -#{(a_start || 0) + 1},#{a_count} +#{(b_start || 0) + 1},#{b_count} @@\n"
-      slice.each do |e|
-        prefix = e[:tag] == :equal ? " " : (e[:tag] == :delete ? "-" : "+")
-        text = e[:text].to_s
-        text = "#{text}\n" unless text.end_with?("\n")
-        out << "#{prefix}#{text}"
-      end
-    end
-    out
-  end
-
-  # -------------------------------------------------------------------------
-  # Text helpers (sort / uniq / counter)
-  # -------------------------------------------------------------------------
-
-  def sort(text, reverse: false, unique: false)
-    lines = text.to_s.lines.map(&:chomp)
-    lines = lines.uniq if unique
-    lines = lines.sort
-    lines = lines.reverse if reverse
-    out = lines.join("\n")
-    __omp_emit_status("sort", "lines" => lines.length, "unique" => unique, "reverse" => reverse)
-    out
-  end
-
-  def uniq(text, count: false)
-    lines = text.to_s.lines.map(&:chomp)
-    if lines.empty?
-      __omp_emit_status("uniq", "groups" => 0)
-      return count ? [] : ""
-    end
-    groups = []
-    current = lines[0]
-    run = 1
-    lines[1..].each do |line|
-      if line == current
-        run += 1
-      else
-        groups << [run, current]
-        current = line
-        run = 1
-      end
-    end
-    groups << [run, current]
-    __omp_emit_status("uniq", "groups" => groups.length, "count_mode" => count)
-    count ? groups : groups.map { |_, l| l }.join("\n")
-  end
-
-  def counter(items, limit: nil, reverse: true)
-    arr = items.is_a?(String) ? items.lines.map(&:chomp) : items.to_a
-    counts = Hash.new(0)
-    arr.each { |i| counts[i] += 1 }
-    sorted = counts.sort_by { |item, c| [c, item] }
-    sorted = sorted.reverse if reverse
-    sorted = sorted.first(limit) if limit
-    result = sorted.map { |item, c| [c, item] }
-    __omp_emit_status("counter", "unique" => counts.size, "total" => arr.length, "top" => result.first(10))
-    result
-  end
-
   # -------------------------------------------------------------------------
   # Task/agent output reader
   # -------------------------------------------------------------------------
@@ -577,16 +392,23 @@ unless defined?($__omp_prelude_loaded) && $__omp_prelude_loaded
     schema.nil? ? text : JSON.parse(text)
   end
 
-  def agent(prompt, agent_type: "task", model: nil, label: nil, schema: nil, return_handle: false)
+  def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, isolated: nil, apply: nil, merge: nil, handle: false)
     args = { "prompt" => prompt }
-    args["agentType"] = agent_type unless agent_type.nil?
+    args["agent"] = agent unless agent.nil?
     args["model"] = model unless model.nil?
     args["label"] = label unless label.nil?
     args["schema"] = schema unless schema.nil?
+    # Isolation knobs mirror the `task` tool: strict opt-in via `isolated`,
+    # with `apply`/`merge` controlling the post-run patch/branch merge.
+    args["isolated"] = !!isolated unless isolated.nil?
+    args["apply"] = !!apply unless apply.nil?
+    args["merge"] = !!merge unless merge.nil?
+    # Tell the bridge a handle is wanted so it preserves the backing artifacts.
+    args["handle"] = true if handle
     res = OmpBridge.call("__agent__", args)
     text = res.is_a?(Hash) ? res["text"] : res
     parsed = schema.nil? ? text : JSON.parse(text)
-    return parsed unless return_handle
+    return parsed unless handle
     details = res.is_a?(Hash) ? res["details"] : nil
     if !details.is_a?(Hash) || details["id"].nil?
       return { "text" => text, "output" => text, "handle" => nil, "id" => nil, "agent" => nil }
@@ -599,6 +421,16 @@ unless defined?($__omp_prelude_loaded) && $__omp_prelude_loaded
       "agent" => details["agent"],
     }
     node["data"] = parsed unless schema.nil?
+    {
+      "isolated" => "isolated",
+      "patchPath" => "patch_path",
+      "branchName" => "branch_name",
+      "nestedPatches" => "nested_patches",
+      "changesApplied" => "changes_applied",
+      "isolationSummary" => "isolation_summary",
+    }.each do |src_key, dst_key|
+      node[dst_key] = details[src_key] if details.key?(src_key)
+    end
     node
   end
 

package/src/eval/rb/runner.rb

@@ -129,10 +129,122 @@ def __omp_emit_status(op, data = {})
   __omp_emit_display({ "application/x-omp-status" => status }, "display")
 end
 
+OMP_IMAGE_MIMES = %w[image/png image/jpeg].freeze
+
+# True when `str` already looks like base64 text (ASCII, base64 alphabet, length
+# a multiple of 4). Raw image blobs (PNG/JPEG bytes) contain high bytes, so they
+# fail the ASCII check and get encoded instead of passed through unchanged.
+def __omp_base64?(str)
+  s = str.to_s
+  # ascii_only? is safe on any encoding (no regex over invalid bytes). Raw image
+  # blobs carry high bytes and fail here, so they get encoded rather than scanned.
+  return false unless s.ascii_only?
+  stripped = s.gsub(/\s+/, "")
+  return false if stripped.empty? || (stripped.bytesize % 4) != 0
+  stripped.match?(%r{\A[A-Za-z0-9+/]*={0,2}\z})
+end
+
+# Coerce an image payload to the base64 ASCII the host renders. IRuby-style
+# `to_iruby` hands back raw binary blobs (Gruff#to_blob, ChunkyPNG, RMagick),
+# which would also break JSON.generate; strict-encode them unless already base64.
+def __omp_image_payload(content)
+  require "base64"
+  s = content.to_s
+  return s.gsub(/\s+/, "") if __omp_base64?(s)
+  Base64.strict_encode64(s.b)
+end
+
+# Detect a host-renderable image MIME from a binary blob's magic bytes. Lets us
+# treat the generic `to_blob` (Gruff/RMagick/ChunkyPNG/Vips) as an image only
+# when it really is one, avoiding false positives on unrelated `to_blob` methods.
+def __omp_sniff_image_mime(bytes)
+  b = bytes.to_s.b
+  return "image/png" if b.start_with?("\x89PNG\r\n\x1a\n".b)
+  return "image/jpeg" if b.start_with?("\xFF\xD8\xFF".b)
+  nil
+end
+
+# Stringify keys, base64-encode image payloads, and scrub text payloads so the
+# bundle is always JSON-safe before it reaches __omp_emit.
+def __omp_normalize_bundle(hash)
+  bundle = {}
+  hash.each do |key, val|
+    k = key.to_s
+    bundle[k] =
+      if OMP_IMAGE_MIMES.include?(k)
+        __omp_image_payload(val)
+      elsif val.is_a?(String)
+        __omp_scrub(val)
+      else
+        val
+      end
+  end
+  bundle
+end
+
+# Guarantee a text/plain entry so the model always sees a textual hint, even for
+# image-only bundles (mirrors the Python runner).
+def __omp_finalize_bundle(bundle, value)
+  bundle["text/plain"] ||= __omp_scrub((value.inspect rescue value.class.name))
+  bundle
+end
+
+# Rich-display resolution for non-collection objects. Honors the repo
+# `to_omp_mime` convention first, then the IRuby protocol
+# (`to_iruby_mimebundle` -> [data, metadata], `to_iruby` -> [mime, data]) so plot
+# and image objects (gruff, rubyplot, gnuplotrb, chunky_png, daru, ...) render
+# inline — the Ruby analog of IPython's _repr_*_ methods. Returns nil when the
+# value advertises no rich representation.
+def __omp_rich_mime_bundle(value)
+  if value.respond_to?(:to_omp_mime)
+    mime = (value.to_omp_mime rescue nil)
+    return __omp_finalize_bundle(__omp_normalize_bundle(mime), value) if mime.is_a?(Hash) && !mime.empty?
+  end
+  if value.respond_to?(:to_iruby_mimebundle)
+    data =
+      begin
+        value.to_iruby_mimebundle
+      rescue ArgumentError
+        (value.to_iruby_mimebundle(include: []) rescue nil)
+      rescue StandardError
+        nil
+      end
+    data = data.first if data.is_a?(Array)
+    return __omp_finalize_bundle(__omp_normalize_bundle(data), value) if data.is_a?(Hash) && !data.empty?
+  end
+  if value.respond_to?(:to_iruby)
+    pair = (value.to_iruby rescue nil)
+    if pair.is_a?(Array) && pair.size == 2 && !pair[0].nil?
+      return __omp_finalize_bundle(__omp_normalize_bundle({ pair[0].to_s => pair[1] }), value)
+    end
+  end
+  # Last resort: probe well-known image emitters. Named methods (to_png/to_jpeg)
+  # are trusted; the generic to_blob is accepted only when its bytes sniff as an
+  # image. Covers gems that render via IRuby's registry rather than to_iruby
+  # (Gruff#to_blob, ChunkyPNG#to_blob, RMagick, Vips, ...).
+  if value.respond_to?(:to_png)
+    png = (value.to_png rescue nil)
+    return __omp_finalize_bundle({ "image/png" => __omp_image_payload(png) }, value) if png
+  end
+  jpeg_method = %i[to_jpeg to_jpg].find { |m| value.respond_to?(m) }
+  if jpeg_method
+    jpg = (value.public_send(jpeg_method) rescue nil)
+    return __omp_finalize_bundle({ "image/jpeg" => __omp_image_payload(jpg) }, value) if jpg
+  end
+  if value.respond_to?(:to_blob)
+    blob = (value.to_blob rescue nil)
+    if blob.is_a?(String) && (mime = __omp_sniff_image_mime(blob))
+      return __omp_finalize_bundle({ mime => __omp_image_payload(blob) }, value)
+    end
+  end
+
+  nil
+end
+
 # Build a Jupyter-style MIME bundle for a value. Strings render as plain text,
-# Hash/Array render as JSON (plus a text/plain repr) so the model sees structure,
-# and anything else falls back to its inspect string. Objects may opt into a
-# richer bundle by defining `to_omp_mime` returning a Hash of mime => value.
+# Hash/Array render as JSON (plus a text/plain repr) so the model sees structure.
+# Other objects may expose a rich representation via `to_omp_mime` or the IRuby
+# protocol (`to_iruby`/`to_iruby_mimebundle`); otherwise they fall back to inspect.
 def __omp_mime_bundle(value)
   case value
   when String
@@ -151,12 +263,7 @@ def __omp_mime_bundle(value)
   when nil
     { "text/plain" => "nil" }
   else
-    if value.respond_to?(:to_omp_mime)
-      mime = (value.to_omp_mime rescue nil)
-      mime.is_a?(Hash) ? mime : { "text/plain" => __omp_scrub(value.inspect) }
-    else
-      { "text/plain" => __omp_scrub(value.inspect) }
-    end
+    __omp_rich_mime_bundle(value) || { "text/plain" => __omp_scrub(value.inspect) }
   end
 end