Message compaction / summarisation for long-running conversation

[atensity]

A lot of times when the conversation goes on for a very long time; or when I use gptel-agent and there are a ton of tool-calls (e.g. Read tool calls), it becomes both expensive, and difficult for the LLM to keep all (correct) information in it's context. A lot of other providers, such as Anthropic/Claude have their message compaction systems, to avoid context rot.

So, thought I could try implementing something similar here. More or less, we set a context percentage limit when the compaction should occur (e.g 75% of context limit), we estimate token count from character count (i.e. 1:4 ratio) and by hooking into gptel-post-response-functions, determine whether compaction needs to be done.

I have been using it so far, and it seems to do a decent job. One thing I've noticed is that since gptel-agent's sub-agents initially weren't affected by this, I've made some adjustments that also tries to execute the same functionality in long-running sub-agents called by the "Agent" tool.

Note: A lot of this was done with the help of LLMs (using gptel + introspector of course!), as my Emacs Lisp skills aren't up to par. I'm sure there can be a lot of improvements, but I thought I would share something like this anyway just in case people could get some use out of this, or maybe even improve upon it!

;;; gptel-episodic.el --- Buffer-aware episodic memory for gptel  -*- lexical-binding: t; -*-

;;; Commentary:
;; `gptel-episodic` automated context management for 'gptel' by implementing a
;; "sliding" episodic memory.  Instead of allowing long-running conversations to
;; exceed the LLM's context window—leading to truncated history or API
;; errors—this package detects when a buffer or a background tool-agent is
;; approaching its limit and compresses the preceding transcript into a
;; structured summary.  This is the same as "compaction" as done by some of the
;; more popular LLM providers.

;;  Active `gptel` chat buffers are monitored via
;; 'gptel-post-response-functions'.  When the estimated token count (default:
;; 75% of context) is reached, the package asynchronously generates a summary
;; and sets a marker.  Subsequent requests are narrowed to the post-marker
;; region, with the summary injected as "Message 0" to maintain continuity.

;; Sub-agents (i.e. background agents spawned by the `Agent` tool), which run in
;; an FSM loop without a visible buffer, are also managed.  The package
;; intercepts the `WAIT` state of the FSM to truncate the growth of the
;; `:messages` vector, replacing the intermediary "thought-action-result" chain
;; with a single summary message.  I wasn't able to find a better way to manage
;; sub-agents that were spawned to also have this available

;; Configurable `gptel-episodic-model` to use a faster/cheaper model for
;; creating summaries instead of using the main model.

;; The memory/summary checkpoints are serialized into `org-mode` properties or
;; file-local variables, so it can be picked back up on opening.

;; We do not delete buffer text.  Summarization markers are indicated by
;; overlays, and the original transcript remains visible to the user.

;; Token Estimation: Uses a character-count-to-token ratio (1:4) for
;; performance and as rough estimate It queries the `:context-window` property
;; from the 'gptel-model' symbol, falling back to 128k if undefined.

;; How does this get accomplished? 'gptel--create-prompt-buffer' is advised to
;; handle the injection of the summary.  This is the most stable injection point
;; as it targets the temporary buffer used by 'gptel' to construct the final
;; JSON payload that gets sent off to the LLM.

;; By advising 'gptel--handle-wait' we can "pause" the FSM.  Because 'gptel'
;; agents are asynchronous, delaying the call to `orig-fun` until the
;; summarization callback hopefully create a non-blocking pause for any
;; background task





