Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

add context details

Justin D'Souzab9fbdbf49531
diff --git a/cli/beacon/internal/cursorsession/collect_test.go b/cli/beacon/internal/cursorsession/collect_test.go
index 5fd589a7..aaa47fcf 100644
--- a/cli/beacon/internal/cursorsession/collect_test.go
+++ b/cli/beacon/internal/cursorsession/collect_test.go
@@ -30,6 +30,8 @@ func TestCollectGlobalStorageComposer(t *testing.T) {
"bubbleId:composer-1:t1": `{
"type":2,
"createdAt":"2026-09-19T20:00:02Z",
+ "context_tokens":185000,
+ "context_window_size":200000,
"toolFormerData":{"name":"run_terminal_cmd","params":"{\"command\":\"go test ./...\"}","result":"ok","status":"success"}
}`,
})
@@ -58,6 +60,10 @@ func TestCollectGlobalStorageComposer(t *testing.T) {
if got := nested(events[3], "harness")["collection_method"]; got != "poll" {
t.Fatalf("collection method = %v, want poll", got)
}
+ context := nested(events[3], "gen_ai", "context")
+ if context["used_tokens"] != float64(185000) || context["limit_tokens"] != float64(200000) {
+ t.Fatalf("context = %#v, want used/limit tokens", context)
+ }
}
func TestCollectTranscriptJSONL(t *testing.T) {
@@ -68,7 +74,7 @@ func TestCollectTranscriptJSONL(t *testing.T) {
}
if err := os.WriteFile(filepath.Join(project, "session-1.jsonl"), []byte(strings.Join([]string{
`{"type":"user_message","id":"u1","text":"hello","timestamp":"2026-09-19T20:00:00Z"}`,
- `{"type":"message","id":"a1","message":{"role":"assistant","content":[{"type":"reasoning","text":"thinking"},{"type":"text","text":"hi"}],"model":"claude-sonnet-4"},"timestamp":"2026-09-19T20:00:01Z"}`,
+ `{"type":"message","id":"a1","contextTokens":42,"contextWindowSize":100,"message":{"role":"assistant","content":[{"type":"reasoning","text":"thinking"},{"type":"text","text":"hi"}],"model":"claude-sonnet-4"},"timestamp":"2026-09-19T20:00:01Z"}`,
`{"type":"tool_call","id":"c1","toolCall":{"id":"call-1","name":"read_file","args":{"path":"/tmp/a.txt"}},"timestamp":"2026-09-19T20:00:02Z"}`,
}, "\n")), 0o644); err != nil {
t.Fatal(err)
@@ -94,6 +100,10 @@ func TestCollectTranscriptJSONL(t *testing.T) {
if got := nested(events[1], "gen_ai", "output")["messages"]; got == nil {
t.Fatalf("reasoning event missing gen_ai output: %#v", events[1])
}
+ context := nested(events[1], "gen_ai", "context")
+ if context["used_tokens"] != float64(42) || context["limit_tokens"] != float64(100) {
+ t.Fatalf("transcript context = %#v, want used/limit tokens", context)
+ }
}
func writeCursorDB(t *testing.T, path string, kv map[string]string) {
diff --git a/cli/beacon/internal/cursorsession/mapper.go b/cli/beacon/internal/cursorsession/mapper.go
index 91862fa8..d8b87f5c 100644
--- a/cli/beacon/internal/cursorsession/mapper.go
+++ b/cli/beacon/internal/cursorsession/mapper.go
@@ -158,6 +158,18 @@ func baseEvent(ref TraceRef, record Record, action, category string, severity sc
if record.Model != "" {
ev.Model = asymptoteobserve.NormalizeModelName(record.Model)
}
+ if record.ContextUsedTokens > 0 || record.ContextLimitTokens > 0 {
+ ev.GenAI = withGenAI(ev.GenAI, func(genAI *schema.GenAIInfo) {
+ context := &schema.GenAIContextInfo{}
+ if record.ContextUsedTokens > 0 {
+ context.UsedTokens = &record.ContextUsedTokens
+ }
+ if record.ContextLimitTokens > 0 {
+ context.LimitTokens = &record.ContextLimitTokens
+ }
+ genAI.Context = context
+ })
+ }
return ev
}
diff --git a/cli/beacon/internal/cursorsession/parse.go b/cli/beacon/internal/cursorsession/parse.go
index ae30201e..d4149d28 100644
--- a/cli/beacon/internal/cursorsession/parse.go
+++ b/cli/beacon/internal/cursorsession/parse.go
@@ -131,9 +131,10 @@ func coerceTranscriptCandidates(v interface{}) []transcriptRecord {
func appendTranscriptMessage(out *[]Record, pending map[string]Record, msg map[string]interface{}, baseID string, ts int64, fallbackRole, fallbackModel string, order int) int {
role := normalizeRole(firstNonEmpty(pickString(msg, "role"), fallbackRole))
model := firstNonEmpty(pickString(msg, "modelId", "model"), fallbackModel)
+ used, limit := contextFromAny(msg)
if role == "user" {
if text := messageText(msg); text != "" {
- *out = append(*out, Record{Order: order, NativeID: baseID, Type: "user_message", TimestampMS: ts, Content: stripUserQueryTags(text), Model: model})
+ *out = append(*out, Record{Order: order, NativeID: baseID, Type: "user_message", TimestampMS: ts, ContextUsedTokens: used, ContextLimitTokens: limit, Content: stripUserQueryTags(text), Model: model})
order++
}
return order
@@ -144,15 +145,17 @@ func appendTranscriptMessage(out *[]Record, pending map[string]Record, msg map[s
if strings.TrimSpace(thinking) == "" {
continue
}
- *out = append(*out, Record{Order: order, NativeID: fmt.Sprintf("%s:thinking:%d", baseID, i), Type: "agent_thinking", TimestampMS: ts, Content: thinking, Model: model})
+ *out = append(*out, Record{Order: order, NativeID: fmt.Sprintf("%s:thinking:%d", baseID, i), Type: "agent_thinking", TimestampMS: ts, ContextUsedTokens: used, ContextLimitTokens: limit, Content: thinking, Model: model})
order++
}
if text := messageText(msg); text != "" {
- *out = append(*out, Record{Order: order, NativeID: baseID, Type: "agent_text", TimestampMS: ts, Content: text, Model: model})
+ *out = append(*out, Record{Order: order, NativeID: baseID, Type: "agent_text", TimestampMS: ts, ContextUsedTokens: used, ContextLimitTokens: limit, Content: text, Model: model})
order++
}
for _, call := range toolCallsFromMessage(msg) {
r := transcriptToolCall(call, baseID, ts, order)
+ r.ContextUsedTokens = used
+ r.ContextLimitTokens = limit
pending[r.CallID] = r
*out = append(*out, r)
order++
@@ -160,7 +163,7 @@ func appendTranscriptMessage(out *[]Record, pending map[string]Record, msg map[s
return order
}
if text := messageText(msg); text != "" {
- *out = append(*out, Record{Order: order, NativeID: baseID, Type: "agent_text", TimestampMS: ts, Content: text, Model: model})
+ *out = append(*out, Record{Order: order, NativeID: baseID, Type: "agent_text", TimestampMS: ts, ContextUsedTokens: used, ContextLimitTokens: limit, Content: text, Model: model})
order++
}
return order
@@ -231,7 +234,8 @@ func transcriptToolCall(call map[string]interface{}, baseID string, ts int64, or
callID := firstNonEmpty(pickString(call, "id", "toolCallId", "callId"), baseID+":call")
name := firstNonEmpty(pickString(call, "name", "toolName", "tool"), "unknown_tool")
args := objectArgs(firstNonNil(call["args"], call["arguments"], call["params"], call["input"]))
- return Record{Order: order, NativeID: baseID + ":tool_call", Type: "tool_call", TimestampMS: ts, CallID: callID, ToolName: name, Args: args}
+ used, limit := contextFromAny(call)
+ return Record{Order: order, NativeID: baseID + ":tool_call", Type: "tool_call", TimestampMS: ts, ContextUsedTokens: used, ContextLimitTokens: limit, CallID: callID, ToolName: name, Args: args}
}
func transcriptToolResult(result map[string]interface{}, baseID string, ts int64, order int, pending map[string]Record) Record {
@@ -243,7 +247,14 @@ func transcriptToolResult(result map[string]interface{}, baseID string, ts int64
if status == "failure" || status == "failed" {
status = "error"
}
- return Record{Order: order, NativeID: baseID + ":tool_result", Type: "tool_result", TimestampMS: ts, CallID: callID, ToolName: name, Args: args, Output: output, Status: status}
+ used, limit := contextFromAny(result)
+ if used == 0 {
+ used = pending[callID].ContextUsedTokens
+ }
+ if limit == 0 {
+ limit = pending[callID].ContextLimitTokens
+ }
+ return Record{Order: order, NativeID: baseID + ":tool_result", Type: "tool_result", TimestampMS: ts, ContextUsedTokens: used, ContextLimitTokens: limit, CallID: callID, ToolName: name, Args: args, Output: output, Status: status}
}
func parseTranscriptTimestamp(rec map[string]interface{}, fallback int64) int64 {
@@ -278,6 +289,123 @@ func millisFrom(v interface{}) int64 {
return 0
}
+func contextFromAny(values ...interface{}) (used, limit int64) {
+ for _, value := range values {
+ u, l := contextFromValue(value, 0)
+ if used == 0 {
+ used = u
+ }
+ if limit == 0 {
+ limit = l
+ }
+ }
+ return used, limit
+}
+
+func contextFromValue(value interface{}, depth int) (used, limit int64) {
+ if value == nil || depth > 4 {
+ return 0, 0
+ }
+ switch typed := value.(type) {
+ case map[string]interface{}:
+ used = firstIntKey(typed,
+ "context_tokens",
+ "contextTokens",
+ "contextTokenCount",
+ "context_usage_tokens",
+ "contextUsageTokens",
+ "context_used_tokens",
+ "contextUsedTokens",
+ "used_context_tokens",
+ "usedContextTokens",
+ )
+ limit = firstIntKey(typed,
+ "context_window_size",
+ "contextWindowSize",
+ "context_window_tokens",
+ "contextWindowTokens",
+ "context_token_budget",
+ "contextTokenBudget",
+ "max_context_tokens",
+ "maxContextTokens",
+ "context_limit",
+ "contextLimit",
+ "context_limit_tokens",
+ "contextLimitTokens",
+ )
+ if used > 0 && limit > 0 {
+ return used, limit
+ }
+ for key, child := range typed {
+ if !strings.Contains(strings.ToLower(key), "context") && key != "data" && key != "message" {
+ continue
+ }
+ u, l := contextFromValue(child, depth+1)
+ if used == 0 {
+ used = u
+ }
+ if limit == 0 {
+ limit = l
+ }
+ if used > 0 && limit > 0 {
+ return used, limit
+ }
+ }
+ case []interface{}:
+ for _, child := range typed {
+ u, l := contextFromValue(child, depth+1)
+ if used == 0 {
+ used = u
+ }
+ if limit == 0 {
+ limit = l
+ }
+ if used > 0 && limit > 0 {
+ return used, limit
+ }
+ }
+ default:
+ data, err := json.Marshal(typed)
+ if err != nil || len(data) == 0 || data[0] != '{' {
+ return 0, 0
+ }
+ var asObject map[string]interface{}
+ if err := json.Unmarshal(data, &asObject); err != nil {
+ return 0, 0
+ }
+ return contextFromValue(asObject, depth+1)
+ }
+ return used, limit
+}
+
+func firstIntKey(m map[string]interface{}, keys ...string) int64 {
+ for _, key := range keys {
+ if value := int64From(m[key]); value > 0 {
+ return value
+ }
+ }
+ return 0
+}
+
+func int64From(value interface{}) int64 {
+ switch typed := value.(type) {
+ case int:
+ return int64(typed)
+ case int64:
+ return typed
+ case float64:
+ return int64(typed)
+ case json.Number:
+ n, _ := typed.Int64()
+ return n
+ case string:
+ n, _ := strconv.ParseInt(strings.TrimSpace(typed), 10, 64)
+ return n
+ default:
+ return 0
+ }
+}
+
func formatToolFormerResult(data *toolFormerData) string {
if data == nil {
return ""
diff --git a/cli/beacon/internal/cursorsession/store.go b/cli/beacon/internal/cursorsession/store.go
index 1e9839e2..094e79e2 100644
--- a/cli/beacon/internal/cursorsession/store.go
+++ b/cli/beacon/internal/cursorsession/store.go
@@ -295,10 +295,11 @@ func (s *Store) readGlobalStorage(ref TraceRef) ([]Record, error) {
}
ts := bubble.CreatedAt.Millis
duration := bubble.TurnDurationMS
+ used, limit := contextFromAny(bubble, bubble.Context)
switch bubble.Type {
case 1:
if strings.TrimSpace(bubble.Text) != "" {
- records = append(records, Record{Order: order, NativeID: header.BubbleID, Type: "user_message", TimestampMS: ts, Content: bubble.Text})
+ records = append(records, Record{Order: order, NativeID: header.BubbleID, Type: "user_message", TimestampMS: ts, ContextUsedTokens: used, ContextLimitTokens: limit, Content: bubble.Text})
order++
}
case 2:
@@ -306,11 +307,11 @@ func (s *Store) readGlobalStorage(ref TraceRef) ([]Record, error) {
if strings.TrimSpace(block.Thinking) == "" {
continue
}
- records = append(records, Record{Order: order, NativeID: fmt.Sprintf("%s:thinking:%d", header.BubbleID, i), Type: "agent_thinking", TimestampMS: ts, DurationMS: duration, Content: block.Thinking})
+ records = append(records, Record{Order: order, NativeID: fmt.Sprintf("%s:thinking:%d", header.BubbleID, i), Type: "agent_thinking", TimestampMS: ts, DurationMS: duration, ContextUsedTokens: used, ContextLimitTokens: limit, Content: block.Thinking})
order++
}
if bubble.Thinking != nil && strings.TrimSpace(bubble.Thinking.Text) != "" {
- records = append(records, Record{Order: order, NativeID: header.BubbleID + ":thinking", Type: "agent_thinking", TimestampMS: ts, DurationMS: bubble.ThinkingDurationMS, Content: bubble.Thinking.Text})
+ records = append(records, Record{Order: order, NativeID: header.BubbleID + ":thinking", Type: "agent_thinking", TimestampMS: ts, DurationMS: bubble.ThinkingDurationMS, ContextUsedTokens: used, ContextLimitTokens: limit, Content: bubble.Thinking.Text})
order++
}
if bubble.ToolFormerData != nil {
@@ -319,18 +320,18 @@ func (s *Store) readGlobalStorage(ref TraceRef) ([]Record, error) {
if bubble.ToolFormerData.Name == "edit_file_v2" {
args = s.enrichEditFileV2Args(db, args, bubble.ToolFormerData.Result)
}
- records = append(records, Record{Order: order, NativeID: header.BubbleID + ":tool_call", Type: "tool_call", TimestampMS: ts, DurationMS: duration, CallID: callID, ToolName: firstNonEmpty(bubble.ToolFormerData.Name, "unknown_tool"), Args: args})
+ records = append(records, Record{Order: order, NativeID: header.BubbleID + ":tool_call", Type: "tool_call", TimestampMS: ts, DurationMS: duration, ContextUsedTokens: used, ContextLimitTokens: limit, CallID: callID, ToolName: firstNonEmpty(bubble.ToolFormerData.Name, "unknown_tool"), Args: args})
order++
if output := formatToolFormerResult(bubble.ToolFormerData); output != "" {
status := "success"
if bubble.ToolFormerData.Status == "error" {
status = "error"
}
- records = append(records, Record{Order: order, NativeID: header.BubbleID + ":tool_result", Type: "tool_result", TimestampMS: ts, DurationMS: duration, CallID: callID, ToolName: firstNonEmpty(bubble.ToolFormerData.Name, "unknown_tool"), Args: args, Output: output, Status: status})
+ records = append(records, Record{Order: order, NativeID: header.BubbleID + ":tool_result", Type: "tool_result", TimestampMS: ts, DurationMS: duration, ContextUsedTokens: used, ContextLimitTokens: limit, CallID: callID, ToolName: firstNonEmpty(bubble.ToolFormerData.Name, "unknown_tool"), Args: args, Output: output, Status: status})
order++
}
} else if strings.TrimSpace(bubble.Text) != "" {
- records = append(records, Record{Order: order, NativeID: header.BubbleID, Type: "agent_text", TimestampMS: ts, DurationMS: duration, Content: bubble.Text, Model: model})
+ records = append(records, Record{Order: order, NativeID: header.BubbleID, Type: "agent_text", TimestampMS: ts, DurationMS: duration, ContextUsedTokens: used, ContextLimitTokens: limit, Content: bubble.Text, Model: model})
order++
}
if bubble.ErrorDetails != nil && strings.TrimSpace(bubble.ErrorDetails.Message) != "" {
@@ -338,13 +339,14 @@ func (s *Store) readGlobalStorage(ref TraceRef) ([]Record, error) {
if strings.TrimSpace(bubble.ErrorDetails.Title) != "" {
msg = bubble.ErrorDetails.Title + ": " + msg
}
- records = append(records, Record{Order: order, NativeID: header.BubbleID + ":error", Type: "error", TimestampMS: ts, DurationMS: duration, Content: msg})
+ records = append(records, Record{Order: order, NativeID: header.BubbleID + ":error", Type: "error", TimestampMS: ts, DurationMS: duration, ContextUsedTokens: used, ContextLimitTokens: limit, Content: msg})
order++
}
}
}
if summary := compactionSummary(composer); summary != nil {
- records = append(records, Record{Order: order, NativeID: "compaction:" + stringValue(summary["compacted_through_id"]), Type: "system_event", Subtype: "compaction", TimestampMS: ref.UpdatedAtUnixMS, Data: summary})
+ used, limit := contextFromAny(composer, composer.Context, summary)
+ records = append(records, Record{Order: order, NativeID: "compaction:" + stringValue(summary["compacted_through_id"]), Type: "system_event", Subtype: "compaction", TimestampMS: ref.UpdatedAtUnixMS, ContextUsedTokens: used, ContextLimitTokens: limit, Data: summary})
}
return records, nil
}
@@ -377,6 +379,7 @@ func (s *Store) readTranscript(ref TraceRef) ([]Record, error) {
typ := strings.ToLower(pickString(rec, "type"))
role := normalizeRole(pickString(rec, "role"))
baseID := firstNonEmpty(pickString(rec, "id"), fmt.Sprintf("entry-%d", i+1))
+ used, limit := contextFromAny(rec, rec["data"], rec["message"])
before := len(out)
switch {
case typ == "message":
@@ -408,6 +411,16 @@ func (s *Store) readTranscript(ref TraceRef) ([]Record, error) {
if len(out) == before && role != "" {
order = appendTranscriptMessage(outPtr(&out), pending, rec, baseID, ts, role, model, order)
}
+ if used > 0 || limit > 0 {
+ for idx := before; idx < len(out); idx++ {
+ if out[idx].ContextUsedTokens == 0 {
+ out[idx].ContextUsedTokens = used
+ }
+ if out[idx].ContextLimitTokens == 0 {
+ out[idx].ContextLimitTokens = limit
+ }
+ }
+ }
}
return out, nil
}
diff --git a/cli/beacon/internal/cursorsession/types.go b/cli/beacon/internal/cursorsession/types.go
index e8c1d23a..141575d8 100644
--- a/cli/beacon/internal/cursorsession/types.go
+++ b/cli/beacon/internal/cursorsession/types.go
@@ -38,20 +38,22 @@ type TraceRef struct {
}
type Record struct {
- Order int
- NativeID string
- Type string
- Subtype string
- TimestampMS int64
- DurationMS int64
- Content string
- Model string
- CallID string
- ToolName string
- Args map[string]interface{}
- Output string
- Status string
- Data map[string]interface{}
+ Order int
+ NativeID string
+ Type string
+ Subtype string
+ TimestampMS int64
+ DurationMS int64
+ ContextUsedTokens int64
+ ContextLimitTokens int64
+ Content string
+ Model string
+ CallID string
+ ToolName string
+ Args map[string]interface{}
+ Output string
+ Status string
+ Data map[string]interface{}
}
type composerData struct {
@@ -66,6 +68,11 @@ type composerData struct {
Context map[string]interface{} `json:"context"`
LatestConversationSummary *latestConversationState `json:"latestConversationSummary"`
SubagentComposerIDs []string `json:"subagentComposerIds"`
+ ContextTokens int64 `json:"context_tokens"`
+ ContextTokensCamel int64 `json:"contextTokens"`
+ ContextWindowSize int64 `json:"context_window_size"`
+ ContextWindowSizeCamel int64 `json:"contextWindowSize"`
+ ContextTokenBudget int64 `json:"contextTokenBudget"`
}
type composerModelConfig struct {
@@ -90,6 +97,11 @@ type bubbleData struct {
Text string `json:"text"`
} `json:"thinking"`
ThinkingDurationMS int64 `json:"thinkingDurationMs"`
+ ContextTokens int64 `json:"context_tokens"`
+ ContextTokensCamel int64 `json:"contextTokens"`
+ ContextWindowSize int64 `json:"context_window_size"`
+ ContextWindowCamel int64 `json:"contextWindowSize"`
+ ContextTokenBudget int64 `json:"contextTokenBudget"`
AllThinkingBlocks []struct {
Thinking string `json:"thinking"`
} `json:"allThinkingBlocks"`