Download sdk/translator/state.go from shimen/API: direct link, hf CLI and curl.
- Browser
- Download file 9.54 kB
-
https://huggingface.co/spaces/shimen/API/resolve/main/sdk/translator/state.go
- Command line
-
hf download hf://spaces/shimen/API/sdk/translator/state.go
-
curl -L -o state.go https://huggingface.co/spaces/shimen/API/resolve/main/sdk/translator/state.go
9.54 kB
| // Package translator provides types and functions for converting chat requests and responses between different schemas. | |
| // This file contains shared state utilities for streaming response translators. | |
| package translator | |
| import ( | |
| "fmt" | |
| "strings" | |
| "sync/atomic" | |
| "time" | |
| ) | |
| // StreamState provides common state fields for streaming response translators. | |
| // Embed this struct into translator-specific state types. | |
| type StreamState struct { | |
| // ResponseID is the unique identifier for the response. | |
| ResponseID string | |
| // CreatedAt is the Unix timestamp when the response was created. | |
| CreatedAt int64 | |
| // Model is the name of the model being used. | |
| Model string | |
| // SequenceNum is used for ordered events (e.g., OpenAI Responses API). | |
| SequenceNum int | |
| // FinishReason is the mapped finish reason in target format. | |
| FinishReason string | |
| // NativeFinishReason is the original finish reason from the source. | |
| NativeFinishReason string | |
| // InputTokens tracks the number of input tokens used. | |
| InputTokens int64 | |
| // OutputTokens tracks the number of output tokens used. | |
| OutputTokens int64 | |
| // UsageSeen indicates whether usage data has been processed. | |
| UsageSeen bool | |
| } | |
| // Reset clears the state for reuse. | |
| func (s *StreamState) Reset() { | |
| s.ResponseID = "" | |
| s.CreatedAt = 0 | |
| s.Model = "" | |
| s.SequenceNum = 0 | |
| s.FinishReason = "" | |
| s.NativeFinishReason = "" | |
| s.InputTokens = 0 | |
| s.OutputTokens = 0 | |
| s.UsageSeen = false | |
| } | |
| // NextSequence returns the next sequence number for event ordering. | |
| func (s *StreamState) NextSequence() int { | |
| s.SequenceNum++ | |
| return s.SequenceNum | |
| } | |
| // EnsureTimestamp sets CreatedAt to current time if not already set. | |
| func (s *StreamState) EnsureTimestamp() int64 { | |
| if s.CreatedAt == 0 { | |
| s.CreatedAt = time.Now().Unix() | |
| } | |
| return s.CreatedAt | |
| } | |
| // ToolCallState tracks the state of a single tool/function call being accumulated. | |
| type ToolCallState struct { | |
| // ID is the unique identifier for this tool call. | |
| ID string | |
| // Name is the name of the tool/function. | |
| Name string | |
| // Index is the position of this tool call in the sequence. | |
| Index int | |
| // Arguments accumulates the JSON arguments for this tool call. | |
| Arguments strings.Builder | |
| // Complete indicates whether this tool call has been fully received. | |
| Complete bool | |
| } | |
| // GetArguments returns the accumulated arguments, defaulting to "{}" if empty. | |
| func (t *ToolCallState) GetArguments() string { | |
| args := t.Arguments.String() | |
| if args == "" { | |
| return "{}" | |
| } | |
| return args | |
| } | |
| // WriteArguments appends partial argument JSON. | |
| func (t *ToolCallState) WriteArguments(partial string) { | |
| t.Arguments.WriteString(partial) | |
| } | |
| // ToolCallAccumulator manages multiple concurrent tool calls indexed by position. | |
| type ToolCallAccumulator struct { | |
| // calls maps index -> tool call state. | |
| calls map[int]*ToolCallState | |
| // ordered tracks the order of indices for deterministic iteration. | |
| ordered []int | |
| // nextIndex tracks the next available index for new calls. | |
| nextIndex int | |
| } | |
| // NewToolCallAccumulator creates a new accumulator. | |
| func NewToolCallAccumulator() *ToolCallAccumulator { | |
| return &ToolCallAccumulator{ | |
| calls: make(map[int]*ToolCallState), | |
| ordered: make([]int, 0), | |
| nextIndex: 0, | |
| } | |
| } | |
| // Get retrieves a tool call by index, returning nil if not found. | |
| func (t *ToolCallAccumulator) Get(index int) *ToolCallState { | |
| return t.calls[index] | |
| } | |
| // GetOrCreate retrieves or creates a tool call at the given index. | |
| func (t *ToolCallAccumulator) GetOrCreate(index int) *ToolCallState { | |
| if tc, exists := t.calls[index]; exists { | |
| return tc | |
| } | |
| tc := &ToolCallState{Index: index} | |
| t.calls[index] = tc | |
| t.ordered = append(t.ordered, index) | |
| return tc | |
| } | |
| // CreateNext creates a new tool call at the next available index. | |
| func (t *ToolCallAccumulator) CreateNext(id, name string) *ToolCallState { | |
| tc := &ToolCallState{ | |
| ID: id, | |
| Name: name, | |
| Index: t.nextIndex, | |
| } | |
| t.calls[t.nextIndex] = tc | |
| t.ordered = append(t.ordered, t.nextIndex) | |
| t.nextIndex++ | |
| return tc | |
| } | |
| // MarkComplete marks a tool call as complete and returns it. | |
| func (t *ToolCallAccumulator) MarkComplete(index int) *ToolCallState { | |
| if tc, exists := t.calls[index]; exists { | |
| tc.Complete = true | |
| return tc | |
| } | |
| return nil | |
| } | |
| // Remove deletes a tool call from the accumulator (cleanup after processing). | |
| func (t *ToolCallAccumulator) Remove(index int) { | |
| delete(t.calls, index) | |
| // Rebuild ordered slice | |
| newOrdered := make([]int, 0, len(t.calls)) | |
| for _, idx := range t.ordered { | |
| if idx != index { | |
| newOrdered = append(newOrdered, idx) | |
| } | |
| } | |
| t.ordered = newOrdered | |
| } | |
| // HasAny returns true if any tool calls are being tracked. | |
| func (t *ToolCallAccumulator) HasAny() bool { | |
| return len(t.calls) > 0 | |
| } | |
| // Count returns the number of tracked tool calls. | |
| func (t *ToolCallAccumulator) Count() int { | |
| return len(t.calls) | |
| } | |
| // GetOrdered returns tool calls in the order they were created. | |
| func (t *ToolCallAccumulator) GetOrdered() []*ToolCallState { | |
| result := make([]*ToolCallState, 0, len(t.ordered)) | |
| for _, idx := range t.ordered { | |
| if tc, exists := t.calls[idx]; exists { | |
| result = append(result, tc) | |
| } | |
| } | |
| return result | |
| } | |
| // Reset clears all accumulated state. | |
| func (t *ToolCallAccumulator) Reset() { | |
| t.calls = make(map[int]*ToolCallState) | |
| t.ordered = make([]int, 0) | |
| t.nextIndex = 0 | |
| } | |
| // ContentBuffer accumulates text and reasoning content. | |
| type ContentBuffer struct { | |
| // Text accumulates the main text content. | |
| Text strings.Builder | |
| // Reasoning accumulates reasoning/thinking content. | |
| Reasoning strings.Builder | |
| } | |
| // Reset clears the buffers. | |
| func (c *ContentBuffer) Reset() { | |
| c.Text.Reset() | |
| c.Reasoning.Reset() | |
| } | |
| // HasContent returns true if any content has been accumulated. | |
| func (c *ContentBuffer) HasContent() bool { | |
| return c.Text.Len() > 0 || c.Reasoning.Len() > 0 | |
| } | |
| // StreamingState combines all common state for streaming translators. | |
| type StreamingState struct { | |
| StreamState | |
| // ToolCalls tracks accumulated tool calls. | |
| ToolCalls *ToolCallAccumulator | |
| // Content accumulates text and reasoning content. | |
| Content ContentBuffer | |
| // InTextBlock indicates whether currently processing a text block. | |
| InTextBlock bool | |
| // InToolBlock indicates whether currently processing a tool block. | |
| InToolBlock bool | |
| // InReasoningBlock indicates whether currently processing a reasoning block. | |
| InReasoningBlock bool | |
| // CurrentMessageID is the ID of the current message being processed. | |
| CurrentMessageID string | |
| // CurrentToolCallID is the ID of the current tool call being processed. | |
| CurrentToolCallID string | |
| // CurrentReasoningID is the ID of the current reasoning block being processed. | |
| CurrentReasoningID string | |
| } | |
| // NewStreamingState creates a fully initialized streaming state. | |
| func NewStreamingState() *StreamingState { | |
| return &StreamingState{ | |
| ToolCalls: NewToolCallAccumulator(), | |
| } | |
| } | |
| // Reset clears all state for reuse. | |
| func (s *StreamingState) Reset() { | |
| s.StreamState.Reset() | |
| s.ToolCalls.Reset() | |
| s.Content.Reset() | |
| s.InTextBlock = false | |
| s.InToolBlock = false | |
| s.InReasoningBlock = false | |
| s.CurrentMessageID = "" | |
| s.CurrentToolCallID = "" | |
| s.CurrentReasoningID = "" | |
| } | |
| // FinishReasonMapper provides bidirectional finish reason mapping. | |
| type FinishReasonMapper struct { | |
| toOpenAI map[string]string | |
| fromOpenAI map[string]string | |
| } | |
| // NewFinishReasonMapper creates a mapper with standard OpenAI mappings. | |
| func NewFinishReasonMapper() *FinishReasonMapper { | |
| return &FinishReasonMapper{ | |
| toOpenAI: map[string]string{ | |
| // Anthropic/Claude | |
| "end_turn": "stop", | |
| "tool_use": "tool_calls", | |
| "max_tokens": "length", | |
| "stop_sequence": "stop", | |
| // Gemini | |
| "STOP": "stop", | |
| "MAX_TOKENS": "length", | |
| "SAFETY": "content_filter", | |
| "RECITATION": "content_filter", | |
| "OTHER": "stop", | |
| // Codex | |
| "completed": "stop", | |
| }, | |
| fromOpenAI: map[string]string{ | |
| "stop": "end_turn", | |
| "tool_calls": "tool_use", | |
| "length": "max_tokens", | |
| "content_filter": "SAFETY", | |
| }, | |
| } | |
| } | |
| // ToOpenAI converts a provider-specific finish reason to OpenAI format. | |
| func (m *FinishReasonMapper) ToOpenAI(reason string) string { | |
| if mapped, ok := m.toOpenAI[reason]; ok { | |
| return mapped | |
| } | |
| return "stop" // default | |
| } | |
| // FromOpenAI converts an OpenAI finish reason to provider-specific format. | |
| func (m *FinishReasonMapper) FromOpenAI(reason string) string { | |
| if mapped, ok := m.fromOpenAI[reason]; ok { | |
| return mapped | |
| } | |
| return "STOP" // default | |
| } | |
| // RegisterMapping adds or overrides a mapping. | |
| func (m *FinishReasonMapper) RegisterMapping(providerReason, openAIReason string) { | |
| m.toOpenAI[providerReason] = openAIReason | |
| m.fromOpenAI[openAIReason] = providerReason | |
| } | |
| // DefaultFinishReasonMapper is the package-level default mapper. | |
| var DefaultFinishReasonMapper = NewFinishReasonMapper() | |
| // Process-wide unique ID generators. | |
| var ( | |
| responseIDCounter uint64 | |
| functionCallIDCounter uint64 | |
| ) | |
| // GenerateResponseID creates a unique response ID with optional prefix. | |
| func GenerateResponseID(prefix string) string { | |
| counter := atomic.AddUint64(&responseIDCounter, 1) | |
| if prefix != "" { | |
| return fmt.Sprintf("%s_%x_%d", prefix, time.Now().UnixNano(), counter) | |
| } | |
| return fmt.Sprintf("resp_%x_%d", time.Now().UnixNano(), counter) | |
| } | |
| // GenerateFunctionCallID creates a unique function call ID. | |
| func GenerateFunctionCallID(name string) string { | |
| counter := atomic.AddUint64(&functionCallIDCounter, 1) | |
| if name != "" { | |
| return fmt.Sprintf("call_%s_%d_%d", name, time.Now().UnixNano(), counter) | |
| } | |
| return fmt.Sprintf("call_%d_%d", time.Now().UnixNano(), counter) | |
| } | |