fitzgibbon/madrigal - Change ALIV37TMXXHTQ3Q2HHHEXLOQDNUZVZ3NNO6WN46DQBPJELDXJOXAC

Add org-mode request logging for agent edits

Created by G8qzBDPkyFWiTEg4ytm8NUw2bhYLjE9mvCJek2frJAVK on February 19, 2026

ALIV37TMXXHTQ3Q2HHHEXLOQDNUZVZ3NNO6WN46DQBPJELDXJOXAC

Dependencies

In channels

main

Change contents

Insertion in madrigal.el at line 21 [4.1]
[4.601]
[4.601]
```
(require 'org)
(require 'pp)
```

Insertion in madrigal.el at line 55 [4.1]

[4.1435]


(defcustom madrigal-log-buffer-name "*madrigal-log*"
  "Name of the org buffer used for madrigal request logs."
  :type 'string)
(defcustom madrigal-open-log-buffer t
  "When non-nil, open the madrigal log buffer when a request starts."
  :type 'boolean)
(defcustom madrigal-log-include-reasoning t
  "When non-nil, include model reasoning in the madrigal org log."
  :type 'boolean)
(defcustom madrigal-log-include-context t
  "When non-nil, include the full context window sent to the model in logs."
  :type 'boolean)
(defcustom madrigal-log-start-collapsed t
  "When non-nil, keep the madrigal org log folded to top-level headings."
  :type 'boolean)

Insertion in madrigal.el at line 87 [4.1]

[4.1821]

(defvar madrigal--log-request-seq 0)
(defvar madrigal--log-request-markers (make-hash-table :test #'equal))

Insertion in madrigal.el at line 94 [4.1]

[4.1883]


(defun madrigal--ensure-log-buffer ()
  (let ((buf (get-buffer-create madrigal-log-buffer-name)))
    (with-current-buffer buf
      (unless (derived-mode-p 'org-mode)
        (org-mode)))
    buf))
(defun madrigal--log-refresh-visibility (buffer)
  (when madrigal-log-start-collapsed
    (with-current-buffer buffer
      (when (derived-mode-p 'org-mode)
        (save-excursion
          (org-overview))))))
(defun madrigal--pp-string (obj)
  (with-temp-buffer
    (let ((print-length nil)
          (print-level nil))
      (pp obj (current-buffer))
      (buffer-string))))
(defun madrigal--log-insert-example-block (text)
  (insert "#+begin_example\n")
  (insert (or text ""))
  (unless (or (string-empty-p (or text ""))
              (string-suffix-p "\n" text))
    (insert "\n"))
  (insert "#+end_example\n\n"))
(defun madrigal--log-insert-src-block (obj)
  (let ((text (madrigal--pp-string obj)))
  (insert "#+begin_src emacs-lisp\n")
    (insert text)
    (unless (string-suffix-p "\n" text)
    (insert "\n"))
    (insert "#+end_src\n\n")))

Insertion in madrigal.el at line 132 [4.1]

[4.1884]

(defun madrigal--log-new-request (agent-id source-buffer prompt-text context-text)
  (let* ((buf (madrigal--ensure-log-buffer))
         (stamp (format-time-string "%Y-%m-%d %H:%M:%S"))
         (path (with-current-buffer source-buffer
                 (or buffer-file-name "(no file)")))
         (request-id (format "%s-%04d"
                             (format-time-string "%Y%m%dT%H%M%S")
                             (cl-incf madrigal--log-request-seq)))
         marker)
    (with-current-buffer buf
      (goto-char (point-max))
      (unless (bolp)
        (insert "\n"))
      (insert (format "* Request %s\n" stamp))
      (insert ":PROPERTIES:\n")
      (insert (format ":agent: %s\n" agent-id))
      (insert (format ":buffer: %s\n" (buffer-name source-buffer)))
      (insert (format ":path: %s\n" path))
      (insert (format ":request-id: %s\n" request-id))
      (insert ":END:\n\n")
      (insert "** User Prompt\n")
      (madrigal--log-insert-example-block prompt-text)
      (when madrigal-log-include-context
        (insert "** Context Window\n")
        (madrigal--log-insert-example-block context-text))
      (setq marker (copy-marker (point) t)))
    (puthash request-id marker madrigal--log-request-markers)
    (when madrigal-open-log-buffer
      (display-buffer buf))
    (madrigal--log-refresh-visibility buf)
    request-id))
(defun madrigal--log-append-heading (request-id level heading)
  (let* ((buf (madrigal--ensure-log-buffer))
         (marker (gethash request-id madrigal--log-request-markers)))
    (with-current-buffer buf
      (save-excursion
        (goto-char (if (and marker (marker-buffer marker)) marker (point-max)))
        (insert (make-string level ?*) " " heading "\n")
        (setf marker (copy-marker (point) t))
        (puthash request-id marker madrigal--log-request-markers)))
    (madrigal--log-refresh-visibility buf)
    buf))
(defun madrigal--log-append-example (request-id level heading text)
  (let ((buf (madrigal--log-append-heading request-id level heading)))
    (with-current-buffer buf
      (save-excursion
        (goto-char (gethash request-id madrigal--log-request-markers))
        (madrigal--log-insert-example-block text)
        (puthash request-id (copy-marker (point) t) madrigal--log-request-markers)))
    (madrigal--log-refresh-visibility buf)))
(defun madrigal--log-append-obj (request-id level heading obj)
  (let ((buf (madrigal--log-append-heading request-id level heading)))
    (with-current-buffer buf
      (save-excursion
        (goto-char (gethash request-id madrigal--log-request-markers))
        (madrigal--log-insert-src-block obj)
        (puthash request-id (copy-marker (point) t) madrigal--log-request-markers)))
    (madrigal--log-refresh-visibility buf)))
(defun madrigal--log-round (request-id round final)
  (when request-id
    (madrigal--log-append-heading request-id 2 (format "Round %d" round))
    (let ((reasoning (plist-get final :reasoning))
          (text (plist-get final :text))
          (tool-uses (plist-get final :tool-uses))
          (tool-results (plist-get final :tool-results)))
      (when (and madrigal-log-include-reasoning reasoning)
        (madrigal--log-append-example request-id 3 "Reasoning" (format "%s" reasoning)))
      (when (and text (> (length text) 0))
        (madrigal--log-append-example request-id 3 "Response" text))
      (when tool-uses
        (madrigal--log-append-obj request-id 3 "Tool Uses" tool-uses))
      (when tool-results
        (madrigal--log-append-obj request-id 3 "Tool Results" tool-results)))))
(defun madrigal--log-error (request-id heading etype message)
  (when request-id
    (madrigal--log-append-heading request-id 2 heading)
    (madrigal--log-append-obj request-id 3 "Error"
                              `((type . ,etype)
                                (message . ,message)))))
(defun madrigal--log-tool-op (request-id heading payload)
  (when request-id
    (madrigal--log-append-obj request-id 4 heading payload)))

Replacement in madrigal.el at line 438 [4.1]

B:BD[4.8074] → [4.8074:8120]

(defun madrigal--tool-exec-ops (agent-id ops)

[4.8074]

[4.8120]

(defun madrigal--tool-exec-ops (agent-id ops &optional request-id)

Replacement in madrigal.el at line 451 [4.1]

B:BD[4.8698] → [4.8698:8783]

             (op-name (if (symbolp op) (symbol-name op) op))
             (row nil))

[4.8698]

[4.8783]

              (op-name (if (symbolp op) (symbol-name op) op))
              (row nil))

Insertion in madrigal.el at line 455 [4.1]

[4.8880]

        (madrigal--log-tool-op request-id
                               (format "exec_ops input: %s" op-name)
                               raw-op)

Replacement in madrigal.el at line 460 [4.1]

B:BD[4.8948] → [4.8948:9172]

          ("open_file"
           (let* ((path0 (or (madrigal--alist-get* 'path raw-op)
                             (madrigal--alist-get* :path raw-op)))
                  (create0 (or (madrigal--alist-get* 'create raw-op)

[4.8948]

[4.9172]

                ("open_file"
            (let* ((path0 (or (madrigal--alist-get* 'path raw-op)
                              (madrigal--alist-get* :path raw-op)))
                   (create0 (or (madrigal--alist-get* 'create raw-op)

Replacement in madrigal.el at line 481 [4.1]

∅:D[3.3170] → [4.10133:10632]

B:BD[4.10133] → [4.10133:10632]

          ("list_buffers"
           (let (names)
             (maphash (lambda (k _v) (push k names))
                      (crdt--session-buffer-table madrigal--server-session))
             (setq row (append row (list (cons 'buffers (nreverse names)))))))
          ("switch_buffer"
           (let* ((name0 (or (madrigal--alist-get* 'network_name raw-op)
                             (madrigal--alist-get* :network_name raw-op)
                             (madrigal--alist-get* 'buffer raw-op)

[3.3170]

[4.10632]

                ("list_buffers"
            (let (names)
              (maphash (lambda (k _v) (push k names))
                       (crdt--session-buffer-table madrigal--server-session))
              (setq row (append row (list (cons 'buffers (nreverse names)))))))
                ("switch_buffer"
            (let* ((name0 (or (madrigal--alist-get* 'network_name raw-op)
                              (madrigal--alist-get* :network_name raw-op)
                              (madrigal--alist-get* 'buffer raw-op)

Replacement in madrigal.el at line 499 [4.1]

B:BD[3.3620] → [3.3620:3683]

∅:D[3.3683] → [4.10875:10910]

B:BD[4.10875] → [4.10875:10910]

B:BD[4.10910] → [3.3684:4219]

          ("get_point"
           (with-current-buffer replica
             (setq row (append row
                               (list (cons 'point (point))
                                     (cons 'region_active (and (use-region-p) t))
                                     (cons 'region_start (and (use-region-p) (region-beginning)))
                                     (cons 'region_end (and (use-region-p) (region-end))))))))
          ("goto_char"
           (let* ((pos0 (or (madrigal--alist-get* 'pos raw-op)
                            (madrigal--alist-get* :pos raw-op)))
                  (pos (madrigal--require-integer

[3.3620]

[3.4219]

                ("get_point"
            (with-current-buffer replica
              (setq row (append row
                                (list (cons 'point (point))
                                      (cons 'region_active (and (use-region-p) t))
                                      (cons 'region_start (and (use-region-p) (region-beginning)))
                                      (cons 'region_end (and (use-region-p) (region-end))))))))
                ("goto_char"
            (let* ((pos0 (or (madrigal--alist-get* 'pos raw-op)
                             (madrigal--alist-get* :pos raw-op)))
                   (pos (madrigal--require-integer

Replacement in madrigal.el at line 515 [4.1]

B:BD[3.4500] → [3.4500:4735]

          ("search_forward"
           (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                               (madrigal--alist-get* :needle raw-op)))
                  (count0 (or (madrigal--alist-get* 'count raw-op)

[3.4500]

[3.4735]

                ("search_forward"
            (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                                (madrigal--alist-get* :needle raw-op)))
                   (count0 (or (madrigal--alist-get* 'count raw-op)

Replacement in madrigal.el at line 543 [4.1]

B:BD[3.6104] → [3.6104:6413]

                                         (cons 'match_end (point))))))))
          ("search_backward"
           (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                               (madrigal--alist-get* :needle raw-op)))
                  (count0 (or (madrigal--alist-get* 'count raw-op)

[3.6104]

[3.6413]

                                         (cons 'match_end (point)))))))))
                ("search_backward"
            (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                                (madrigal--alist-get* :needle raw-op)))
                   (count0 (or (madrigal--alist-get* 'count raw-op)

Replacement in madrigal.el at line 573 [4.1]

B:BD[3.7793] → [3.7793:7908]

∅:D[3.7908] → [4.11273:11472]

B:BD[4.11273] → [4.11273:11472]

                                         (cons 'match_end (+ found (length needle)))))))))
          ("set_region"
           (let* ((start0 (or (madrigal--alist-get* 'start raw-op)
                              (madrigal--alist-get* :start raw-op)))
                  (end0 (or (madrigal--alist-get* 'end raw-op)

[3.7793]

[4.11472]

                                         (cons 'match_end (+ found (length needle))))))))))
                ("set_region"
            (let* ((start0 (or (madrigal--alist-get* 'start raw-op)
                               (madrigal--alist-get* :start raw-op)))
                   (end0 (or (madrigal--alist-get* 'end raw-op)

Replacement in madrigal.el at line 587 [4.1]

B:BD[3.8160] → [3.8160:8619]

                                       (cons 'point (with-current-buffer replica (point))))))))
          ("clear_region"
           (madrigal--clear-region replica)
           (setq row (append row (list (cons 'region_active nil)))))
          ("read_region"
           (let* ((start0 (or (madrigal--alist-get* 'start raw-op)
                              (madrigal--alist-get* :start raw-op)))
                  (end0 (or (madrigal--alist-get* 'end raw-op)

[3.8160]

[3.8619]

                                       (cons 'point (with-current-buffer replica (point)))))))))
                ("clear_region"
            (madrigal--clear-region replica)
            (setq row (append row (list (cons 'region_active nil)))))
                ("read_region"
            (let* ((start0 (or (madrigal--alist-get* 'start raw-op)
                               (madrigal--alist-get* :start raw-op)))
                   (end0 (or (madrigal--alist-get* 'end raw-op)

Replacement in madrigal.el at line 610 [4.1]

B:BD[4.12247] → [3.9354:9444]

∅:D[3.9444] → [4.12463:12530]

B:BD[4.12463] → [4.12463:12530]

B:BD[4.12649] → [4.12649:12727]

          ("insert_text"
           (let* ((text0 (or (madrigal--alist-get* 'text raw-op)
                             (madrigal--alist-get* :text raw-op)))
                  (text (format "%s" (madrigal--resolve-ref text0 results))))

[4.12247]

[4.12727]

                ("insert_text"
            (let* ((text0 (or (madrigal--alist-get* 'text raw-op)
                              (madrigal--alist-get* :text raw-op)))
                   (text (format "%s" (madrigal--resolve-ref text0 results))))

Replacement in madrigal.el at line 619 [4.1]

B:BD[4.13035] → [3.9445:9632]

          ("delete_selection"
           (with-current-buffer replica
             (pcase-let ((`(,s . ,e) (madrigal--region-bounds-required replica)))
               (delete-region s e)

[4.13035]

[3.9632]

                ("delete_selection"
            (with-current-buffer replica
              (pcase-let ((`(,s . ,e) (madrigal--region-bounds-required replica)))
                (delete-region s e)

Replacement in madrigal.el at line 627 [4.1]

B:BD[3.9847] → [3.9847:9943]

∅:D[3.9943] → [4.14222:14289]

B:BD[4.14222] → [4.14222:14289]

B:BD[4.14535] → [4.14535:14613]

          ("replace_selection"
           (let* ((text0 (or (madrigal--alist-get* 'text raw-op)
                             (madrigal--alist-get* :text raw-op)))
                  (text (format "%s" (madrigal--resolve-ref text0 results))))

[3.9847]

[4.14613]

                ("replace_selection"
            (let* ((text0 (or (madrigal--alist-get* 'text raw-op)
                              (madrigal--alist-get* :text raw-op)))
                   (text (format "%s" (madrigal--resolve-ref text0 results))))

Replacement in madrigal.el at line 640 [4.1]

B:BD[4.15084] → [3.10148:10380]

          ("replace_match"
           (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                               (madrigal--alist-get* :needle raw-op)))
                  (text0 (or (madrigal--alist-get* 'text raw-op)

[4.15084]

[3.10380]

                ("replace_match"
            (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                                (madrigal--alist-get* :needle raw-op)))
                   (text0 (or (madrigal--alist-get* 'text raw-op)

Replacement in madrigal.el at line 676 [4.1]

B:BD[3.12099] → [3.12099:12429]

                                            (cons 'point (or last-pos (point)))))))))))
          ("replace_in_selection"
           (let* ((bounds (madrigal--region-bounds-required replica))
                  (old0 (or (madrigal--alist-get* 'old_text raw-op)
                            (madrigal--alist-get* :old_text raw-op)))

[3.12099]

[3.12429]

                                            (cons 'point (or last-pos (point))))))))))
                ("replace_in_selection"
            (let* ((bounds (madrigal--region-bounds-required replica))
                   (old0 (or (madrigal--alist-get* 'old_text raw-op)
                             (madrigal--alist-get* :old_text raw-op)))

Replacement in madrigal.el at line 702 [4.1]

∅:D[3.13649] → [4.15084:15324]

B:BD[4.15084] → [4.15084:15324]

          ("save_buffer"
           (let ((server-buffer (madrigal--server-buffer-from-network-name network-name)))
             (unless (buffer-live-p server-buffer)
               (error "madrigal: no server buffer for %s" network-name))

[3.13649]

[4.15324]

                ("save_buffer"
            (let ((server-buffer (madrigal--server-buffer-from-network-name network-name)))
              (unless (buffer-live-p server-buffer)
                (error "madrigal: no server buffer for %s" network-name))

Replacement in madrigal.el at line 712 [4.1]

B:BD[4.15658] → [4.15658:15726]

          (_
           (error "madrigal: unknown op %s" op-name)))

[4.15658]

[4.15726]

                (_
                 (error "madrigal: unknown op %s" op-name)))
        (madrigal--log-tool-op request-id
                               (format "exec_ops output: %s" op-name)
                               row)

Replacement in madrigal.el at line 719 [4.1]

B:BD[4.15778] → [3.13650:13693]

          :results (nreverse results))))))

[4.15778]

[4.15819]

          :results (nreverse results))))

Replacement in madrigal.el at line 721 [4.1]

B:BD[4.15820] → [4.15820:15862]

(defun madrigal--exec-ops-tool (agent-id)

[4.15820]

[4.15862]

(defun madrigal--exec-ops-tool (agent-id &optional request-id)

Replacement in madrigal.el at line 738 [4.1]

∅:D[2.138] → [4.16336:16420]

B:BD[4.16336] → [4.16336:16420]

   :function (lambda (ops)
               (madrigal--tool-exec-ops agent-id ops))))

[2.138]

[4.16420]

    :function (lambda (ops)
                (condition-case err
                    (madrigal--tool-exec-ops agent-id ops request-id)
                  (error
                   (madrigal--log-tool-op request-id
                                          "exec_ops failure"
                                          `((error . ,(error-message-string err))))
                   (signal (car err) (cdr err)))))))

Replacement in madrigal.el at line 750 [4.1]

B:BD[4.16533] → [4.16533:16973]

(defun madrigal--run-model-loop (provider prompt rounds-left done)
  (if (<= rounds-left 0)
      (funcall done (list :status 'error :message "madrigal: max rounds reached"))
    (let* ((streaming-tool-use (madrigal--provider-capable-p 'streaming-tool-use))
           (streaming (madrigal--provider-capable-p 'streaming))
           (use-streaming (and streaming streaming-tool-use)))
      (if use-streaming
          (llm-chat-streaming

[4.16533]

[4.16973]

(defun madrigal--run-model-loop (provider prompt rounds-left done &optional request-id round)
  (let ((round-no (or round 1)))
    (if (<= rounds-left 0)
        (progn
          (madrigal--log-error request-id "Loop Error" 'max-rounds "madrigal: max rounds reached")
          (funcall done (list :status 'error :message "madrigal: max rounds reached")))
      (let* ((streaming-tool-use (madrigal--provider-capable-p 'streaming-tool-use))
             (streaming (madrigal--provider-capable-p 'streaming))
             (use-streaming (and streaming streaming-tool-use)))
        (if use-streaming
            (llm-chat-streaming
             provider prompt
             (lambda (partial)
               (let ((txt (plist-get partial :text)))
                 (when (and txt (> (length txt) 0))
                   (message "madrigal: %s" (truncate-string-to-width txt 120 nil nil t)))))
             (lambda (final)
               (madrigal--log-round request-id round-no final)
               (if (plist-get final :tool-results)
                   (madrigal--run-model-loop provider prompt (1- rounds-left) done request-id (1+ round-no))
                 (funcall done (list :status 'ok :result final))))
             (lambda (etype emsg)
               (madrigal--log-error request-id (format "Round %d Error" round-no) etype emsg)
               (funcall done (list :status 'error :etype etype :message emsg)))
             t)
          (llm-chat-async

Deletion in madrigal.el at line 777 [4.1]

B:BD[4.17000] → [4.17000:17221]

           (lambda (partial)
             (let ((txt (plist-get partial :text)))
               (when (and txt (> (length txt) 0))
                 (message "madrigal: %s" (truncate-string-to-width txt 120 nil nil t)))))

Insertion in madrigal.el at line 778 [4.1]

[4.17248]

             (madrigal--log-round request-id round-no final)

Replacement in madrigal.el at line 780 [4.1]

B:BD[4.17297] → [4.17297:17444]

                 (madrigal--run-model-loop provider prompt (1- rounds-left) done)
               (funcall done (list :status 'ok :result final))))

[4.17297]

[4.17444]

                 (madrigal--run-model-loop provider prompt (1- rounds-left) done request-id (1+ round-no))
               (funcall done (list :status 'ok :result final :fallback 'non-streaming-tool-use))))

Insertion in madrigal.el at line 783 [4.1]

[4.17476]

             (madrigal--log-error request-id (format "Round %d Error" round-no) etype emsg)

Replacement in madrigal.el at line 785 [4.1]

B:BD[4.17554] → [4.17554:17988]

           t)
        (llm-chat-async
         provider prompt
         (lambda (final)
           (if (plist-get final :tool-results)
               (madrigal--run-model-loop provider prompt (1- rounds-left) done)
             (funcall done (list :status 'ok :result final :fallback 'non-streaming-tool-use))))
         (lambda (etype emsg)
           (funcall done (list :status 'error :etype etype :message emsg)))
         t)))))

[4.17554]

[4.17988]

           t))))))

Replacement in madrigal.el at line 801 [4.1]

B:BD[4.18533] → [4.18533:18657]

  (let* ((_agent (madrigal--ensure-agent agent-id))
         (_shared (madrigal--ensure-shared-in-server (current-buffer)))

[4.18533]

[4.18657]

  (let* ((source-buffer (current-buffer))
         (context-text (plist-get (madrigal--context-window) :text))
         (request-id (madrigal--log-new-request agent-id source-buffer prompt-text context-text))
         (_agent (madrigal--ensure-agent agent-id))
         (_shared (madrigal--ensure-shared-in-server source-buffer))

Replacement in madrigal.el at line 807 [4.1]

B:BD[4.18696] → [4.18696:18879]

                  (madrigal--build-user-prompt prompt-text)
                  :context (madrigal--system-prompt)
                  :tools (list (madrigal--exec-ops-tool agent-id)))))

[4.18696]

[4.18879]

                   (madrigal--build-user-prompt prompt-text)
                   :context (madrigal--system-prompt)
                   :tools (list (madrigal--exec-ops-tool agent-id request-id)))))

Replacement in madrigal.el at line 811 [4.1]

B:BD[4.18909] → [4.18909:19000]

B:BD[4.19000] → [3.14125:14791]

     madrigal-llm-provider
     prompt
     madrigal-max-tool-rounds
     (lambda (status)
       (unwind-protect
           (pcase (plist-get status :status)
             ('ok
              (let* ((res (plist-get status :result))
                     (text (or (plist-get res :text) ""))
                     (fallback (plist-get status :fallback)))
                (if fallback
                    (message "madrigal: done (fallback %s). %s" fallback text)
                  (message "madrigal: done. %s" text))))
             (_
              (message "madrigal: error (%s) %s"
                       (or (plist-get status :etype) 'error)
                       (or (plist-get status :message) "unknown"))))
         (madrigal--drop-agent agent-id))))))

[4.18909]

[4.19553]

      madrigal-llm-provider
      prompt
      madrigal-max-tool-rounds
      (lambda (status)
        (unwind-protect
            (pcase (plist-get status :status)
              ('ok
               (let* ((res (plist-get status :result))
                      (text (or (plist-get res :text) ""))
                      (fallback (plist-get status :fallback)))
                 (madrigal--log-append-heading request-id 2 "Outcome")
                 (madrigal--log-append-obj request-id 3 "Status"
                                           `((status . ok)
                                             (fallback . ,fallback)
                                             (text . ,text)))
                 (if fallback
                     (message "madrigal: done (fallback %s). %s" fallback text)
                   (message "madrigal: done. %s" text))))
              (_
               (madrigal--log-append-heading request-id 2 "Outcome")
               (madrigal--log-append-obj request-id 3 "Status"
                                         `((status . error)
                                           (type . ,(or (plist-get status :etype) 'error))
                                           (message . ,(or (plist-get status :message) "unknown"))))
                (message "madrigal: error (%s) %s"
                        (or (plist-get status :etype) 'error)
                        (or (plist-get status :message) "unknown"))))
          (madrigal--drop-agent agent-id)))
      request-id)))