From 621d7fee0ace729f8d44126032d2c6e13f72ee7f Mon Sep 17 00:00:00 2001 From: t Date: Tue, 7 Jul 2026 11:29:23 -0600 Subject: Move libpanto projects to libpantograph dependency Remove the in-repo libpanto sources and binding projects from pantograph. Consume libpantograph through the Zig package URL at code.tjp.lol/libpantograph.git, including the Lua module artifact used by CLI extensions. --- libpanto-go/panto.go | 1591 -------------------------------------------------- 1 file changed, 1591 deletions(-) delete mode 100644 libpanto-go/panto.go (limited to 'libpanto-go/panto.go') diff --git a/libpanto-go/panto.go b/libpanto-go/panto.go deleted file mode 100644 index 30caaca..0000000 --- a/libpanto-go/panto.go +++ /dev/null @@ -1,1591 +0,0 @@ -package panto - -/* -#cgo CFLAGS: -I../libpanto-c/include -#cgo LDFLAGS: -L../libpanto-c/zig-out/lib -lpanto -#include -#include -extern PantoStatus pantoGoStoreCreate(void *ctx, PantoSession **out); -extern PantoStatus pantoGoStoreList(void *ctx, PantoSessionInfoList *out); -extern void pantoGoStoreFreeSessionInfos(void *ctx, PantoSessionInfoList infos); -extern PantoStatus pantoGoStoreResolve(void *ctx, PantoSlice id, PantoSessionResult *out); -extern PantoStatus pantoGoStoreLatest(void *ctx, PantoSessionResult *out); -extern PantoStatus pantoGoStoreLoad(void *ctx, PantoSlice id, PantoConversation **out); -extern PantoStatus pantoGoStoreAppendMessages(void *ctx, PantoSlice session_id, PantoPersistentMessage *messages, size_t len); -static PantoStatus pantoGoStoreAppendMessagesConst(void *ctx, PantoSlice session_id, const PantoPersistentMessage *messages, size_t len) { - return pantoGoStoreAppendMessages(ctx, session_id, (PantoPersistentMessage*)messages, len); -} -extern PantoStatus pantoGoToolInvoke(void *ctx, PantoSlice input, PantoResultParts *out); -extern void pantoGoCallbackDestroy(void *ctx); -static PantoSessionStoreVTable panto_go_store_vtable = { - pantoGoStoreCreate, - pantoGoStoreList, - pantoGoStoreFreeSessionInfos, - pantoGoStoreResolve, - pantoGoStoreLatest, - pantoGoStoreLoad, - pantoGoStoreAppendMessagesConst, - pantoGoCallbackDestroy, -}; -static PantoStatus panto_go_session_store_create(void *ctx, PantoSessionStore **out) { - return panto_session_store_create(ctx, &panto_go_store_vtable, out); -} -*/ -import "C" - -import ( - "errors" - "fmt" - "iter" - "runtime" - "unsafe" -) - -type ( - APIStyle int - ReasoningEffort int - Thinking int - Effort int - MessageRole int - ContentBlockTag int - EventTag int - SystemMode int -) - -// These enums mirror libpanto-c's C enums. Each constant wraps its C value -// (rather than a hand-kept iota sequence) so the Go side can never silently -// drift from the ABI: if a variant is inserted in panto.h, the values shift -// with it instead of desyncing. Keep one Go constant per C value. -const ( - OpenAIChat APIStyle = APIStyle(C.PANTO_OPENAI_CHAT) - AnthropicMessages APIStyle = APIStyle(C.PANTO_ANTHROPIC_MESSAGES) - OpenAIResponses APIStyle = APIStyle(C.PANTO_OPENAI_RESPONSES) - OpenAICodexResponses APIStyle = APIStyle(C.PANTO_OPENAI_CODEX_RESPONSES) -) - -const ( - ReasoningDefault ReasoningEffort = ReasoningEffort(C.PANTO_REASONING_DEFAULT) - ReasoningOff ReasoningEffort = ReasoningEffort(C.PANTO_REASONING_OFF) - ReasoningMinimal ReasoningEffort = ReasoningEffort(C.PANTO_REASONING_MINIMAL) - ReasoningLow ReasoningEffort = ReasoningEffort(C.PANTO_REASONING_LOW) - ReasoningMedium ReasoningEffort = ReasoningEffort(C.PANTO_REASONING_MEDIUM) - ReasoningHigh ReasoningEffort = ReasoningEffort(C.PANTO_REASONING_HIGH) -) - -const ( - ThinkingDisabled Thinking = Thinking(C.PANTO_THINKING_DISABLED) - ThinkingEnabled Thinking = Thinking(C.PANTO_THINKING_ENABLED) - ThinkingAdaptive Thinking = Thinking(C.PANTO_THINKING_ADAPTIVE) -) - -const ( - EffortLow Effort = Effort(C.PANTO_EFFORT_LOW) - EffortMedium Effort = Effort(C.PANTO_EFFORT_MEDIUM) - EffortHigh Effort = Effort(C.PANTO_EFFORT_HIGH) - EffortXHigh Effort = Effort(C.PANTO_EFFORT_XHIGH) - EffortMax Effort = Effort(C.PANTO_EFFORT_MAX) -) - -const ( - RoleSystem MessageRole = MessageRole(C.PANTO_ROLE_SYSTEM) - RoleUser MessageRole = MessageRole(C.PANTO_ROLE_USER) - RoleAssistant MessageRole = MessageRole(C.PANTO_ROLE_ASSISTANT) -) - -const ( - BlockText ContentBlockTag = ContentBlockTag(C.PANTO_BLOCK_TEXT) - BlockThinking ContentBlockTag = ContentBlockTag(C.PANTO_BLOCK_THINKING) - BlockToolUse ContentBlockTag = ContentBlockTag(C.PANTO_BLOCK_TOOL_USE) - BlockToolResult ContentBlockTag = ContentBlockTag(C.PANTO_BLOCK_TOOL_RESULT) - BlockSystem ContentBlockTag = ContentBlockTag(C.PANTO_BLOCK_SYSTEM) - BlockCompactionSummary ContentBlockTag = ContentBlockTag(C.PANTO_BLOCK_COMPACTION_SUMMARY) -) - -const ( - SystemAppend SystemMode = SystemMode(C.PANTO_SYSTEM_APPEND) - SystemReplace SystemMode = SystemMode(C.PANTO_SYSTEM_REPLACE) -) - -const ( - EventMessageStart EventTag = EventTag(C.PANTO_EVENT_MESSAGE_START) - EventBlockStart EventTag = EventTag(C.PANTO_EVENT_BLOCK_START) - EventToolDetails EventTag = EventTag(C.PANTO_EVENT_TOOL_DETAILS) - EventContentDelta EventTag = EventTag(C.PANTO_EVENT_CONTENT_DELTA) - EventBlockComplete EventTag = EventTag(C.PANTO_EVENT_BLOCK_COMPLETE) - EventMessageComplete EventTag = EventTag(C.PANTO_EVENT_MESSAGE_COMPLETE) - EventProviderRetry EventTag = EventTag(C.PANTO_EVENT_PROVIDER_RETRY) - EventToolDispatchStart EventTag = EventTag(C.PANTO_EVENT_TOOL_DISPATCH_START) - EventToolDispatchResult EventTag = EventTag(C.PANTO_EVENT_TOOL_DISPATCH_RESULT) - EventToolDispatchComplete EventTag = EventTag(C.PANTO_EVENT_TOOL_DISPATCH_COMPLETE) - EventTurnComplete EventTag = EventTag(C.PANTO_EVENT_TURN_COMPLETE) -) - -type Config struct { - Provider ProviderConfig - Compaction CompactionConfig - Retry RetryConfig -} -type ProviderConfig struct { - OpenAIChat *OpenAIChatConfig - AnthropicMessages *AnthropicMessagesConfig - OpenAIResponses *OpenAIResponsesConfig -} -type OpenAIChatConfig struct { - APIKey, BaseURL, Model string - Reasoning ReasoningEffort - MaxTokens uint32 -} -type OpenAIResponsesConfig struct { - APIKey, BaseURL, Model string - Reasoning ReasoningEffort - MaxTokens uint32 -} -type AnthropicMessagesConfig struct { - APIKey, BaseURL, Model, APIVersion string - MaxTokens uint32 - Thinking Thinking - Effort Effort - ThinkingBudgetTokens *uint32 - ThinkingInterleaved bool -} -type CompactionConfig struct { - KeepVerbatim uint32 - Model *ProviderConfig - CompactionPrompt *string -} -type RetryConfig struct { - MaxAttempts uint - InitialDelayMS, MaxDelayMS uint64 - Multiplier float64 - Jitter bool -} -type ( - Usage struct{ Input, Output, CacheRead, CacheWrite, Reasoning uint64 } - CompactionResult struct { - Compacted bool - KeptTurns, SummarizedMessages uint - } -) - -// Event is one streaming-progress notification from a Stream. The concrete -// type is one of the *Event structs below; type-switch on it, or branch on -// EventType() when only the kind matters. The terminal event of a turn is -// TurnCompleteEvent (EventType() == EventTurnComplete). -type Event interface { - // EventType reports the kind of event, mirroring the concrete type. It - // lets callers branch without a type switch (e.g. skip everything until - // EventMessageComplete) and is the cheap terminal check used by Iter. - EventType() EventTag -} - -// MessageStartEvent: an assistant message began streaming. -type MessageStartEvent struct{ Role MessageRole } - -// BlockStartEvent: a content block opened. -type BlockStartEvent struct { - BlockType ContentBlockTag - Index uint -} - -// ToolDetailsEvent: the tool identity (id + name) for a ToolUse block resolved. -type ToolDetailsEvent struct { - Index uint - ID, Name string -} - -// ContentDeltaEvent: streaming content for the open block (text/thinking/args). -type ContentDeltaEvent struct { - Index uint - Delta string -} - -// BlockCompleteEvent: a content block closed. -type BlockCompleteEvent struct { - Index uint - BlockType ContentBlockTag -} - -// MessageCompleteEvent: one assistant message finished streaming. The message -// is the current tail of Agent.Conversation(); MessageIndex is its index there -// and BlockCount its number of content blocks, so the full content can be read -// back via Agent.Conversation().Message(MessageIndex) without marshalling every -// block onto the event. Usage is the wire-reported token usage, if any. -type MessageCompleteEvent struct { - Role MessageRole - MessageIndex uint - BlockCount uint - Usage *Usage -} - -// ProviderRetryEvent: a provider retry was scheduled before the next attempt. -type ProviderRetryEvent struct { - Attempt, MaxAttempts uint - DelayMS uint64 - ErrorName string - StatusCode *uint16 - RetryAfterMS *uint64 - Message string - Compaction bool -} - -// ToolDispatchStartEvent: the agent began dispatching the just-completed -// message's tool calls. -type ToolDispatchStartEvent struct{ Count uint } - -// ToolDispatchResultEvent: a single tool's result became available, before the -// aggregate ToolDispatchCompleteEvent. MessageIndex is the index of the -// ToolResult-carrying message in the conversation. -type ToolDispatchResultEvent struct{ MessageIndex uint } - -// ToolDispatchCompleteEvent: the agent appended a user(ToolResult) message. -type ToolDispatchCompleteEvent struct{ MessageIndex uint } - -// TurnCompleteEvent: the turn terminal. Emitted exactly once; every Next after -// it returns nil. -type TurnCompleteEvent struct{} - -func (MessageStartEvent) EventType() EventTag { return EventMessageStart } -func (BlockStartEvent) EventType() EventTag { return EventBlockStart } -func (ToolDetailsEvent) EventType() EventTag { return EventToolDetails } -func (ContentDeltaEvent) EventType() EventTag { return EventContentDelta } -func (BlockCompleteEvent) EventType() EventTag { return EventBlockComplete } -func (MessageCompleteEvent) EventType() EventTag { return EventMessageComplete } -func (ProviderRetryEvent) EventType() EventTag { return EventProviderRetry } -func (ToolDispatchStartEvent) EventType() EventTag { return EventToolDispatchStart } -func (ToolDispatchResultEvent) EventType() EventTag { return EventToolDispatchResult } -func (ToolDispatchCompleteEvent) EventType() EventTag { return EventToolDispatchComplete } -func (TurnCompleteEvent) EventType() EventTag { return EventTurnComplete } - -type ( - Agent struct { - ptr *C.PantoAgent - retainedSession *Session - retainedConv *Conversation - retainedStoreCloser func() - } - Stream struct { - ptr *C.PantoStream - err error - done bool - } -) - -type Conversation struct { - ptr *C.PantoConversation - owned bool -} -type ( - Session struct{ ptr *C.PantoSession } - SessionInfo struct { - ID, Created, Modified, LastUserMessage, BaseURL, Model string - MessageCount uint - APIStyle APIStyle - Reasoning ReasoningEffort - } -) - -type SessionStore interface { - Create() (*Session, error) - List() ([]SessionInfo, error) - Resolve(id string) (*Session, bool, error) - Latest() (*Session, bool, error) - Load(id string) (*Conversation, bool, error) - AppendMessages(sessionID string, messages []PersistentMessage) error -} -type ( - cSessionStore interface{ cptr() *C.PantoSessionStore } - NullStore struct{ ptr *C.PantoSessionStore } - FileSystemJSONLStore struct{ ptr *C.PantoSessionStore } - GoSessionStore struct { - ptr *C.PantoSessionStore - impl SessionStore - } -) - -type PersistentMessage struct { - Role MessageRole - Usage *Usage - Metadata string - Content []OwnedContentBlock - // Per-message wire identity: the provider that produced this message. May - // drift within a conversation (compaction on another model, mid-chat - // switch), so persist these per message rather than from static config. - APIStyle APIStyle - BaseURL string - Model string - Reasoning ReasoningEffort -} -type OwnedMessage struct { - Role MessageRole - Usage *Usage - Metadata string - Content []OwnedContentBlock -} -type OwnedContentBlock struct { - Tag ContentBlockTag - Text string - ToolID string - ToolName string - IsError bool - SystemMode SystemMode - // Thinking-block signature provenance. Populated for blocks delivered to - // AppendMessages; empty otherwise. To replay a thinking block faithfully, - // persist all four and feed them back via ThinkingBlock — Anthropic drops - // a thinking block whose signature lacks a matching origin. - ThinkingSignature string - ThinkingSignatureStyle APIStyle - ThinkingSignatureBaseURL string - ThinkingSignatureModel string -} - -type cStrings []*C.char - -func (cs cStrings) free() { - for _, s := range cs { - C.free(unsafe.Pointer(s)) - } -} -func Init() { C.panto_init() } -func Deinit() { C.panto_deinit() } -func lastError() error { - s := C.panto_last_error() - if s.ptr == nil || s.len == 0 { - return errors.New("libpanto error") - } - return errors.New(C.GoStringN((*C.char)(unsafe.Pointer(s.ptr)), C.int(s.len))) -} - -func NewNullStore() (*NullStore, error) { - var out *C.PantoSessionStore - if C.panto_null_store_create(&out) != C.PANTO_OK { - return nil, lastError() - } - s := &NullStore{out} - runtime.SetFinalizer(s, (*NullStore).Close) - return s, nil -} -func (s *NullStore) cptr() *C.PantoSessionStore { return s.ptr } -func (s *NullStore) Create() (*Session, error) { return CreateSession(s) } -func (s *NullStore) List() ([]SessionInfo, error) { return ListSessions(s) } -func (s *NullStore) Resolve(id string) (*Session, bool, error) { return ResolveSession(s, id) } -func (s *NullStore) Latest() (*Session, bool, error) { return LatestSession(s) } -func (s *NullStore) Load(id string) (*Conversation, bool, error) { - sess, ok, err := ResolveSession(s, id) - if err != nil || !ok { - return nil, ok, err - } - c, err := sess.Load() - return c, err == nil, err -} -func (s *NullStore) AppendMessages(sessionID string, messages []PersistentMessage) error { return nil } -func (s *NullStore) Close() { - if s != nil && s.ptr != nil { - C.panto_session_store_destroy(s.ptr) - s.ptr = nil - } -} - -func NewFileSystemJSONLStore(dir, metadata string) (*FileSystemJSONLStore, error) { - cd := C.CString(dir) - defer C.free(unsafe.Pointer(cd)) - cm := C.CString(metadata) - defer C.free(unsafe.Pointer(cm)) - var out *C.PantoSessionStore - if C.panto_file_system_jsonl_store_create(cd, cm, &out) != C.PANTO_OK { - return nil, lastError() - } - s := &FileSystemJSONLStore{out} - runtime.SetFinalizer(s, (*FileSystemJSONLStore).Close) - return s, nil -} -func (s *FileSystemJSONLStore) cptr() *C.PantoSessionStore { return s.ptr } -func (s *FileSystemJSONLStore) Create() (*Session, error) { return CreateSession(s) } -func (s *FileSystemJSONLStore) List() ([]SessionInfo, error) { return ListSessions(s) } -func (s *FileSystemJSONLStore) Resolve(id string) (*Session, bool, error) { - return ResolveSession(s, id) -} -func (s *FileSystemJSONLStore) Latest() (*Session, bool, error) { return LatestSession(s) } -func (s *FileSystemJSONLStore) Load(id string) (*Conversation, bool, error) { - sess, ok, err := ResolveSession(s, id) - if err != nil || !ok { - return nil, ok, err - } - c, err := sess.Load() - return c, err == nil, err -} - -func (s *FileSystemJSONLStore) AppendMessages(sessionID string, messages []PersistentMessage) error { - return nil -} - -func (s *FileSystemJSONLStore) Close() { - if s != nil && s.ptr != nil { - C.panto_session_store_destroy(s.ptr) - s.ptr = nil - } -} - -func CreateSession(store cSessionStore) (*Session, error) { - var out *C.PantoSession - if C.panto_session_store_create_session(store.cptr(), &out) != C.PANTO_OK { - return nil, lastError() - } - s := &Session{out} - runtime.SetFinalizer(s, (*Session).Close) - return s, nil -} - -// NewSession mints a *Session bound to store, carrying info (at least a -// store-assigned ID). Unlike CreateSession/ResolveSession/LatestSession it does -// NOT dispatch into the store's vtable, so a custom SessionStore can call it -// from its own Create/Resolve/Latest to build the *Session it must return -// without recursing back into itself. The session's bound store is used for -// later load/append; pass the store the session belongs to. -func NewSession(store cSessionStore, info SessionInfo) (*Session, error) { - ci := cSessionInfo(info) - defer freeCSessionInfo(ci) - var out *C.PantoSession - if C.panto_session_create(store.cptr(), ci, &out) != C.PANTO_OK { - return nil, lastError() - } - s := &Session{out} - runtime.SetFinalizer(s, (*Session).Close) - return s, nil -} - -// NewNullSession mints a standalone *Session backed by a null store — load and -// append are no-ops. Useful as a placeholder when a store performs its own -// persistence outside the session's bound store. -func NewNullSession() (*Session, error) { - var out *C.PantoSession - if C.panto_session_create_null(&out) != C.PANTO_OK { - return nil, lastError() - } - s := &Session{out} - runtime.SetFinalizer(s, (*Session).Close) - return s, nil -} - -func ResolveSession(store cSessionStore, id string) (*Session, bool, error) { - cid := C.CString(id) - defer C.free(unsafe.Pointer(cid)) - var r C.PantoSessionResult - if C.panto_session_store_resolve(store.cptr(), cid, &r) != C.PANTO_OK { - return nil, false, lastError() - } - if !bool(r.found) { - return nil, false, nil - } - s := &Session{r.session} - runtime.SetFinalizer(s, (*Session).Close) - return s, true, nil -} - -func LatestSession(store cSessionStore) (*Session, bool, error) { - var r C.PantoSessionResult - if C.panto_session_store_latest(store.cptr(), &r) != C.PANTO_OK { - return nil, false, lastError() - } - if !bool(r.found) { - return nil, false, nil - } - s := &Session{r.session} - runtime.SetFinalizer(s, (*Session).Close) - return s, true, nil -} - -func ListSessions(store cSessionStore) ([]SessionInfo, error) { - var l C.PantoSessionInfoList - if C.panto_session_store_list(store.cptr(), &l) != C.PANTO_OK { - return nil, lastError() - } - defer C.panto_session_info_list_destroy(l) - out := make([]SessionInfo, int(l.len)) - if l.ptr != nil { - xs := unsafe.Slice(l.ptr, int(l.len)) - for i, x := range xs { - out[i] = sessionInfo(x) - } - } - return out, nil -} - -func (s *Session) Close() { - if s != nil && s.ptr != nil { - C.panto_session_destroy(s.ptr) - s.ptr = nil - } -} - -func (s *Session) Load() (*Conversation, error) { - var out *C.PantoConversation - if C.panto_session_load(s.ptr, &out) != C.PANTO_OK { - return nil, lastError() - } - c := &Conversation{ptr: out, owned: true} - runtime.SetFinalizer(c, (*Conversation).Close) - return c, nil -} - -func NewConversation() (*Conversation, error) { - var out *C.PantoConversation - if C.panto_conversation_create(&out) != C.PANTO_OK { - return nil, lastError() - } - c := &Conversation{ptr: out, owned: true} - runtime.SetFinalizer(c, (*Conversation).Close) - return c, nil -} - -func (c *Conversation) Close() { - if c != nil && c.owned && c.ptr != nil { - C.panto_conversation_destroy(c.ptr) - c.ptr = nil - } -} -func (c *Conversation) MessageCount() uint { return uint(C.panto_conversation_message_count(c.ptr)) } -func (c *Conversation) Message(i uint) Message { return Message{conv: c, index: i} } -func (c *Conversation) AddSystemMessage(text string) error { - ct := C.CString(text) - defer C.free(unsafe.Pointer(ct)) - if C.panto_conversation_add_system_message(c.ptr, ct) != C.PANTO_OK { - return lastError() - } - return nil -} - -func (c *Conversation) ReplaceSystemMessage(text string) error { - ct := C.CString(text) - defer C.free(unsafe.Pointer(ct)) - if C.panto_conversation_replace_system_message(c.ptr, ct) != C.PANTO_OK { - return lastError() - } - return nil -} - -func (c *Conversation) AddUserText(text string) error { - ct := C.CString(text) - defer C.free(unsafe.Pointer(ct)) - if C.panto_conversation_add_user_text(c.ptr, ct) != C.PANTO_OK { - return lastError() - } - return nil -} - -func (c *Conversation) AddAssistantText(text string, u *Usage) error { - ct := C.CString(text) - defer C.free(unsafe.Pointer(ct)) - var cu C.PantoUsage - has := false - if u != nil { - cu = cUsage(*u) - has = true - } - if C.panto_conversation_add_assistant_text(c.ptr, ct, C.bool(has), cu) != C.PANTO_OK { - return lastError() - } - return nil -} - -func (c *Conversation) AddCompactionSummary(text string) error { - ct := C.CString(text) - defer C.free(unsafe.Pointer(ct)) - if C.panto_conversation_add_compaction_summary(c.ptr, ct) != C.PANTO_OK { - return lastError() - } - return nil -} - -// Block is one immutable content block — text, thinking, tool use, tool -// result, or system text. Build it with the constructors below (TextBlock, -// ToolResultBlock, …) and assemble blocks into a message with UserMessage / -// AssistantMessage. This is the single content-block vocabulary used both to -// open a turn (Agent.Run) and to rebuild a persisted message for resumption -// (Conversation.AddMessage). -type Block struct { - tag ContentBlockTag - text string - toolID string - toolName string - input string - isError bool - systemMode SystemMode - thinkingSignature string - thinkingSigStyle APIStyle - thinkingSigBaseURL string - thinkingSigModel string -} - -// TextBlock is a plain text block. -func TextBlock(text string) Block { return Block{tag: BlockText, text: text} } - -// ThinkingBlock is an assistant reasoning block. signature/baseURL/model carry -// the signature provenance (see OwnedContentBlock); pass "" for signature when -// the provider emitted none, in which case style/baseURL/model are ignored. -func ThinkingBlock(text, signature string, style APIStyle, baseURL, model string) Block { - return Block{tag: BlockThinking, text: text, thinkingSignature: signature, thinkingSigStyle: style, thinkingSigBaseURL: baseURL, thinkingSigModel: model} -} - -// ToolUseBlock is an assistant tool call. -func ToolUseBlock(id, name, input string) Block { - return Block{tag: BlockToolUse, toolID: id, toolName: name, input: input} -} - -// ToolResultBlock is a user-role tool result keyed by the originating tool-use -// id. Used to resume a turn whose tool calls the embedder handled itself. -func ToolResultBlock(toolUseID, text string, isError bool) Block { - return Block{tag: BlockToolResult, toolID: toolUseID, text: text, isError: isError} -} - -// SystemBlock is a system-prompt block (append or replace mode). -func SystemBlock(text string, mode SystemMode) Block { - return Block{tag: BlockSystem, text: text, systemMode: mode} -} - -// MessageIdentity is the wire identity (provider style/baseURL/model + -// reasoning) that produced a message. Attach it to an InputMessage when -// rebuilding a conversation for resumption: it is the per-message source of -// truth for replaying thinking signatures and is preserved through compaction, -// so a kept-verbatim turn is not re-stamped with the compaction model. Set it -// from a PersistentMessage's APIStyle/BaseURL/Model/Reasoning. -type MessageIdentity struct { - APIStyle APIStyle - BaseURL string - Model string - Reasoning ReasoningEffort -} - -// InputMessage is one role-tagged message assembled from value Blocks, with -// optional usage and wire identity. Build it with UserMessage / AssistantMessage -// (or set the fields directly), then pass it to Agent.Run (user role) or -// Conversation.AddMessage (any role, for replay). -type InputMessage struct { - Role MessageRole - Usage *Usage - Identity *MessageIdentity - Blocks []Block -} - -// UserMessage assembles a user-role message — the argument to Agent.Run. A -// plain chat turn is a single TextBlock; a turn resuming after embedder-handled -// tool calls is one or more ToolResultBlocks. -func UserMessage(blocks ...Block) InputMessage { - return InputMessage{Role: RoleUser, Blocks: blocks} -} - -// AssistantMessage assembles an assistant-role message with optional usage — -// used to rebuild a persisted turn via Conversation.AddMessage. -func AssistantMessage(usage *Usage, blocks ...Block) InputMessage { - return InputMessage{Role: RoleAssistant, Usage: usage, Blocks: blocks} -} - -// WithIdentity returns a copy of the message tagged with the given wire -// identity (see MessageIdentity). -func (m InputMessage) WithIdentity(id MessageIdentity) InputMessage { - m.Identity = &id - return m -} - -// buildCBuilder materializes an InputMessage as a transient C message builder, -// pushing each block in order and attaching identity if present. The returned -// builder is owned by the caller and must be consumed by exactly one of -// panto_agent_run / panto_conversation_add_message (both of which destroy it). -// On error it is destroyed here and nil is returned. -func buildCBuilder(msg InputMessage) (*C.PantoMessageBuilder, error) { - p := C.panto_message_builder_create(C.PantoMessageRole(msg.Role)) - if p == nil { - return nil, lastError() - } - committed := false - defer func() { - if !committed { - C.panto_message_builder_destroy(p) - } - }() - if msg.Identity != nil { - cb := C.CString(msg.Identity.BaseURL) - defer C.free(unsafe.Pointer(cb)) - cm := C.CString(msg.Identity.Model) - defer C.free(unsafe.Pointer(cm)) - if C.panto_message_builder_set_identity(p, C.PantoAPIStyle(msg.Identity.APIStyle), cb, cm, C.PantoReasoningEffort(msg.Identity.Reasoning)) != C.PANTO_OK { - return nil, lastError() - } - } - for _, b := range msg.Blocks { - if err := pushBlock(p, b); err != nil { - return nil, err - } - } - committed = true - return p, nil -} - -func pushBlock(p *C.PantoMessageBuilder, b Block) error { - switch b.tag { - case BlockText: - ct := C.CString(b.text) - defer C.free(unsafe.Pointer(ct)) - if C.panto_message_builder_add_text(p, ct) != C.PANTO_OK { - return lastError() - } - case BlockThinking: - ct := C.CString(b.text) - defer C.free(unsafe.Pointer(ct)) - cs := C.CString(b.thinkingSignature) - defer C.free(unsafe.Pointer(cs)) - cb := C.CString(b.thinkingSigBaseURL) - defer C.free(unsafe.Pointer(cb)) - cm := C.CString(b.thinkingSigModel) - defer C.free(unsafe.Pointer(cm)) - if C.panto_message_builder_add_thinking(p, ct, cs, C.PantoAPIStyle(b.thinkingSigStyle), cb, cm) != C.PANTO_OK { - return lastError() - } - case BlockToolUse: - cid := C.CString(b.toolID) - defer C.free(unsafe.Pointer(cid)) - cn := C.CString(b.toolName) - defer C.free(unsafe.Pointer(cn)) - ci := C.CString(b.input) - defer C.free(unsafe.Pointer(ci)) - if C.panto_message_builder_add_tool_use(p, cid, cn, ci) != C.PANTO_OK { - return lastError() - } - case BlockToolResult: - cid := C.CString(b.toolID) - defer C.free(unsafe.Pointer(cid)) - ct := C.CString(b.text) - defer C.free(unsafe.Pointer(ct)) - if C.panto_message_builder_add_tool_result(p, cid, ct, C.bool(b.isError)) != C.PANTO_OK { - return lastError() - } - case BlockSystem: - ct := C.CString(b.text) - defer C.free(unsafe.Pointer(ct)) - if C.panto_message_builder_add_system(p, ct, C.PantoSystemMode(b.systemMode)) != C.PANTO_OK { - return lastError() - } - default: - return fmt.Errorf("unknown content block tag %d", int(b.tag)) - } - return nil -} - -// AddMessage commits msg as one message of msg.Role (with its optional usage -// and identity) — the block-level path for rebuilding a persisted conversation -// containing tool calls or thinking that the text-only AddUserText/ -// AddAssistantText cannot. -func (c *Conversation) AddMessage(msg InputMessage) error { - b, err := buildCBuilder(msg) - if err != nil { - return err - } - var cu C.PantoUsage - has := false - if msg.Usage != nil { - cu = cUsage(*msg.Usage) - has = true - } - // panto_conversation_add_message consumes (destroys) the builder on every - // outcome, so there is nothing to free here afterwards. - if C.panto_conversation_add_message(c.ptr, b, C.bool(has), cu) != C.PANTO_OK { - return lastError() - } - return nil -} - -type Message struct { - conv *Conversation - index uint -} - -func (m Message) Role() MessageRole { - return MessageRole(C.panto_conversation_message_role(m.conv.ptr, C.size_t(m.index))) -} - -func (m Message) Usage() *Usage { - if !bool(C.panto_conversation_message_has_usage(m.conv.ptr, C.size_t(m.index))) { - return nil - } - u := usage(C.panto_conversation_message_usage(m.conv.ptr, C.size_t(m.index))) - return &u -} - -func (m Message) BlockCount() uint { - return uint(C.panto_conversation_message_block_count(m.conv.ptr, C.size_t(m.index))) -} - -func (m Message) Block(i uint) ContentBlock { - return ContentBlock{conv: m.conv, msg: m.index, index: i} -} - -func (m Message) Snapshot() OwnedMessage { - blocks := make([]OwnedContentBlock, m.BlockCount()) - for i := range blocks { - blocks[i] = m.Block(uint(i)).Snapshot() - } - return OwnedMessage{Role: m.Role(), Usage: m.Usage(), Content: blocks} -} - -type ContentBlock struct { - conv *Conversation - msg, index uint -} - -func (b ContentBlock) Tag() ContentBlockTag { - return ContentBlockTag(C.panto_conversation_block_tag(b.conv.ptr, C.size_t(b.msg), C.size_t(b.index))) -} - -func (b ContentBlock) Text() string { - return goSlice(C.panto_conversation_block_text(b.conv.ptr, C.size_t(b.msg), C.size_t(b.index))) -} - -func (b ContentBlock) ToolID() string { - return goSlice(C.panto_conversation_block_tool_id(b.conv.ptr, C.size_t(b.msg), C.size_t(b.index))) -} - -func (b ContentBlock) ToolName() string { - return goSlice(C.panto_conversation_block_tool_name(b.conv.ptr, C.size_t(b.msg), C.size_t(b.index))) -} - -func (b ContentBlock) ToolResultIsError() bool { - return bool(C.panto_conversation_block_tool_result_is_error(b.conv.ptr, C.size_t(b.msg), C.size_t(b.index))) -} - -func (b ContentBlock) SystemMode() SystemMode { - return SystemMode(C.panto_conversation_block_system_mode(b.conv.ptr, C.size_t(b.msg), C.size_t(b.index))) -} - -func (b ContentBlock) Snapshot() OwnedContentBlock { - return OwnedContentBlock{ - Tag: b.Tag(), - Text: b.Text(), - ToolID: b.ToolID(), - ToolName: b.ToolName(), - IsError: b.ToolResultIsError(), - SystemMode: b.SystemMode(), - } -} - -func NewAgent(cfg Config) (*Agent, error) { - return NewAgentWithSession(cfg, nil, nil) -} - -func NewAgentWithSession(cfg Config, session *Session, conv *Conversation) (*Agent, error) { - ccfg, strings, err := cfg.c() - if err != nil { - return nil, err - } - defer strings.free() - var csession *C.PantoSession - if session != nil { - csession = session.ptr - runtime.SetFinalizer(session, nil) - } - var cconv *C.PantoConversation - if conv != nil { - cconv = conv.ptr - conv.owned = false - runtime.SetFinalizer(conv, nil) - } - var out *C.PantoAgent - if C.panto_agent_create(&ccfg, csession, cconv, &out) != C.PANTO_OK { - return nil, lastError() - } - a := &Agent{ptr: out, retainedSession: session, retainedConv: conv} - runtime.SetFinalizer(a, (*Agent).Close) - return a, nil -} - -func (a *Agent) Close() { - if a != nil && a.ptr != nil { - C.panto_agent_destroy(a.ptr) - a.ptr = nil - } - if a != nil { - if a.retainedSession != nil { - a.retainedSession.ptr = nil - a.retainedSession = nil - } - if a.retainedConv != nil { - a.retainedConv.ptr = nil - a.retainedConv = nil - } - if a.retainedStoreCloser != nil { - a.retainedStoreCloser() - a.retainedStoreCloser = nil - } - } -} -func (a *Agent) SessionID() string { return goSlice(C.panto_agent_session_id(a.ptr)) } -func (a *Agent) Conversation() *Conversation { - return &Conversation{ptr: C.panto_agent_conversation(a.ptr), owned: false} -} - -func (a *Agent) SetConfig(cfg Config) error { - ccfg, strings, err := cfg.c() - if err != nil { - return err - } - defer strings.free() - if C.panto_agent_set_config(a.ptr, &ccfg) != C.PANTO_OK { - return lastError() - } - return nil -} - -func (a *Agent) Compact(overrideSystemPrompt, extraInstructions *string) (CompactionResult, error) { - var co, ce *C.char - if overrideSystemPrompt != nil { - co = C.CString(*overrideSystemPrompt) - defer C.free(unsafe.Pointer(co)) - } - if extraInstructions != nil { - ce = C.CString(*extraInstructions) - defer C.free(unsafe.Pointer(ce)) - } - var out C.PantoCompactionResult - if C.panto_agent_compact(a.ptr, co, ce, &out) != C.PANTO_OK { - return CompactionResult{}, lastError() - } - return CompactionResult{ - Compacted: bool(out.compacted), - KeptTurns: uint(out.kept_turns), - SummarizedMessages: uint(out.summarized_messages), - }, nil -} - -// Run opens a turn from a user-role message and returns a resumable Stream. -// Build the message with UserMessage: a single TextBlock for a plain prompt, -// or ToolResultBlocks to resume a turn whose tool calls the embedder handled -// itself after breaking out of a prior stream. The message must be user-role. -func (a *Agent) Run(msg InputMessage) (*Stream, error) { - if msg.Role != RoleUser { - return nil, fmt.Errorf("Run requires a user-role message, got role %d", int(msg.Role)) - } - b, err := buildCBuilder(msg) - if err != nil { - return nil, err - } - // panto_agent_run consumes (destroys) the builder on every outcome. - var out *C.PantoStream - if C.panto_agent_run(a.ptr, b, &out) != C.PANTO_OK { - return nil, lastError() - } - s := &Stream{ptr: out} - runtime.SetFinalizer(s, (*Stream).Close) - return s, nil -} - -func (a *Agent) AddSystemMessage(text string) error { - ct := C.CString(text) - defer C.free(unsafe.Pointer(ct)) - if C.panto_agent_add_system_message(a.ptr, ct) != C.PANTO_OK { - return lastError() - } - return nil -} - -func (a *Agent) SetSystemPrompt(text string) error { - ct := C.CString(text) - defer C.free(unsafe.Pointer(ct)) - if C.panto_agent_set_system_prompt(a.ptr, ct) != C.PANTO_OK { - return lastError() - } - return nil -} - -func (s *Stream) Close() { - if s != nil && s.ptr != nil { - C.panto_stream_destroy(s.ptr) - s.ptr = nil - } -} - -// Reopen resets a failed stream back to its turn-open boundary so the caller -// can resume Next() after changing the agent config (e.g. catch a terminal -// bad-request, swap the provider config via Agent.SetConfig, and retry the -// SAME turn without re-appending the user message). It is valid only on a -// stream whose Next() has surfaced a terminal error; otherwise it returns an -// error. On success the stream's local error/done state is cleared so the -// iteration can continue. -func (s *Stream) Reopen() error { - if s == nil || s.ptr == nil { - return fmt.Errorf("reopen on a closed stream") - } - if C.panto_stream_reopen(s.ptr) != C.PANTO_OK { - return lastError() - } - s.err = nil - s.done = false - return nil -} - -func (s *Stream) Next() (Event, bool, error) { - if s.err != nil { - return nil, false, s.err - } - if s.done { - return nil, false, nil - } - var cev C.PantoEvent - status := C.panto_stream_next(s.ptr, &cev) - switch status { - case C.PANTO_NEXT_EVENT: - defer C.panto_event_free(&cev) - ev := marshalEvent(&cev) - if ev.EventType() == EventTurnComplete { - s.done = true - } - return ev, true, nil - case C.PANTO_NEXT_DONE: - s.done = true - return nil, false, nil - case C.PANTO_NEXT_ERROR: - s.err = lastError() - return nil, false, s.err - default: - s.err = fmt.Errorf("unknown panto next status %d", int(status)) - return nil, false, s.err - } -} -func (s *Stream) Err() error { return s.err } -func (s *Stream) Iter() iter.Seq[Event] { - return func(yield func(Event) bool) { - for { - ev, ok, err := s.Next() - if err != nil || !ok { - return - } - if !yield(ev) { - return - } - if ev.EventType() == EventTurnComplete { - return - } - } - } -} - -func (s *Stream) Chan() <-chan Event { - ch := make(chan Event) - go func() { - defer close(ch) - for ev := range s.Iter() { - ch <- ev - } - }() - return ch -} - -func (cfg Config) c() (C.PantoConfig, cStrings, error) { - var cs cStrings - provider, pstrings, err := cfg.Provider.c() - cs = append(cs, pstrings...) - if err != nil { - cs.free() - return C.PantoConfig{}, nil, err - } - out := C.PantoConfig{provider: provider} - out.compaction.keep_verbatim = C.uint32_t(cfg.Compaction.KeepVerbatim) - if cfg.Compaction.Model != nil { - m, ms, err := cfg.Compaction.Model.c() - cs = append(cs, ms...) - if err != nil { - cs.free() - return C.PantoConfig{}, nil, err - } - out.compaction.has_model = true - out.compaction.model = m - } - if cfg.Compaction.CompactionPrompt != nil { - c := C.CString(*cfg.Compaction.CompactionPrompt) - cs = append(cs, c) - out.compaction.has_compaction_prompt = true - out.compaction.compaction_prompt = c - } - out.retry.max_attempts = C.size_t(cfg.Retry.MaxAttempts) - out.retry.initial_delay_ms = C.uint64_t(cfg.Retry.InitialDelayMS) - out.retry.max_delay_ms = C.uint64_t(cfg.Retry.MaxDelayMS) - out.retry.multiplier = C.double(cfg.Retry.Multiplier) - out.retry.jitter = C.bool(cfg.Retry.Jitter) - return out, cs, nil -} - -func (p ProviderConfig) c() (C.PantoProviderConfig, cStrings, error) { - var out C.PantoProviderConfig - var cs cStrings - n := 0 - if p.OpenAIChat != nil { - n++ - } - if p.AnthropicMessages != nil { - n++ - } - if p.OpenAIResponses != nil { - n++ - } - if n != 1 { - return out, nil, errors.New("exactly one provider config must be set") - } - if p.OpenAIChat != nil { - out.tag = C.PANTO_OPENAI_CHAT - setOpenAI(&out, p.OpenAIChat, &cs) - return out, cs, nil - } - if p.OpenAIResponses != nil { - out.tag = C.PANTO_OPENAI_RESPONSES - setOpenAIResponses(&out, p.OpenAIResponses, &cs) - return out, cs, nil - } - out.tag = C.PANTO_ANTHROPIC_MESSAGES - setAnthropic(&out, p.AnthropicMessages, &cs) - return out, cs, nil -} - -func setOpenAI(out *C.PantoProviderConfig, cfg *OpenAIChatConfig, cs *cStrings) { - apiKey, baseURL, model := C.CString(cfg.APIKey), C.CString(cfg.BaseURL), C.CString(cfg.Model) - *cs = append(*cs, apiKey, baseURL, model) - c := (*C.PantoOpenAIChatConfig)(unsafe.Pointer(&out.data[0])) - c.api_key = apiKey - c.base_url = baseURL - c.model = model - c.reasoning = C.PantoReasoningEffort(cfg.Reasoning) - c.max_tokens = C.uint32_t(cfg.MaxTokens) -} - -func setOpenAIResponses(out *C.PantoProviderConfig, cfg *OpenAIResponsesConfig, cs *cStrings) { - apiKey, baseURL, model := C.CString(cfg.APIKey), C.CString(cfg.BaseURL), C.CString(cfg.Model) - *cs = append(*cs, apiKey, baseURL, model) - c := (*C.PantoOpenAIResponsesConfig)(unsafe.Pointer(&out.data[0])) - c.api_key = apiKey - c.base_url = baseURL - c.model = model - c.reasoning = C.PantoReasoningEffort(cfg.Reasoning) - c.max_tokens = C.uint32_t(cfg.MaxTokens) -} - -func setAnthropic(out *C.PantoProviderConfig, cfg *AnthropicMessagesConfig, cs *cStrings) { - apiKey, baseURL, model, ver := C.CString(cfg.APIKey), C.CString(cfg.BaseURL), C.CString(cfg.Model), C.CString(cfg.APIVersion) - *cs = append(*cs, apiKey, baseURL, model, ver) - c := (*C.PantoAnthropicMessagesConfig)(unsafe.Pointer(&out.data[0])) - c.api_key = apiKey - c.base_url = baseURL - c.model = model - c.api_version = ver - c.max_tokens = C.uint32_t(cfg.MaxTokens) - c.thinking = C.PantoThinking(cfg.Thinking) - c.effort = C.PantoEffort(cfg.Effort) - c.thinking_interleaved = C.bool(cfg.ThinkingInterleaved) - if cfg.ThinkingBudgetTokens != nil { - c.has_thinking_budget_tokens = true - c.thinking_budget_tokens = C.uint32_t(*cfg.ThinkingBudgetTokens) - } -} - -func marshalEvent(cev *C.PantoEvent) Event { - switch cev.tag { - case C.PANTO_EVENT_MESSAGE_START: - return MessageStartEvent{Role: MessageRole(*(*C.PantoMessageRole)(unsafe.Pointer(&cev.data[0])))} - case C.PANTO_EVENT_BLOCK_START: - b := (*C.PantoBlockStart)(unsafe.Pointer(&cev.data[0])) - return BlockStartEvent{BlockType: ContentBlockTag(b.block_type), Index: uint(b.index)} - case C.PANTO_EVENT_TOOL_DETAILS: - t := (*C.PantoToolDetails)(unsafe.Pointer(&cev.data[0])) - return ToolDetailsEvent{Index: uint(t.index), ID: goSlice(t.id), Name: goSlice(t.name)} - case C.PANTO_EVENT_CONTENT_DELTA: - d := (*C.PantoContentDelta)(unsafe.Pointer(&cev.data[0])) - return ContentDeltaEvent{Index: uint(d.index), Delta: goSlice(d.delta)} - case C.PANTO_EVENT_BLOCK_COMPLETE: - b := (*C.PantoBlockComplete)(unsafe.Pointer(&cev.data[0])) - return BlockCompleteEvent{Index: uint(b.index), BlockType: ContentBlockTag(b.block_type)} - case C.PANTO_EVENT_MESSAGE_COMPLETE: - m := (*C.PantoMessageComplete)(unsafe.Pointer(&cev.data[0])) - ev := MessageCompleteEvent{ - Role: MessageRole(m.role), - MessageIndex: uint(m.message_index), - BlockCount: uint(m.block_count), - } - if m.has_usage { - u := usage(m.usage) - ev.Usage = &u - } - return ev - case C.PANTO_EVENT_PROVIDER_RETRY: - r := (*C.PantoProviderRetry)(unsafe.Pointer(&cev.data[0])) - ev := ProviderRetryEvent{ - Attempt: uint(r.attempt), - MaxAttempts: uint(r.max_attempts), - DelayMS: uint64(r.delay_ms), - ErrorName: goSlice(r.error_name), - Message: goSlice(r.message), - Compaction: bool(r.compaction), - } - if r.has_status_code { - v := uint16(r.status_code) - ev.StatusCode = &v - } - if r.has_retry_after_ms { - v := uint64(r.retry_after_ms) - ev.RetryAfterMS = &v - } - return ev - case C.PANTO_EVENT_TOOL_DISPATCH_START: - t := (*C.PantoToolDispatchStart)(unsafe.Pointer(&cev.data[0])) - return ToolDispatchStartEvent{Count: uint(t.count)} - case C.PANTO_EVENT_TOOL_DISPATCH_RESULT: - t := (*C.PantoToolDispatchComplete)(unsafe.Pointer(&cev.data[0])) - return ToolDispatchResultEvent{MessageIndex: uint(t.message_index)} - case C.PANTO_EVENT_TOOL_DISPATCH_COMPLETE: - t := (*C.PantoToolDispatchComplete)(unsafe.Pointer(&cev.data[0])) - return ToolDispatchCompleteEvent{MessageIndex: uint(t.message_index)} - case C.PANTO_EVENT_TURN_COMPLETE: - return TurnCompleteEvent{} - } - return TurnCompleteEvent{} -} - -func goSlice(s C.PantoSlice) string { - if s.ptr == nil || s.len == 0 { - return "" - } - return C.GoStringN((*C.char)(unsafe.Pointer(s.ptr)), C.int(s.len)) -} - -func usage(u C.PantoUsage) Usage { - return Usage{ - Input: uint64(u.input), - Output: uint64(u.output), - CacheRead: uint64(u.cache_read), - CacheWrite: uint64(u.cache_write), - Reasoning: uint64(u.reasoning), - } -} - -func cUsage(u Usage) C.PantoUsage { - return C.PantoUsage{ - input: C.uint64_t(u.Input), - output: C.uint64_t(u.Output), - cache_read: C.uint64_t(u.CacheRead), - cache_write: C.uint64_t(u.CacheWrite), - reasoning: C.uint64_t(u.Reasoning), - } -} - -func sessionInfo(i C.PantoSessionInfo) SessionInfo { - return SessionInfo{ - ID: goSlice(i.id), - Created: goSlice(i.created), - Modified: goSlice(i.modified), - LastUserMessage: goSlice(i.last_user_message), - BaseURL: goSlice(i.base_url), - Model: goSlice(i.model), - MessageCount: uint(i.message_count), - APIStyle: APIStyle(i.api_style), - Reasoning: ReasoningEffort(i.reasoning), - } -} - -// Tool callback support. -type ( - ToolDecl struct{ Name, Description, SchemaJSON string } - ResultPart struct { - Text string - // Media carries raw bytes, not base64. libpanto detects/resizes/encodes - // supported images and PDFs for the provider; MediaType is an optional - // MIME hint. - MediaType string - Media []byte - } - ResultParts []ResultPart - ToolFunc func(input string) (ResultParts, error) - Tool struct { - Decl ToolDecl - Invoke ToolFunc - } -) - -var ( - callbackHandles = map[uintptr]any{} - nextCallbackHandle uintptr = 1 -) - -func saveCallback(v any) unsafe.Pointer { - h := nextCallbackHandle - nextCallbackHandle++ - callbackHandles[h] = v - return unsafe.Pointer(h) -} -func dropCallback(p unsafe.Pointer) { delete(callbackHandles, uintptr(p)) } - -//export pantoGoToolInvoke -func pantoGoToolInvoke(ctx unsafe.Pointer, input C.PantoSlice, out *C.PantoResultParts) C.PantoStatus { - t := callbackHandles[uintptr(ctx)].(Tool) - parts, err := t.Invoke(goSlice(input)) - if err != nil { - return C.PANTO_ERROR - } - *out = makeCResultParts(parts) - return C.PANTO_OK -} - -//export pantoGoCallbackDestroy -func pantoGoCallbackDestroy(ctx unsafe.Pointer) { dropCallback(ctx) } - -// RegisterTool registers a single tool. Note: libpanto invokes each tool call -// on its own thread, so Invoke may run concurrently — guard any shared state. -// -// TODO: back all Go tool registrations with one process-global Zig ToolSource so -// libpanto delivers the whole turn's batch on a single thread and we fan out onto -// goroutines instead of libpanto threads. Pure efficiency (cheaper than N pthreads -// per turn); the public API stays exactly this. Punted as not worth the work yet. -func (a *Agent) RegisterTool(t Tool) error { - ctx := saveCallback(t) - d, free := cToolDecl(t.Decl) - defer free() - if C.panto_agent_register_tool(a.ptr, d, ctx, (C.PantoToolInvokeFn)(C.pantoGoToolInvoke), (C.PantoToolDestroyFn)(C.pantoGoCallbackDestroy)) != C.PANTO_OK { - dropCallback(ctx) - return lastError() - } - return nil -} - -func cToolDecl(d ToolDecl) (C.PantoToolDecl, func()) { - n := cSlice(d.Name) - desc := cSlice(d.Description) - schema := cSlice(d.SchemaJSON) - return C.PantoToolDecl{name: n, description: desc, schema_json: schema}, func() { - C.free(unsafe.Pointer(n.ptr)) - C.free(unsafe.Pointer(desc.ptr)) - C.free(unsafe.Pointer(schema.ptr)) - } -} - -func cSlice(s string) C.PantoSlice { - cs := C.CString(s) - return C.PantoSlice{ptr: (*C.uint8_t)(unsafe.Pointer(cs)), len: C.size_t(len(s))} -} - -func makeCResultParts(parts ResultParts) C.PantoResultParts { - if len(parts) == 0 { - return C.PantoResultParts{} - } - arr := (*C.PantoResultPart)(C.calloc(C.size_t(len(parts)), C.size_t(unsafe.Sizeof(C.PantoResultPart{})))) - xs := unsafe.Slice(arr, len(parts)) - for i, p := range parts { - if p.Media == nil { - cs := cSlice(p.Text) - xs[i].tag = C.PANTO_RESULT_TEXT - (*C.PantoSlice)(unsafe.Pointer(&xs[i].data[0])).ptr = cs.ptr - (*C.PantoSlice)(unsafe.Pointer(&xs[i].data[0])).len = cs.len - continue - } - - xs[i].tag = C.PANTO_RESULT_MEDIA - m := (*C.PantoMediaPart)(unsafe.Pointer(&xs[i].data[0])) - m.data = C.PantoSlice{ptr: (*C.uint8_t)(C.CBytes(p.Media)), len: C.size_t(len(p.Media))} - if p.MediaType != "" { - m.media_type = cSlice(p.MediaType) - m.has_media_type = C.bool(true) - } - } - return C.PantoResultParts{ptr: arr, len: C.size_t(len(parts))} -} - -func NewGoSessionStore(impl SessionStore) (*GoSessionStore, error) { - ctx := saveCallback(impl) - var out *C.PantoSessionStore - if C.panto_go_session_store_create(ctx, &out) != C.PANTO_OK { - dropCallback(ctx) - return nil, lastError() - } - s := &GoSessionStore{ptr: out, impl: impl} - runtime.SetFinalizer(s, (*GoSessionStore).Close) - return s, nil -} -func (s *GoSessionStore) cptr() *C.PantoSessionStore { return s.ptr } -func (s *GoSessionStore) Create() (*Session, error) { return CreateSession(s) } -func (s *GoSessionStore) List() ([]SessionInfo, error) { return ListSessions(s) } -func (s *GoSessionStore) Resolve(id string) (*Session, bool, error) { return ResolveSession(s, id) } -func (s *GoSessionStore) Latest() (*Session, bool, error) { return LatestSession(s) } -func (s *GoSessionStore) Load(id string) (*Conversation, bool, error) { return s.impl.Load(id) } -func (s *GoSessionStore) AppendMessages(sessionID string, messages []PersistentMessage) error { - return s.impl.AppendMessages(sessionID, messages) -} - -func (s *GoSessionStore) Close() { - if s != nil && s.ptr != nil { - C.panto_session_store_destroy(s.ptr) - s.ptr = nil - } -} - -//export pantoGoStoreCreate -func pantoGoStoreCreate(ctx unsafe.Pointer, out **C.PantoSession) C.PantoStatus { - impl := callbackHandles[uintptr(ctx)].(SessionStore) - s, err := impl.Create() - if err != nil { - return C.PANTO_ERROR - } - *out = s.ptr - runtime.SetFinalizer(s, nil) - return C.PANTO_OK -} - -//export pantoGoStoreList -func pantoGoStoreList(ctx unsafe.Pointer, out *C.PantoSessionInfoList) C.PantoStatus { - impl := callbackHandles[uintptr(ctx)].(SessionStore) - infos, err := impl.List() - if err != nil { - return C.PANTO_ERROR - } - if len(infos) == 0 { - *out = C.PantoSessionInfoList{} - return C.PANTO_OK - } - arr := (*C.PantoSessionInfo)(C.calloc(C.size_t(len(infos)), C.size_t(unsafe.Sizeof(C.PantoSessionInfo{})))) - xs := unsafe.Slice(arr, len(infos)) - for i, info := range infos { - xs[i] = cSessionInfo(info) - } - *out = C.PantoSessionInfoList{ptr: arr, len: C.size_t(len(infos))} - return C.PANTO_OK -} - -//export pantoGoStoreFreeSessionInfos -func pantoGoStoreFreeSessionInfos(ctx unsafe.Pointer, infos C.PantoSessionInfoList) { - _ = ctx - freeCSessionInfoList(infos) -} - -//export pantoGoStoreResolve -func pantoGoStoreResolve(ctx unsafe.Pointer, id C.PantoSlice, out *C.PantoSessionResult) C.PantoStatus { - impl := callbackHandles[uintptr(ctx)].(SessionStore) - s, ok, err := impl.Resolve(goSlice(id)) - if err != nil { - return C.PANTO_ERROR - } - if !ok { - *out = C.PantoSessionResult{} - return C.PANTO_OK - } - *out = C.PantoSessionResult{found: true, session: s.ptr} - runtime.SetFinalizer(s, nil) - return C.PANTO_OK -} - -//export pantoGoStoreLatest -func pantoGoStoreLatest(ctx unsafe.Pointer, out *C.PantoSessionResult) C.PantoStatus { - impl := callbackHandles[uintptr(ctx)].(SessionStore) - s, ok, err := impl.Latest() - if err != nil { - return C.PANTO_ERROR - } - if !ok { - *out = C.PantoSessionResult{} - return C.PANTO_OK - } - *out = C.PantoSessionResult{found: true, session: s.ptr} - runtime.SetFinalizer(s, nil) - return C.PANTO_OK -} - -//export pantoGoStoreLoad -func pantoGoStoreLoad(ctx unsafe.Pointer, id C.PantoSlice, out **C.PantoConversation) C.PantoStatus { - impl := callbackHandles[uintptr(ctx)].(SessionStore) - c, ok, err := impl.Load(goSlice(id)) - if err != nil { - return C.PANTO_ERROR - } - if !ok { - return C.PANTO_ERROR - } - *out = c.ptr - c.owned = false - runtime.SetFinalizer(c, nil) - return C.PANTO_OK -} - -//export pantoGoStoreAppendMessages -func pantoGoStoreAppendMessages(ctx unsafe.Pointer, sessionID C.PantoSlice, messages *C.PantoPersistentMessage, n C.size_t) C.PantoStatus { - impl := callbackHandles[uintptr(ctx)].(SessionStore) - xs := unsafe.Slice(messages, int(n)) - out := make([]PersistentMessage, int(n)) - for i, m := range xs { - var u *Usage - if m.has_usage { - uu := usage(m.usage) - u = &uu - } - out[i] = PersistentMessage{ - Role: MessageRole(m.role), - Usage: u, - Metadata: goSlice(m.metadata), - Content: goOwnedBlocks(m.content, m.content_len), - APIStyle: APIStyle(m.api_style), - BaseURL: goSlice(m.base_url), - Model: goSlice(m.model), - Reasoning: ReasoningEffort(m.reasoning), - } - } - if err := impl.AppendMessages(goSlice(sessionID), out); err != nil { - return C.PANTO_ERROR - } - return C.PANTO_OK -} - -func goOwnedBlocks(ptr *C.PantoOwnedContentBlock, n C.size_t) []OwnedContentBlock { - if ptr == nil || n == 0 { - return nil - } - xs := unsafe.Slice(ptr, int(n)) - out := make([]OwnedContentBlock, int(n)) - for i, b := range xs { - out[i] = OwnedContentBlock{ - Tag: ContentBlockTag(b.tag), - Text: goSlice(b.text), - ToolID: goSlice(b.tool_id), - ToolName: goSlice(b.tool_name), - IsError: bool(b.is_error), - SystemMode: SystemMode(b.system_mode), - ThinkingSignature: goSlice(b.thinking_signature), - ThinkingSignatureStyle: APIStyle(b.thinking_signature_api_style), - ThinkingSignatureBaseURL: goSlice(b.thinking_signature_base_url), - ThinkingSignatureModel: goSlice(b.thinking_signature_model), - } - } - return out -} - -func cSessionInfo(i SessionInfo) C.PantoSessionInfo { - return C.PantoSessionInfo{ - id: cSlice(i.ID), - created: cSlice(i.Created), - modified: cSlice(i.Modified), - last_user_message: cSlice(i.LastUserMessage), - base_url: cSlice(i.BaseURL), - model: cSlice(i.Model), - message_count: C.size_t(i.MessageCount), - api_style: C.PantoAPIStyle(i.APIStyle), - reasoning: C.PantoReasoningEffort(i.Reasoning), - } -} - -func freeCSessionInfo(i C.PantoSessionInfo) { - C.free(unsafe.Pointer(i.id.ptr)) - C.free(unsafe.Pointer(i.created.ptr)) - C.free(unsafe.Pointer(i.modified.ptr)) - C.free(unsafe.Pointer(i.last_user_message.ptr)) - C.free(unsafe.Pointer(i.base_url.ptr)) - C.free(unsafe.Pointer(i.model.ptr)) -} - -func freeCSessionInfoList(l C.PantoSessionInfoList) { - if l.ptr == nil { - return - } - xs := unsafe.Slice(l.ptr, int(l.len)) - for _, i := range xs { - freeCSessionInfo(i) - } - C.free(unsafe.Pointer(l.ptr)) -} -- cgit v1.3