The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
package dshsession
import (
"crypto/sha1"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/schema"
"github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve"
)
func MapSession(ref SessionRef, records []Record, opts MapOptions) []MappedEvent {
m := &mapper{
ref: ref,
opts: opts,
session: sessionMetaFromRef(ref),
calls: map[string]toolCall{},
lastTime: ref.ModTimeUnixMS,
}
seedCut := inheritedSeedCut(records)
for _, record := range records {
m.consumeContext(record)
if record.Line <= opts.MinLine {
continue
}
if record.Line <= seedCut && record.Kind != "session" {
// Inherited history: the parent session's own records, already collected under the
// parent. Read for context only, so a fork does not re-emit them as its own activity.
continue
}
m.consume(record)
}
return m.out
}
// inheritedSeedCut returns the line of a fork's inherited-prefix marker, or zero for a session that
// inherited nothing. A fork child copies its parent's history verbatim and closes it with one
// `session/end-seed {inherited: true}` marker; untagged `session/end-seed` markers only separate
// restored settings from live work and inherit no history. The last tagged marker is the cut.
func inheritedSeedCut(records []Record) int {
cut := 0
for _, record := range records {
if record.Kind == "session/end-seed" && boolValue(record.Data["inherited"]) {
cut = record.Line
}
}
return cut
}
type mapper struct {
ref SessionRef
opts MapOptions
session SessionMeta
model string
calls map[string]toolCall
out []MappedEvent
lastTime int64
}
type toolCall struct {
ID string
Name string
Arguments map[string]interface{}
Line int
}
func sessionMetaFromRef(ref SessionRef) SessionMeta {
if ref.Meta != nil {
return *ref.Meta
}
return SessionMeta{ID: ref.ID}
}
func (m *mapper) consumeContext(record Record) {
if record.TimeMS > 0 {
m.lastTime = record.TimeMS
}
switch record.Kind {
case "session":
if id := firstString(record.Data, "id", "sessionId", "session_id"); id != "" {
m.session.ID = id
}
if cwd := firstString(record.Data, "cwd", "workingDirectory", "working_directory"); cwd != "" {
m.session.CWD = cwd
}
if parent := firstString(record.Data, "parentSession", "parent_session", "parentSessionId"); parent != "" {
m.session.ParentSessionID = parent
}
case "request/header":
if model := requestHeaderModel(record.Data); model != "" {
m.model = model
m.session.Model = model
}
case "session/title":
if title := firstString(record.Data, "title"); title != "" {
m.session.Title = title
}
case "assistant/message":
if model := assistantModel(record.Data); model != "" {
m.model = model
}
case "tool/call", "tool/code-dispatch-start", "tool/ptc-dispatch-start":
call := parseToolCall(record)
if call.ID != "" {
m.calls[call.ID] = call
}
}
}
func (m *mapper) consume(record Record) {
m.consumeContext(record)
if record.SurfaceReplace {
// A compaction rewrite of history already collected (see Record.SurfaceReplace).
return
}
switch record.Kind {
case "session":
if !m.opts.SkipSessionStarted {
m.emitSessionStarted(record)
}
case "user/message":
m.emitPrompt(record)
case "assistant/message":
m.emitAssistant(record)
case "compaction/summary":
m.emitCompactionUsage(record)
// run_code (programmatic tool calling) dispatches nested tool calls through the same guarded
// pipeline; DSH logs them as tool/ptc-dispatch-start and tool/ptc-dispatch, keyed by subCallId.
// tool/code-dispatch* is the earlier spelling.
case "tool/call", "tool/code-dispatch-start", "tool/ptc-dispatch-start":
m.emitToolCall(record)
case "tool/result", "tool/code-dispatch", "tool/ptc-dispatch":
m.emitToolResult(record)
case "turn/end":
m.emitTurnEnd(record)
}
}
func (m *mapper) emitSessionStarted(record Record) {
ev := m.base(record, "session.started", "session", schema.SeverityInfo, "DeepSeek Harness session started")
ev.Raw = m.rawDsh(record, map[string]interface{}{"source_path": m.ref.Path})
m.append(record, "session.started", ev)
}
func (m *mapper) emitPrompt(record Record) {
if !userMessageFromPerson(record.Data) {
return
}
text := userMessageText(record.Data)
if text == "" {
return
}
ev := m.base(record, "prompt.submitted", "prompt", schema.SeverityInfo, "DeepSeek prompt submitted")
ev.Prompt = &schema.PromptInfo{Text: text}
ev.Content = asymptoteobserve.RetainedContent(text, asymptoteobserve.DefaultStringLimit)
ev.GenAI = withGenAI(ev.GenAI, func(genAI *schema.GenAIInfo) {
genAI.Input = &schema.GenAIInputInfo{Messages: asymptoteobserve.TextInputMessages(text)}
})
ev.Raw = m.rawDsh(record, nil)
m.append(record, "prompt.submitted", ev)
if info, ok := asymptoteobserve.ParseHandoffMarker(text); ok {
link := m.base(record, "session.handoff", "session", schema.SeverityInfo, "Session continued from a "+info.SourceHarness+" session")
link.Handoff = &info
m.append(record, "prompt.submitted.handoff", link)
}
}
func (m *mapper) emitAssistant(record Record) {
model := firstNonEmpty(assistantModel(record.Data), m.model, m.session.Model)
for i, part := range assistantParts(record.Data) {
switch part.kind {
case "reasoning":
ev := m.base(record, "agent.reasoning", "agent", schema.SeverityInfo, "DeepSeek assistant reasoning")
ev.Model = model
ev.GenAI = withGenAI(ev.GenAI, func(genAI *schema.GenAIInfo) {
genAI.Output = &schema.GenAIOutputInfo{Messages: []map[string]interface{}{{
"role": "assistant",
"content": []map[string]string{{"type": "reasoning", "text": part.text}},
}}}
})
ev.Content = asymptoteobserve.RetainedContent(part.text, asymptoteobserve.DefaultRawStringLimit)
ev.Raw = m.rawDsh(record, nil)
m.append(record, fmt.Sprintf("assistant.reasoning.%d", i), ev)
case "text":
ev := m.base(record, "agent.message", "agent", schema.SeverityInfo, "DeepSeek assistant message")
ev.Model = model
ev.GenAI = withGenAI(ev.GenAI, func(genAI *schema.GenAIInfo) {
genAI.Output = &schema.GenAIOutputInfo{Messages: asymptoteobserve.TextOutputMessages(part.text)}
})
ev.Content = asymptoteobserve.RetainedContent(part.text, asymptoteobserve.DefaultRawStringLimit)
ev.Raw = m.rawDsh(record, nil)
m.append(record, fmt.Sprintf("assistant.text.%d", i), ev)
}
}
m.emitUsage(record)
}
func (m *mapper) emitToolCall(record Record) {
call := parseToolCall(record)
if call.ID != "" {
m.calls[call.ID] = call
}
if call.Name == "" {
return
}
ev := m.base(record, "tool.invoked", "tool", schema.SeverityInfo, "DeepSeek tool invoked")
ev.Tool = &schema.ToolInfo{Name: call.Name}
applyCall(&ev, call)
ev.Raw = m.rawDsh(record, nil)
m.append(record, "tool.call", ev)
}
func (m *mapper) emitToolResult(record Record) {
result := parseToolResult(record)
call := m.calls[result.CallID]
if result.Name != "" {
call.Name = result.Name
}
if call.ID == "" {
call.ID = result.CallID
}
if call.Name == "" {
return
}
action, category, severity, message := classifyDsh(call, result)
ev := m.base(record, action, category, severity, message)
ev.Tool = &schema.ToolInfo{Name: call.Name}
applyCall(&ev, call)
switch action {
case "command.executed":
applyCommand(&ev, call, result)
case "file.read", "file.modified":
applyFile(&ev, call, result)
case "mcp.tool_invoked":
ev.MCP = mcpInfo(call.Name)
}
if result.IsError {
ev.Error = &schema.ErrorInfo{Type: "tool_execution_failed"}
}
ev.Raw = m.rawDsh(record, map[string]interface{}{"tool_result": result.Raw})
m.append(record, "tool.result", ev)
}
func (m *mapper) emitTurnEnd(record Record) {
reason := childMap(record.Data, "reason")
kind := firstString(reason, "kind", "type")
if kind != "error" && kind != "interrupted" {
return
}
ev := m.base(record, "agent.error", "session", schema.SeverityHigh, "DeepSeek turn ended with error")
ev.Error = &schema.ErrorInfo{Type: kind}
ev.Raw = m.rawDsh(record, nil)
m.append(record, "turn.end."+kind, ev)
}
func (m *mapper) emitUsage(record Record) {
usage := usageFromAssistant(record.Data)
if usage == nil {
return
}
ev := m.base(record, "token.usage", "metric", schema.SeverityInfo, "DeepSeek token usage")
ev.GenAI = withGenAI(ev.GenAI, func(genAI *schema.GenAIInfo) { genAI.Usage = usage })
ev.Model = firstNonEmpty(assistantModel(record.Data), m.model, m.session.Model)
ev.Raw = m.rawDsh(record, map[string]interface{}{"token_source": "assistant_message"})
m.append(record, "usage", ev)
}
// emitCompactionUsage records the tokens of the model call DSH makes to summarize history. That
// call is not an assistant/message, so its usage would otherwise be missing from the session total.
func (m *mapper) emitCompactionUsage(record Record) {
usage := usageFromAssistant(record.Data)
if usage == nil {
return
}
ev := m.base(record, "token.usage", "metric", schema.SeverityInfo, "DeepSeek compaction token usage")
ev.GenAI = withGenAI(ev.GenAI, func(genAI *schema.GenAIInfo) { genAI.Usage = usage })
ev.Model = firstNonEmpty(firstString(record.Data, "model"), m.model, m.session.Model)
ev.Raw = m.rawDsh(record, map[string]interface{}{"token_source": "compaction_summary"})
m.append(record, "usage", ev)
}
func (m *mapper) base(record Record, action, category string, severity schema.Severity, message string) schema.Event {
ts := m.lastTime
if record.TimeMS > 0 {
ts = record.TimeMS
}
if ts <= 0 {
ts = m.ref.ModTimeUnixMS
}
ev := schema.NewEvent(schema.NewEventOptions{
Action: action,
Category: category,
Severity: severity,
Harness: schema.HarnessInfo{
Name: Harness,
CollectionMethod: schema.CollectionMethodPoll,
},
Origin: schema.OriginLocal,
Fidelity: schema.FidelityObserved,
Message: message,
})
if ts > 0 {
ev.Timestamp = schema.FormatTimestamp(time.UnixMilli(ts))
}
ev.Session = &schema.SessionInfo{ID: firstNonEmpty(m.session.ID, m.ref.ID), WorkingDirectory: m.session.CWD}
if model := firstNonEmpty(m.model, m.session.Model); model != "" {
ev.Model = model
}
return ev
}
func (m *mapper) append(record Record, suffix string, ev schema.Event) {
dedupID := fmt.Sprintf("%s:%s:%d:%s", m.ref.Path, firstNonEmpty(m.session.ID, m.ref.ID), record.Line, suffix)
ev.Event.ID = dshEventID(dedupID)
if m.session.ParentSessionID != "" {
ev.Raw = mergeRaw(ev.Raw, map[string]interface{}{"parent_session": m.session.ParentSessionID})
}
m.out = append(m.out, MappedEvent{SourceLine: record.Line, DedupID: dedupID, Event: ev})
}
type assistantPart struct {
kind string
text string
}
type toolResult struct {
CallID string
Name string
Text string
IsError bool
Raw interface{}
}
func parseToolCall(record Record) toolCall {
data := unwrap(record.Data, "call", "toolCall", "tool_call")
args := argumentsFrom(data)
return toolCall{
// subCallId names a call run_code dispatched; its parentCallId is the run_code call.
ID: firstString(data, "callId", "callID", "subCallId", "id", "tool_call_id", "tool_use_id"),
Name: firstString(data, "name", "toolName", "tool_name"),
Arguments: args,
Line: record.Line,
}
}
func parseToolResult(record Record) toolResult {
data := unwrap(record.Data, "result", "toolResult", "tool_result")
// Since session format v4 a tool/result carries the model-facing ToolResultMessage under
// `message`: the call id as `toolCallId` (and `source.callId`), the output as content blocks,
// and the failure flag as `isError`. A failure's identity sits beside it as `error`
// ({name, code, reason}), which is an object, not a flag.
if msg := childMap(data, "message"); firstString(msg, "toolCallId") != "" || firstString(msg, "role") == "tool" {
callID := firstNonEmpty(firstString(msg, "toolCallId"), firstString(childMap(msg, "source"), "callId"))
isError := boolValue(msg["isError"]) || len(childMap(data, "error")) > 0
return toolResult{CallID: callID, Name: firstString(data, "name", "toolName"), Text: resultText(msg), IsError: isError, Raw: data}
}
callID := firstString(data, "callId", "callID", "subCallId", "id", "tool_call_id", "toolUseId", "tool_use_id")
name := firstString(data, "name", "toolName", "tool_name")
isError := boolValue(data["isError"]) || boolValue(data["is_error"]) || boolValue(data["error"])
text := resultText(data)
return toolResult{CallID: callID, Name: name, Text: text, IsError: isError, Raw: data}
}
func classifyDsh(call toolCall, result toolResult) (action, category string, severity schema.Severity, message string) {
name := strings.ToLower(strings.TrimSpace(call.Name))
if strings.HasPrefix(name, "mcp__") {
return "mcp.tool_invoked", "mcp", schema.SeverityInfo, "DeepSeek MCP tool invoked"
}
if result.IsError {
return "tool.failed", "tool", schema.SeverityHigh, "DeepSeek tool failed"
}
switch dshToolAction(call.Name, call.Arguments) {
case "command.executed":
return "command.executed", "command", schema.SeverityInfo, "DeepSeek command executed"
case "file.read":
return "file.read", "file", schema.SeverityInfo, "DeepSeek file read"
case "file.modified":
return "file.modified", "file", schema.SeverityInfo, "DeepSeek file modified"
default:
return "tool.completed", "tool", schema.SeverityInfo, "DeepSeek tool completed"
}
}
func applyCall(ev *schema.Event, call toolCall) {
ev.GenAI = withGenAI(ev.GenAI, func(genAI *schema.GenAIInfo) {
genAI.Operation = &schema.GenAIOperationInfo{Name: "execute_tool"}
genAI.Tool = &schema.GenAIToolInfo{
Name: call.Name,
Call: &schema.GenAIToolCallInfo{
ID: call.ID,
Arguments: call.Arguments,
},
}
})
if path := firstString(call.Arguments, "path", "file_path", "target_path"); path != "" {
ev.Tool.Path = path
}
if command := commandFromCall(call); command != "" {
ev.Tool.Command = command
}
}
func applyCommand(ev *schema.Event, call toolCall, result toolResult) {
info := &schema.CommandInfo{Command: commandFromCall(call)}
if result.Text != "" {
info.Output = result.Text
ev.Content = asymptoteobserve.RetainedContent(result.Text, asymptoteobserve.DefaultStringLimit)
}
if code, ok := dshExitCode(result.Text); ok {
info.ExitCode = &code
}
ev.Command = info
}
func applyFile(ev *schema.Event, call toolCall, result toolResult) {
path := firstString(call.Arguments, "file_path", "path")
info := &schema.FileInfo{Path: path, Operation: dshFileOperation(call.Name, call.Arguments)}
if path != "" {
info.Language = strings.TrimPrefix(filepath.Ext(path), ".")
}
if diff := diffFromCall(call); diff != "" && !result.IsError {
info.Diff = diff
ev.Content, info.DiffHash, info.DiffBytes = asymptoteobserve.RetainedDiff(diff, asymptoteobserve.DefaultStringLimit)
}
ev.File = info
}
func diffFromCall(call toolCall) string {
name := strings.ToLower(strings.TrimSpace(call.Name))
path := firstString(call.Arguments, "file_path", "path")
switch name {
case "write":
content := firstStringRaw(call.Arguments, "content", "file_text")
if path != "" && content != "" {
return "--- /dev/null\n+++ " + path + "\n+" + strings.ReplaceAll(content, "\n", "\n+") + "\n"
}
case "edit":
oldText := firstStringRaw(call.Arguments, "old_string", "old_str")
newText := firstStringRaw(call.Arguments, "new_string", "new_str")
if oldText != "" || newText != "" {
return "-" + strings.ReplaceAll(oldText, "\n", "\n-") + "\n+" + strings.ReplaceAll(newText, "\n", "\n+") + "\n"
}
case "str_replace_editor":
op := dshEditorOperation(call.Name, call.Arguments)
if op == "create" {
content := firstStringRaw(call.Arguments, "file_text")
if content != "" {
return "--- /dev/null\n+++ " + path + "\n+" + strings.ReplaceAll(content, "\n", "\n+") + "\n"
}
}
if op == "str_replace" || op == "insert" {
oldText := firstStringRaw(call.Arguments, "old_str")
newText := firstStringRaw(call.Arguments, "new_str", "insert")
if oldText != "" || newText != "" {
return "-" + strings.ReplaceAll(oldText, "\n", "\n-") + "\n+" + strings.ReplaceAll(newText, "\n", "\n+") + "\n"
}
}
}
return ""
}
func mcpInfo(name string) *schema.MCPInfo {
trimmed := strings.TrimPrefix(name, "mcp__")
parts := strings.SplitN(trimmed, "__", 2)
if len(parts) == 2 {
return &schema.MCPInfo{Server: parts[0], Tool: parts[1]}
}
return &schema.MCPInfo{Tool: name}
}
func userMessageText(data map[string]interface{}) string {
data = unwrap(data, "message")
return textValue(firstPresent(data, "text", "content", "message"))
}
// userMessageFromPerson reports whether a user/message is something a person sent. DSH records
// every user-role message the model sees as user/message: the person's prompt has
// `source.kind: "user"`, while agent instructions, time and runtime snapshots, skill catalogs,
// messages relayed from other agents, job and subagent notices, goal continuations and compaction
// checkpoints each name their own producer. A message with no source predates the field and is
// read as a prompt, as before.
func userMessageFromPerson(data map[string]interface{}) bool {
source := childMap(unwrap(data, "message"), "source")
kind := firstString(source, "kind")
return kind == "" || kind == "user"
}
func assistantParts(data map[string]interface{}) []assistantPart {
msg := unwrap(data, "message")
raw := firstPresent(msg, "content", "parts")
var out []assistantPart
switch v := raw.(type) {
case []interface{}:
for _, item := range v {
m, _ := item.(map[string]interface{})
kind := firstNonEmpty(firstString(m, "type"), "text")
if kind == "tool-call" || kind == "tool_call" {
continue
}
text := textValue(firstPresent(m, "text", "content"))
if text != "" {
out = append(out, assistantPart{kind: normalizePartKind(kind), text: text})
}
}
default:
if text := textValue(raw); text != "" {
out = append(out, assistantPart{kind: "text", text: text})
}
}
if reasoning := firstString(msg, "reasoning", "reasoningText", "reasoning_content"); reasoning != "" {
out = append([]assistantPart{{kind: "reasoning", text: reasoning}}, out...)
}
return out
}
func usageFromAssistant(data map[string]interface{}) *schema.GenAIUsageInfo {
msg := unwrap(data, "message")
u := childMap(firstMap(msg, "usage"), "usage")
if len(u) == 0 {
u = firstMap(msg, "usage")
}
if len(u) == 0 {
u = firstMap(data, "usage")
}
usage := &schema.GenAIUsageInfo{}
if n, ok := int64Value(firstPresent(u, "inputTokens", "input_tokens", "promptTokens")); ok && n > 0 {
usage.InputTokens = &n
}
if n, ok := int64Value(firstPresent(u, "outputTokens", "output_tokens", "completionTokens")); ok && n > 0 {
usage.OutputTokens = &n
}
if n, ok := int64Value(firstPresent(u, "cacheReadTokens", "cache_read_tokens")); ok && n > 0 {
usage.CacheRead = &schema.GenAIUsageCacheReadInfo{InputTokens: &n}
}
if n, ok := int64Value(firstPresent(u, "cacheWriteTokens", "cache_write_tokens")); ok && n > 0 {
usage.CacheCreation = &schema.GenAIUsageCacheCreationInfo{InputTokens: &n}
}
if n, ok := int64Value(firstPresent(u, "reasoningTokens", "reasoning_tokens")); ok && n > 0 {
usage.Reasoning = &schema.GenAIUsageReasoningInfo{OutputTokens: &n}
}
if usage.InputTokens == nil && usage.OutputTokens == nil && usage.CacheRead == nil && usage.CacheCreation == nil && usage.Reasoning == nil {
return nil
}
return usage
}
func requestHeaderModel(data map[string]interface{}) string {
header := childMap(data, "header")
config := childMap(header, "config")
return firstString(config, "model")
}
func assistantModel(data map[string]interface{}) string {
msg := unwrap(data, "message")
source := childMap(msg, "source")
return firstNonEmpty(firstString(source, "model"), firstString(msg, "model"))
}
func (m *mapper) rawDsh(record Record, extra map[string]interface{}) map[string]interface{} {
raw := map[string]interface{}{}
if len(record.Raw) > 0 {
var decoded map[string]interface{}
if json.Unmarshal(record.Raw, &decoded) == nil {
raw["record"] = decoded
}
}
if m.session.ParentSessionID != "" {
raw["parent_session"] = m.session.ParentSessionID
}
for k, v := range extra {
raw[k] = v
}
return map[string]interface{}{"dsh": raw}
}
func mergeRaw(existing map[string]interface{}, fields map[string]interface{}) map[string]interface{} {
if len(fields) == 0 {
return existing
}
if existing == nil {
existing = map[string]interface{}{}
}
dsh, _ := existing["dsh"].(map[string]interface{})
if dsh == nil {
dsh = map[string]interface{}{}
}
for k, v := range fields {
dsh[k] = v
}
existing["dsh"] = dsh
return existing
}
func withGenAI(genAI *schema.GenAIInfo, edit func(*schema.GenAIInfo)) *schema.GenAIInfo {
if genAI == nil {
genAI = &schema.GenAIInfo{}
}
edit(genAI)
return genAI
}
func unwrap(data map[string]interface{}, keys ...string) map[string]interface{} {
for _, key := range keys {
if child, ok := data[key].(map[string]interface{}); ok {
return child
}
}
return data
}
func argumentsFrom(data map[string]interface{}) map[string]interface{} {
if args := firstMap(data, "arguments", "args", "input", "tool_input"); len(args) > 0 {
return args
}
// A tool/call stores `arguments` as the raw JSON string the model produced, unparsed; nested
// run_code dispatches and older records carry an object, handled above.
if text := firstStringRaw(data, "arguments", "argumentsJson", "arguments_json"); strings.TrimSpace(text) != "" {
var args map[string]interface{}
if json.Unmarshal([]byte(text), &args) == nil && args != nil {
return args
}
return map[string]interface{}{"value": text}
}
return map[string]interface{}{}
}
func resultText(data map[string]interface{}) string {
return textValue(firstPresent(data, "text", "output", "content", "result"))
}
func textValue(value interface{}) string {
switch v := value.(type) {
case nil:
return ""
case string:
return v
case []interface{}:
parts := make([]string, 0, len(v))
for _, item := range v {
if text := textValue(item); text != "" {
parts = append(parts, text)
}
}
return strings.Join(parts, "\n")
case map[string]interface{}:
return firstNonEmpty(firstString(v, "text"), firstString(v, "content"), firstString(v, "value"))
default:
return fmt.Sprint(v)
}
}
func firstPresent(data map[string]interface{}, keys ...string) interface{} {
for _, key := range keys {
if value, ok := data[key]; ok {
return value
}
}
return nil
}
func firstMap(data map[string]interface{}, keys ...string) map[string]interface{} {
for _, key := range keys {
if child, ok := data[key].(map[string]interface{}); ok {
return child
}
}
return nil
}
func childMap(data map[string]interface{}, key string) map[string]interface{} {
child, _ := data[key].(map[string]interface{})
if child == nil {
return map[string]interface{}{}
}
return child
}
func firstString(data map[string]interface{}, keys ...string) string {
for _, key := range keys {
if value, ok := data[key]; ok {
if text := strings.TrimSpace(textValue(value)); text != "" {
return text
}
}
}
return ""
}
func firstStringRaw(data map[string]interface{}, keys ...string) string {
for _, key := range keys {
if value, ok := data[key]; ok {
if text := textValue(value); text != "" {
return text
}
}
}
return ""
}
func firstNonEmpty(values ...string) string {
for _, value := range values {
if strings.TrimSpace(value) != "" {
return value
}
}
return ""
}
func int64Value(value interface{}) (int64, bool) {
switch v := value.(type) {
case float64:
return int64(v), v >= 0
case int64:
return v, v >= 0
case int:
return int64(v), v >= 0
case string:
n, err := strconv.ParseInt(strings.TrimSpace(v), 10, 64)
return n, err == nil && n >= 0
default:
return 0, false
}
}
func boolValue(value interface{}) bool {
switch v := value.(type) {
case bool:
return v
case string:
return strings.EqualFold(v, "true") || strings.EqualFold(v, "error")
default:
return false
}
}
func normalizePartKind(kind string) string {
switch strings.ToLower(strings.TrimSpace(kind)) {
case "reasoning", "thinking":
return "reasoning"
default:
return "text"
}
}
var dshIDNamespace = [16]byte{
0x4d, 0x73, 0x68, 0x21, 0x18, 0xa5, 0x4e, 0x6f,
0x99, 0x0a, 0xdf, 0x82, 0x33, 0x52, 0x1c, 0x0d,
}
func dshEventID(dedupID string) string {
digest := sha1.New()
digest.Write(dshIDNamespace[:])
io.WriteString(digest, dedupID)
var id [16]byte
copy(id[:], digest.Sum(nil))
id[6] = (id[6] & 0x0f) | 0x50
id[8] = (id[8] & 0x3f) | 0x80
out := make([]byte, 32)
hex.Encode(out, id[:])
return fmt.Sprintf("%s-%s-%s-%s-%s", out[0:8], out[8:12], out[12:16], out[16:20], out[20:32])
}