copilot-sdk-clojure/examples/session_events.clj at main · githubnext/copilot-sdk-clojure · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
(ns session-events
  "Example: Monitoring session state events.

   This example demonstrates how to observe and handle session events."
  (:require [clojure.core.async :refer [<!!]]
            [github.copilot-sdk :as copilot :refer [evt]]))

;; See examples/README.md for usage
(declare format-event)

(defn run
  "Run a conversation while monitoring all session state events."
  [{:keys [prompt model reasoning-effort]
    :or {prompt "Think hard - How many \"r\"s in strawberry?"
         model "gpt-5.2"
         reasoning-effort "high"}}]
  (copilot/with-client-session
      [client {:log-level :debug}
       session {:model model
                :streaming? true
                :reasoning-effort reasoning-effort}]
    (let [events-ch (copilot/subscribe-events session)
          all-events (atom [])]
      (copilot/send! session {:prompt prompt})
      (loop []
        (when-let [event (<!! events-ch)]
          (swap! all-events conj event)
          (println (format-event event))
          (condp = (:type event)
            (evt :session.idle)
            (do
              (println "\n=== Summary ===")
              (println (format "Total events: %d" (count @all-events)))
              (doseq [[evt-type cnt] (->> @all-events
                                          (map :type)
                                          frequencies
                                          (sort-by val >))]
                (println (format "  %s: %d" (name evt-type) cnt))))

            (evt :session.error)
            (println "\n⚠️  Session ended with error")

            ;; Keep looping for other events
            (recur)))))))

(defn format-event
  "Format a session event for display."
  [event]
  (let [event-type (:type event)
        data (:data event)
        ephemeral? (:ephemeral? event)]
    (condp = event-type
      (evt :session.start)
      (format "🚀 Session started: %s (model: %s)"
              (:session-id data)
              (or (:selected-model data) "default"))

      (evt :session.resume)
      (format "🔄 Session resumed at %s (%d events)"
              (:resume-time data)
              (or (:event-count data) 0))

      (evt :session.idle)
      "⏸️  Session idle - ready for input"

      (evt :session.error)
      (format "❌ Error [%s]: %s"
              (:error-type data)
              (:message data))

      (evt :session.info)
      (format "ℹ️  Info [%s]: %s"
              (:info-type data)
              (:message data))

      (evt :session.model_change)
      (format "🔀 Model changed: %s → %s"
              (or (:previous-model data) "none")
              (:new-model data))

      (evt :session.truncation)
      (format "✂️  Context truncated: %d tokens removed (%d → %d messages)"
              (or (:tokens-removed-during-truncation data) 0)
              (or (:pre-truncation-messages-length data) 0)
              (or (:post-truncation-messages-length data) 0))

      (evt :session.snapshot_rewind)
      (format "⏪ Snapshot rewind: rolled back to event %s (%d events removed)"
              (:up-to-event-id data)
              (or (:events-removed data) 0))

      (evt :session.usage_info)
      (format "📊 Usage: %d/%d tokens (%d messages)"
              (or (:current-tokens data) 0)
              (or (:token-limit data) 0)
              (or (:messages-length data) 0))

      (evt :session.compaction_start)
      "🗜️  Compaction starting..."

      (evt :session.compaction_complete)
      (if (:success data)
        (format "🗜️  Compaction complete: %d → %d tokens (%d removed)"
                (or (:pre-compaction-tokens data) 0)
                (or (:post-compaction-tokens data) 0)
                (or (:tokens-removed data) 0))
        (format "🗜️  Compaction failed: %s" (:error data)))

      (evt :session.handoff)
      (format "🤝 Session handoff from %s" (:source-type data))

      (evt :assistant.turn_start)
      "🎬 Assistant turn started"

      (evt :assistant.intent)
      (format "🎯 Intent: %s" (:intent data))

      (evt :assistant.reasoning)
      (format "💭 Reasoning: %s" (:content data))

      (evt :assistant.reasoning_delta)
      (format "💭 %s" (:delta-content data))

      (evt :assistant.message)
      (format "💬 Message: %s" (:content data))

      (evt :assistant.message_delta)
      (format "📝 %s" (:delta-content data))

      (evt :assistant.turn_end)
      "🏁 Assistant turn ended"

      (evt :assistant.usage)
      (format "📈 Usage: %d input, %d output tokens"
              (or (:input-tokens data) 0)
              (or (:output-tokens data) 0))

      ;; Default
      (format "📋 %s: %s%s"
              (name event-type)
              (pr-str data)
              (if ephemeral? " (ephemeral)" "")))))