;;Code:
(require 'gptel)
(require 'cl-lib)

;; Declared but not required -- loaded only when gptel-agent is in use.
(defvar gptel-agent-request--handlers)

(defgroup gptel-episodic nil
  "Episodic memory compression for gptel."
  :group 'gptel)


;;; --- Customisation -----------------------------------------------------------

(defcustom gptel-episodic-token-threshold 0.75
  "Compact context when estimated usage exceeds this fraction of the model window.

0.75 means compact when the conversation is approximately 75% full."
  :type 'float
  :group 'gptel-episodic)

(defcustom gptel-episodic-backend nil
  "Backend used for summarization.  nil means use the buffer's `gptel-backend'."
  :type '(choice (const :tag "Default backend" nil)
                 (restricted-sexp :match-alternatives (gptel-backend-p 'nil)
                                  :tag "Specific backend"))
  :group 'gptel-episodic)

(defcustom gptel-episodic-model nil
  "Model used for summarization.  nil means use the buffer's `gptel-model'.

A cheaper/faster model reduces compaction cost without affecting the main
conversation."
  :type '(choice (const :tag "Default model" nil)
                 (symbol :tag "Model symbol"))
  :group 'gptel-episodic)

(defcustom gptel-episodic-worker-compaction t
  "When non-nil, also compact context for worker agents spawned via the Agent tool.

Worker agents run in an internal FSM loop rather than a visible buffer.
When this is enabled and `gptel-episodic-mode' is active, each worker's
message history is compacted when it approaches the model's context window.

The worker is briefly paused while summarization runs asynchronously, then
resumes automatically.  The total round-trip cost increases slightly but
the worker can continue indefinitely regardless of task length."
  :type 'boolean
  :group 'gptel-episodic)


;;; --- Buffer-local state ------------------------------------------------------

(defvar-local gptel-episodic--memories nil
  "List of (MARKER . SUMMARY-STRING) cons cells, newest first.

MARKER points to the position in the buffer where compaction occurred.
On each gptel request the buffer is narrowed to content after the latest
marker, and the summary is injected as a synthetic opening exchange.

The actual buffer text before the marker is never deleted or altered.")

(defvar-local gptel-episodic--inhibited nil
  "Non-nil while building or processing a summarization request.
Prevents the post-response hook from triggering compaction recursively.")

(defvar-local gptel-episodic--pending nil
  "Non-nil while a buffer-level summarization request is in flight (async).")

(defvar-local gptel-episodic--saved-memories nil
  "Serialized (OFFSET . SUMMARY) pairs for file persistence.

Written as a file-local variable by `gptel-episodic--save-state'; read
back when the mode is re-enabled.  Offsets are converted to/from markers.")

(put 'gptel-episodic--saved-memories 'safe-local-variable
     (lambda (v)
       (and (listp v)
            (cl-every (lambda (e)
                        (and (consp e) (integerp (car e)) (stringp (cdr e))))
                      v))))

;; Worker compaction state -- not buffer-local (workers have no visible buffer).
(defvar gptel-episodic--worker-pending (make-hash-table :test 'eq)
  "Hash table mapping worker FSMs currently undergoing compaction to t.

Prevents a second compaction from being triggered while one is already in
flight for the same FSM.")


;;; --- Token estimation --------------------------------------------------------

(defun gptel-episodic--context-window-tokens (&optional model)
  "Return MODEL's context window size in tokens.

The :context-window property on the model symbol is in thousands of tokens
(e.g. 128 means 128k), matching the pattern in gptel-transient.el:1274.
Falls back to 128k when unset.  MODEL defaults to `gptel-model'."
  (round (* (or (get (or model gptel-model) :context-window) 128) 1000)))

(defun gptel-episodic--estimate-tokens (end)
  "Estimate tokens that will be in the next buffer-level request up to END.

Counts characters from the latest memory marker (or buffer start) to END,
divided by 4 -- a standard English text approximation."
  (let ((start (if gptel-episodic--memories
                   (marker-position (caar gptel-episodic--memories))
                 (point-min))))
    (/ (max 0 (- end start)) 4)))


;;; --- Shared transcript/summary helpers ---------------------------------------

(defconst gptel-episodic--summary-prompt
  "Your task is to create a structured summary of the conversation or work log
above.  This summary will be the ONLY context available when execution continues
-- the original messages will be discarded.  Preserve all information needed to
continue without any reference to the original transcript.

Write your summary inside <summary> tags using exactly this structure:

<summary>
1. Primary topic and user intent: [What is this about?]
2. Key facts and conclusions: [Facts, answers, decisions, or results so far]
3. User preferences and constraints: [Stated preferences, style, requirements]
4. Unresolved questions and pending items: [What has not yet been completed]
5. Current state: [What was most recently being discussed or worked on]
</summary>

Be thorough.  Omit nothing needed to continue seamlessly."
  "Prompt appended to transcripts when requesting compaction summaries.")

(defun gptel-episodic--extract-summary (response)
  "Extract text inside <summary>...</summary> from RESPONSE.

Falls back to the full trimmed response when tags are absent."
  (if (string-match
       "<summary>\\([\0-\377[:nonascii:]]*?\\)</summary>"
       response)
      (string-trim (match-string 1 response))
    (string-trim response)))

(defun gptel-episodic--messages-to-string (messages)
  "Convert MESSAGES (list of backend message plists) to a plain-text transcript.

Handles string content and multi-part content vectors, as returned by
`gptel--parse-buffer' for media-capable backends."
  (mapconcat
   (lambda (msg)
     (let* ((role    (plist-get msg :role))
            (content (plist-get msg :content))
            (text    (cond
                      ((stringp content) content)
                      ((or (vectorp content) (listp content))
                       (mapconcat
                        (lambda (part)
                          (or (and (listp part) (plist-get part :text)) ""))
                        (if (vectorp content) (append content nil) content)
                        " "))
                      (t ""))))
       (format "%s: %s" (capitalize (or role "unknown")) (string-trim text))))
   messages "\n\n"))


;;; ==========================================================================
;;; PART 1: Buffer-level compaction (lead agent / regular gptel buffers)
;;; ==========================================================================

;;; --- Buffer summarization request -------------------------------------------

(defun gptel-episodic--trigger-summary (end)
  "Send an async request to summarize the buffer conversation up to END.

END is a buffer position immediately after the latest response.  A marker
is saved at this position and used to narrow all subsequent requests.
The buffer content is never modified."
  (let* ((source-buf (current-buffer))
         (cut-marker (copy-marker end))
         (transcript
          (let ((gptel-episodic--inhibited t))
            (save-excursion
              (goto-char end)
              (let* ((prompt-buf (gptel--create-prompt-buffer (copy-marker end)))
                     (messages
                      (with-current-buffer prompt-buf
                        (unwind-protect
                            (gptel--parse-buffer gptel-backend nil)
                          (kill-buffer prompt-buf)))))
                (gptel-episodic--messages-to-string messages))))))
    (when (and transcript (not (string-blank-p (string-trim transcript))))
      (message "gptel-episodic: Condensing memory...")
      (let ((gptel-episodic--inhibited t)
            (gptel-backend (or gptel-episodic-backend gptel-backend))
            (gptel-model   (or gptel-episodic-model   gptel-model)))
        (gptel-request
         (format "Here is a conversation transcript:\n\n%s\n\n%s"
                 transcript gptel-episodic--summary-prompt)
         :buffer source-buf
         :callback
         (lambda (response _info)
           (when (and (stringp response) (buffer-live-p source-buf))
             (with-current-buffer source-buf
               (let ((summary (gptel-episodic--extract-summary response)))
                 (push (cons cut-marker summary) gptel-episodic--memories)
                 (setq gptel-episodic--pending nil)
                 (let ((ov (make-overlay cut-marker cut-marker source-buf)))
                   (overlay-put ov 'gptel-episodic t)
                   (overlay-put ov 'before-string
                                (propertize
                                 (format "\n[* Memory compacted -- %d chars ]\n"
                                         (length summary))
                                 'face 'shadow))))
               (message "gptel-episodic: Memory consolidated.")))))))))

;;; --- Buffer post-response hook ----------------------------------------------

(defun gptel-episodic--post-response (_beg end)
  "Check whether to compact the buffer context after each gptel response.

_BEG and END are bounds provided by `gptel-post-response-functions'."
  (unless (or gptel-episodic--inhibited gptel-episodic--pending)
    (let* ((estimated (gptel-episodic--estimate-tokens end))
           (window    (gptel-episodic--context-window-tokens))
           (fraction  (/ (float estimated) window)))
      (when (>= fraction gptel-episodic-token-threshold)
        (setq gptel-episodic--pending t)
        (gptel-episodic--trigger-summary end)))))

;;; --- Prompt buffer advice (narrows to post-compaction text + injects summary)

;; Narrowing note: gptel--create-prompt-buffer (gptel-request.el) uses
;; (gptel--with-buffer-copy buf (point-min) prompt-end ...) where (point-min)
;; respects active narrowing.  gptel-org--create-prompt-buffer (gptel-org.el)
;; also discards positions before (point-min).
;;
;; Text property conventions (gptel-request.el):
;;   User turns  -> plain insert, no 'gptel property
;;   LLM turns   -> (propertize text 'gptel 'response)

(defun gptel-episodic--create-prompt-buffer-advice (orig-fun &optional prompt-end)
  "Around advice for `gptel--create-prompt-buffer' applying episodic memory."
  (if (or gptel-episodic--inhibited (null gptel-episodic--memories))
      (funcall orig-fun prompt-end)
    (let* ((latest  (car gptel-episodic--memories))
           (marker  (car latest))
           (summary (cdr latest))
           temp-buf)
      (save-restriction
        (narrow-to-region marker (point-max))
        (setq temp-buf (funcall orig-fun prompt-end)))
      (when (buffer-live-p temp-buf)
        (with-current-buffer temp-buf
          (save-excursion
            (goto-char (point-min))
            (let ((inhibit-read-only t))
              (insert "What has been discussed in our conversation so far?\n")
              (let ((resp-start (point)))
                (insert
                 (format "The following is a complete summary of our conversation \
prior to this point.  Everything described below is accurate context for \
continuing our discussion:\n\n%s\n\n" summary))
                (put-text-property resp-start (point) 'gptel 'response))))))
      temp-buf)))


;;; --- Persistence ------------------------------------------------------------

(defun gptel-episodic--save-state ()
  "Serialize `gptel-episodic--memories' to disk alongside gptel state.
Called via `gptel-save-state-hook'.  Converts markers to character offsets."
  (when gptel-episodic--memories
    (let* ((serialized
            (mapcar (lambda (cell)
                      (cons (marker-position (car cell)) (cdr cell)))
                    gptel-episodic--memories))
           (print-escape-newlines t))
      (if (derived-mode-p 'org-mode)
          (progn
            (require 'gptel-org)
            (org-with-wide-buffer
             (org-entry-put (point-min) "GPTEL_EPISODIC_MEMORIES"
                            (prin1-to-string serialized))))
        (add-file-local-variable
         'gptel-episodic--saved-memories serialized)))))

(defun gptel-episodic--restore-state ()
  "Restore `gptel-episodic--memories' when the mode is enabled.
Reads (OFFSET . SUMMARY) pairs and converts offsets back to markers."
  (let ((serialized
         (if (derived-mode-p 'org-mode)
             (when-let* ((raw (progn
                                (require 'gptel-org)
                                (org-with-wide-buffer
                                 (org-entry-get (point-min)
                                                "GPTEL_EPISODIC_MEMORIES")))))
               (condition-case nil (read raw) (error nil)))
           gptel-episodic--saved-memories)))
    (when (and serialized (listp serialized))
      (setq gptel-episodic--memories
            (mapcar (lambda (cell)
                      (cons (set-marker (make-marker) (car cell))
                            (cdr cell)))
                    serialized))
      (dolist (cell gptel-episodic--memories)
        (when (marker-position (car cell))
          (let ((ov (make-overlay (car cell) (car cell) (current-buffer))))
            (overlay-put ov 'gptel-episodic t)
            (overlay-put ov 'before-string
                         (propertize
                          (format "\n[* Memory compacted -- %d chars ]\n"
                                  (length (cdr cell)))
                          'face 'shadow)))))
      (message "gptel-episodic: Restored %d memory checkpoint(s)."
               (length gptel-episodic--memories)))))


;;; ==========================================================================
;;; PART 2: Worker-agent compaction (FSM-level, no visible buffer)
;;; ==========================================================================
;;
;; Worker agents are spawned by `gptel-agent--task' (gptel-agent-tools.el) via
;; `gptel-request' with a STRING prompt.  When prompt is a string,
;; 'gptel--realize-query' (gptel-request.el) bypasses 'gptel--create-prompt-buffer'
;; entirely, so our normal method of doing the compaction (Part 1's advice)
;; never fires.  Instead the worker's history lives in the FSM's (plist-get info
;; :data) plist, with :messages as a vector that grows via 'gptel--inject-prompt'
;; after every tool round.
;;
;; We can try to intercept 'gptel--handle-wait' (gptel-request.el) instead.
;; This is called when the FSM transitions to WAIT state, AFTER all tool results
;; are injected into :data, but BEFORE the HTTP request fires.  The :data plist
;; (including :messages) is JSON-encoded at HTTP-fire time, so
;; replacing :messages in :data before calling orig-fun should send the compacted
;; history.
;;
;; Worker FSM detection: the worker FSM is created with
;;   (gptel-make-fsm :handlers gptel-agent-request--handlers)
;; gptel-agent-request--handlers is a module-level defvar (not a let binding),
;; stored directly into the FSM struct slot.  eq comparison is reliable.
;;
;; Pause/resume: we simply do NOT call orig-fun until compaction completes.
;; The FSM is effectively frozen at WAIT state.  After the async summary
;; callback replaces :messages, it calls orig-fun to fire the HTTP request.

(defun gptel-episodic--worker-content-string (content)
  "Extract a plain text string from a message :content value.

CONTENT may be a string, a vector of typed parts (Anthropic format),
or a list of typed parts."
  (cond
   ((stringp content) content)
   ((or (vectorp content) (listp content))
    (mapconcat (lambda (part)
                 (or (and (listp part)
                          (or (plist-get part :text)
                              (plist-get part :content)))
                     ""))
               (if (vectorp content) (append content nil) content)
               " "))
   (t "")))

(defun gptel-episodic--worker-messages-chars (messages)
  "Estimate total character count across all messages in the MESSAGES vector."
  (cl-loop for msg across messages
           sum (length (gptel-episodic--worker-content-string
                        (plist-get msg :content)))))

(defun gptel-episodic--worker-transcript (messages)
  "Build a human-readable transcript string from the MESSAGES vector."
  (mapconcat
   (lambda (msg)
     (let ((role    (or (plist-get msg :role) "unknown"))
           (content (gptel-episodic--worker-content-string
                     (plist-get msg :content))))
       (format "%s: %s" (capitalize role) (string-trim content))))
   messages "\n\n"))

(defun gptel-episodic--worker-summary-message (backend summary)
  "Build an assistant message plist containing SUMMARY in BACKEND's wire format.

Anthropic expects :content as a vector of typed text parts.
OpenAI-compatible backends accept :content as a plain string."
  (if (cl-typep backend 'gptel-anthropic)
      (list :role "assistant"
            :content (vector (list :type "text" :text summary)))
    (list :role "assistant" :content summary)))

(defun gptel-episodic--worker-handle-wait-advice (orig-fun fsm)
  "Around advice on `gptel--handle-wait' that compacts worker-agent context.

Fires only when ALL of the following hold:
  - `gptel-episodic-mode' is active in the lead agent's buffer
  - `gptel-episodic-worker-compaction' is non-nil
  - FSM is a worker FSM (identified by its handlers list)
  - :messages in :data exceeds `gptel-episodic-token-threshold'
  - No compaction is already in flight for this FSM

When triggered the HTTP request is deferred until the async summarization
callback fires, at which point :messages is replaced and orig-fun is called
to resume normally."
  (let* ((info     (gptel-fsm-info fsm))
         (data     (and info (plist-get info :data)))
         (messages (and data (plist-get data :messages))))
    (if (not (and gptel-episodic-worker-compaction
                  ;; Only act on worker FSMs, not lead-agent or other requests.
                  (boundp 'gptel-agent-request--handlers)
                  (eq (gptel-fsm-handlers fsm) gptel-agent-request--handlers)
                  ;; Only when the lead-agent buffer has episodic-mode active.
                  (buffer-live-p (plist-get info :buffer))
                  (buffer-local-value 'gptel-episodic-mode (plist-get info :buffer))
                  ;; Need at least a few turns before it's worth compacting.
                  (vectorp messages)
                  (>= (length messages) 4)
                  ;; Not already compacting this FSM.
                  (not (gethash fsm gptel-episodic--worker-pending))))
        (funcall orig-fun fsm)
      ;; Check token threshold using the model stored in the FSM info.
      (let* ((model         (plist-get info :model))
             (window-tokens (gptel-episodic--context-window-tokens model))
             (estimated     (/ (gptel-episodic--worker-messages-chars messages) 4))
             (fraction      (/ (float estimated) window-tokens)))
        (if (< fraction gptel-episodic-token-threshold)
            (funcall orig-fun fsm)
          ;; --- Compact: pause FSM, summarize, resume. ---
          (puthash fsm t gptel-episodic--worker-pending)
          (message "gptel-episodic: Compacting worker (%d messages, ~%dk tokens)..."
                   (length messages) (/ estimated 1000))
          (let* ((backend   (plist-get info :backend))
                 (first-msg (aref messages 0)) ; preserve original task prompt
                 (transcript (gptel-episodic--worker-transcript messages))
                 (lead-buf  (plist-get info :buffer))
                 ;; Use episodic backend/model if configured, else lead agent's.
                 (gptel-backend (with-current-buffer lead-buf
                                  (or gptel-episodic-backend gptel-backend)))
                 (gptel-model   (with-current-buffer lead-buf
                                  (or gptel-episodic-model gptel-model))))
            (gptel-request
             (format "Here is a work log from an autonomous agent:\n\n%s\n\n%s"
                     transcript gptel-episodic--summary-prompt)
             :buffer lead-buf
             ;; No tools -- we want a plain text summary, not more tool calls.
             :transforms nil
             :callback
             (lambda (response _resp-info)
               (remhash fsm gptel-episodic--worker-pending)
               (if (not (stringp response))
                   (progn
                     (message "gptel-episodic: Worker compaction failed, resuming.")
                     (funcall orig-fun fsm))
                 (let* ((summary     (gptel-episodic--extract-summary response))
                        (summary-msg (gptel-episodic--worker-summary-message
                                      backend summary)))
                   ;; Replace :messages with [original-task-prompt, summary].
                   ;; :data is a live plist -- this mutation is visible to the
                   ;; FSM immediately (gptel-request.el:2475 reads it at fire time).
                   (plist-put data :messages (vector first-msg summary-msg))
                   (message "gptel-episodic: Worker context compacted.")
                   ;; Resume the FSM: fire the actual HTTP request.
                   (funcall orig-fun fsm)))))))))))


;;; ==========================================================================
;;; Minor mode
;;; ==========================================================================

;;;###autoload
(define-minor-mode gptel-episodic-mode
  "Episodic memory compression for gptel chat buffers.

BUFFER-LEVEL COMPACTION (Part 1)

When the estimated token count in the current buffer approaches the model's
context window (controlled by `gptel-episodic-token-threshold', default 75%),
the conversation is automatically summarized:

1. The full conversation is sent to the LLM with a structured summarization
   prompt (optionally using a cheaper model via `gptel-episodic-model').

2. The summary is stored as a (MARKER . TEXT) pair.  The marker records where
   compaction occurred in the buffer.

3. All subsequent requests are narrowed to the text AFTER the marker.  The
   summary is injected as a synthetic prior-context exchange.

The buffer content is NEVER modified.  Narrowing is temporary (protected by
`save-restriction') and overlays are display-only.

WORKER-AGENT COMPACTION (Part 2)

When `gptel-episodic-worker-compaction' is non-nil (the default), worker
agents spawned by the `Agent' tool are also compacted.  Worker history lives
inside the FSM's :data plist rather than a visible buffer.

The FSM is briefly paused before each network request if the accumulated
:messages vector exceeds the threshold.  An async summarization runs, the
:messages vector is replaced with [original-task, summary], and the request
resumes.  The worker is unaware this happened.

PERSISTENCE

Memory checkpoints are saved on file write via `gptel-save-state-hook' and
restored when the mode is re-enabled.  Org buffers use a
GPTEL_EPISODIC_MEMORIES property; other buffers use a file-local variable."
  :lighter " G-Mem"
  (if gptel-episodic-mode
      (progn
        ;; Part 1: buffer-level compaction
        (add-hook 'gptel-post-response-functions
                  #'gptel-episodic--post-response nil t)
        (add-hook 'gptel-save-state-hook
                  #'gptel-episodic--save-state nil t)
        (advice-add 'gptel--create-prompt-buffer :around
                    #'gptel-episodic--create-prompt-buffer-advice)
        (gptel-episodic--restore-state)
        ;; Part 2: worker-agent compaction (global advice, filtered inside)
        (advice-add 'gptel--handle-wait :around
                    #'gptel-episodic--worker-handle-wait-advice))
    ;; Disable
    (remove-hook 'gptel-post-response-functions
                 #'gptel-episodic--post-response t)
    (remove-hook 'gptel-save-state-hook
                 #'gptel-episodic--save-state t)
    (advice-remove 'gptel--create-prompt-buffer
                   #'gptel-episodic--create-prompt-buffer-advice)
    (advice-remove 'gptel--handle-wait
                   #'gptel-episodic--worker-handle-wait-advice)
    (setq gptel-episodic--memories nil
          gptel-episodic--pending  nil)
    (clrhash gptel-episodic--worker-pending)
    (remove-overlays nil nil 'gptel-episodic t)))

(provide 'gptel-episodic)
;;; gptel-episodic.el ends here

[Jeremias-A-Queiroz]

This is gold!!!