From 2a47389f2c8ca76db0db7b57ca3373983051e723 Mon Sep 17 00:00:00 2001 From: Eliah Rusin Date: Mon, 16 Feb 2026 13:35:40 +0300 Subject: [PATCH] feat: add Go client SDK with ogen code generation (#375) Add a Go client for the Hindsight API using ogen for strongly-typed code generation from the OpenAPI 3.1 spec. The client provides a high-level wrapper with functional options around the generated code, covering all core operations (retain, recall, reflect, bank management). Includes: - ogen-based code generation with OpenAPI 3.1 spec preprocessing - High-level Client wrapper with idiomatic Go API - Functional options for all operations (WithBudget, WithTags, etc.) - OgenClient() escape hatch for advanced operations - Integration tests and godoc examples - Go SDK reference docs and cookbook entries (quickstart, concurrent pipeline, memory-augmented API service) - Updated generate-clients.sh with Go generation step Co-authored-by: Claude Opus 4.6 --- hindsight-clients/go/README.md | 178 + hindsight-clients/go/banks.go | 118 + hindsight-clients/go/doc.go | 40 + hindsight-clients/go/example_test.go | 124 + hindsight-clients/go/generate.go | 4 + hindsight-clients/go/go.mod | 29 + hindsight-clients/go/go.sum | 60 + hindsight-clients/go/hindsight.go | 66 + hindsight-clients/go/integration_test.go | 399 + .../go/internal/cmd/preprocess/main.go | 111 + .../go/internal/ogenapi/.gitignore | 2 + .../go/internal/ogenapi/oas_cfg_gen.go | 61 + .../go/internal/ogenapi/oas_client_gen.go | 3638 +++++ .../go/internal/ogenapi/oas_defaults_gen.go | 179 + .../go/internal/ogenapi/oas_interfaces_gen.go | 170 + .../go/internal/ogenapi/oas_json_gen.go | 12849 ++++++++++++++++ .../go/internal/ogenapi/oas_operations_gen.go | 54 + .../go/internal/ogenapi/oas_parameters_gen.go | 264 + .../ogenapi/oas_request_encoders_gen.go | 179 + .../ogenapi/oas_response_decoders_gen.go | 3873 +++++ .../go/internal/ogenapi/oas_schemas_gen.go | 5666 +++++++ .../go/internal/ogenapi/oas_validators_gen.go | 935 ++ hindsight-clients/go/ogen.yml | 9 + hindsight-clients/go/options.go | 321 + hindsight-clients/go/recall.go | 59 + hindsight-clients/go/reflect.go | 74 + hindsight-clients/go/retain.go | 73 + .../applications/go-memory-service.md | 345 + hindsight-docs/docs/cookbook/index.mdx | 18 + .../recipes/go-concurrent-pipeline.md | 272 + .../docs/cookbook/recipes/go-quickstart.md | 216 + hindsight-docs/docs/sdks/cli.md | 2 +- hindsight-docs/docs/sdks/embed.md | 2 +- hindsight-docs/docs/sdks/go.md | 294 + .../applications/go-memory-service.md | 345 + .../version-0.4/cookbook/index.mdx | 18 + .../recipes/go-concurrent-pipeline.md | 272 + .../cookbook/recipes/go-quickstart.md | 216 + .../versioned_docs/version-0.4/sdks/cli.md | 2 +- .../versioned_docs/version-0.4/sdks/embed.md | 2 +- .../versioned_docs/version-0.4/sdks/go.md | 294 + scripts/generate-clients.sh | 23 +- 42 files changed, 31851 insertions(+), 5 deletions(-) create mode 100644 hindsight-clients/go/README.md create mode 100644 hindsight-clients/go/banks.go create mode 100644 hindsight-clients/go/doc.go create mode 100644 hindsight-clients/go/example_test.go create mode 100644 hindsight-clients/go/generate.go create mode 100644 hindsight-clients/go/go.mod create mode 100644 hindsight-clients/go/go.sum create mode 100644 hindsight-clients/go/hindsight.go create mode 100644 hindsight-clients/go/integration_test.go create mode 100644 hindsight-clients/go/internal/cmd/preprocess/main.go create mode 100644 hindsight-clients/go/internal/ogenapi/.gitignore create mode 100644 hindsight-clients/go/internal/ogenapi/oas_cfg_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_client_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_defaults_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_interfaces_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_json_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_operations_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_parameters_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_request_encoders_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_response_decoders_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_schemas_gen.go create mode 100644 hindsight-clients/go/internal/ogenapi/oas_validators_gen.go create mode 100644 hindsight-clients/go/ogen.yml create mode 100644 hindsight-clients/go/options.go create mode 100644 hindsight-clients/go/recall.go create mode 100644 hindsight-clients/go/reflect.go create mode 100644 hindsight-clients/go/retain.go create mode 100644 hindsight-docs/docs/cookbook/applications/go-memory-service.md create mode 100644 hindsight-docs/docs/cookbook/recipes/go-concurrent-pipeline.md create mode 100644 hindsight-docs/docs/cookbook/recipes/go-quickstart.md create mode 100644 hindsight-docs/docs/sdks/go.md create mode 100644 hindsight-docs/versioned_docs/version-0.4/cookbook/applications/go-memory-service.md create mode 100644 hindsight-docs/versioned_docs/version-0.4/cookbook/recipes/go-concurrent-pipeline.md create mode 100644 hindsight-docs/versioned_docs/version-0.4/cookbook/recipes/go-quickstart.md create mode 100644 hindsight-docs/versioned_docs/version-0.4/sdks/go.md diff --git a/hindsight-clients/go/README.md b/hindsight-clients/go/README.md new file mode 100644 index 00000000..e67ee892 --- /dev/null +++ b/hindsight-clients/go/README.md @@ -0,0 +1,178 @@ +# Hindsight Go Client + +Go client for the [Hindsight](https://github.com/vectorize-io/hindsight) agent memory API. + +## Installation + +```bash +go get github.com/vectorize-io/hindsight-client-go +``` + +Requires Go 1.25+. + +## Quick Start + +```go +package main + +import ( + "context" + "fmt" + "log" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +func main() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + + // Store a memory + _, err = client.Retain(ctx, "my-bank", "The user prefers dark mode") + if err != nil { + log.Fatal(err) + } + + // Recall memories + resp, err := client.Recall(ctx, "my-bank", "What are the user's preferences?") + if err != nil { + log.Fatal(err) + } + for _, r := range resp.Results { + fmt.Println(r.Text) + } + + // Reflect with reasoning + ref, err := client.Reflect(ctx, "my-bank", "Summarize what you know about the user") + if err != nil { + log.Fatal(err) + } + fmt.Println(ref.Text) +} +``` + +## Authentication + +```go +client, err := hindsight.New("http://localhost:8888", hindsight.WithAPIKey("your-key")) +``` + +## Core Operations + +### Retain (Store Memories) + +```go +// Single memory +_, err := client.Retain(ctx, "bank-id", "Alice loves Python", + hindsight.WithContext("programming discussion"), + hindsight.WithTags([]string{"tech"}), + hindsight.WithDocumentID("conv-123"), +) + +// Batch +items := []hindsight.MemoryItem{ + {Content: "First memory"}, + {Content: "Second memory"}, +} +_, err := client.RetainBatch(ctx, "bank-id", items, + hindsight.WithDocumentTags([]string{"import"}), + hindsight.WithAsync(true), +) +``` + +### Recall (Retrieve Memories) + +```go +resp, err := client.Recall(ctx, "bank-id", "What does Alice like?", + hindsight.WithBudget(hindsight.BudgetHigh), + hindsight.WithMaxTokens(4096), + hindsight.WithTypes([]string{"world", "experience"}), + hindsight.WithTrace(true), + hindsight.WithRecallTags([]string{"tech"}), +) + +for _, r := range resp.Results { + fmt.Printf("[%s] %s\n", r.Type.Or("unknown"), r.Text) +} +``` + +### Reflect (Reason with Memories) + +```go +resp, err := client.Reflect(ctx, "bank-id", "What are the user's interests?", + hindsight.WithReflectBudget(hindsight.BudgetMid), + hindsight.WithReflectMaxTokens(2048), + hindsight.WithResponseSchema(map[string]any{ + "type": "object", + "properties": map[string]any{ + "interests": map[string]any{"type": "array", "items": map[string]any{"type": "string"}}, + }, + }), +) + +fmt.Println(resp.Text) +``` + +### Bank Management + +```go +// Create bank with personality +_, err := client.CreateBank(ctx, "my-bank", + hindsight.WithBankName("My Agent"), + hindsight.WithMission("Help users with coding tasks"), + hindsight.WithDisposition(hindsight.DispositionTraits{ + Skepticism: 3, + Literalism: 2, + Empathy: 4, + }), +) + +// Update mission +_, err = client.SetMission(ctx, "my-bank", "New mission statement") + +// List all banks +banks, err := client.ListBanks(ctx) + +// Delete bank +err = client.DeleteBank(ctx, "my-bank") +``` + +## Advanced Usage + +For operations not covered by the high-level wrapper (documents, entities, operations, mental models, directives), access the ogen-generated client directly: + +```go +ogen := client.OgenClient() + +// List entities +resp, err := ogen.ListEntities(ctx, ogenapi.ListEntitiesParams{ + BankID: "my-bank", +}) + +// Create mental model +resp, err := ogen.CreateMentalModel(ctx, &ogenapi.CreateMentalModelRequest{ + Name: "user-preferences", + SourceQuery: "What are the user's preferences?", +}, ogenapi.CreateMentalModelParams{BankID: "my-bank"}) +``` + +## Code Generation + +The client is built on [ogen](https://github.com/ogen-go/ogen), generating strongly-typed Go code from the OpenAPI 3.1 spec. To regenerate after API changes: + +```bash +cd hindsight-clients/go +go generate ./... +``` + +## Running Tests + +Integration tests require a running Hindsight API server: + +```bash +HINDSIGHT_API_URL=http://localhost:8888 go test -v -tags=integration ./... +``` diff --git a/hindsight-clients/go/banks.go b/hindsight-clients/go/banks.go new file mode 100644 index 00000000..54cf5c89 --- /dev/null +++ b/hindsight-clients/go/banks.go @@ -0,0 +1,118 @@ +package hindsight + +import ( + "context" + "fmt" + + "github.com/vectorize-io/hindsight-client-go/internal/ogenapi" +) + +// CreateBank creates a new memory bank or updates an existing one. +func (c *Client) CreateBank(ctx context.Context, bankID string, opts ...CreateBankOption) (*BankProfileResponse, error) { + var cfg createBankConfig + for _, o := range opts { + o(&cfg) + } + + req := &ogenapi.CreateBankRequest{} + if cfg.name != nil { + req.Name = ogenapi.NewOptString(*cfg.name) + } + if cfg.mission != nil { + req.Mission = ogenapi.NewOptString(*cfg.mission) + } + if cfg.disposition != nil { + req.Disposition = ogenapi.NewOptDispositionTraits(*cfg.disposition) + } + + res, err := c.api.CreateOrUpdateBank(ctx, req, ogenapi.CreateOrUpdateBankParams{ + BankID: bankID, + }) + if err != nil { + return nil, err + } + + resp, ok := res.(*ogenapi.BankProfileResponse) + if !ok { + return nil, fmt.Errorf("hindsight: unexpected response type %T", res) + } + return resp, nil +} + +// GetBankProfile retrieves the profile for a memory bank. +func (c *Client) GetBankProfile(ctx context.Context, bankID string) (*BankProfileResponse, error) { + res, err := c.api.GetBankProfile(ctx, ogenapi.GetBankProfileParams{ + BankID: bankID, + }) + if err != nil { + return nil, err + } + + resp, ok := res.(*ogenapi.BankProfileResponse) + if !ok { + return nil, fmt.Errorf("hindsight: unexpected response type %T", res) + } + return resp, nil +} + +// ListBanks returns all memory banks. +func (c *Client) ListBanks(ctx context.Context) (*BankListResponse, error) { + res, err := c.api.ListBanks(ctx) + if err != nil { + return nil, err + } + + resp, ok := res.(*ogenapi.BankListResponse) + if !ok { + return nil, fmt.Errorf("hindsight: unexpected response type %T", res) + } + return resp, nil +} + +// DeleteBank permanently deletes a memory bank and all its data. +func (c *Client) DeleteBank(ctx context.Context, bankID string) error { + _, err := c.api.DeleteBank(ctx, ogenapi.DeleteBankParams{ + BankID: bankID, + }) + return err +} + +// SetMission updates the mission for a memory bank. +func (c *Client) SetMission(ctx context.Context, bankID, mission string) (*BankProfileResponse, error) { + req := &ogenapi.CreateBankRequest{ + Mission: ogenapi.NewOptString(mission), + } + + res, err := c.api.CreateOrUpdateBank(ctx, req, ogenapi.CreateOrUpdateBankParams{ + BankID: bankID, + }) + if err != nil { + return nil, err + } + + resp, ok := res.(*ogenapi.BankProfileResponse) + if !ok { + return nil, fmt.Errorf("hindsight: unexpected response type %T", res) + } + return resp, nil +} + +// UpdateDisposition updates the personality traits for a memory bank. +func (c *Client) UpdateDisposition(ctx context.Context, bankID string, traits DispositionTraits) (*BankProfileResponse, error) { + req := &ogenapi.UpdateDispositionRequest{ + Disposition: traits, + } + + res, err := c.api.UpdateBankDisposition(ctx, req, ogenapi.UpdateBankDispositionParams{ + BankID: bankID, + }) + if err != nil { + return nil, err + } + + resp, ok := res.(*ogenapi.BankProfileResponse) + if !ok { + return nil, fmt.Errorf("hindsight: unexpected response type %T", res) + } + return resp, nil +} diff --git a/hindsight-clients/go/doc.go b/hindsight-clients/go/doc.go new file mode 100644 index 00000000..262f7ae2 --- /dev/null +++ b/hindsight-clients/go/doc.go @@ -0,0 +1,40 @@ +// Package hindsight provides a Go client for the Hindsight agent memory API. +// +// Hindsight is a long-term memory system for AI agents. This client wraps the +// auto-generated ogen API client with a simpler, Go-idiomatic interface for the +// core operations: retain (store), recall (retrieve), and reflect (reason). +// +// # Quick Start +// +// client, err := hindsight.New("http://localhost:8888") +// if err != nil { +// log.Fatal(err) +// } +// +// // Store a memory +// _, err = client.Retain(ctx, "my-bank", "The user prefers dark mode") +// +// // Recall memories +// resp, err := client.Recall(ctx, "my-bank", "What are the user's preferences?") +// for _, r := range resp.Results { +// fmt.Println(r.Text) +// } +// +// // Reflect with reasoning +// ref, err := client.Reflect(ctx, "my-bank", "Summarize what you know about the user") +// fmt.Println(ref.Text) +// +// # Authentication +// +// For authenticated deployments, pass an API key: +// +// client, err := hindsight.New("http://localhost:8888", hindsight.WithAPIKey("your-key")) +// +// # Advanced Usage +// +// For operations not covered by the high-level wrapper (documents, entities, +// operations, mental models, directives), access the ogen-generated client: +// +// ogen := client.OgenClient() +// resp, err := ogen.ListEntities(ctx, ogenapi.ListEntitiesParams{BankID: "my-bank"}) +package hindsight diff --git a/hindsight-clients/go/example_test.go b/hindsight-clients/go/example_test.go new file mode 100644 index 00000000..17ffe657 --- /dev/null +++ b/hindsight-clients/go/example_test.go @@ -0,0 +1,124 @@ +package hindsight_test + +import ( + "context" + "fmt" + "log" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +func Example() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + + // Store a memory + _, err = client.Retain(ctx, "my-bank", "The user prefers dark mode") + if err != nil { + log.Fatal(err) + } + + // Recall memories + resp, err := client.Recall(ctx, "my-bank", "What are the user's preferences?") + if err != nil { + log.Fatal(err) + } + for _, r := range resp.Results { + fmt.Println(r.Text) + } + + // Reflect with reasoning + ref, err := client.Reflect(ctx, "my-bank", "Summarize what you know about the user") + if err != nil { + log.Fatal(err) + } + fmt.Println(ref.Text) +} + +func ExampleNew_withAPIKey() { + _, err := hindsight.New( + "http://localhost:8888", + hindsight.WithAPIKey("your-api-key"), + ) + if err != nil { + log.Fatal(err) + } +} + +func ExampleClient_Retain() { + client, _ := hindsight.New("http://localhost:8888") + ctx := context.Background() + + // Simple retain + _, _ = client.Retain(ctx, "my-bank", "Alice loves Python programming") + + // Retain with options + _, _ = client.Retain(ctx, "my-bank", "Bob went hiking", + hindsight.WithContext("outdoor activities"), + hindsight.WithTags([]string{"hobbies"}), + hindsight.WithDocumentID("conversation-123"), + ) +} + +func ExampleClient_RetainBatch() { + client, _ := hindsight.New("http://localhost:8888") + ctx := context.Background() + + items := []hindsight.MemoryItem{ + {Content: "Alice completed the project"}, + {Content: "Bob started learning Go"}, + {Content: "Charlie presented at the conference"}, + } + + _, _ = client.RetainBatch(ctx, "my-bank", items, + hindsight.WithDocumentTags([]string{"team-updates"}), + ) +} + +func ExampleClient_Recall() { + client, _ := hindsight.New("http://localhost:8888") + ctx := context.Background() + + resp, _ := client.Recall(ctx, "my-bank", "What does Alice like?", + hindsight.WithBudget(hindsight.BudgetHigh), + hindsight.WithMaxTokens(4096), + hindsight.WithTypes([]string{"world", "experience"}), + hindsight.WithTrace(true), + ) + + for _, r := range resp.Results { + fmt.Printf("[%s] %s\n", r.Type.Or("unknown"), r.Text) + } +} + +func ExampleClient_Reflect() { + client, _ := hindsight.New("http://localhost:8888") + ctx := context.Background() + + resp, _ := client.Reflect(ctx, "my-bank", + "What are the user's professional interests?", + hindsight.WithReflectBudget(hindsight.BudgetMid), + hindsight.WithReflectMaxTokens(2048), + ) + + fmt.Println(resp.Text) +} + +func ExampleClient_CreateBank() { + client, _ := hindsight.New("http://localhost:8888") + ctx := context.Background() + + _, _ = client.CreateBank(ctx, "my-bank", + hindsight.WithBankName("My Agent"), + hindsight.WithMission("Help users with programming tasks"), + hindsight.WithDisposition(hindsight.DispositionTraits{ + Skepticism: 3, + Literalism: 2, + Empathy: 4, + }), + ) +} diff --git a/hindsight-clients/go/generate.go b/hindsight-clients/go/generate.go new file mode 100644 index 00000000..eba3da80 --- /dev/null +++ b/hindsight-clients/go/generate.go @@ -0,0 +1,4 @@ +package hindsight + +//go:generate go run ./internal/cmd/preprocess ../../hindsight-docs/static/openapi.json internal/ogenapi/openapi.json +//go:generate go run github.com/ogen-go/ogen/cmd/ogen --target internal/ogenapi -package ogenapi --clean --config ogen.yml internal/ogenapi/openapi.json diff --git a/hindsight-clients/go/go.mod b/hindsight-clients/go/go.mod new file mode 100644 index 00000000..39014484 --- /dev/null +++ b/hindsight-clients/go/go.mod @@ -0,0 +1,29 @@ +module github.com/vectorize-io/hindsight-client-go + +go 1.25.0 + +require ( + github.com/go-faster/errors v0.7.1 + github.com/go-faster/jx v1.2.0 + github.com/ogen-go/ogen v1.19.0 +) + +require ( + github.com/dlclark/regexp2 v1.11.5 // indirect + github.com/fatih/color v1.18.0 // indirect + github.com/ghodss/yaml v1.0.0 // indirect + github.com/go-faster/yaml v0.4.6 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/segmentio/asm v1.2.1 // indirect + github.com/shopspring/decimal v1.4.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.1 // indirect + golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 // indirect + golang.org/x/net v0.50.0 // indirect + golang.org/x/sync v0.19.0 // indirect + golang.org/x/sys v0.41.0 // indirect + golang.org/x/text v0.34.0 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect +) diff --git a/hindsight-clients/go/go.sum b/hindsight-clients/go/go.sum new file mode 100644 index 00000000..c97d746f --- /dev/null +++ b/hindsight-clients/go/go.sum @@ -0,0 +1,60 @@ +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ= +github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= +github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= +github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg= +github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo= +github.com/go-faster/jx v1.2.0 h1:T2YHJPrFaYu21fJtUxC9GzmluKu8rVIFDwwGBKTDseI= +github.com/go-faster/jx v1.2.0/go.mod h1:UWLOVDmMG597a5tBFPLIWJdUxz5/2emOpfsj9Neg0PE= +github.com/go-faster/yaml v0.4.6 h1:lOK/EhI04gCpPgPhgt0bChS6bvw7G3WwI8xxVe0sw9I= +github.com/go-faster/yaml v0.4.6/go.mod h1:390dRIvV4zbnO7qC9FGo6YYutc+wyyUSHBgbXL52eXk= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/ogen-go/ogen v1.19.0 h1:YvdNpeQJ8A8dLLpS6Vs4WxXL53BT6tBPxH0VSjfALhA= +github.com/ogen-go/ogen v1.19.0/go.mod h1:DeShwO+TEpLYXNCuZliSAedphphXsJaTGGbmSomWUjE= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0= +github.com/segmentio/asm v1.2.1/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs= +github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= +github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc= +go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 h1:Di6/M8l0O2lCLc6VVRWhgCiApHV8MnQurBnFSHsQtNY= +golang.org/x/exp v0.0.0-20230725093048-515e97ebf090/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= +golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60= +golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM= +golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4= +golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k= +golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk= +golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/hindsight-clients/go/hindsight.go b/hindsight-clients/go/hindsight.go new file mode 100644 index 00000000..7b852fb0 --- /dev/null +++ b/hindsight-clients/go/hindsight.go @@ -0,0 +1,66 @@ +package hindsight + +import ( + "net/http" + + "github.com/vectorize-io/hindsight-client-go/internal/ogenapi" +) + +// Client is the high-level Hindsight API client. It wraps the ogen-generated +// client with convenience methods for core operations. +type Client struct { + api *ogenapi.Client +} + +// New creates a new Hindsight client for the given base URL. +// +// By default, no authentication is configured. Use [WithAPIKey] to set a +// Bearer token, or [WithHTTPClient] for full control over the HTTP transport. +func New(baseURL string, opts ...Option) (*Client, error) { + cfg := clientConfig{} + for _, o := range opts { + o(&cfg) + } + + var httpClient http.Client + if cfg.httpClient != nil { + httpClient = *cfg.httpClient + } + + if cfg.apiKey != "" { + base := httpClient.Transport + if base == nil { + base = http.DefaultTransport + } + httpClient.Transport = &authTransport{ + base: base, + token: cfg.apiKey, + } + } + + api, err := ogenapi.NewClient(baseURL, ogenapi.WithClient(&httpClient)) + if err != nil { + return nil, err + } + + return &Client{api: api}, nil +} + +// OgenClient returns the underlying ogen-generated client for advanced +// operations not covered by the high-level wrapper (documents, entities, +// operations, mental models, directives). +func (c *Client) OgenClient() *ogenapi.Client { + return c.api +} + +// authTransport injects a Bearer token into every request. +type authTransport struct { + base http.RoundTripper + token string +} + +func (t *authTransport) RoundTrip(r *http.Request) (*http.Response, error) { + r = r.Clone(r.Context()) + r.Header.Set("Authorization", "Bearer "+t.token) + return t.base.RoundTrip(r) +} diff --git a/hindsight-clients/go/integration_test.go b/hindsight-clients/go/integration_test.go new file mode 100644 index 00000000..618e9d4b --- /dev/null +++ b/hindsight-clients/go/integration_test.go @@ -0,0 +1,399 @@ +//go:build integration + +package hindsight_test + +import ( + "context" + "fmt" + "os" + "testing" + "time" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +func apiURL(t *testing.T) string { + t.Helper() + u := os.Getenv("HINDSIGHT_API_URL") + if u == "" { + u = "http://localhost:8888" + } + return u +} + +func newClient(t *testing.T) *hindsight.Client { + t.Helper() + c, err := hindsight.New(apiURL(t)) + if err != nil { + t.Fatal(err) + } + return c +} + +func uniqueBank(t *testing.T) string { + t.Helper() + return fmt.Sprintf("go_test_%d", time.Now().UnixNano()) +} + +// --- Retain tests --- + +func TestRetainSingle(t *testing.T) { + c := newClient(t) + ctx := context.Background() + + resp, err := c.Retain(ctx, uniqueBank(t), "Alice loves artificial intelligence and machine learning") + if err != nil { + t.Fatal(err) + } + if !resp.Success { + t.Error("expected success=true") + } +} + +func TestRetainWithContext(t *testing.T) { + c := newClient(t) + ctx := context.Background() + + resp, err := c.Retain(ctx, uniqueBank(t), "Bob went hiking in the mountains", + hindsight.WithTimestamp(time.Date(2024, 1, 15, 10, 30, 0, 0, time.UTC)), + hindsight.WithContext("outdoor activities"), + ) + if err != nil { + t.Fatal(err) + } + if !resp.Success { + t.Error("expected success=true") + } +} + +func TestRetainBatch(t *testing.T) { + c := newClient(t) + ctx := context.Background() + + items := []hindsight.MemoryItem{ + {Content: "Charlie enjoys reading science fiction books"}, + {Content: "Diana is learning to play the guitar"}, + {Content: "Eve completed a marathon last month"}, + } + + resp, err := c.RetainBatch(ctx, uniqueBank(t), items) + if err != nil { + t.Fatal(err) + } + if !resp.Success { + t.Error("expected success=true") + } + if resp.ItemsCount != 3 { + t.Errorf("expected items_count=3, got %d", resp.ItemsCount) + } +} + +func TestRetainWithTags(t *testing.T) { + c := newClient(t) + ctx := context.Background() + + resp, err := c.Retain(ctx, uniqueBank(t), "New feature implementation for project Z", + hindsight.WithTags([]string{"project_z", "features"}), + ) + if err != nil { + t.Fatal(err) + } + if !resp.Success { + t.Error("expected success=true") + } +} + +func TestRetainBatchWithDocumentTags(t *testing.T) { + c := newClient(t) + ctx := context.Background() + + items := []hindsight.MemoryItem{ + {Content: "First item in batch"}, + {Content: "Second item in batch"}, + } + + resp, err := c.RetainBatch(ctx, uniqueBank(t), items, + hindsight.WithDocumentTags([]string{"batch_import", "test_data"}), + ) + if err != nil { + t.Fatal(err) + } + if !resp.Success { + t.Error("expected success=true") + } + if resp.ItemsCount != 2 { + t.Errorf("expected items_count=2, got %d", resp.ItemsCount) + } +} + +// --- Recall tests --- + +func setupRecallBank(t *testing.T, c *hindsight.Client, bankID string) { + t.Helper() + ctx := context.Background() + + items := []hindsight.MemoryItem{ + {Content: "Alice loves programming in Python"}, + {Content: "Bob enjoys hiking and outdoor adventures"}, + {Content: "Charlie is interested in quantum physics"}, + {Content: "Diana plays the violin beautifully"}, + } + + _, err := c.RetainBatch(ctx, bankID, items) + if err != nil { + t.Fatal(err) + } +} + +func TestRecallBasic(t *testing.T) { + c := newClient(t) + ctx := context.Background() + bankID := uniqueBank(t) + setupRecallBank(t, c, bankID) + + resp, err := c.Recall(ctx, bankID, "What does Alice like?") + if err != nil { + t.Fatal(err) + } + if len(resp.Results) == 0 { + t.Error("expected at least one result") + } + + found := false + for _, r := range resp.Results { + if contains(r.Text, "Alice") || contains(r.Text, "Python") || contains(r.Text, "programming") { + found = true + break + } + } + if !found { + t.Error("expected a result mentioning Alice or Python") + } +} + +func TestRecallWithMaxTokens(t *testing.T) { + c := newClient(t) + ctx := context.Background() + bankID := uniqueBank(t) + setupRecallBank(t, c, bankID) + + resp, err := c.Recall(ctx, bankID, "outdoor activities", + hindsight.WithMaxTokens(1024), + ) + if err != nil { + t.Fatal(err) + } + if resp.Results == nil { + t.Error("expected results, got nil") + } +} + +func TestRecallFullFeatured(t *testing.T) { + c := newClient(t) + ctx := context.Background() + bankID := uniqueBank(t) + setupRecallBank(t, c, bankID) + + resp, err := c.Recall(ctx, bankID, "What are people's hobbies?", + hindsight.WithTypes([]string{"world"}), + hindsight.WithMaxTokens(2048), + hindsight.WithTrace(true), + ) + if err != nil { + t.Fatal(err) + } + if resp.Results == nil { + t.Error("expected results, got nil") + } +} + +// --- Reflect tests --- + +func setupReflectBank(t *testing.T, c *hindsight.Client, bankID string) { + t.Helper() + ctx := context.Background() + + _, err := c.CreateBank(ctx, bankID, + hindsight.WithMission("I am a helpful AI assistant interested in technology and science."), + ) + if err != nil { + t.Fatal(err) + } + + items := []hindsight.MemoryItem{ + {Content: "The Python programming language is great for data science"}, + {Content: "Machine learning models can recognize patterns in data"}, + {Content: "Neural networks are inspired by biological neurons"}, + } + + _, err = c.RetainBatch(ctx, bankID, items) + if err != nil { + t.Fatal(err) + } +} + +func TestReflectBasic(t *testing.T) { + c := newClient(t) + ctx := context.Background() + bankID := uniqueBank(t) + setupReflectBank(t, c, bankID) + + resp, err := c.Reflect(ctx, bankID, "What do you think about artificial intelligence?") + if err != nil { + t.Fatal(err) + } + if resp.Text == "" { + t.Error("expected non-empty response text") + } +} + +func TestReflectWithMaxTokens(t *testing.T) { + c := newClient(t) + ctx := context.Background() + bankID := uniqueBank(t) + setupReflectBank(t, c, bankID) + + resp, err := c.Reflect(ctx, bankID, "What do you think about Python?", + hindsight.WithReflectMaxTokens(500), + ) + if err != nil { + t.Fatal(err) + } + if resp.Text == "" { + t.Error("expected non-empty response text") + } +} + +// --- Bank tests --- + +func TestCreateBank(t *testing.T) { + c := newClient(t) + ctx := context.Background() + + bankID := uniqueBank(t) + resp, err := c.CreateBank(ctx, bankID, + hindsight.WithBankName("Test Bank"), + hindsight.WithMission("A test bank for Go client"), + ) + if err != nil { + t.Fatal(err) + } + if resp.BankID != bankID { + t.Errorf("expected bank_id=%q, got %q", bankID, resp.BankID) + } +} + +func TestSetMission(t *testing.T) { + c := newClient(t) + ctx := context.Background() + + bankID := uniqueBank(t) + resp, err := c.SetMission(ctx, bankID, "Be a helpful PM tracking sprint progress") + if err != nil { + t.Fatal(err) + } + if resp.BankID != bankID { + t.Errorf("expected bank_id=%q, got %q", bankID, resp.BankID) + } + if resp.Mission != "Be a helpful PM tracking sprint progress" { + t.Errorf("expected mission=%q, got %q", "Be a helpful PM tracking sprint progress", resp.Mission) + } +} + +func TestListBanks(t *testing.T) { + c := newClient(t) + ctx := context.Background() + + // Create a bank first + bankID := uniqueBank(t) + _, err := c.CreateBank(ctx, bankID) + if err != nil { + t.Fatal(err) + } + + resp, err := c.ListBanks(ctx) + if err != nil { + t.Fatal(err) + } + if len(resp.Banks) == 0 { + t.Error("expected at least one bank") + } +} + +func TestDeleteBank(t *testing.T) { + c := newClient(t) + ctx := context.Background() + + bankID := uniqueBank(t) + _, err := c.CreateBank(ctx, bankID, hindsight.WithMission("will be deleted")) + if err != nil { + t.Fatal(err) + } + + err = c.DeleteBank(ctx, bankID) + if err != nil { + t.Fatal(err) + } +} + +// --- End-to-end workflow --- + +func TestCompleteWorkflow(t *testing.T) { + c := newClient(t) + ctx := context.Background() + bankID := uniqueBank(t) + + // 1. Create bank + _, err := c.CreateBank(ctx, bankID, + hindsight.WithMission("I am a software engineer who loves Python programming."), + ) + if err != nil { + t.Fatal(err) + } + + // 2. Store memories + items := []hindsight.MemoryItem{ + {Content: "I completed a project using FastAPI"}, + {Content: "I learned about async programming in Python"}, + {Content: "I enjoy working on open source projects"}, + } + storeResp, err := c.RetainBatch(ctx, bankID, items) + if err != nil { + t.Fatal(err) + } + if !storeResp.Success { + t.Error("expected retain success") + } + + // 3. Search for relevant memories + recallResp, err := c.Recall(ctx, bankID, "What programming technologies do I use?") + if err != nil { + t.Fatal(err) + } + if len(recallResp.Results) == 0 { + t.Error("expected recall results") + } + + // 4. Generate contextual answer + reflectResp, err := c.Reflect(ctx, bankID, "What are my professional interests?") + if err != nil { + t.Fatal(err) + } + if reflectResp.Text == "" { + t.Error("expected non-empty reflect response") + } +} + +// contains checks if s contains substr (case-sensitive). +func contains(s, substr string) bool { + return len(s) >= len(substr) && searchString(s, substr) +} + +func searchString(s, substr string) bool { + for i := 0; i <= len(s)-len(substr); i++ { + if s[i:i+len(substr)] == substr { + return true + } + } + return false +} diff --git a/hindsight-clients/go/internal/cmd/preprocess/main.go b/hindsight-clients/go/internal/cmd/preprocess/main.go new file mode 100644 index 00000000..85eff26c --- /dev/null +++ b/hindsight-clients/go/internal/cmd/preprocess/main.go @@ -0,0 +1,111 @@ +// Command preprocess converts an OpenAPI 3.1 spec to be ogen-compatible. +// +// Hindsight's OpenAPI spec uses anyOf: [{type: T}, {type: null}] for optional +// fields. ogen cannot handle the null type in header/query parameter schemas +// with style:simple. This tool rewrites such patterns to plain {type: T}, +// making the spec consumable by ogen while preserving semantic meaning (the +// fields are already marked as required: false). +package main + +import ( + "encoding/json" + "fmt" + "os" +) + +func main() { + if len(os.Args) != 3 { + fmt.Fprintf(os.Stderr, "usage: preprocess \n") + os.Exit(1) + } + + data, err := os.ReadFile(os.Args[1]) + if err != nil { + fmt.Fprintf(os.Stderr, "read: %v\n", err) + os.Exit(1) + } + + var spec map[string]any + if err := json.Unmarshal(data, &spec); err != nil { + fmt.Fprintf(os.Stderr, "parse: %v\n", err) + os.Exit(1) + } + + convertAnyOfNull(spec) + + out, err := json.MarshalIndent(spec, "", " ") + if err != nil { + fmt.Fprintf(os.Stderr, "marshal: %v\n", err) + os.Exit(1) + } + + if err := os.WriteFile(os.Args[2], out, 0o644); err != nil { + fmt.Fprintf(os.Stderr, "write: %v\n", err) + os.Exit(1) + } +} + +// convertAnyOfNull recursively walks the spec and converts +// anyOf: [{type: T}, {type: null}] → {type: T} (or just the non-null schema). +// For component schema properties, it also does the conversion but additionally +// handles cases where the non-null branch is a $ref. +func convertAnyOfNull(v any) { + switch val := v.(type) { + case map[string]any: + // Check if this object has an "anyOf" with exactly a non-null + null pair. + if tryConvertAnyOf(val) { + // Converted in place; recurse into the result. + convertAnyOfNull(val) + return + } + // Recurse into all values. + for _, child := range val { + convertAnyOfNull(child) + } + case []any: + for _, child := range val { + convertAnyOfNull(child) + } + } +} + +// tryConvertAnyOf checks if m has anyOf: [{...}, {type: null}] and converts +// it in-place. Returns true if conversion happened. +func tryConvertAnyOf(m map[string]any) bool { + anyOf, ok := m["anyOf"].([]any) + if !ok || len(anyOf) != 2 { + return false + } + + // Identify which branch is null and which is the real type. + var realIdx int = -1 + for i, branch := range anyOf { + branchMap, ok := branch.(map[string]any) + if !ok { + return false + } + if branchMap["type"] == "null" { + continue + } + realIdx = i + } + + if realIdx == -1 { + return false // Both are null? Skip. + } + + realBranch, ok := anyOf[realIdx].(map[string]any) + if !ok { + return false + } + + // Remove the anyOf key. + delete(m, "anyOf") + + // Copy all properties from the real branch into the parent. + for k, v := range realBranch { + m[k] = v + } + + return true +} diff --git a/hindsight-clients/go/internal/ogenapi/.gitignore b/hindsight-clients/go/internal/ogenapi/.gitignore new file mode 100644 index 00000000..80f61910 --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/.gitignore @@ -0,0 +1,2 @@ +# Preprocessed OpenAPI spec (intermediate artifact, regenerated by go generate) +openapi.json diff --git a/hindsight-clients/go/internal/ogenapi/oas_cfg_gen.go b/hindsight-clients/go/internal/ogenapi/oas_cfg_gen.go new file mode 100644 index 00000000..96a03bd7 --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_cfg_gen.go @@ -0,0 +1,61 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +import ( + "net/http" + + ht "github.com/ogen-go/ogen/http" +) + +type ( + optionFunc[C any] func(*C) +) + +type clientConfig struct { + Client ht.Client +} + +// ClientOption is client config option. +type ClientOption interface { + applyClient(*clientConfig) +} + +var _ ClientOption = (optionFunc[clientConfig])(nil) + +func (o optionFunc[C]) applyClient(c *C) { + o(c) +} + +func newClientConfig(opts ...ClientOption) clientConfig { + cfg := clientConfig{ + Client: http.DefaultClient, + } + for _, opt := range opts { + opt.applyClient(&cfg) + } + return cfg +} + +type baseClient struct { + cfg clientConfig +} + +func (cfg clientConfig) baseClient() (c baseClient, err error) { + c = baseClient{cfg: cfg} + return c, nil +} + +// Option is config option. +type Option interface { + ClientOption +} + +// WithClient specifies http client to use. +func WithClient(client ht.Client) ClientOption { + return optionFunc[clientConfig](func(cfg *clientConfig) { + if client != nil { + cfg.Client = client + } + }) +} diff --git a/hindsight-clients/go/internal/ogenapi/oas_client_gen.go b/hindsight-clients/go/internal/ogenapi/oas_client_gen.go new file mode 100644 index 00000000..341f3eaa --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_client_gen.go @@ -0,0 +1,3638 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +import ( + "context" + "net/url" + "strings" + + "github.com/go-faster/errors" + "github.com/go-faster/jx" + "github.com/ogen-go/ogen/conv" + ht "github.com/ogen-go/ogen/http" + "github.com/ogen-go/ogen/uri" +) + +func trimTrailingSlashes(u *url.URL) { + u.Path = strings.TrimRight(u.Path, "/") + u.RawPath = strings.TrimRight(u.RawPath, "/") +} + +// Invoker invokes operations described by OpenAPI v3 specification. +type Invoker interface { + // AddBankBackground invokes add_bank_background operation. + // + // Deprecated: Use PUT /mission instead. This endpoint now updates the mission field. + // + // Deprecated: schema marks this operation as deprecated. + // + // POST /v1/default/banks/{bank_id}/background + AddBankBackground(ctx context.Context, request *AddBackgroundRequest, params AddBankBackgroundParams) (AddBankBackgroundRes, error) + // CancelOperation invokes cancel_operation operation. + // + // Cancel a pending async operation by removing it from the queue. + // + // DELETE /v1/default/banks/{bank_id}/operations/{operation_id} + CancelOperation(ctx context.Context, params CancelOperationParams) (CancelOperationRes, error) + // ClearBankMemories invokes clear_bank_memories operation. + // + // Delete memory units for a memory bank. Optionally filter by type (world, experience, opinion) to + // delete only specific types. This is a destructive operation that cannot be undone. The bank + // profile (disposition and background) will be preserved. + // + // DELETE /v1/default/banks/{bank_id}/memories + ClearBankMemories(ctx context.Context, params ClearBankMemoriesParams) (ClearBankMemoriesRes, error) + // ClearObservations invokes clear_observations operation. + // + // Delete all observations for a memory bank. This is useful for resetting the consolidated knowledge. + // + // DELETE /v1/default/banks/{bank_id}/observations + ClearObservations(ctx context.Context, params ClearObservationsParams) (ClearObservationsRes, error) + // CreateDirective invokes create_directive operation. + // + // Create a hard rule that will be injected into prompts. + // + // POST /v1/default/banks/{bank_id}/directives + CreateDirective(ctx context.Context, request *CreateDirectiveRequest, params CreateDirectiveParams) (CreateDirectiveRes, error) + // CreateMentalModel invokes create_mental_model operation. + // + // Create a mental model by running reflect with the source query in the background. Returns an + // operation ID to track progress. The content is auto-generated by the reflect endpoint. Use the + // operations endpoint to check completion status. + // + // POST /v1/default/banks/{bank_id}/mental-models + CreateMentalModel(ctx context.Context, request *CreateMentalModelRequest, params CreateMentalModelParams) (CreateMentalModelRes, error) + // CreateOrUpdateBank invokes create_or_update_bank operation. + // + // Create a new agent or update existing agent with disposition and mission. Auto-fills missing + // fields with defaults. + // + // PUT /v1/default/banks/{bank_id} + CreateOrUpdateBank(ctx context.Context, request *CreateBankRequest, params CreateOrUpdateBankParams) (CreateOrUpdateBankRes, error) + // DeleteBank invokes delete_bank operation. + // + // Delete an entire memory bank including all memories, entities, documents, and the bank profile + // itself. This is a destructive operation that cannot be undone. + // + // DELETE /v1/default/banks/{bank_id} + DeleteBank(ctx context.Context, params DeleteBankParams) (DeleteBankRes, error) + // DeleteDirective invokes delete_directive operation. + // + // Delete a directive. + // + // DELETE /v1/default/banks/{bank_id}/directives/{directive_id} + DeleteDirective(ctx context.Context, params DeleteDirectiveParams) (DeleteDirectiveRes, error) + // DeleteDocument invokes delete_document operation. + // + // Delete a document and all its associated memory units and links. + // This will cascade delete: + // - The document itself + // - All memory units extracted from this document + // - All links (temporal, semantic, entity) associated with those memory units + // This operation cannot be undone. + // + // DELETE /v1/default/banks/{bank_id}/documents/{document_id} + DeleteDocument(ctx context.Context, params DeleteDocumentParams) (DeleteDocumentRes, error) + // DeleteMentalModel invokes delete_mental_model operation. + // + // Delete a mental model. + // + // DELETE /v1/default/banks/{bank_id}/mental-models/{mental_model_id} + DeleteMentalModel(ctx context.Context, params DeleteMentalModelParams) (DeleteMentalModelRes, error) + // GetAgentStats invokes get_agent_stats operation. + // + // Get statistics about nodes and links for a specific agent. + // + // GET /v1/default/banks/{bank_id}/stats + GetAgentStats(ctx context.Context, params GetAgentStatsParams) (GetAgentStatsRes, error) + // GetBankConfig invokes get_bank_config operation. + // + // Get fully resolved configuration for a bank including all hierarchical overrides (global → + // tenant → bank). The 'config' field contains all resolved config values. The 'overrides' field + // shows only bank-specific overrides. + // + // GET /v1/default/banks/{bank_id}/config + GetBankConfig(ctx context.Context, params GetBankConfigParams) (GetBankConfigRes, error) + // GetBankProfile invokes get_bank_profile operation. + // + // Get disposition traits and mission for a memory bank. Auto-creates agent with defaults if not + // exists. + // + // GET /v1/default/banks/{bank_id}/profile + GetBankProfile(ctx context.Context, params GetBankProfileParams) (GetBankProfileRes, error) + // GetChunk invokes get_chunk operation. + // + // Get a specific chunk by its ID. + // + // GET /v1/default/chunks/{chunk_id} + GetChunk(ctx context.Context, params GetChunkParams) (GetChunkRes, error) + // GetDirective invokes get_directive operation. + // + // Get a specific directive by ID. + // + // GET /v1/default/banks/{bank_id}/directives/{directive_id} + GetDirective(ctx context.Context, params GetDirectiveParams) (GetDirectiveRes, error) + // GetDocument invokes get_document operation. + // + // Get a specific document including its original text. + // + // GET /v1/default/banks/{bank_id}/documents/{document_id} + GetDocument(ctx context.Context, params GetDocumentParams) (GetDocumentRes, error) + // GetEntity invokes get_entity operation. + // + // Get detailed information about an entity including observations (mental model). + // + // GET /v1/default/banks/{bank_id}/entities/{entity_id} + GetEntity(ctx context.Context, params GetEntityParams) (GetEntityRes, error) + // GetGraph invokes get_graph operation. + // + // Retrieve graph data for visualization, optionally filtered by type (world/experience/opinion). + // + // GET /v1/default/banks/{bank_id}/graph + GetGraph(ctx context.Context, params GetGraphParams) (GetGraphRes, error) + // GetMemory invokes get_memory operation. + // + // Get a single memory unit by ID with all its metadata including entities and tags. + // + // GET /v1/default/banks/{bank_id}/memories/{memory_id} + GetMemory(ctx context.Context, params GetMemoryParams) (GetMemoryRes, error) + // GetMentalModel invokes get_mental_model operation. + // + // Get a specific mental model by ID. + // + // GET /v1/default/banks/{bank_id}/mental-models/{mental_model_id} + GetMentalModel(ctx context.Context, params GetMentalModelParams) (GetMentalModelRes, error) + // GetOperationStatus invokes get_operation_status operation. + // + // Get the status of a specific async operation. Returns 'pending', 'completed', or 'failed'. + // Completed operations are removed from storage, so 'completed' means the operation finished + // successfully. + // + // GET /v1/default/banks/{bank_id}/operations/{operation_id} + GetOperationStatus(ctx context.Context, params GetOperationStatusParams) (GetOperationStatusRes, error) + // GetVersion invokes get_version operation. + // + // Returns API version information and enabled feature flags. Use this to check which capabilities + // are available in this deployment. + // + // GET /version + GetVersion(ctx context.Context) (*VersionResponse, error) + // HealthEndpointHealthGet invokes health_endpoint_health_get operation. + // + // Checks the health of the API and database connection. + // + // GET /health + HealthEndpointHealthGet(ctx context.Context) (jx.Raw, error) + // ListBanks invokes list_banks operation. + // + // Get a list of all agents with their profiles. + // + // GET /v1/default/banks + ListBanks(ctx context.Context) (ListBanksRes, error) + // ListDirectives invokes list_directives operation. + // + // List hard rules that are injected into prompts. + // + // GET /v1/default/banks/{bank_id}/directives + ListDirectives(ctx context.Context, params ListDirectivesParams) (ListDirectivesRes, error) + // ListDocuments invokes list_documents operation. + // + // List documents with pagination and optional search. Documents are the source content from which + // memory units are extracted. + // + // GET /v1/default/banks/{bank_id}/documents + ListDocuments(ctx context.Context, params ListDocumentsParams) (ListDocumentsRes, error) + // ListEntities invokes list_entities operation. + // + // List all entities (people, organizations, etc.) known by the bank, ordered by mention count. + // Supports pagination. + // + // GET /v1/default/banks/{bank_id}/entities + ListEntities(ctx context.Context, params ListEntitiesParams) (ListEntitiesRes, error) + // ListMemories invokes list_memories operation. + // + // List memory units with pagination and optional full-text search. Supports filtering by type. + // Results are sorted by most recent first (mentioned_at DESC, then created_at DESC). + // + // GET /v1/default/banks/{bank_id}/memories/list + ListMemories(ctx context.Context, params ListMemoriesParams) (ListMemoriesRes, error) + // ListMentalModels invokes list_mental_models operation. + // + // List user-curated living documents that stay current. + // + // GET /v1/default/banks/{bank_id}/mental-models + ListMentalModels(ctx context.Context, params ListMentalModelsParams) (ListMentalModelsRes, error) + // ListOperations invokes list_operations operation. + // + // Get a list of async operations for a specific agent, with optional filtering by status. Results + // are sorted by most recent first. + // + // GET /v1/default/banks/{bank_id}/operations + ListOperations(ctx context.Context, params ListOperationsParams) (ListOperationsRes, error) + // ListTags invokes list_tags operation. + // + // List all unique tags in a memory bank with usage counts. Supports wildcard search using '*' (e.g., + // 'user:*', '*-fred', 'tag*-2'). Case-insensitive. + // + // GET /v1/default/banks/{bank_id}/tags + ListTags(ctx context.Context, params ListTagsParams) (ListTagsRes, error) + // MetricsEndpointMetricsGet invokes metrics_endpoint_metrics_get operation. + // + // Exports metrics in Prometheus format for scraping. + // + // GET /metrics + MetricsEndpointMetricsGet(ctx context.Context) (jx.Raw, error) + // RecallMemories invokes recall_memories operation. + // + // Recall memory using semantic similarity and spreading activation. + // The type parameter is optional and must be one of: + // - `world`: General knowledge about people, places, events, and things that happen + // - `experience`: Memories about experience, conversations, actions taken, and tasks performed. + // + // POST /v1/default/banks/{bank_id}/memories/recall + RecallMemories(ctx context.Context, request *RecallRequest, params RecallMemoriesParams) (RecallMemoriesRes, error) + // Reflect invokes reflect operation. + // + // Reflect and formulate an answer using bank identity, world facts, and opinions. + // This endpoint: + // 1. Retrieves experience (conversations and events) + // 2. Retrieves world facts relevant to the query + // 3. Retrieves existing opinions (bank's perspectives) + // 4. Uses LLM to formulate a contextual answer + // 5. Returns plain text answer and the facts used. + // + // POST /v1/default/banks/{bank_id}/reflect + Reflect(ctx context.Context, request *ReflectRequest, params ReflectParams) (ReflectRes, error) + // RefreshMentalModel invokes refresh_mental_model operation. + // + // Submit an async task to re-run the source query through reflect and update the content. + // + // POST /v1/default/banks/{bank_id}/mental-models/{mental_model_id}/refresh + RefreshMentalModel(ctx context.Context, params RefreshMentalModelParams) (RefreshMentalModelRes, error) + // RegenerateEntityObservations invokes regenerate_entity_observations operation. + // + // This endpoint is deprecated. Entity observations have been replaced by mental models. + // + // Deprecated: schema marks this operation as deprecated. + // + // POST /v1/default/banks/{bank_id}/entities/{entity_id}/regenerate + RegenerateEntityObservations(ctx context.Context, params RegenerateEntityObservationsParams) (RegenerateEntityObservationsRes, error) + // ResetBankConfig invokes reset_bank_config operation. + // + // Reset bank configuration to defaults by removing all bank-specific overrides. The bank will then + // use global and tenant-level configuration only. + // + // DELETE /v1/default/banks/{bank_id}/config + ResetBankConfig(ctx context.Context, params ResetBankConfigParams) (ResetBankConfigRes, error) + // RetainMemories invokes retain_memories operation. + // + // Retain memory items with automatic fact extraction. + // This is the main endpoint for storing memories. It supports both synchronous and asynchronous + // processing via the `async` parameter. + // **Features:** + // - Efficient batch processing + // - Automatic fact extraction from natural language + // - Entity recognition and linking + // - Document tracking with automatic upsert (when document_id is provided) + // - Temporal and semantic linking + // - Optional asynchronous processing + // **The system automatically:** + // 1. Extracts semantic facts from the content + // 2. Generates embeddings + // 3. Deduplicates similar facts + // 4. Creates temporal, semantic, and entity links + // 5. Tracks document metadata + // **When `async=true`:** Returns immediately after queuing. Use the operations endpoint to monitor + // progress. + // **When `async=false` (default):** Waits for processing to complete. + // **Note:** If a memory item has a `document_id` that already exists, the old document and its + // memory units will be deleted before creating new ones (upsert behavior). + // + // POST /v1/default/banks/{bank_id}/memories + RetainMemories(ctx context.Context, request *RetainRequest, params RetainMemoriesParams) (RetainMemoriesRes, error) + // TriggerConsolidation invokes trigger_consolidation operation. + // + // Run memory consolidation to create/update observations from recent memories. + // + // POST /v1/default/banks/{bank_id}/consolidate + TriggerConsolidation(ctx context.Context, params TriggerConsolidationParams) (TriggerConsolidationRes, error) + // UpdateBank invokes update_bank operation. + // + // Partially update an agent's profile. Only provided fields will be updated. + // + // PATCH /v1/default/banks/{bank_id} + UpdateBank(ctx context.Context, request *CreateBankRequest, params UpdateBankParams) (UpdateBankRes, error) + // UpdateBankConfig invokes update_bank_config operation. + // + // Update configuration overrides for a bank. Only hierarchical fields can be overridden (LLM + // settings, retention parameters, etc.). Keys can be provided in Python field format (llm_provider) + // or environment variable format (HINDSIGHT_API_LLM_PROVIDER). + // + // PATCH /v1/default/banks/{bank_id}/config + UpdateBankConfig(ctx context.Context, request *BankConfigUpdate, params UpdateBankConfigParams) (UpdateBankConfigRes, error) + // UpdateBankDisposition invokes update_bank_disposition operation. + // + // Update bank's disposition traits (skepticism, literalism, empathy). + // + // PUT /v1/default/banks/{bank_id}/profile + UpdateBankDisposition(ctx context.Context, request *UpdateDispositionRequest, params UpdateBankDispositionParams) (UpdateBankDispositionRes, error) + // UpdateDirective invokes update_directive operation. + // + // Update a directive's properties. + // + // PATCH /v1/default/banks/{bank_id}/directives/{directive_id} + UpdateDirective(ctx context.Context, request *UpdateDirectiveRequest, params UpdateDirectiveParams) (UpdateDirectiveRes, error) + // UpdateMentalModel invokes update_mental_model operation. + // + // Update a mental model's name and/or source query. + // + // PATCH /v1/default/banks/{bank_id}/mental-models/{mental_model_id} + UpdateMentalModel(ctx context.Context, request *UpdateMentalModelRequest, params UpdateMentalModelParams) (UpdateMentalModelRes, error) +} + +// Client implements OAS client. +type Client struct { + serverURL *url.URL + baseClient +} + +// NewClient initializes new Client defined by OAS. +func NewClient(serverURL string, opts ...ClientOption) (*Client, error) { + u, err := url.Parse(serverURL) + if err != nil { + return nil, err + } + trimTrailingSlashes(u) + + c, err := newClientConfig(opts...).baseClient() + if err != nil { + return nil, err + } + return &Client{ + serverURL: u, + baseClient: c, + }, nil +} + +type serverURLKey struct{} + +// WithServerURL sets context key to override server URL. +func WithServerURL(ctx context.Context, u *url.URL) context.Context { + return context.WithValue(ctx, serverURLKey{}, u) +} + +func (c *Client) requestURL(ctx context.Context) *url.URL { + u, ok := ctx.Value(serverURLKey{}).(*url.URL) + if !ok { + return c.serverURL + } + return u +} + +// AddBankBackground invokes add_bank_background operation. +// +// Deprecated: Use PUT /mission instead. This endpoint now updates the mission field. +// +// Deprecated: schema marks this operation as deprecated. +// +// POST /v1/default/banks/{bank_id}/background +func (c *Client) AddBankBackground(ctx context.Context, request *AddBackgroundRequest, params AddBankBackgroundParams) (AddBankBackgroundRes, error) { + res, err := c.sendAddBankBackground(ctx, request, params) + return res, err +} + +func (c *Client) sendAddBankBackground(ctx context.Context, request *AddBackgroundRequest, params AddBankBackgroundParams) (res AddBankBackgroundRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/background" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeAddBankBackgroundRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeAddBankBackgroundResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// CancelOperation invokes cancel_operation operation. +// +// Cancel a pending async operation by removing it from the queue. +// +// DELETE /v1/default/banks/{bank_id}/operations/{operation_id} +func (c *Client) CancelOperation(ctx context.Context, params CancelOperationParams) (CancelOperationRes, error) { + res, err := c.sendCancelOperation(ctx, params) + return res, err +} + +func (c *Client) sendCancelOperation(ctx context.Context, params CancelOperationParams) (res CancelOperationRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/operations/" + { + // Encode "operation_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "operation_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.OperationID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "DELETE", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeCancelOperationResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ClearBankMemories invokes clear_bank_memories operation. +// +// Delete memory units for a memory bank. Optionally filter by type (world, experience, opinion) to +// delete only specific types. This is a destructive operation that cannot be undone. The bank +// profile (disposition and background) will be preserved. +// +// DELETE /v1/default/banks/{bank_id}/memories +func (c *Client) ClearBankMemories(ctx context.Context, params ClearBankMemoriesParams) (ClearBankMemoriesRes, error) { + res, err := c.sendClearBankMemories(ctx, params) + return res, err +} + +func (c *Client) sendClearBankMemories(ctx context.Context, params ClearBankMemoriesParams) (res ClearBankMemoriesRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/memories" + uri.AddPathParts(u, pathParts[:]...) + + q := uri.NewQueryEncoder() + { + // Encode "type" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "type", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Type.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + r, err := ht.NewRequest(ctx, "DELETE", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeClearBankMemoriesResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ClearObservations invokes clear_observations operation. +// +// Delete all observations for a memory bank. This is useful for resetting the consolidated knowledge. +// +// DELETE /v1/default/banks/{bank_id}/observations +func (c *Client) ClearObservations(ctx context.Context, params ClearObservationsParams) (ClearObservationsRes, error) { + res, err := c.sendClearObservations(ctx, params) + return res, err +} + +func (c *Client) sendClearObservations(ctx context.Context, params ClearObservationsParams) (res ClearObservationsRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/observations" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "DELETE", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeClearObservationsResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// CreateDirective invokes create_directive operation. +// +// Create a hard rule that will be injected into prompts. +// +// POST /v1/default/banks/{bank_id}/directives +func (c *Client) CreateDirective(ctx context.Context, request *CreateDirectiveRequest, params CreateDirectiveParams) (CreateDirectiveRes, error) { + res, err := c.sendCreateDirective(ctx, request, params) + return res, err +} + +func (c *Client) sendCreateDirective(ctx context.Context, request *CreateDirectiveRequest, params CreateDirectiveParams) (res CreateDirectiveRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/directives" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeCreateDirectiveRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeCreateDirectiveResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// CreateMentalModel invokes create_mental_model operation. +// +// Create a mental model by running reflect with the source query in the background. Returns an +// operation ID to track progress. The content is auto-generated by the reflect endpoint. Use the +// operations endpoint to check completion status. +// +// POST /v1/default/banks/{bank_id}/mental-models +func (c *Client) CreateMentalModel(ctx context.Context, request *CreateMentalModelRequest, params CreateMentalModelParams) (CreateMentalModelRes, error) { + res, err := c.sendCreateMentalModel(ctx, request, params) + return res, err +} + +func (c *Client) sendCreateMentalModel(ctx context.Context, request *CreateMentalModelRequest, params CreateMentalModelParams) (res CreateMentalModelRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/mental-models" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeCreateMentalModelRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeCreateMentalModelResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// CreateOrUpdateBank invokes create_or_update_bank operation. +// +// Create a new agent or update existing agent with disposition and mission. Auto-fills missing +// fields with defaults. +// +// PUT /v1/default/banks/{bank_id} +func (c *Client) CreateOrUpdateBank(ctx context.Context, request *CreateBankRequest, params CreateOrUpdateBankParams) (CreateOrUpdateBankRes, error) { + res, err := c.sendCreateOrUpdateBank(ctx, request, params) + return res, err +} + +func (c *Client) sendCreateOrUpdateBank(ctx context.Context, request *CreateBankRequest, params CreateOrUpdateBankParams) (res CreateOrUpdateBankRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [2]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "PUT", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeCreateOrUpdateBankRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeCreateOrUpdateBankResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// DeleteBank invokes delete_bank operation. +// +// Delete an entire memory bank including all memories, entities, documents, and the bank profile +// itself. This is a destructive operation that cannot be undone. +// +// DELETE /v1/default/banks/{bank_id} +func (c *Client) DeleteBank(ctx context.Context, params DeleteBankParams) (DeleteBankRes, error) { + res, err := c.sendDeleteBank(ctx, params) + return res, err +} + +func (c *Client) sendDeleteBank(ctx context.Context, params DeleteBankParams) (res DeleteBankRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [2]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "DELETE", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeDeleteBankResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// DeleteDirective invokes delete_directive operation. +// +// Delete a directive. +// +// DELETE /v1/default/banks/{bank_id}/directives/{directive_id} +func (c *Client) DeleteDirective(ctx context.Context, params DeleteDirectiveParams) (DeleteDirectiveRes, error) { + res, err := c.sendDeleteDirective(ctx, params) + return res, err +} + +func (c *Client) sendDeleteDirective(ctx context.Context, params DeleteDirectiveParams) (res DeleteDirectiveRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/directives/" + { + // Encode "directive_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "directive_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.DirectiveID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "DELETE", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeDeleteDirectiveResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// DeleteDocument invokes delete_document operation. +// +// Delete a document and all its associated memory units and links. +// This will cascade delete: +// - The document itself +// - All memory units extracted from this document +// - All links (temporal, semantic, entity) associated with those memory units +// This operation cannot be undone. +// +// DELETE /v1/default/banks/{bank_id}/documents/{document_id} +func (c *Client) DeleteDocument(ctx context.Context, params DeleteDocumentParams) (DeleteDocumentRes, error) { + res, err := c.sendDeleteDocument(ctx, params) + return res, err +} + +func (c *Client) sendDeleteDocument(ctx context.Context, params DeleteDocumentParams) (res DeleteDocumentRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/documents/" + { + // Encode "document_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "document_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.DocumentID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "DELETE", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeDeleteDocumentResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// DeleteMentalModel invokes delete_mental_model operation. +// +// Delete a mental model. +// +// DELETE /v1/default/banks/{bank_id}/mental-models/{mental_model_id} +func (c *Client) DeleteMentalModel(ctx context.Context, params DeleteMentalModelParams) (DeleteMentalModelRes, error) { + res, err := c.sendDeleteMentalModel(ctx, params) + return res, err +} + +func (c *Client) sendDeleteMentalModel(ctx context.Context, params DeleteMentalModelParams) (res DeleteMentalModelRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/mental-models/" + { + // Encode "mental_model_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "mental_model_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.MentalModelID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "DELETE", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeDeleteMentalModelResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetAgentStats invokes get_agent_stats operation. +// +// Get statistics about nodes and links for a specific agent. +// +// GET /v1/default/banks/{bank_id}/stats +func (c *Client) GetAgentStats(ctx context.Context, params GetAgentStatsParams) (GetAgentStatsRes, error) { + res, err := c.sendGetAgentStats(ctx, params) + return res, err +} + +func (c *Client) sendGetAgentStats(ctx context.Context, params GetAgentStatsParams) (res GetAgentStatsRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/stats" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetAgentStatsResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetBankConfig invokes get_bank_config operation. +// +// Get fully resolved configuration for a bank including all hierarchical overrides (global → +// tenant → bank). The 'config' field contains all resolved config values. The 'overrides' field +// shows only bank-specific overrides. +// +// GET /v1/default/banks/{bank_id}/config +func (c *Client) GetBankConfig(ctx context.Context, params GetBankConfigParams) (GetBankConfigRes, error) { + res, err := c.sendGetBankConfig(ctx, params) + return res, err +} + +func (c *Client) sendGetBankConfig(ctx context.Context, params GetBankConfigParams) (res GetBankConfigRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/config" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetBankConfigResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetBankProfile invokes get_bank_profile operation. +// +// Get disposition traits and mission for a memory bank. Auto-creates agent with defaults if not +// exists. +// +// GET /v1/default/banks/{bank_id}/profile +func (c *Client) GetBankProfile(ctx context.Context, params GetBankProfileParams) (GetBankProfileRes, error) { + res, err := c.sendGetBankProfile(ctx, params) + return res, err +} + +func (c *Client) sendGetBankProfile(ctx context.Context, params GetBankProfileParams) (res GetBankProfileRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/profile" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetBankProfileResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetChunk invokes get_chunk operation. +// +// Get a specific chunk by its ID. +// +// GET /v1/default/chunks/{chunk_id} +func (c *Client) GetChunk(ctx context.Context, params GetChunkParams) (GetChunkRes, error) { + res, err := c.sendGetChunk(ctx, params) + return res, err +} + +func (c *Client) sendGetChunk(ctx context.Context, params GetChunkParams) (res GetChunkRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [2]string + pathParts[0] = "/v1/default/chunks/" + { + // Encode "chunk_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "chunk_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.ChunkID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetChunkResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetDirective invokes get_directive operation. +// +// Get a specific directive by ID. +// +// GET /v1/default/banks/{bank_id}/directives/{directive_id} +func (c *Client) GetDirective(ctx context.Context, params GetDirectiveParams) (GetDirectiveRes, error) { + res, err := c.sendGetDirective(ctx, params) + return res, err +} + +func (c *Client) sendGetDirective(ctx context.Context, params GetDirectiveParams) (res GetDirectiveRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/directives/" + { + // Encode "directive_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "directive_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.DirectiveID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetDirectiveResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetDocument invokes get_document operation. +// +// Get a specific document including its original text. +// +// GET /v1/default/banks/{bank_id}/documents/{document_id} +func (c *Client) GetDocument(ctx context.Context, params GetDocumentParams) (GetDocumentRes, error) { + res, err := c.sendGetDocument(ctx, params) + return res, err +} + +func (c *Client) sendGetDocument(ctx context.Context, params GetDocumentParams) (res GetDocumentRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/documents/" + { + // Encode "document_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "document_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.DocumentID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetDocumentResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetEntity invokes get_entity operation. +// +// Get detailed information about an entity including observations (mental model). +// +// GET /v1/default/banks/{bank_id}/entities/{entity_id} +func (c *Client) GetEntity(ctx context.Context, params GetEntityParams) (GetEntityRes, error) { + res, err := c.sendGetEntity(ctx, params) + return res, err +} + +func (c *Client) sendGetEntity(ctx context.Context, params GetEntityParams) (res GetEntityRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/entities/" + { + // Encode "entity_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "entity_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.EntityID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetEntityResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetGraph invokes get_graph operation. +// +// Retrieve graph data for visualization, optionally filtered by type (world/experience/opinion). +// +// GET /v1/default/banks/{bank_id}/graph +func (c *Client) GetGraph(ctx context.Context, params GetGraphParams) (GetGraphRes, error) { + res, err := c.sendGetGraph(ctx, params) + return res, err +} + +func (c *Client) sendGetGraph(ctx context.Context, params GetGraphParams) (res GetGraphRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/graph" + uri.AddPathParts(u, pathParts[:]...) + + q := uri.NewQueryEncoder() + { + // Encode "type" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "type", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Type.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetGraphResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetMemory invokes get_memory operation. +// +// Get a single memory unit by ID with all its metadata including entities and tags. +// +// GET /v1/default/banks/{bank_id}/memories/{memory_id} +func (c *Client) GetMemory(ctx context.Context, params GetMemoryParams) (GetMemoryRes, error) { + res, err := c.sendGetMemory(ctx, params) + return res, err +} + +func (c *Client) sendGetMemory(ctx context.Context, params GetMemoryParams) (res GetMemoryRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/memories/" + { + // Encode "memory_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "memory_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.MemoryID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetMemoryResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetMentalModel invokes get_mental_model operation. +// +// Get a specific mental model by ID. +// +// GET /v1/default/banks/{bank_id}/mental-models/{mental_model_id} +func (c *Client) GetMentalModel(ctx context.Context, params GetMentalModelParams) (GetMentalModelRes, error) { + res, err := c.sendGetMentalModel(ctx, params) + return res, err +} + +func (c *Client) sendGetMentalModel(ctx context.Context, params GetMentalModelParams) (res GetMentalModelRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/mental-models/" + { + // Encode "mental_model_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "mental_model_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.MentalModelID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetMentalModelResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetOperationStatus invokes get_operation_status operation. +// +// Get the status of a specific async operation. Returns 'pending', 'completed', or 'failed'. +// Completed operations are removed from storage, so 'completed' means the operation finished +// successfully. +// +// GET /v1/default/banks/{bank_id}/operations/{operation_id} +func (c *Client) GetOperationStatus(ctx context.Context, params GetOperationStatusParams) (GetOperationStatusRes, error) { + res, err := c.sendGetOperationStatus(ctx, params) + return res, err +} + +func (c *Client) sendGetOperationStatus(ctx context.Context, params GetOperationStatusParams) (res GetOperationStatusRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/operations/" + { + // Encode "operation_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "operation_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.OperationID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetOperationStatusResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetVersion invokes get_version operation. +// +// Returns API version information and enabled feature flags. Use this to check which capabilities +// are available in this deployment. +// +// GET /version +func (c *Client) GetVersion(ctx context.Context) (*VersionResponse, error) { + res, err := c.sendGetVersion(ctx) + return res, err +} + +func (c *Client) sendGetVersion(ctx context.Context) (res *VersionResponse, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/version" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeGetVersionResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// HealthEndpointHealthGet invokes health_endpoint_health_get operation. +// +// Checks the health of the API and database connection. +// +// GET /health +func (c *Client) HealthEndpointHealthGet(ctx context.Context) (jx.Raw, error) { + res, err := c.sendHealthEndpointHealthGet(ctx) + return res, err +} + +func (c *Client) sendHealthEndpointHealthGet(ctx context.Context) (res jx.Raw, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/health" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeHealthEndpointHealthGetResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListBanks invokes list_banks operation. +// +// Get a list of all agents with their profiles. +// +// GET /v1/default/banks +func (c *Client) ListBanks(ctx context.Context) (ListBanksRes, error) { + res, err := c.sendListBanks(ctx) + return res, err +} + +func (c *Client) sendListBanks(ctx context.Context) (res ListBanksRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/v1/default/banks" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeListBanksResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListDirectives invokes list_directives operation. +// +// List hard rules that are injected into prompts. +// +// GET /v1/default/banks/{bank_id}/directives +func (c *Client) ListDirectives(ctx context.Context, params ListDirectivesParams) (ListDirectivesRes, error) { + res, err := c.sendListDirectives(ctx, params) + return res, err +} + +func (c *Client) sendListDirectives(ctx context.Context, params ListDirectivesParams) (res ListDirectivesRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/directives" + uri.AddPathParts(u, pathParts[:]...) + + q := uri.NewQueryEncoder() + { + // Encode "tags" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "tags", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if params.Tags != nil { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.Tags { + if err := func() error { + return e.EncodeValue(conv.StringToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } + } + return nil + }) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "tags_match" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "tags_match", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.TagsMatch.Get(); ok { + return e.EncodeValue(conv.StringToString(string(val))) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "active_only" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "active_only", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.ActiveOnly.Get(); ok { + return e.EncodeValue(conv.BoolToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "offset" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "offset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Offset.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeListDirectivesResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListDocuments invokes list_documents operation. +// +// List documents with pagination and optional search. Documents are the source content from which +// memory units are extracted. +// +// GET /v1/default/banks/{bank_id}/documents +func (c *Client) ListDocuments(ctx context.Context, params ListDocumentsParams) (ListDocumentsRes, error) { + res, err := c.sendListDocuments(ctx, params) + return res, err +} + +func (c *Client) sendListDocuments(ctx context.Context, params ListDocumentsParams) (res ListDocumentsRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/documents" + uri.AddPathParts(u, pathParts[:]...) + + q := uri.NewQueryEncoder() + { + // Encode "q" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "q", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Q.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "offset" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "offset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Offset.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeListDocumentsResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListEntities invokes list_entities operation. +// +// List all entities (people, organizations, etc.) known by the bank, ordered by mention count. +// Supports pagination. +// +// GET /v1/default/banks/{bank_id}/entities +func (c *Client) ListEntities(ctx context.Context, params ListEntitiesParams) (ListEntitiesRes, error) { + res, err := c.sendListEntities(ctx, params) + return res, err +} + +func (c *Client) sendListEntities(ctx context.Context, params ListEntitiesParams) (res ListEntitiesRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/entities" + uri.AddPathParts(u, pathParts[:]...) + + q := uri.NewQueryEncoder() + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "offset" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "offset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Offset.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeListEntitiesResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListMemories invokes list_memories operation. +// +// List memory units with pagination and optional full-text search. Supports filtering by type. +// Results are sorted by most recent first (mentioned_at DESC, then created_at DESC). +// +// GET /v1/default/banks/{bank_id}/memories/list +func (c *Client) ListMemories(ctx context.Context, params ListMemoriesParams) (ListMemoriesRes, error) { + res, err := c.sendListMemories(ctx, params) + return res, err +} + +func (c *Client) sendListMemories(ctx context.Context, params ListMemoriesParams) (res ListMemoriesRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/memories/list" + uri.AddPathParts(u, pathParts[:]...) + + q := uri.NewQueryEncoder() + { + // Encode "type" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "type", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Type.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "q" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "q", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Q.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "offset" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "offset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Offset.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeListMemoriesResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListMentalModels invokes list_mental_models operation. +// +// List user-curated living documents that stay current. +// +// GET /v1/default/banks/{bank_id}/mental-models +func (c *Client) ListMentalModels(ctx context.Context, params ListMentalModelsParams) (ListMentalModelsRes, error) { + res, err := c.sendListMentalModels(ctx, params) + return res, err +} + +func (c *Client) sendListMentalModels(ctx context.Context, params ListMentalModelsParams) (res ListMentalModelsRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/mental-models" + uri.AddPathParts(u, pathParts[:]...) + + q := uri.NewQueryEncoder() + { + // Encode "tags" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "tags", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if params.Tags != nil { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.Tags { + if err := func() error { + return e.EncodeValue(conv.StringToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } + } + return nil + }) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "tags_match" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "tags_match", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.TagsMatch.Get(); ok { + return e.EncodeValue(conv.StringToString(string(val))) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "offset" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "offset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Offset.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeListMentalModelsResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListOperations invokes list_operations operation. +// +// Get a list of async operations for a specific agent, with optional filtering by status. Results +// are sorted by most recent first. +// +// GET /v1/default/banks/{bank_id}/operations +func (c *Client) ListOperations(ctx context.Context, params ListOperationsParams) (ListOperationsRes, error) { + res, err := c.sendListOperations(ctx, params) + return res, err +} + +func (c *Client) sendListOperations(ctx context.Context, params ListOperationsParams) (res ListOperationsRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/operations" + uri.AddPathParts(u, pathParts[:]...) + + q := uri.NewQueryEncoder() + { + // Encode "status" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "status", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Status.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "offset" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "offset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Offset.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeListOperationsResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListTags invokes list_tags operation. +// +// List all unique tags in a memory bank with usage counts. Supports wildcard search using '*' (e.g., +// 'user:*', '*-fred', 'tag*-2'). Case-insensitive. +// +// GET /v1/default/banks/{bank_id}/tags +func (c *Client) ListTags(ctx context.Context, params ListTagsParams) (ListTagsRes, error) { + res, err := c.sendListTags(ctx, params) + return res, err +} + +func (c *Client) sendListTags(ctx context.Context, params ListTagsParams) (res ListTagsRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/tags" + uri.AddPathParts(u, pathParts[:]...) + + q := uri.NewQueryEncoder() + { + // Encode "q" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "q", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Q.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "offset" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "offset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Offset.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeListTagsResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// MetricsEndpointMetricsGet invokes metrics_endpoint_metrics_get operation. +// +// Exports metrics in Prometheus format for scraping. +// +// GET /metrics +func (c *Client) MetricsEndpointMetricsGet(ctx context.Context) (jx.Raw, error) { + res, err := c.sendMetricsEndpointMetricsGet(ctx) + return res, err +} + +func (c *Client) sendMetricsEndpointMetricsGet(ctx context.Context) (res jx.Raw, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/metrics" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeMetricsEndpointMetricsGetResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// RecallMemories invokes recall_memories operation. +// +// Recall memory using semantic similarity and spreading activation. +// The type parameter is optional and must be one of: +// - `world`: General knowledge about people, places, events, and things that happen +// - `experience`: Memories about experience, conversations, actions taken, and tasks performed. +// +// POST /v1/default/banks/{bank_id}/memories/recall +func (c *Client) RecallMemories(ctx context.Context, request *RecallRequest, params RecallMemoriesParams) (RecallMemoriesRes, error) { + res, err := c.sendRecallMemories(ctx, request, params) + return res, err +} + +func (c *Client) sendRecallMemories(ctx context.Context, request *RecallRequest, params RecallMemoriesParams) (res RecallMemoriesRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/memories/recall" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeRecallMemoriesRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeRecallMemoriesResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// Reflect invokes reflect operation. +// +// Reflect and formulate an answer using bank identity, world facts, and opinions. +// This endpoint: +// 1. Retrieves experience (conversations and events) +// 2. Retrieves world facts relevant to the query +// 3. Retrieves existing opinions (bank's perspectives) +// 4. Uses LLM to formulate a contextual answer +// 5. Returns plain text answer and the facts used. +// +// POST /v1/default/banks/{bank_id}/reflect +func (c *Client) Reflect(ctx context.Context, request *ReflectRequest, params ReflectParams) (ReflectRes, error) { + res, err := c.sendReflect(ctx, request, params) + return res, err +} + +func (c *Client) sendReflect(ctx context.Context, request *ReflectRequest, params ReflectParams) (res ReflectRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/reflect" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeReflectRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeReflectResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// RefreshMentalModel invokes refresh_mental_model operation. +// +// Submit an async task to re-run the source query through reflect and update the content. +// +// POST /v1/default/banks/{bank_id}/mental-models/{mental_model_id}/refresh +func (c *Client) RefreshMentalModel(ctx context.Context, params RefreshMentalModelParams) (RefreshMentalModelRes, error) { + res, err := c.sendRefreshMentalModel(ctx, params) + return res, err +} + +func (c *Client) sendRefreshMentalModel(ctx context.Context, params RefreshMentalModelParams) (res RefreshMentalModelRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [5]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/mental-models/" + { + // Encode "mental_model_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "mental_model_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.MentalModelID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + pathParts[4] = "/refresh" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeRefreshMentalModelResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// RegenerateEntityObservations invokes regenerate_entity_observations operation. +// +// This endpoint is deprecated. Entity observations have been replaced by mental models. +// +// Deprecated: schema marks this operation as deprecated. +// +// POST /v1/default/banks/{bank_id}/entities/{entity_id}/regenerate +func (c *Client) RegenerateEntityObservations(ctx context.Context, params RegenerateEntityObservationsParams) (RegenerateEntityObservationsRes, error) { + res, err := c.sendRegenerateEntityObservations(ctx, params) + return res, err +} + +func (c *Client) sendRegenerateEntityObservations(ctx context.Context, params RegenerateEntityObservationsParams) (res RegenerateEntityObservationsRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [5]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/entities/" + { + // Encode "entity_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "entity_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.EntityID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + pathParts[4] = "/regenerate" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeRegenerateEntityObservationsResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ResetBankConfig invokes reset_bank_config operation. +// +// Reset bank configuration to defaults by removing all bank-specific overrides. The bank will then +// use global and tenant-level configuration only. +// +// DELETE /v1/default/banks/{bank_id}/config +func (c *Client) ResetBankConfig(ctx context.Context, params ResetBankConfigParams) (ResetBankConfigRes, error) { + res, err := c.sendResetBankConfig(ctx, params) + return res, err +} + +func (c *Client) sendResetBankConfig(ctx context.Context, params ResetBankConfigParams) (res ResetBankConfigRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/config" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "DELETE", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeResetBankConfigResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// RetainMemories invokes retain_memories operation. +// +// Retain memory items with automatic fact extraction. +// This is the main endpoint for storing memories. It supports both synchronous and asynchronous +// processing via the `async` parameter. +// **Features:** +// - Efficient batch processing +// - Automatic fact extraction from natural language +// - Entity recognition and linking +// - Document tracking with automatic upsert (when document_id is provided) +// - Temporal and semantic linking +// - Optional asynchronous processing +// **The system automatically:** +// 1. Extracts semantic facts from the content +// 2. Generates embeddings +// 3. Deduplicates similar facts +// 4. Creates temporal, semantic, and entity links +// 5. Tracks document metadata +// **When `async=true`:** Returns immediately after queuing. Use the operations endpoint to monitor +// progress. +// **When `async=false` (default):** Waits for processing to complete. +// **Note:** If a memory item has a `document_id` that already exists, the old document and its +// memory units will be deleted before creating new ones (upsert behavior). +// +// POST /v1/default/banks/{bank_id}/memories +func (c *Client) RetainMemories(ctx context.Context, request *RetainRequest, params RetainMemoriesParams) (RetainMemoriesRes, error) { + res, err := c.sendRetainMemories(ctx, request, params) + return res, err +} + +func (c *Client) sendRetainMemories(ctx context.Context, request *RetainRequest, params RetainMemoriesParams) (res RetainMemoriesRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/memories" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeRetainMemoriesRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeRetainMemoriesResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TriggerConsolidation invokes trigger_consolidation operation. +// +// Run memory consolidation to create/update observations from recent memories. +// +// POST /v1/default/banks/{bank_id}/consolidate +func (c *Client) TriggerConsolidation(ctx context.Context, params TriggerConsolidationParams) (TriggerConsolidationRes, error) { + res, err := c.sendTriggerConsolidation(ctx, params) + return res, err +} + +func (c *Client) sendTriggerConsolidation(ctx context.Context, params TriggerConsolidationParams) (res TriggerConsolidationRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/consolidate" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeTriggerConsolidationResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// UpdateBank invokes update_bank operation. +// +// Partially update an agent's profile. Only provided fields will be updated. +// +// PATCH /v1/default/banks/{bank_id} +func (c *Client) UpdateBank(ctx context.Context, request *CreateBankRequest, params UpdateBankParams) (UpdateBankRes, error) { + res, err := c.sendUpdateBank(ctx, request, params) + return res, err +} + +func (c *Client) sendUpdateBank(ctx context.Context, request *CreateBankRequest, params UpdateBankParams) (res UpdateBankRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [2]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "PATCH", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeUpdateBankRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeUpdateBankResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// UpdateBankConfig invokes update_bank_config operation. +// +// Update configuration overrides for a bank. Only hierarchical fields can be overridden (LLM +// settings, retention parameters, etc.). Keys can be provided in Python field format (llm_provider) +// or environment variable format (HINDSIGHT_API_LLM_PROVIDER). +// +// PATCH /v1/default/banks/{bank_id}/config +func (c *Client) UpdateBankConfig(ctx context.Context, request *BankConfigUpdate, params UpdateBankConfigParams) (UpdateBankConfigRes, error) { + res, err := c.sendUpdateBankConfig(ctx, request, params) + return res, err +} + +func (c *Client) sendUpdateBankConfig(ctx context.Context, request *BankConfigUpdate, params UpdateBankConfigParams) (res UpdateBankConfigRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/config" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "PATCH", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeUpdateBankConfigRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeUpdateBankConfigResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// UpdateBankDisposition invokes update_bank_disposition operation. +// +// Update bank's disposition traits (skepticism, literalism, empathy). +// +// PUT /v1/default/banks/{bank_id}/profile +func (c *Client) UpdateBankDisposition(ctx context.Context, request *UpdateDispositionRequest, params UpdateBankDispositionParams) (UpdateBankDispositionRes, error) { + res, err := c.sendUpdateBankDisposition(ctx, request, params) + return res, err +} + +func (c *Client) sendUpdateBankDisposition(ctx context.Context, request *UpdateDispositionRequest, params UpdateBankDispositionParams) (res UpdateBankDispositionRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/profile" + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "PUT", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeUpdateBankDispositionRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeUpdateBankDispositionResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// UpdateDirective invokes update_directive operation. +// +// Update a directive's properties. +// +// PATCH /v1/default/banks/{bank_id}/directives/{directive_id} +func (c *Client) UpdateDirective(ctx context.Context, request *UpdateDirectiveRequest, params UpdateDirectiveParams) (UpdateDirectiveRes, error) { + res, err := c.sendUpdateDirective(ctx, request, params) + return res, err +} + +func (c *Client) sendUpdateDirective(ctx context.Context, request *UpdateDirectiveRequest, params UpdateDirectiveParams) (res UpdateDirectiveRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/directives/" + { + // Encode "directive_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "directive_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.DirectiveID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "PATCH", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeUpdateDirectiveRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeUpdateDirectiveResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// UpdateMentalModel invokes update_mental_model operation. +// +// Update a mental model's name and/or source query. +// +// PATCH /v1/default/banks/{bank_id}/mental-models/{mental_model_id} +func (c *Client) UpdateMentalModel(ctx context.Context, request *UpdateMentalModelRequest, params UpdateMentalModelParams) (UpdateMentalModelRes, error) { + res, err := c.sendUpdateMentalModel(ctx, request, params) + return res, err +} + +func (c *Client) sendUpdateMentalModel(ctx context.Context, request *UpdateMentalModelRequest, params UpdateMentalModelParams) (res UpdateMentalModelRes, err error) { + + u := uri.Clone(c.requestURL(ctx)) + var pathParts [4]string + pathParts[0] = "/v1/default/banks/" + { + // Encode "bank_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "bank_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BankID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/mental-models/" + { + // Encode "mental_model_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "mental_model_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.MentalModelID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + uri.AddPathParts(u, pathParts[:]...) + + r, err := ht.NewRequest(ctx, "PATCH", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeUpdateMentalModelRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + result, err := decodeUpdateMentalModelResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} diff --git a/hindsight-clients/go/internal/ogenapi/oas_defaults_gen.go b/hindsight-clients/go/internal/ogenapi/oas_defaults_gen.go new file mode 100644 index 00000000..d60c9f18 --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_defaults_gen.go @@ -0,0 +1,179 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +// setDefaults set default value of fields. +func (s *AddBackgroundRequest) setDefaults() { + { + val := bool(true) + s.UpdateDisposition.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *BankStatsResponse) setDefaults() { + { + val := int(0) + s.PendingConsolidation.SetTo(val) + } + { + val := int(0) + s.TotalObservations.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *ChunkData) setDefaults() { + { + val := bool(false) + s.Truncated.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *ChunkIncludeOptions) setDefaults() { + { + val := int(8192) + s.MaxTokens.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *ConsolidationResponse) setDefaults() { + { + val := bool(false) + s.Deduplicated.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *CreateDirectiveRequest) setDefaults() { + { + val := bool(true) + s.IsActive.SetTo(val) + } + { + val := int(0) + s.Priority.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *CreateMentalModelRequest) setDefaults() { + { + val := int(2048) + s.MaxTokens.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *DirectiveResponse) setDefaults() { + { + val := bool(true) + s.IsActive.SetTo(val) + } + { + val := int(0) + s.Priority.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *EntityIncludeOptions) setDefaults() { + { + val := int(500) + s.MaxTokens.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *MentalModelResponse) setDefaults() { + { + val := int(2048) + s.MaxTokens.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *MentalModelTrigger) setDefaults() { + { + val := bool(false) + s.RefreshAfterConsolidation.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *RecallRequest) setDefaults() { + { + val := Budget("low") + s.Budget.SetTo(val) + } + { + val := int(4096) + s.MaxTokens.SetTo(val) + } + { + val := RecallRequestTagsMatch("any") + s.TagsMatch.SetTo(val) + } + { + val := bool(false) + s.Trace.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *ReflectRequest) setDefaults() { + { + val := Budget("low") + s.Budget.SetTo(val) + } + { + val := int(4096) + s.MaxTokens.SetTo(val) + } + { + val := ReflectRequestTagsMatch("any") + s.TagsMatch.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *ReflectToolCall) setDefaults() { + { + val := int(0) + s.Iteration.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *RetainRequest) setDefaults() { + { + val := bool(false) + s.Async.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *TokenUsage) setDefaults() { + { + val := int(0) + s.InputTokens.SetTo(val) + } + { + val := int(0) + s.OutputTokens.SetTo(val) + } + { + val := int(0) + s.TotalTokens.SetTo(val) + } +} + +// setDefaults set default value of fields. +func (s *ToolCallsIncludeOptions) setDefaults() { + { + val := bool(true) + s.Output.SetTo(val) + } +} diff --git a/hindsight-clients/go/internal/ogenapi/oas_interfaces_gen.go b/hindsight-clients/go/internal/ogenapi/oas_interfaces_gen.go new file mode 100644 index 00000000..38f74677 --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_interfaces_gen.go @@ -0,0 +1,170 @@ +// Code generated by ogen, DO NOT EDIT. +package ogenapi + +type AddBankBackgroundRes interface { + addBankBackgroundRes() +} + +type CancelOperationRes interface { + cancelOperationRes() +} + +type ClearBankMemoriesRes interface { + clearBankMemoriesRes() +} + +type ClearObservationsRes interface { + clearObservationsRes() +} + +type CreateDirectiveRes interface { + createDirectiveRes() +} + +type CreateMentalModelRes interface { + createMentalModelRes() +} + +type CreateOrUpdateBankRes interface { + createOrUpdateBankRes() +} + +type DeleteBankRes interface { + deleteBankRes() +} + +type DeleteDirectiveRes interface { + deleteDirectiveRes() +} + +type DeleteDocumentRes interface { + deleteDocumentRes() +} + +type DeleteMentalModelRes interface { + deleteMentalModelRes() +} + +type GetAgentStatsRes interface { + getAgentStatsRes() +} + +type GetBankConfigRes interface { + getBankConfigRes() +} + +type GetBankProfileRes interface { + getBankProfileRes() +} + +type GetChunkRes interface { + getChunkRes() +} + +type GetDirectiveRes interface { + getDirectiveRes() +} + +type GetDocumentRes interface { + getDocumentRes() +} + +type GetEntityRes interface { + getEntityRes() +} + +type GetGraphRes interface { + getGraphRes() +} + +type GetMemoryRes interface { + getMemoryRes() +} + +type GetMentalModelRes interface { + getMentalModelRes() +} + +type GetOperationStatusRes interface { + getOperationStatusRes() +} + +type ListBanksRes interface { + listBanksRes() +} + +type ListDirectivesRes interface { + listDirectivesRes() +} + +type ListDocumentsRes interface { + listDocumentsRes() +} + +type ListEntitiesRes interface { + listEntitiesRes() +} + +type ListMemoriesRes interface { + listMemoriesRes() +} + +type ListMentalModelsRes interface { + listMentalModelsRes() +} + +type ListOperationsRes interface { + listOperationsRes() +} + +type ListTagsRes interface { + listTagsRes() +} + +type RecallMemoriesRes interface { + recallMemoriesRes() +} + +type ReflectRes interface { + reflectRes() +} + +type RefreshMentalModelRes interface { + refreshMentalModelRes() +} + +type RegenerateEntityObservationsRes interface { + regenerateEntityObservationsRes() +} + +type ResetBankConfigRes interface { + resetBankConfigRes() +} + +type RetainMemoriesRes interface { + retainMemoriesRes() +} + +type TriggerConsolidationRes interface { + triggerConsolidationRes() +} + +type UpdateBankConfigRes interface { + updateBankConfigRes() +} + +type UpdateBankDispositionRes interface { + updateBankDispositionRes() +} + +type UpdateBankRes interface { + updateBankRes() +} + +type UpdateDirectiveRes interface { + updateDirectiveRes() +} + +type UpdateMentalModelRes interface { + updateMentalModelRes() +} diff --git a/hindsight-clients/go/internal/ogenapi/oas_json_gen.go b/hindsight-clients/go/internal/ogenapi/oas_json_gen.go new file mode 100644 index 00000000..a2f4e2b5 --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_json_gen.go @@ -0,0 +1,12849 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +import ( + "math/bits" + "strconv" + "time" + + "github.com/go-faster/errors" + "github.com/go-faster/jx" + "github.com/ogen-go/ogen/json" + "github.com/ogen-go/ogen/validate" +) + +// Encode implements json.Marshaler. +func (s *AddBackgroundRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *AddBackgroundRequest) encodeFields(e *jx.Encoder) { + { + e.FieldStart("content") + e.Str(s.Content) + } + { + if s.UpdateDisposition.Set { + e.FieldStart("update_disposition") + s.UpdateDisposition.Encode(e) + } + } +} + +var jsonFieldsNameOfAddBackgroundRequest = [2]string{ + 0: "content", + 1: "update_disposition", +} + +// Decode decodes AddBackgroundRequest from json. +func (s *AddBackgroundRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode AddBackgroundRequest to nil") + } + var requiredBitSet [1]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "content": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Content = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content\"") + } + case "update_disposition": + if err := func() error { + s.UpdateDisposition.Reset() + if err := s.UpdateDisposition.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"update_disposition\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode AddBackgroundRequest") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfAddBackgroundRequest) { + name = jsonFieldsNameOfAddBackgroundRequest[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *AddBackgroundRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *AddBackgroundRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *AsyncOperationSubmitResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *AsyncOperationSubmitResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("operation_id") + e.Str(s.OperationID) + } + { + e.FieldStart("status") + e.Str(s.Status) + } +} + +var jsonFieldsNameOfAsyncOperationSubmitResponse = [2]string{ + 0: "operation_id", + 1: "status", +} + +// Decode decodes AsyncOperationSubmitResponse from json. +func (s *AsyncOperationSubmitResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode AsyncOperationSubmitResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "operation_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.OperationID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operation_id\"") + } + case "status": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Status = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode AsyncOperationSubmitResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfAsyncOperationSubmitResponse) { + name = jsonFieldsNameOfAsyncOperationSubmitResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *AsyncOperationSubmitResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *AsyncOperationSubmitResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BackgroundResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BackgroundResponse) encodeFields(e *jx.Encoder) { + { + if s.Background.Set { + e.FieldStart("background") + s.Background.Encode(e) + } + } + { + if s.Disposition.Set { + e.FieldStart("disposition") + s.Disposition.Encode(e) + } + } + { + e.FieldStart("mission") + e.Str(s.Mission) + } +} + +var jsonFieldsNameOfBackgroundResponse = [3]string{ + 0: "background", + 1: "disposition", + 2: "mission", +} + +// Decode decodes BackgroundResponse from json. +func (s *BackgroundResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BackgroundResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "background": + if err := func() error { + s.Background.Reset() + if err := s.Background.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"background\"") + } + case "disposition": + if err := func() error { + s.Disposition.Reset() + if err := s.Disposition.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"disposition\"") + } + case "mission": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Mission = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mission\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BackgroundResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000100, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBackgroundResponse) { + name = jsonFieldsNameOfBackgroundResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BackgroundResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BackgroundResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BankConfigResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BankConfigResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + e.FieldStart("config") + s.Config.Encode(e) + } + { + e.FieldStart("overrides") + s.Overrides.Encode(e) + } +} + +var jsonFieldsNameOfBankConfigResponse = [3]string{ + 0: "bank_id", + 1: "config", + 2: "overrides", +} + +// Decode decodes BankConfigResponse from json. +func (s *BankConfigResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankConfigResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bank_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "config": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Config.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"config\"") + } + case "overrides": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.Overrides.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"overrides\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BankConfigResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBankConfigResponse) { + name = jsonFieldsNameOfBankConfigResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BankConfigResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankConfigResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s BankConfigResponseConfig) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s BankConfigResponseConfig) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes BankConfigResponseConfig from json. +func (s *BankConfigResponseConfig) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankConfigResponseConfig to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode BankConfigResponseConfig") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s BankConfigResponseConfig) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankConfigResponseConfig) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s BankConfigResponseOverrides) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s BankConfigResponseOverrides) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes BankConfigResponseOverrides from json. +func (s *BankConfigResponseOverrides) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankConfigResponseOverrides to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode BankConfigResponseOverrides") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s BankConfigResponseOverrides) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankConfigResponseOverrides) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BankConfigUpdate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BankConfigUpdate) encodeFields(e *jx.Encoder) { + { + e.FieldStart("updates") + s.Updates.Encode(e) + } +} + +var jsonFieldsNameOfBankConfigUpdate = [1]string{ + 0: "updates", +} + +// Decode decodes BankConfigUpdate from json. +func (s *BankConfigUpdate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankConfigUpdate to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "updates": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Updates.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updates\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BankConfigUpdate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBankConfigUpdate) { + name = jsonFieldsNameOfBankConfigUpdate[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BankConfigUpdate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankConfigUpdate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s BankConfigUpdateUpdates) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s BankConfigUpdateUpdates) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes BankConfigUpdateUpdates from json. +func (s *BankConfigUpdateUpdates) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankConfigUpdateUpdates to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode BankConfigUpdateUpdates") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s BankConfigUpdateUpdates) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankConfigUpdateUpdates) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BankListItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BankListItem) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e) + } + } + { + e.FieldStart("disposition") + s.Disposition.Encode(e) + } + { + if s.Mission.Set { + e.FieldStart("mission") + s.Mission.Encode(e) + } + } + { + if s.Name.Set { + e.FieldStart("name") + s.Name.Encode(e) + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e) + } + } +} + +var jsonFieldsNameOfBankListItem = [6]string{ + 0: "bank_id", + 1: "created_at", + 2: "disposition", + 3: "mission", + 4: "name", + 5: "updated_at", +} + +// Decode decodes BankListItem from json. +func (s *BankListItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankListItem to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bank_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "disposition": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.Disposition.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"disposition\"") + } + case "mission": + if err := func() error { + s.Mission.Reset() + if err := s.Mission.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mission\"") + } + case "name": + if err := func() error { + s.Name.Reset() + if err := s.Name.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BankListItem") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000101, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBankListItem) { + name = jsonFieldsNameOfBankListItem[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BankListItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankListItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BankListResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BankListResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("banks") + e.ArrStart() + for _, elem := range s.Banks { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfBankListResponse = [1]string{ + 0: "banks", +} + +// Decode decodes BankListResponse from json. +func (s *BankListResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankListResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "banks": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Banks = make([]BankListItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem BankListItem + if err := elem.Decode(d); err != nil { + return err + } + s.Banks = append(s.Banks, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"banks\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BankListResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBankListResponse) { + name = jsonFieldsNameOfBankListResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BankListResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankListResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BankProfileResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BankProfileResponse) encodeFields(e *jx.Encoder) { + { + if s.Background.Set { + e.FieldStart("background") + s.Background.Encode(e) + } + } + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + e.FieldStart("disposition") + s.Disposition.Encode(e) + } + { + e.FieldStart("mission") + e.Str(s.Mission) + } + { + e.FieldStart("name") + e.Str(s.Name) + } +} + +var jsonFieldsNameOfBankProfileResponse = [5]string{ + 0: "background", + 1: "bank_id", + 2: "disposition", + 3: "mission", + 4: "name", +} + +// Decode decodes BankProfileResponse from json. +func (s *BankProfileResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankProfileResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "background": + if err := func() error { + s.Background.Reset() + if err := s.Background.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"background\"") + } + case "bank_id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "disposition": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.Disposition.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"disposition\"") + } + case "mission": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.Mission = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mission\"") + } + case "name": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BankProfileResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011110, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBankProfileResponse) { + name = jsonFieldsNameOfBankProfileResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BankProfileResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankProfileResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BankStatsResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BankStatsResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + e.FieldStart("failed_operations") + e.Int(s.FailedOperations) + } + { + if s.LastConsolidatedAt.Set { + e.FieldStart("last_consolidated_at") + s.LastConsolidatedAt.Encode(e) + } + } + { + e.FieldStart("links_breakdown") + s.LinksBreakdown.Encode(e) + } + { + e.FieldStart("links_by_fact_type") + s.LinksByFactType.Encode(e) + } + { + e.FieldStart("links_by_link_type") + s.LinksByLinkType.Encode(e) + } + { + e.FieldStart("nodes_by_fact_type") + s.NodesByFactType.Encode(e) + } + { + if s.PendingConsolidation.Set { + e.FieldStart("pending_consolidation") + s.PendingConsolidation.Encode(e) + } + } + { + e.FieldStart("pending_operations") + e.Int(s.PendingOperations) + } + { + e.FieldStart("total_documents") + e.Int(s.TotalDocuments) + } + { + e.FieldStart("total_links") + e.Int(s.TotalLinks) + } + { + e.FieldStart("total_nodes") + e.Int(s.TotalNodes) + } + { + if s.TotalObservations.Set { + e.FieldStart("total_observations") + s.TotalObservations.Encode(e) + } + } +} + +var jsonFieldsNameOfBankStatsResponse = [13]string{ + 0: "bank_id", + 1: "failed_operations", + 2: "last_consolidated_at", + 3: "links_breakdown", + 4: "links_by_fact_type", + 5: "links_by_link_type", + 6: "nodes_by_fact_type", + 7: "pending_consolidation", + 8: "pending_operations", + 9: "total_documents", + 10: "total_links", + 11: "total_nodes", + 12: "total_observations", +} + +// Decode decodes BankStatsResponse from json. +func (s *BankStatsResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankStatsResponse to nil") + } + var requiredBitSet [2]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bank_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "failed_operations": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.FailedOperations = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"failed_operations\"") + } + case "last_consolidated_at": + if err := func() error { + s.LastConsolidatedAt.Reset() + if err := s.LastConsolidatedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last_consolidated_at\"") + } + case "links_breakdown": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + if err := s.LinksBreakdown.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"links_breakdown\"") + } + case "links_by_fact_type": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + if err := s.LinksByFactType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"links_by_fact_type\"") + } + case "links_by_link_type": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + if err := s.LinksByLinkType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"links_by_link_type\"") + } + case "nodes_by_fact_type": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + if err := s.NodesByFactType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"nodes_by_fact_type\"") + } + case "pending_consolidation": + if err := func() error { + s.PendingConsolidation.Reset() + if err := s.PendingConsolidation.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"pending_consolidation\"") + } + case "pending_operations": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.PendingOperations = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"pending_operations\"") + } + case "total_documents": + requiredBitSet[1] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.TotalDocuments = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total_documents\"") + } + case "total_links": + requiredBitSet[1] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.TotalLinks = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total_links\"") + } + case "total_nodes": + requiredBitSet[1] |= 1 << 3 + if err := func() error { + v, err := d.Int() + s.TotalNodes = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total_nodes\"") + } + case "total_observations": + if err := func() error { + s.TotalObservations.Reset() + if err := s.TotalObservations.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total_observations\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BankStatsResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b01111011, + 0b00001111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfBankStatsResponse) { + name = jsonFieldsNameOfBankStatsResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *BankStatsResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankStatsResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s BankStatsResponseLinksBreakdown) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s BankStatsResponseLinksBreakdown) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + elem.Encode(e) + } +} + +// Decode decodes BankStatsResponseLinksBreakdown from json. +func (s *BankStatsResponseLinksBreakdown) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankStatsResponseLinksBreakdown to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem BankStatsResponseLinksBreakdownItem + if err := func() error { + if err := elem.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode BankStatsResponseLinksBreakdown") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s BankStatsResponseLinksBreakdown) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankStatsResponseLinksBreakdown) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s BankStatsResponseLinksBreakdownItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s BankStatsResponseLinksBreakdownItem) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Int(elem) + } +} + +// Decode decodes BankStatsResponseLinksBreakdownItem from json. +func (s *BankStatsResponseLinksBreakdownItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankStatsResponseLinksBreakdownItem to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem int + if err := func() error { + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode BankStatsResponseLinksBreakdownItem") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s BankStatsResponseLinksBreakdownItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankStatsResponseLinksBreakdownItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s BankStatsResponseLinksByFactType) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s BankStatsResponseLinksByFactType) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Int(elem) + } +} + +// Decode decodes BankStatsResponseLinksByFactType from json. +func (s *BankStatsResponseLinksByFactType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankStatsResponseLinksByFactType to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem int + if err := func() error { + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode BankStatsResponseLinksByFactType") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s BankStatsResponseLinksByFactType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankStatsResponseLinksByFactType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s BankStatsResponseLinksByLinkType) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s BankStatsResponseLinksByLinkType) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Int(elem) + } +} + +// Decode decodes BankStatsResponseLinksByLinkType from json. +func (s *BankStatsResponseLinksByLinkType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankStatsResponseLinksByLinkType to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem int + if err := func() error { + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode BankStatsResponseLinksByLinkType") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s BankStatsResponseLinksByLinkType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankStatsResponseLinksByLinkType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s BankStatsResponseNodesByFactType) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s BankStatsResponseNodesByFactType) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Int(elem) + } +} + +// Decode decodes BankStatsResponseNodesByFactType from json. +func (s *BankStatsResponseNodesByFactType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BankStatsResponseNodesByFactType to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem int + if err := func() error { + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode BankStatsResponseNodesByFactType") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s BankStatsResponseNodesByFactType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BankStatsResponseNodesByFactType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes Budget as json. +func (s Budget) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes Budget from json. +func (s *Budget) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Budget to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch Budget(v) { + case BudgetLow: + *s = BudgetLow + case BudgetMid: + *s = BudgetMid + case BudgetHigh: + *s = BudgetHigh + default: + *s = Budget(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s Budget) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Budget) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CancelOperationResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CancelOperationResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("message") + e.Str(s.Message) + } + { + e.FieldStart("operation_id") + e.Str(s.OperationID) + } + { + e.FieldStart("success") + e.Bool(s.Success) + } +} + +var jsonFieldsNameOfCancelOperationResponse = [3]string{ + 0: "message", + 1: "operation_id", + 2: "success", +} + +// Decode decodes CancelOperationResponse from json. +func (s *CancelOperationResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CancelOperationResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "message": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Message = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"message\"") + } + case "operation_id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.OperationID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operation_id\"") + } + case "success": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Bool() + s.Success = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"success\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CancelOperationResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfCancelOperationResponse) { + name = jsonFieldsNameOfCancelOperationResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *CancelOperationResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CancelOperationResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ChunkData) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ChunkData) encodeFields(e *jx.Encoder) { + { + e.FieldStart("chunk_index") + e.Int(s.ChunkIndex) + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + e.FieldStart("text") + e.Str(s.Text) + } + { + if s.Truncated.Set { + e.FieldStart("truncated") + s.Truncated.Encode(e) + } + } +} + +var jsonFieldsNameOfChunkData = [4]string{ + 0: "chunk_index", + 1: "id", + 2: "text", + 3: "truncated", +} + +// Decode decodes ChunkData from json. +func (s *ChunkData) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ChunkData to nil") + } + var requiredBitSet [1]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "chunk_index": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ChunkIndex = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"chunk_index\"") + } + case "id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "text": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Text = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"text\"") + } + case "truncated": + if err := func() error { + s.Truncated.Reset() + if err := s.Truncated.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"truncated\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ChunkData") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfChunkData) { + name = jsonFieldsNameOfChunkData[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ChunkData) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ChunkData) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ChunkIncludeOptions) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ChunkIncludeOptions) encodeFields(e *jx.Encoder) { + { + if s.MaxTokens.Set { + e.FieldStart("max_tokens") + s.MaxTokens.Encode(e) + } + } +} + +var jsonFieldsNameOfChunkIncludeOptions = [1]string{ + 0: "max_tokens", +} + +// Decode decodes ChunkIncludeOptions from json. +func (s *ChunkIncludeOptions) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ChunkIncludeOptions to nil") + } + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "max_tokens": + if err := func() error { + s.MaxTokens.Reset() + if err := s.MaxTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_tokens\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ChunkIncludeOptions") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ChunkIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ChunkIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ChunkResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ChunkResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + e.FieldStart("chunk_id") + e.Str(s.ChunkID) + } + { + e.FieldStart("chunk_index") + e.Int(s.ChunkIndex) + } + { + e.FieldStart("chunk_text") + e.Str(s.ChunkText) + } + { + e.FieldStart("created_at") + e.Str(s.CreatedAt) + } + { + e.FieldStart("document_id") + e.Str(s.DocumentID) + } +} + +var jsonFieldsNameOfChunkResponse = [6]string{ + 0: "bank_id", + 1: "chunk_id", + 2: "chunk_index", + 3: "chunk_text", + 4: "created_at", + 5: "document_id", +} + +// Decode decodes ChunkResponse from json. +func (s *ChunkResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ChunkResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bank_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "chunk_id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.ChunkID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"chunk_id\"") + } + case "chunk_index": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.ChunkIndex = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"chunk_index\"") + } + case "chunk_text": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.ChunkText = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"chunk_text\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.CreatedAt = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "document_id": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Str() + s.DocumentID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"document_id\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ChunkResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00111111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfChunkResponse) { + name = jsonFieldsNameOfChunkResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ChunkResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ChunkResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ConsolidationResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ConsolidationResponse) encodeFields(e *jx.Encoder) { + { + if s.Deduplicated.Set { + e.FieldStart("deduplicated") + s.Deduplicated.Encode(e) + } + } + { + e.FieldStart("operation_id") + e.Str(s.OperationID) + } +} + +var jsonFieldsNameOfConsolidationResponse = [2]string{ + 0: "deduplicated", + 1: "operation_id", +} + +// Decode decodes ConsolidationResponse from json. +func (s *ConsolidationResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ConsolidationResponse to nil") + } + var requiredBitSet [1]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "deduplicated": + if err := func() error { + s.Deduplicated.Reset() + if err := s.Deduplicated.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"deduplicated\"") + } + case "operation_id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.OperationID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operation_id\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ConsolidationResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000010, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfConsolidationResponse) { + name = jsonFieldsNameOfConsolidationResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ConsolidationResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ConsolidationResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CreateBankRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreateBankRequest) encodeFields(e *jx.Encoder) { + { + if s.Background.Set { + e.FieldStart("background") + s.Background.Encode(e) + } + } + { + if s.Disposition.Set { + e.FieldStart("disposition") + s.Disposition.Encode(e) + } + } + { + if s.Mission.Set { + e.FieldStart("mission") + s.Mission.Encode(e) + } + } + { + if s.Name.Set { + e.FieldStart("name") + s.Name.Encode(e) + } + } +} + +var jsonFieldsNameOfCreateBankRequest = [4]string{ + 0: "background", + 1: "disposition", + 2: "mission", + 3: "name", +} + +// Decode decodes CreateBankRequest from json. +func (s *CreateBankRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreateBankRequest to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "background": + if err := func() error { + s.Background.Reset() + if err := s.Background.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"background\"") + } + case "disposition": + if err := func() error { + s.Disposition.Reset() + if err := s.Disposition.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"disposition\"") + } + case "mission": + if err := func() error { + s.Mission.Reset() + if err := s.Mission.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mission\"") + } + case "name": + if err := func() error { + s.Name.Reset() + if err := s.Name.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreateBankRequest") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *CreateBankRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreateBankRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CreateDirectiveRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreateDirectiveRequest) encodeFields(e *jx.Encoder) { + { + e.FieldStart("content") + e.Str(s.Content) + } + { + if s.IsActive.Set { + e.FieldStart("is_active") + s.IsActive.Encode(e) + } + } + { + e.FieldStart("name") + e.Str(s.Name) + } + { + if s.Priority.Set { + e.FieldStart("priority") + s.Priority.Encode(e) + } + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfCreateDirectiveRequest = [5]string{ + 0: "content", + 1: "is_active", + 2: "name", + 3: "priority", + 4: "tags", +} + +// Decode decodes CreateDirectiveRequest from json. +func (s *CreateDirectiveRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreateDirectiveRequest to nil") + } + var requiredBitSet [1]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "content": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Content = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content\"") + } + case "is_active": + if err := func() error { + s.IsActive.Reset() + if err := s.IsActive.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"is_active\"") + } + case "name": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "priority": + if err := func() error { + s.Priority.Reset() + if err := s.Priority.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"priority\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreateDirectiveRequest") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000101, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfCreateDirectiveRequest) { + name = jsonFieldsNameOfCreateDirectiveRequest[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *CreateDirectiveRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreateDirectiveRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CreateMentalModelRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreateMentalModelRequest) encodeFields(e *jx.Encoder) { + { + if s.ID.Set { + e.FieldStart("id") + s.ID.Encode(e) + } + } + { + if s.MaxTokens.Set { + e.FieldStart("max_tokens") + s.MaxTokens.Encode(e) + } + } + { + e.FieldStart("name") + e.Str(s.Name) + } + { + e.FieldStart("source_query") + e.Str(s.SourceQuery) + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + if s.Trigger.Set { + e.FieldStart("trigger") + s.Trigger.Encode(e) + } + } +} + +var jsonFieldsNameOfCreateMentalModelRequest = [6]string{ + 0: "id", + 1: "max_tokens", + 2: "name", + 3: "source_query", + 4: "tags", + 5: "trigger", +} + +// Decode decodes CreateMentalModelRequest from json. +func (s *CreateMentalModelRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreateMentalModelRequest to nil") + } + var requiredBitSet [1]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + if err := func() error { + s.ID.Reset() + if err := s.ID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "max_tokens": + if err := func() error { + s.MaxTokens.Reset() + if err := s.MaxTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_tokens\"") + } + case "name": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "source_query": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.SourceQuery = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"source_query\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + case "trigger": + if err := func() error { + s.Trigger.Reset() + if err := s.Trigger.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"trigger\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreateMentalModelRequest") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00001100, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfCreateMentalModelRequest) { + name = jsonFieldsNameOfCreateMentalModelRequest[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *CreateMentalModelRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreateMentalModelRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CreateMentalModelResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreateMentalModelResponse) encodeFields(e *jx.Encoder) { + { + if s.MentalModelID.Set { + e.FieldStart("mental_model_id") + s.MentalModelID.Encode(e) + } + } + { + e.FieldStart("operation_id") + e.Str(s.OperationID) + } +} + +var jsonFieldsNameOfCreateMentalModelResponse = [2]string{ + 0: "mental_model_id", + 1: "operation_id", +} + +// Decode decodes CreateMentalModelResponse from json. +func (s *CreateMentalModelResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreateMentalModelResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "mental_model_id": + if err := func() error { + s.MentalModelID.Reset() + if err := s.MentalModelID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mental_model_id\"") + } + case "operation_id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.OperationID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operation_id\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreateMentalModelResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000010, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfCreateMentalModelResponse) { + name = jsonFieldsNameOfCreateMentalModelResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *CreateMentalModelResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreateMentalModelResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes DeleteDirectiveOKApplicationJSON as json. +func (s DeleteDirectiveOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := jx.Raw(s) + + if len(unwrapped) != 0 { + e.Raw(unwrapped) + } +} + +// Decode decodes DeleteDirectiveOKApplicationJSON from json. +func (s *DeleteDirectiveOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DeleteDirectiveOKApplicationJSON to nil") + } + var unwrapped jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + unwrapped = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = DeleteDirectiveOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s DeleteDirectiveOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DeleteDirectiveOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DeleteDocumentResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DeleteDocumentResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("document_id") + e.Str(s.DocumentID) + } + { + e.FieldStart("memory_units_deleted") + e.Int(s.MemoryUnitsDeleted) + } + { + e.FieldStart("message") + e.Str(s.Message) + } + { + e.FieldStart("success") + e.Bool(s.Success) + } +} + +var jsonFieldsNameOfDeleteDocumentResponse = [4]string{ + 0: "document_id", + 1: "memory_units_deleted", + 2: "message", + 3: "success", +} + +// Decode decodes DeleteDocumentResponse from json. +func (s *DeleteDocumentResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DeleteDocumentResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "document_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.DocumentID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"document_id\"") + } + case "memory_units_deleted": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.MemoryUnitsDeleted = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"memory_units_deleted\"") + } + case "message": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Message = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"message\"") + } + case "success": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Bool() + s.Success = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"success\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DeleteDocumentResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00001111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDeleteDocumentResponse) { + name = jsonFieldsNameOfDeleteDocumentResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DeleteDocumentResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DeleteDocumentResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes DeleteMentalModelOKApplicationJSON as json. +func (s DeleteMentalModelOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := jx.Raw(s) + + if len(unwrapped) != 0 { + e.Raw(unwrapped) + } +} + +// Decode decodes DeleteMentalModelOKApplicationJSON from json. +func (s *DeleteMentalModelOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DeleteMentalModelOKApplicationJSON to nil") + } + var unwrapped jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + unwrapped = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = DeleteMentalModelOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s DeleteMentalModelOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DeleteMentalModelOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DeleteResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DeleteResponse) encodeFields(e *jx.Encoder) { + { + if s.DeletedCount.Set { + e.FieldStart("deleted_count") + s.DeletedCount.Encode(e) + } + } + { + if s.Message.Set { + e.FieldStart("message") + s.Message.Encode(e) + } + } + { + e.FieldStart("success") + e.Bool(s.Success) + } +} + +var jsonFieldsNameOfDeleteResponse = [3]string{ + 0: "deleted_count", + 1: "message", + 2: "success", +} + +// Decode decodes DeleteResponse from json. +func (s *DeleteResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DeleteResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "deleted_count": + if err := func() error { + s.DeletedCount.Reset() + if err := s.DeletedCount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"deleted_count\"") + } + case "message": + if err := func() error { + s.Message.Reset() + if err := s.Message.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"message\"") + } + case "success": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Bool() + s.Success = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"success\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DeleteResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000100, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDeleteResponse) { + name = jsonFieldsNameOfDeleteResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DeleteResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DeleteResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DirectiveListResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DirectiveListResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("items") + e.ArrStart() + for _, elem := range s.Items { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfDirectiveListResponse = [1]string{ + 0: "items", +} + +// Decode decodes DirectiveListResponse from json. +func (s *DirectiveListResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DirectiveListResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "items": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Items = make([]DirectiveResponse, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem DirectiveResponse + if err := elem.Decode(d); err != nil { + return err + } + s.Items = append(s.Items, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"items\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DirectiveListResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDirectiveListResponse) { + name = jsonFieldsNameOfDirectiveListResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DirectiveListResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DirectiveListResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DirectiveResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DirectiveResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + e.FieldStart("content") + e.Str(s.Content) + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e) + } + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + if s.IsActive.Set { + e.FieldStart("is_active") + s.IsActive.Encode(e) + } + } + { + e.FieldStart("name") + e.Str(s.Name) + } + { + if s.Priority.Set { + e.FieldStart("priority") + s.Priority.Encode(e) + } + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e) + } + } +} + +var jsonFieldsNameOfDirectiveResponse = [9]string{ + 0: "bank_id", + 1: "content", + 2: "created_at", + 3: "id", + 4: "is_active", + 5: "name", + 6: "priority", + 7: "tags", + 8: "updated_at", +} + +// Decode decodes DirectiveResponse from json. +func (s *DirectiveResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DirectiveResponse to nil") + } + var requiredBitSet [2]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bank_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "content": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Content = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "id": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "is_active": + if err := func() error { + s.IsActive.Reset() + if err := s.IsActive.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"is_active\"") + } + case "name": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "priority": + if err := func() error { + s.Priority.Reset() + if err := s.Priority.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"priority\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DirectiveResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00101011, + 0b00000000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDirectiveResponse) { + name = jsonFieldsNameOfDirectiveResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DirectiveResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DirectiveResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DispositionTraits) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DispositionTraits) encodeFields(e *jx.Encoder) { + { + e.FieldStart("empathy") + e.Int(s.Empathy) + } + { + e.FieldStart("literalism") + e.Int(s.Literalism) + } + { + e.FieldStart("skepticism") + e.Int(s.Skepticism) + } +} + +var jsonFieldsNameOfDispositionTraits = [3]string{ + 0: "empathy", + 1: "literalism", + 2: "skepticism", +} + +// Decode decodes DispositionTraits from json. +func (s *DispositionTraits) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DispositionTraits to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "empathy": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.Empathy = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"empathy\"") + } + case "literalism": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.Literalism = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"literalism\"") + } + case "skepticism": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.Skepticism = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"skepticism\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DispositionTraits") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDispositionTraits) { + name = jsonFieldsNameOfDispositionTraits[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DispositionTraits) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DispositionTraits) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DocumentResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DocumentResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + e.FieldStart("content_hash") + e.Str(s.ContentHash) + } + { + e.FieldStart("created_at") + e.Str(s.CreatedAt) + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + e.FieldStart("memory_unit_count") + e.Int(s.MemoryUnitCount) + } + { + e.FieldStart("original_text") + e.Str(s.OriginalText) + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + e.FieldStart("updated_at") + e.Str(s.UpdatedAt) + } +} + +var jsonFieldsNameOfDocumentResponse = [8]string{ + 0: "bank_id", + 1: "content_hash", + 2: "created_at", + 3: "id", + 4: "memory_unit_count", + 5: "original_text", + 6: "tags", + 7: "updated_at", +} + +// Decode decodes DocumentResponse from json. +func (s *DocumentResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DocumentResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bank_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "content_hash": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.ContentHash = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content_hash\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.CreatedAt = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "id": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "memory_unit_count": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int() + s.MemoryUnitCount = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"memory_unit_count\"") + } + case "original_text": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Str() + s.OriginalText = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"original_text\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + case "updated_at": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + v, err := d.Str() + s.UpdatedAt = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DocumentResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b10111111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfDocumentResponse) { + name = jsonFieldsNameOfDocumentResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DocumentResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DocumentResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *EntityDetailResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *EntityDetailResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("canonical_name") + e.Str(s.CanonicalName) + } + { + if s.FirstSeen.Set { + e.FieldStart("first_seen") + s.FirstSeen.Encode(e) + } + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + if s.LastSeen.Set { + e.FieldStart("last_seen") + s.LastSeen.Encode(e) + } + } + { + e.FieldStart("mention_count") + e.Int(s.MentionCount) + } + { + if s.Metadata.Set { + e.FieldStart("metadata") + s.Metadata.Encode(e) + } + } + { + e.FieldStart("observations") + e.ArrStart() + for _, elem := range s.Observations { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfEntityDetailResponse = [7]string{ + 0: "canonical_name", + 1: "first_seen", + 2: "id", + 3: "last_seen", + 4: "mention_count", + 5: "metadata", + 6: "observations", +} + +// Decode decodes EntityDetailResponse from json. +func (s *EntityDetailResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EntityDetailResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "canonical_name": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.CanonicalName = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"canonical_name\"") + } + case "first_seen": + if err := func() error { + s.FirstSeen.Reset() + if err := s.FirstSeen.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"first_seen\"") + } + case "id": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "last_seen": + if err := func() error { + s.LastSeen.Reset() + if err := s.LastSeen.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last_seen\"") + } + case "mention_count": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int() + s.MentionCount = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mention_count\"") + } + case "metadata": + if err := func() error { + s.Metadata.Reset() + if err := s.Metadata.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"metadata\"") + } + case "observations": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + s.Observations = make([]EntityObservationResponse, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem EntityObservationResponse + if err := elem.Decode(d); err != nil { + return err + } + s.Observations = append(s.Observations, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"observations\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode EntityDetailResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b01010101, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfEntityDetailResponse) { + name = jsonFieldsNameOfEntityDetailResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *EntityDetailResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EntityDetailResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s EntityDetailResponseMetadata) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s EntityDetailResponseMetadata) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes EntityDetailResponseMetadata from json. +func (s *EntityDetailResponseMetadata) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EntityDetailResponseMetadata to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode EntityDetailResponseMetadata") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s EntityDetailResponseMetadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EntityDetailResponseMetadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *EntityIncludeOptions) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *EntityIncludeOptions) encodeFields(e *jx.Encoder) { + { + if s.MaxTokens.Set { + e.FieldStart("max_tokens") + s.MaxTokens.Encode(e) + } + } +} + +var jsonFieldsNameOfEntityIncludeOptions = [1]string{ + 0: "max_tokens", +} + +// Decode decodes EntityIncludeOptions from json. +func (s *EntityIncludeOptions) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EntityIncludeOptions to nil") + } + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "max_tokens": + if err := func() error { + s.MaxTokens.Reset() + if err := s.MaxTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_tokens\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode EntityIncludeOptions") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *EntityIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EntityIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *EntityInput) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *EntityInput) encodeFields(e *jx.Encoder) { + { + e.FieldStart("text") + e.Str(s.Text) + } + { + if s.Type.Set { + e.FieldStart("type") + s.Type.Encode(e) + } + } +} + +var jsonFieldsNameOfEntityInput = [2]string{ + 0: "text", + 1: "type", +} + +// Decode decodes EntityInput from json. +func (s *EntityInput) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EntityInput to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "text": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Text = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"text\"") + } + case "type": + if err := func() error { + s.Type.Reset() + if err := s.Type.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"type\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode EntityInput") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfEntityInput) { + name = jsonFieldsNameOfEntityInput[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *EntityInput) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EntityInput) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *EntityListItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *EntityListItem) encodeFields(e *jx.Encoder) { + { + e.FieldStart("canonical_name") + e.Str(s.CanonicalName) + } + { + if s.FirstSeen.Set { + e.FieldStart("first_seen") + s.FirstSeen.Encode(e) + } + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + if s.LastSeen.Set { + e.FieldStart("last_seen") + s.LastSeen.Encode(e) + } + } + { + e.FieldStart("mention_count") + e.Int(s.MentionCount) + } + { + if s.Metadata.Set { + e.FieldStart("metadata") + s.Metadata.Encode(e) + } + } +} + +var jsonFieldsNameOfEntityListItem = [6]string{ + 0: "canonical_name", + 1: "first_seen", + 2: "id", + 3: "last_seen", + 4: "mention_count", + 5: "metadata", +} + +// Decode decodes EntityListItem from json. +func (s *EntityListItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EntityListItem to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "canonical_name": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.CanonicalName = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"canonical_name\"") + } + case "first_seen": + if err := func() error { + s.FirstSeen.Reset() + if err := s.FirstSeen.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"first_seen\"") + } + case "id": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "last_seen": + if err := func() error { + s.LastSeen.Reset() + if err := s.LastSeen.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last_seen\"") + } + case "mention_count": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int() + s.MentionCount = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mention_count\"") + } + case "metadata": + if err := func() error { + s.Metadata.Reset() + if err := s.Metadata.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"metadata\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode EntityListItem") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00010101, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfEntityListItem) { + name = jsonFieldsNameOfEntityListItem[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *EntityListItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EntityListItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s EntityListItemMetadata) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s EntityListItemMetadata) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes EntityListItemMetadata from json. +func (s *EntityListItemMetadata) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EntityListItemMetadata to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode EntityListItemMetadata") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s EntityListItemMetadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EntityListItemMetadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *EntityListResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *EntityListResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("items") + e.ArrStart() + for _, elem := range s.Items { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("limit") + e.Int(s.Limit) + } + { + e.FieldStart("offset") + e.Int(s.Offset) + } + { + e.FieldStart("total") + e.Int(s.Total) + } +} + +var jsonFieldsNameOfEntityListResponse = [4]string{ + 0: "items", + 1: "limit", + 2: "offset", + 3: "total", +} + +// Decode decodes EntityListResponse from json. +func (s *EntityListResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EntityListResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "items": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Items = make([]EntityListItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem EntityListItem + if err := elem.Decode(d); err != nil { + return err + } + s.Items = append(s.Items, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"items\"") + } + case "limit": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.Limit = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "offset": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.Offset = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"offset\"") + } + case "total": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int() + s.Total = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode EntityListResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00001111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfEntityListResponse) { + name = jsonFieldsNameOfEntityListResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *EntityListResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EntityListResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *EntityObservationResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *EntityObservationResponse) encodeFields(e *jx.Encoder) { + { + if s.MentionedAt.Set { + e.FieldStart("mentioned_at") + s.MentionedAt.Encode(e) + } + } + { + e.FieldStart("text") + e.Str(s.Text) + } +} + +var jsonFieldsNameOfEntityObservationResponse = [2]string{ + 0: "mentioned_at", + 1: "text", +} + +// Decode decodes EntityObservationResponse from json. +func (s *EntityObservationResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EntityObservationResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "mentioned_at": + if err := func() error { + s.MentionedAt.Reset() + if err := s.MentionedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mentioned_at\"") + } + case "text": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Text = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"text\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode EntityObservationResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000010, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfEntityObservationResponse) { + name = jsonFieldsNameOfEntityObservationResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *EntityObservationResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EntityObservationResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *EntityStateResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *EntityStateResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("canonical_name") + e.Str(s.CanonicalName) + } + { + e.FieldStart("entity_id") + e.Str(s.EntityID) + } + { + e.FieldStart("observations") + e.ArrStart() + for _, elem := range s.Observations { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfEntityStateResponse = [3]string{ + 0: "canonical_name", + 1: "entity_id", + 2: "observations", +} + +// Decode decodes EntityStateResponse from json. +func (s *EntityStateResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EntityStateResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "canonical_name": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.CanonicalName = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"canonical_name\"") + } + case "entity_id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.EntityID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"entity_id\"") + } + case "observations": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.Observations = make([]EntityObservationResponse, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem EntityObservationResponse + if err := elem.Decode(d); err != nil { + return err + } + s.Observations = append(s.Observations, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"observations\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode EntityStateResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfEntityStateResponse) { + name = jsonFieldsNameOfEntityStateResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *EntityStateResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EntityStateResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *FactsIncludeOptions) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *FactsIncludeOptions) encodeFields(e *jx.Encoder) { +} + +var jsonFieldsNameOfFactsIncludeOptions = [0]string{} + +// Decode decodes FactsIncludeOptions from json. +func (s *FactsIncludeOptions) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode FactsIncludeOptions to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + default: + return d.Skip() + } + }); err != nil { + return errors.Wrap(err, "decode FactsIncludeOptions") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *FactsIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *FactsIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *FeaturesInfo) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *FeaturesInfo) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bank_config_api") + e.Bool(s.BankConfigAPI) + } + { + e.FieldStart("mcp") + e.Bool(s.Mcp) + } + { + e.FieldStart("observations") + e.Bool(s.Observations) + } + { + e.FieldStart("worker") + e.Bool(s.Worker) + } +} + +var jsonFieldsNameOfFeaturesInfo = [4]string{ + 0: "bank_config_api", + 1: "mcp", + 2: "observations", + 3: "worker", +} + +// Decode decodes FeaturesInfo from json. +func (s *FeaturesInfo) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode FeaturesInfo to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bank_config_api": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Bool() + s.BankConfigAPI = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_config_api\"") + } + case "mcp": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Bool() + s.Mcp = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mcp\"") + } + case "observations": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Bool() + s.Observations = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"observations\"") + } + case "worker": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Bool() + s.Worker = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"worker\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode FeaturesInfo") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00001111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfFeaturesInfo) { + name = jsonFieldsNameOfFeaturesInfo[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *FeaturesInfo) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *FeaturesInfo) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes GetMemoryOKApplicationJSON as json. +func (s GetMemoryOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := jx.Raw(s) + + if len(unwrapped) != 0 { + e.Raw(unwrapped) + } +} + +// Decode decodes GetMemoryOKApplicationJSON from json. +func (s *GetMemoryOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GetMemoryOKApplicationJSON to nil") + } + var unwrapped jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + unwrapped = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = GetMemoryOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s GetMemoryOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GetMemoryOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GraphDataResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GraphDataResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("edges") + e.ArrStart() + for _, elem := range s.Edges { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("limit") + e.Int(s.Limit) + } + { + e.FieldStart("nodes") + e.ArrStart() + for _, elem := range s.Nodes { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("table_rows") + e.ArrStart() + for _, elem := range s.TableRows { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("total_units") + e.Int(s.TotalUnits) + } +} + +var jsonFieldsNameOfGraphDataResponse = [5]string{ + 0: "edges", + 1: "limit", + 2: "nodes", + 3: "table_rows", + 4: "total_units", +} + +// Decode decodes GraphDataResponse from json. +func (s *GraphDataResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GraphDataResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "edges": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Edges = make([]GraphDataResponseEdgesItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GraphDataResponseEdgesItem + if err := elem.Decode(d); err != nil { + return err + } + s.Edges = append(s.Edges, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"edges\"") + } + case "limit": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.Limit = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "nodes": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.Nodes = make([]GraphDataResponseNodesItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GraphDataResponseNodesItem + if err := elem.Decode(d); err != nil { + return err + } + s.Nodes = append(s.Nodes, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"nodes\"") + } + case "table_rows": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + s.TableRows = make([]GraphDataResponseTableRowsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GraphDataResponseTableRowsItem + if err := elem.Decode(d); err != nil { + return err + } + s.TableRows = append(s.TableRows, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"table_rows\"") + } + case "total_units": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int() + s.TotalUnits = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total_units\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GraphDataResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfGraphDataResponse) { + name = jsonFieldsNameOfGraphDataResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *GraphDataResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GraphDataResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s GraphDataResponseEdgesItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s GraphDataResponseEdgesItem) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes GraphDataResponseEdgesItem from json. +func (s *GraphDataResponseEdgesItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GraphDataResponseEdgesItem to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode GraphDataResponseEdgesItem") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s GraphDataResponseEdgesItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GraphDataResponseEdgesItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s GraphDataResponseNodesItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s GraphDataResponseNodesItem) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes GraphDataResponseNodesItem from json. +func (s *GraphDataResponseNodesItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GraphDataResponseNodesItem to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode GraphDataResponseNodesItem") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s GraphDataResponseNodesItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GraphDataResponseNodesItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s GraphDataResponseTableRowsItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s GraphDataResponseTableRowsItem) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes GraphDataResponseTableRowsItem from json. +func (s *GraphDataResponseTableRowsItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GraphDataResponseTableRowsItem to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode GraphDataResponseTableRowsItem") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s GraphDataResponseTableRowsItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GraphDataResponseTableRowsItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *HTTPValidationError) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *HTTPValidationError) encodeFields(e *jx.Encoder) { + { + if s.Detail != nil { + e.FieldStart("detail") + e.ArrStart() + for _, elem := range s.Detail { + elem.Encode(e) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfHTTPValidationError = [1]string{ + 0: "detail", +} + +// Decode decodes HTTPValidationError from json. +func (s *HTTPValidationError) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode HTTPValidationError to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "detail": + if err := func() error { + s.Detail = make([]ValidationError, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ValidationError + if err := elem.Decode(d); err != nil { + return err + } + s.Detail = append(s.Detail, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"detail\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode HTTPValidationError") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *HTTPValidationError) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *HTTPValidationError) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *IncludeOptions) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *IncludeOptions) encodeFields(e *jx.Encoder) { + { + if s.Chunks.Set { + e.FieldStart("chunks") + s.Chunks.Encode(e) + } + } + { + if s.Entities.Set { + e.FieldStart("entities") + s.Entities.Encode(e) + } + } +} + +var jsonFieldsNameOfIncludeOptions = [2]string{ + 0: "chunks", + 1: "entities", +} + +// Decode decodes IncludeOptions from json. +func (s *IncludeOptions) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode IncludeOptions to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "chunks": + if err := func() error { + s.Chunks.Reset() + if err := s.Chunks.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"chunks\"") + } + case "entities": + if err := func() error { + s.Entities.Reset() + if err := s.Entities.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"entities\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode IncludeOptions") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *IncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *IncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ListDocumentsResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ListDocumentsResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("items") + e.ArrStart() + for _, elem := range s.Items { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("limit") + e.Int(s.Limit) + } + { + e.FieldStart("offset") + e.Int(s.Offset) + } + { + e.FieldStart("total") + e.Int(s.Total) + } +} + +var jsonFieldsNameOfListDocumentsResponse = [4]string{ + 0: "items", + 1: "limit", + 2: "offset", + 3: "total", +} + +// Decode decodes ListDocumentsResponse from json. +func (s *ListDocumentsResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListDocumentsResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "items": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Items = make([]ListDocumentsResponseItemsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ListDocumentsResponseItemsItem + if err := elem.Decode(d); err != nil { + return err + } + s.Items = append(s.Items, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"items\"") + } + case "limit": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.Limit = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "offset": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.Offset = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"offset\"") + } + case "total": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int() + s.Total = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ListDocumentsResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00001111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfListDocumentsResponse) { + name = jsonFieldsNameOfListDocumentsResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ListDocumentsResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListDocumentsResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s ListDocumentsResponseItemsItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s ListDocumentsResponseItemsItem) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes ListDocumentsResponseItemsItem from json. +func (s *ListDocumentsResponseItemsItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListDocumentsResponseItemsItem to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode ListDocumentsResponseItemsItem") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListDocumentsResponseItemsItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListDocumentsResponseItemsItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ListMemoryUnitsResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ListMemoryUnitsResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("items") + e.ArrStart() + for _, elem := range s.Items { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("limit") + e.Int(s.Limit) + } + { + e.FieldStart("offset") + e.Int(s.Offset) + } + { + e.FieldStart("total") + e.Int(s.Total) + } +} + +var jsonFieldsNameOfListMemoryUnitsResponse = [4]string{ + 0: "items", + 1: "limit", + 2: "offset", + 3: "total", +} + +// Decode decodes ListMemoryUnitsResponse from json. +func (s *ListMemoryUnitsResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListMemoryUnitsResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "items": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Items = make([]ListMemoryUnitsResponseItemsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ListMemoryUnitsResponseItemsItem + if err := elem.Decode(d); err != nil { + return err + } + s.Items = append(s.Items, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"items\"") + } + case "limit": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.Limit = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "offset": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.Offset = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"offset\"") + } + case "total": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int() + s.Total = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ListMemoryUnitsResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00001111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfListMemoryUnitsResponse) { + name = jsonFieldsNameOfListMemoryUnitsResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ListMemoryUnitsResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListMemoryUnitsResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s ListMemoryUnitsResponseItemsItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s ListMemoryUnitsResponseItemsItem) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes ListMemoryUnitsResponseItemsItem from json. +func (s *ListMemoryUnitsResponseItemsItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListMemoryUnitsResponseItemsItem to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode ListMemoryUnitsResponseItemsItem") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListMemoryUnitsResponseItemsItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListMemoryUnitsResponseItemsItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ListTagsResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ListTagsResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("items") + e.ArrStart() + for _, elem := range s.Items { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("limit") + e.Int(s.Limit) + } + { + e.FieldStart("offset") + e.Int(s.Offset) + } + { + e.FieldStart("total") + e.Int(s.Total) + } +} + +var jsonFieldsNameOfListTagsResponse = [4]string{ + 0: "items", + 1: "limit", + 2: "offset", + 3: "total", +} + +// Decode decodes ListTagsResponse from json. +func (s *ListTagsResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListTagsResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "items": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Items = make([]TagItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem TagItem + if err := elem.Decode(d); err != nil { + return err + } + s.Items = append(s.Items, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"items\"") + } + case "limit": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.Limit = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "offset": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.Offset = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"offset\"") + } + case "total": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int() + s.Total = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ListTagsResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00001111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfListTagsResponse) { + name = jsonFieldsNameOfListTagsResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ListTagsResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListTagsResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *MemoryItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *MemoryItem) encodeFields(e *jx.Encoder) { + { + e.FieldStart("content") + e.Str(s.Content) + } + { + if s.Context.Set { + e.FieldStart("context") + s.Context.Encode(e) + } + } + { + if s.DocumentID.Set { + e.FieldStart("document_id") + s.DocumentID.Encode(e) + } + } + { + if s.Entities != nil { + e.FieldStart("entities") + e.ArrStart() + for _, elem := range s.Entities { + elem.Encode(e) + } + e.ArrEnd() + } + } + { + if s.Metadata.Set { + e.FieldStart("metadata") + s.Metadata.Encode(e) + } + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + if s.Timestamp.Set { + e.FieldStart("timestamp") + s.Timestamp.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfMemoryItem = [7]string{ + 0: "content", + 1: "context", + 2: "document_id", + 3: "entities", + 4: "metadata", + 5: "tags", + 6: "timestamp", +} + +// Decode decodes MemoryItem from json. +func (s *MemoryItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MemoryItem to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "content": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Content = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content\"") + } + case "context": + if err := func() error { + s.Context.Reset() + if err := s.Context.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"context\"") + } + case "document_id": + if err := func() error { + s.DocumentID.Reset() + if err := s.DocumentID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"document_id\"") + } + case "entities": + if err := func() error { + s.Entities = make([]EntityInput, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem EntityInput + if err := elem.Decode(d); err != nil { + return err + } + s.Entities = append(s.Entities, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"entities\"") + } + case "metadata": + if err := func() error { + s.Metadata.Reset() + if err := s.Metadata.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"metadata\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + case "timestamp": + if err := func() error { + s.Timestamp.Reset() + if err := s.Timestamp.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"timestamp\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode MemoryItem") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfMemoryItem) { + name = jsonFieldsNameOfMemoryItem[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *MemoryItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *MemoryItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s MemoryItemMetadata) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s MemoryItemMetadata) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Str(elem) + } +} + +// Decode decodes MemoryItemMetadata from json. +func (s *MemoryItemMetadata) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MemoryItemMetadata to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem string + if err := func() error { + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode MemoryItemMetadata") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s MemoryItemMetadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *MemoryItemMetadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *MentalModelListResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *MentalModelListResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("items") + e.ArrStart() + for _, elem := range s.Items { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfMentalModelListResponse = [1]string{ + 0: "items", +} + +// Decode decodes MentalModelListResponse from json. +func (s *MentalModelListResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MentalModelListResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "items": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Items = make([]MentalModelResponse, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem MentalModelResponse + if err := elem.Decode(d); err != nil { + return err + } + s.Items = append(s.Items, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"items\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode MentalModelListResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfMentalModelListResponse) { + name = jsonFieldsNameOfMentalModelListResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *MentalModelListResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *MentalModelListResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *MentalModelResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *MentalModelResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + e.FieldStart("content") + e.Str(s.Content) + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e) + } + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + if s.LastRefreshedAt.Set { + e.FieldStart("last_refreshed_at") + s.LastRefreshedAt.Encode(e) + } + } + { + if s.MaxTokens.Set { + e.FieldStart("max_tokens") + s.MaxTokens.Encode(e) + } + } + { + e.FieldStart("name") + e.Str(s.Name) + } + { + if s.ReflectResponse.Set { + e.FieldStart("reflect_response") + s.ReflectResponse.Encode(e) + } + } + { + e.FieldStart("source_query") + e.Str(s.SourceQuery) + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + if s.Trigger.Set { + e.FieldStart("trigger") + s.Trigger.Encode(e) + } + } +} + +var jsonFieldsNameOfMentalModelResponse = [11]string{ + 0: "bank_id", + 1: "content", + 2: "created_at", + 3: "id", + 4: "last_refreshed_at", + 5: "max_tokens", + 6: "name", + 7: "reflect_response", + 8: "source_query", + 9: "tags", + 10: "trigger", +} + +// Decode decodes MentalModelResponse from json. +func (s *MentalModelResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MentalModelResponse to nil") + } + var requiredBitSet [2]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bank_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "content": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Content = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "id": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "last_refreshed_at": + if err := func() error { + s.LastRefreshedAt.Reset() + if err := s.LastRefreshedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last_refreshed_at\"") + } + case "max_tokens": + if err := func() error { + s.MaxTokens.Reset() + if err := s.MaxTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_tokens\"") + } + case "name": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "reflect_response": + if err := func() error { + s.ReflectResponse.Reset() + if err := s.ReflectResponse.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"reflect_response\"") + } + case "source_query": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.SourceQuery = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"source_query\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + case "trigger": + if err := func() error { + s.Trigger.Reset() + if err := s.Trigger.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"trigger\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode MentalModelResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b01001011, + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfMentalModelResponse) { + name = jsonFieldsNameOfMentalModelResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *MentalModelResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *MentalModelResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s MentalModelResponseReflectResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s MentalModelResponseReflectResponse) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes MentalModelResponseReflectResponse from json. +func (s *MentalModelResponseReflectResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MentalModelResponseReflectResponse to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode MentalModelResponseReflectResponse") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s MentalModelResponseReflectResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *MentalModelResponseReflectResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *MentalModelTrigger) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *MentalModelTrigger) encodeFields(e *jx.Encoder) { + { + if s.RefreshAfterConsolidation.Set { + e.FieldStart("refresh_after_consolidation") + s.RefreshAfterConsolidation.Encode(e) + } + } +} + +var jsonFieldsNameOfMentalModelTrigger = [1]string{ + 0: "refresh_after_consolidation", +} + +// Decode decodes MentalModelTrigger from json. +func (s *MentalModelTrigger) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MentalModelTrigger to nil") + } + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "refresh_after_consolidation": + if err := func() error { + s.RefreshAfterConsolidation.Reset() + if err := s.RefreshAfterConsolidation.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"refresh_after_consolidation\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode MentalModelTrigger") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *MentalModelTrigger) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *MentalModelTrigger) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *OperationResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *OperationResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("created_at") + e.Str(s.CreatedAt) + } + { + if s.DocumentID.Set { + e.FieldStart("document_id") + s.DocumentID.Encode(e) + } + } + { + e.FieldStart("error_message") + e.Str(s.ErrorMessage) + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + e.FieldStart("items_count") + e.Int(s.ItemsCount) + } + { + e.FieldStart("status") + e.Str(s.Status) + } + { + e.FieldStart("task_type") + e.Str(s.TaskType) + } +} + +var jsonFieldsNameOfOperationResponse = [7]string{ + 0: "created_at", + 1: "document_id", + 2: "error_message", + 3: "id", + 4: "items_count", + 5: "status", + 6: "task_type", +} + +// Decode decodes OperationResponse from json. +func (s *OperationResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode OperationResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "created_at": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.CreatedAt = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "document_id": + if err := func() error { + s.DocumentID.Reset() + if err := s.DocumentID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"document_id\"") + } + case "error_message": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.ErrorMessage = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"error_message\"") + } + case "id": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "items_count": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int() + s.ItemsCount = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"items_count\"") + } + case "status": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Str() + s.Status = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + case "task_type": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Str() + s.TaskType = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"task_type\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode OperationResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b01111101, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfOperationResponse) { + name = jsonFieldsNameOfOperationResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *OperationResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OperationResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *OperationStatusResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *OperationStatusResponse) encodeFields(e *jx.Encoder) { + { + if s.CompletedAt.Set { + e.FieldStart("completed_at") + s.CompletedAt.Encode(e) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e) + } + } + { + if s.ErrorMessage.Set { + e.FieldStart("error_message") + s.ErrorMessage.Encode(e) + } + } + { + e.FieldStart("operation_id") + e.Str(s.OperationID) + } + { + if s.OperationType.Set { + e.FieldStart("operation_type") + s.OperationType.Encode(e) + } + } + { + e.FieldStart("status") + s.Status.Encode(e) + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e) + } + } +} + +var jsonFieldsNameOfOperationStatusResponse = [7]string{ + 0: "completed_at", + 1: "created_at", + 2: "error_message", + 3: "operation_id", + 4: "operation_type", + 5: "status", + 6: "updated_at", +} + +// Decode decodes OperationStatusResponse from json. +func (s *OperationStatusResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode OperationStatusResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "completed_at": + if err := func() error { + s.CompletedAt.Reset() + if err := s.CompletedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"completed_at\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "error_message": + if err := func() error { + s.ErrorMessage.Reset() + if err := s.ErrorMessage.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"error_message\"") + } + case "operation_id": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.OperationID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operation_id\"") + } + case "operation_type": + if err := func() error { + s.OperationType.Reset() + if err := s.OperationType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operation_type\"") + } + case "status": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + if err := s.Status.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode OperationStatusResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00101000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfOperationStatusResponse) { + name = jsonFieldsNameOfOperationStatusResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *OperationStatusResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OperationStatusResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes OperationStatusResponseStatus as json. +func (s OperationStatusResponseStatus) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes OperationStatusResponseStatus from json. +func (s *OperationStatusResponseStatus) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode OperationStatusResponseStatus to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch OperationStatusResponseStatus(v) { + case OperationStatusResponseStatusPending: + *s = OperationStatusResponseStatusPending + case OperationStatusResponseStatusCompleted: + *s = OperationStatusResponseStatusCompleted + case OperationStatusResponseStatusFailed: + *s = OperationStatusResponseStatusFailed + case OperationStatusResponseStatusNotFound: + *s = OperationStatusResponseStatusNotFound + default: + *s = OperationStatusResponseStatus(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OperationStatusResponseStatus) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OperationStatusResponseStatus) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *OperationsListResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *OperationsListResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + e.FieldStart("limit") + e.Int(s.Limit) + } + { + e.FieldStart("offset") + e.Int(s.Offset) + } + { + e.FieldStart("operations") + e.ArrStart() + for _, elem := range s.Operations { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("total") + e.Int(s.Total) + } +} + +var jsonFieldsNameOfOperationsListResponse = [5]string{ + 0: "bank_id", + 1: "limit", + 2: "offset", + 3: "operations", + 4: "total", +} + +// Decode decodes OperationsListResponse from json. +func (s *OperationsListResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode OperationsListResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bank_id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "limit": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.Limit = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "offset": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.Offset = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"offset\"") + } + case "operations": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + s.Operations = make([]OperationResponse, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem OperationResponse + if err := elem.Decode(d); err != nil { + return err + } + s.Operations = append(s.Operations, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operations\"") + } + case "total": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int() + s.Total = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode OperationsListResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfOperationsListResponse) { + name = jsonFieldsNameOfOperationsListResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *OperationsListResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OperationsListResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes bool as json. +func (o OptBool) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Bool(bool(o.Value)) +} + +// Decode decodes bool from json. +func (o *OptBool) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptBool to nil") + } + o.Set = true + v, err := d.Bool() + if err != nil { + return err + } + o.Value = bool(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptBool) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptBool) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes Budget as json. +func (o OptBudget) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Str(string(o.Value)) +} + +// Decode decodes Budget from json. +func (o *OptBudget) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptBudget to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptBudget) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptBudget) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ChunkIncludeOptions as json. +func (o OptChunkIncludeOptions) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ChunkIncludeOptions from json. +func (o *OptChunkIncludeOptions) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptChunkIncludeOptions to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptChunkIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptChunkIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes time.Time as json. +func (o OptDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { + if !o.Set { + return + } + format(e, o.Value) +} + +// Decode decodes time.Time from json. +func (o *OptDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error { + if o == nil { + return errors.New("invalid: unable to decode OptDateTime to nil") + } + o.Set = true + v, err := format(d) + if err != nil { + return err + } + o.Value = v + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptDateTime) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e, json.EncodeDateTime) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDateTime) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d, json.DecodeDateTime) +} + +// Encode encodes DispositionTraits as json. +func (o OptDispositionTraits) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes DispositionTraits from json. +func (o *OptDispositionTraits) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptDispositionTraits to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptDispositionTraits) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDispositionTraits) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes EntityDetailResponseMetadata as json. +func (o OptEntityDetailResponseMetadata) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes EntityDetailResponseMetadata from json. +func (o *OptEntityDetailResponseMetadata) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptEntityDetailResponseMetadata to nil") + } + o.Set = true + o.Value = make(EntityDetailResponseMetadata) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptEntityDetailResponseMetadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptEntityDetailResponseMetadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes EntityIncludeOptions as json. +func (o OptEntityIncludeOptions) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes EntityIncludeOptions from json. +func (o *OptEntityIncludeOptions) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptEntityIncludeOptions to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptEntityIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptEntityIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes EntityListItemMetadata as json. +func (o OptEntityListItemMetadata) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes EntityListItemMetadata from json. +func (o *OptEntityListItemMetadata) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptEntityListItemMetadata to nil") + } + o.Set = true + o.Value = make(EntityListItemMetadata) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptEntityListItemMetadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptEntityListItemMetadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes IncludeOptions as json. +func (o OptIncludeOptions) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes IncludeOptions from json. +func (o *OptIncludeOptions) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptIncludeOptions to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes int as json. +func (o OptInt) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Int(int(o.Value)) +} + +// Decode decodes int from json. +func (o *OptInt) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptInt to nil") + } + o.Set = true + v, err := d.Int() + if err != nil { + return err + } + o.Value = int(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptInt) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptInt) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes MemoryItemMetadata as json. +func (o OptMemoryItemMetadata) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes MemoryItemMetadata from json. +func (o *OptMemoryItemMetadata) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptMemoryItemMetadata to nil") + } + o.Set = true + o.Value = make(MemoryItemMetadata) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptMemoryItemMetadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptMemoryItemMetadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes MentalModelResponseReflectResponse as json. +func (o OptMentalModelResponseReflectResponse) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes MentalModelResponseReflectResponse from json. +func (o *OptMentalModelResponseReflectResponse) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptMentalModelResponseReflectResponse to nil") + } + o.Set = true + o.Value = make(MentalModelResponseReflectResponse) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptMentalModelResponseReflectResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptMentalModelResponseReflectResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes MentalModelTrigger as json. +func (o OptMentalModelTrigger) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes MentalModelTrigger from json. +func (o *OptMentalModelTrigger) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptMentalModelTrigger to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptMentalModelTrigger) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptMentalModelTrigger) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes RecallRequestTagsMatch as json. +func (o OptRecallRequestTagsMatch) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Str(string(o.Value)) +} + +// Decode decodes RecallRequestTagsMatch from json. +func (o *OptRecallRequestTagsMatch) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptRecallRequestTagsMatch to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptRecallRequestTagsMatch) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptRecallRequestTagsMatch) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes RecallResponseChunks as json. +func (o OptRecallResponseChunks) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes RecallResponseChunks from json. +func (o *OptRecallResponseChunks) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptRecallResponseChunks to nil") + } + o.Set = true + o.Value = make(RecallResponseChunks) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptRecallResponseChunks) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptRecallResponseChunks) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes RecallResponseEntities as json. +func (o OptRecallResponseEntities) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes RecallResponseEntities from json. +func (o *OptRecallResponseEntities) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptRecallResponseEntities to nil") + } + o.Set = true + o.Value = make(RecallResponseEntities) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptRecallResponseEntities) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptRecallResponseEntities) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes RecallResponseTrace as json. +func (o OptRecallResponseTrace) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes RecallResponseTrace from json. +func (o *OptRecallResponseTrace) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptRecallResponseTrace to nil") + } + o.Set = true + o.Value = make(RecallResponseTrace) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptRecallResponseTrace) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptRecallResponseTrace) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes RecallResultMetadata as json. +func (o OptRecallResultMetadata) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes RecallResultMetadata from json. +func (o *OptRecallResultMetadata) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptRecallResultMetadata to nil") + } + o.Set = true + o.Value = make(RecallResultMetadata) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptRecallResultMetadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptRecallResultMetadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ReflectBasedOn as json. +func (o OptReflectBasedOn) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ReflectBasedOn from json. +func (o *OptReflectBasedOn) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptReflectBasedOn to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptReflectBasedOn) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptReflectBasedOn) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ReflectIncludeOptions as json. +func (o OptReflectIncludeOptions) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ReflectIncludeOptions from json. +func (o *OptReflectIncludeOptions) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptReflectIncludeOptions to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptReflectIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptReflectIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ReflectRequestResponseSchema as json. +func (o OptReflectRequestResponseSchema) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ReflectRequestResponseSchema from json. +func (o *OptReflectRequestResponseSchema) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptReflectRequestResponseSchema to nil") + } + o.Set = true + o.Value = make(ReflectRequestResponseSchema) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptReflectRequestResponseSchema) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptReflectRequestResponseSchema) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ReflectRequestTagsMatch as json. +func (o OptReflectRequestTagsMatch) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Str(string(o.Value)) +} + +// Decode decodes ReflectRequestTagsMatch from json. +func (o *OptReflectRequestTagsMatch) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptReflectRequestTagsMatch to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptReflectRequestTagsMatch) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptReflectRequestTagsMatch) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ReflectResponseStructuredOutput as json. +func (o OptReflectResponseStructuredOutput) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ReflectResponseStructuredOutput from json. +func (o *OptReflectResponseStructuredOutput) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptReflectResponseStructuredOutput to nil") + } + o.Set = true + o.Value = make(ReflectResponseStructuredOutput) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptReflectResponseStructuredOutput) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptReflectResponseStructuredOutput) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ReflectToolCallOutput as json. +func (o OptReflectToolCallOutput) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ReflectToolCallOutput from json. +func (o *OptReflectToolCallOutput) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptReflectToolCallOutput to nil") + } + o.Set = true + o.Value = make(ReflectToolCallOutput) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptReflectToolCallOutput) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptReflectToolCallOutput) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ReflectTrace as json. +func (o OptReflectTrace) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ReflectTrace from json. +func (o *OptReflectTrace) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptReflectTrace to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptReflectTrace) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptReflectTrace) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes string as json. +func (o OptString) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Str(string(o.Value)) +} + +// Decode decodes string from json. +func (o *OptString) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptString to nil") + } + o.Set = true + v, err := d.Str() + if err != nil { + return err + } + o.Value = string(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptString) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptString) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes TokenUsage as json. +func (o OptTokenUsage) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes TokenUsage from json. +func (o *OptTokenUsage) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptTokenUsage to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptTokenUsage) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptTokenUsage) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ToolCallsIncludeOptions as json. +func (o OptToolCallsIncludeOptions) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ToolCallsIncludeOptions from json. +func (o *OptToolCallsIncludeOptions) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptToolCallsIncludeOptions to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptToolCallsIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptToolCallsIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *RecallRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *RecallRequest) encodeFields(e *jx.Encoder) { + { + if s.Budget.Set { + e.FieldStart("budget") + s.Budget.Encode(e) + } + } + { + if s.Include.Set { + e.FieldStart("include") + s.Include.Encode(e) + } + } + { + if s.MaxTokens.Set { + e.FieldStart("max_tokens") + s.MaxTokens.Encode(e) + } + } + { + e.FieldStart("query") + e.Str(s.Query) + } + { + if s.QueryTimestamp.Set { + e.FieldStart("query_timestamp") + s.QueryTimestamp.Encode(e) + } + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + if s.TagsMatch.Set { + e.FieldStart("tags_match") + s.TagsMatch.Encode(e) + } + } + { + if s.Trace.Set { + e.FieldStart("trace") + s.Trace.Encode(e) + } + } + { + if s.Types != nil { + e.FieldStart("types") + e.ArrStart() + for _, elem := range s.Types { + e.Str(elem) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfRecallRequest = [9]string{ + 0: "budget", + 1: "include", + 2: "max_tokens", + 3: "query", + 4: "query_timestamp", + 5: "tags", + 6: "tags_match", + 7: "trace", + 8: "types", +} + +// Decode decodes RecallRequest from json. +func (s *RecallRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RecallRequest to nil") + } + var requiredBitSet [2]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "budget": + if err := func() error { + s.Budget.Reset() + if err := s.Budget.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"budget\"") + } + case "include": + if err := func() error { + s.Include.Reset() + if err := s.Include.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"include\"") + } + case "max_tokens": + if err := func() error { + s.MaxTokens.Reset() + if err := s.MaxTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_tokens\"") + } + case "query": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.Query = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"query\"") + } + case "query_timestamp": + if err := func() error { + s.QueryTimestamp.Reset() + if err := s.QueryTimestamp.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"query_timestamp\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + case "tags_match": + if err := func() error { + s.TagsMatch.Reset() + if err := s.TagsMatch.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags_match\"") + } + case "trace": + if err := func() error { + s.Trace.Reset() + if err := s.Trace.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"trace\"") + } + case "types": + if err := func() error { + s.Types = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Types = append(s.Types, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"types\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode RecallRequest") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00001000, + 0b00000000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfRecallRequest) { + name = jsonFieldsNameOfRecallRequest[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *RecallRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RecallRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes RecallRequestTagsMatch as json. +func (s RecallRequestTagsMatch) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes RecallRequestTagsMatch from json. +func (s *RecallRequestTagsMatch) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RecallRequestTagsMatch to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch RecallRequestTagsMatch(v) { + case RecallRequestTagsMatchAny: + *s = RecallRequestTagsMatchAny + case RecallRequestTagsMatchAll: + *s = RecallRequestTagsMatchAll + case RecallRequestTagsMatchAnyStrict: + *s = RecallRequestTagsMatchAnyStrict + case RecallRequestTagsMatchAllStrict: + *s = RecallRequestTagsMatchAllStrict + default: + *s = RecallRequestTagsMatch(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s RecallRequestTagsMatch) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RecallRequestTagsMatch) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *RecallResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *RecallResponse) encodeFields(e *jx.Encoder) { + { + if s.Chunks.Set { + e.FieldStart("chunks") + s.Chunks.Encode(e) + } + } + { + if s.Entities.Set { + e.FieldStart("entities") + s.Entities.Encode(e) + } + } + { + e.FieldStart("results") + e.ArrStart() + for _, elem := range s.Results { + elem.Encode(e) + } + e.ArrEnd() + } + { + if s.Trace.Set { + e.FieldStart("trace") + s.Trace.Encode(e) + } + } +} + +var jsonFieldsNameOfRecallResponse = [4]string{ + 0: "chunks", + 1: "entities", + 2: "results", + 3: "trace", +} + +// Decode decodes RecallResponse from json. +func (s *RecallResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RecallResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "chunks": + if err := func() error { + s.Chunks.Reset() + if err := s.Chunks.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"chunks\"") + } + case "entities": + if err := func() error { + s.Entities.Reset() + if err := s.Entities.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"entities\"") + } + case "results": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.Results = make([]RecallResult, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem RecallResult + if err := elem.Decode(d); err != nil { + return err + } + s.Results = append(s.Results, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"results\"") + } + case "trace": + if err := func() error { + s.Trace.Reset() + if err := s.Trace.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"trace\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode RecallResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000100, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfRecallResponse) { + name = jsonFieldsNameOfRecallResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *RecallResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RecallResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s RecallResponseChunks) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s RecallResponseChunks) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + elem.Encode(e) + } +} + +// Decode decodes RecallResponseChunks from json. +func (s *RecallResponseChunks) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RecallResponseChunks to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem ChunkData + if err := func() error { + if err := elem.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode RecallResponseChunks") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s RecallResponseChunks) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RecallResponseChunks) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s RecallResponseEntities) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s RecallResponseEntities) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + elem.Encode(e) + } +} + +// Decode decodes RecallResponseEntities from json. +func (s *RecallResponseEntities) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RecallResponseEntities to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem EntityStateResponse + if err := func() error { + if err := elem.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode RecallResponseEntities") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s RecallResponseEntities) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RecallResponseEntities) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s RecallResponseTrace) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s RecallResponseTrace) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes RecallResponseTrace from json. +func (s *RecallResponseTrace) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RecallResponseTrace to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode RecallResponseTrace") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s RecallResponseTrace) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RecallResponseTrace) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *RecallResult) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *RecallResult) encodeFields(e *jx.Encoder) { + { + if s.ChunkID.Set { + e.FieldStart("chunk_id") + s.ChunkID.Encode(e) + } + } + { + if s.Context.Set { + e.FieldStart("context") + s.Context.Encode(e) + } + } + { + if s.DocumentID.Set { + e.FieldStart("document_id") + s.DocumentID.Encode(e) + } + } + { + if s.Entities != nil { + e.FieldStart("entities") + e.ArrStart() + for _, elem := range s.Entities { + e.Str(elem) + } + e.ArrEnd() + } + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + if s.MentionedAt.Set { + e.FieldStart("mentioned_at") + s.MentionedAt.Encode(e) + } + } + { + if s.Metadata.Set { + e.FieldStart("metadata") + s.Metadata.Encode(e) + } + } + { + if s.OccurredEnd.Set { + e.FieldStart("occurred_end") + s.OccurredEnd.Encode(e) + } + } + { + if s.OccurredStart.Set { + e.FieldStart("occurred_start") + s.OccurredStart.Encode(e) + } + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + e.FieldStart("text") + e.Str(s.Text) + } + { + if s.Type.Set { + e.FieldStart("type") + s.Type.Encode(e) + } + } +} + +var jsonFieldsNameOfRecallResult = [12]string{ + 0: "chunk_id", + 1: "context", + 2: "document_id", + 3: "entities", + 4: "id", + 5: "mentioned_at", + 6: "metadata", + 7: "occurred_end", + 8: "occurred_start", + 9: "tags", + 10: "text", + 11: "type", +} + +// Decode decodes RecallResult from json. +func (s *RecallResult) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RecallResult to nil") + } + var requiredBitSet [2]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "chunk_id": + if err := func() error { + s.ChunkID.Reset() + if err := s.ChunkID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"chunk_id\"") + } + case "context": + if err := func() error { + s.Context.Reset() + if err := s.Context.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"context\"") + } + case "document_id": + if err := func() error { + s.DocumentID.Reset() + if err := s.DocumentID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"document_id\"") + } + case "entities": + if err := func() error { + s.Entities = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Entities = append(s.Entities, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"entities\"") + } + case "id": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "mentioned_at": + if err := func() error { + s.MentionedAt.Reset() + if err := s.MentionedAt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mentioned_at\"") + } + case "metadata": + if err := func() error { + s.Metadata.Reset() + if err := s.Metadata.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"metadata\"") + } + case "occurred_end": + if err := func() error { + s.OccurredEnd.Reset() + if err := s.OccurredEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"occurred_end\"") + } + case "occurred_start": + if err := func() error { + s.OccurredStart.Reset() + if err := s.OccurredStart.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"occurred_start\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + case "text": + requiredBitSet[1] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Text = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"text\"") + } + case "type": + if err := func() error { + s.Type.Reset() + if err := s.Type.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"type\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode RecallResult") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00010000, + 0b00000100, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfRecallResult) { + name = jsonFieldsNameOfRecallResult[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *RecallResult) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RecallResult) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s RecallResultMetadata) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s RecallResultMetadata) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Str(elem) + } +} + +// Decode decodes RecallResultMetadata from json. +func (s *RecallResultMetadata) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RecallResultMetadata to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem string + if err := func() error { + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode RecallResultMetadata") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s RecallResultMetadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RecallResultMetadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectBasedOn) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectBasedOn) encodeFields(e *jx.Encoder) { + { + if s.Directives != nil { + e.FieldStart("directives") + e.ArrStart() + for _, elem := range s.Directives { + elem.Encode(e) + } + e.ArrEnd() + } + } + { + if s.Memories != nil { + e.FieldStart("memories") + e.ArrStart() + for _, elem := range s.Memories { + elem.Encode(e) + } + e.ArrEnd() + } + } + { + if s.MentalModels != nil { + e.FieldStart("mental_models") + e.ArrStart() + for _, elem := range s.MentalModels { + elem.Encode(e) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfReflectBasedOn = [3]string{ + 0: "directives", + 1: "memories", + 2: "mental_models", +} + +// Decode decodes ReflectBasedOn from json. +func (s *ReflectBasedOn) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectBasedOn to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "directives": + if err := func() error { + s.Directives = make([]ReflectDirective, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ReflectDirective + if err := elem.Decode(d); err != nil { + return err + } + s.Directives = append(s.Directives, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"directives\"") + } + case "memories": + if err := func() error { + s.Memories = make([]ReflectFact, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ReflectFact + if err := elem.Decode(d); err != nil { + return err + } + s.Memories = append(s.Memories, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"memories\"") + } + case "mental_models": + if err := func() error { + s.MentalModels = make([]ReflectMentalModel, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ReflectMentalModel + if err := elem.Decode(d); err != nil { + return err + } + s.MentalModels = append(s.MentalModels, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mental_models\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectBasedOn") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectBasedOn) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectBasedOn) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectDirective) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectDirective) encodeFields(e *jx.Encoder) { + { + e.FieldStart("content") + e.Str(s.Content) + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + e.FieldStart("name") + e.Str(s.Name) + } +} + +var jsonFieldsNameOfReflectDirective = [3]string{ + 0: "content", + 1: "id", + 2: "name", +} + +// Decode decodes ReflectDirective from json. +func (s *ReflectDirective) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectDirective to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "content": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Content = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content\"") + } + case "id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "name": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectDirective") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfReflectDirective) { + name = jsonFieldsNameOfReflectDirective[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectDirective) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectDirective) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectFact) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectFact) encodeFields(e *jx.Encoder) { + { + if s.Context.Set { + e.FieldStart("context") + s.Context.Encode(e) + } + } + { + if s.ID.Set { + e.FieldStart("id") + s.ID.Encode(e) + } + } + { + if s.OccurredEnd.Set { + e.FieldStart("occurred_end") + s.OccurredEnd.Encode(e) + } + } + { + if s.OccurredStart.Set { + e.FieldStart("occurred_start") + s.OccurredStart.Encode(e) + } + } + { + e.FieldStart("text") + e.Str(s.Text) + } + { + if s.Type.Set { + e.FieldStart("type") + s.Type.Encode(e) + } + } +} + +var jsonFieldsNameOfReflectFact = [6]string{ + 0: "context", + 1: "id", + 2: "occurred_end", + 3: "occurred_start", + 4: "text", + 5: "type", +} + +// Decode decodes ReflectFact from json. +func (s *ReflectFact) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectFact to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "context": + if err := func() error { + s.Context.Reset() + if err := s.Context.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"context\"") + } + case "id": + if err := func() error { + s.ID.Reset() + if err := s.ID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "occurred_end": + if err := func() error { + s.OccurredEnd.Reset() + if err := s.OccurredEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"occurred_end\"") + } + case "occurred_start": + if err := func() error { + s.OccurredStart.Reset() + if err := s.OccurredStart.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"occurred_start\"") + } + case "text": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.Text = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"text\"") + } + case "type": + if err := func() error { + s.Type.Reset() + if err := s.Type.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"type\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectFact") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00010000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfReflectFact) { + name = jsonFieldsNameOfReflectFact[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectFact) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectFact) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectIncludeOptions) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectIncludeOptions) encodeFields(e *jx.Encoder) { + { + if s.Facts != nil { + e.FieldStart("facts") + s.Facts.Encode(e) + } + } + { + if s.ToolCalls.Set { + e.FieldStart("tool_calls") + s.ToolCalls.Encode(e) + } + } +} + +var jsonFieldsNameOfReflectIncludeOptions = [2]string{ + 0: "facts", + 1: "tool_calls", +} + +// Decode decodes ReflectIncludeOptions from json. +func (s *ReflectIncludeOptions) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectIncludeOptions to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "facts": + if err := func() error { + s.Facts = nil + var elem FactsIncludeOptions + if err := elem.Decode(d); err != nil { + return err + } + s.Facts = &elem + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"facts\"") + } + case "tool_calls": + if err := func() error { + s.ToolCalls.Reset() + if err := s.ToolCalls.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tool_calls\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectIncludeOptions") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectLLMCall) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectLLMCall) encodeFields(e *jx.Encoder) { + { + e.FieldStart("duration_ms") + e.Int(s.DurationMs) + } + { + e.FieldStart("scope") + e.Str(s.Scope) + } +} + +var jsonFieldsNameOfReflectLLMCall = [2]string{ + 0: "duration_ms", + 1: "scope", +} + +// Decode decodes ReflectLLMCall from json. +func (s *ReflectLLMCall) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectLLMCall to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "duration_ms": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.DurationMs = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"duration_ms\"") + } + case "scope": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Scope = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"scope\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectLLMCall") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfReflectLLMCall) { + name = jsonFieldsNameOfReflectLLMCall[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectLLMCall) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectLLMCall) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectMentalModel) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectMentalModel) encodeFields(e *jx.Encoder) { + { + if s.Context.Set { + e.FieldStart("context") + s.Context.Encode(e) + } + } + { + e.FieldStart("id") + e.Str(s.ID) + } + { + e.FieldStart("text") + e.Str(s.Text) + } +} + +var jsonFieldsNameOfReflectMentalModel = [3]string{ + 0: "context", + 1: "id", + 2: "text", +} + +// Decode decodes ReflectMentalModel from json. +func (s *ReflectMentalModel) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectMentalModel to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "context": + if err := func() error { + s.Context.Reset() + if err := s.Context.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"context\"") + } + case "id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "text": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Text = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"text\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectMentalModel") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000110, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfReflectMentalModel) { + name = jsonFieldsNameOfReflectMentalModel[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectMentalModel) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectMentalModel) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectRequest) encodeFields(e *jx.Encoder) { + { + if s.Budget.Set { + e.FieldStart("budget") + s.Budget.Encode(e) + } + } + { + if s.Context.Set { + e.FieldStart("context") + s.Context.Encode(e) + } + } + { + if s.Include.Set { + e.FieldStart("include") + s.Include.Encode(e) + } + } + { + if s.MaxTokens.Set { + e.FieldStart("max_tokens") + s.MaxTokens.Encode(e) + } + } + { + e.FieldStart("query") + e.Str(s.Query) + } + { + if s.ResponseSchema.Set { + e.FieldStart("response_schema") + s.ResponseSchema.Encode(e) + } + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + if s.TagsMatch.Set { + e.FieldStart("tags_match") + s.TagsMatch.Encode(e) + } + } +} + +var jsonFieldsNameOfReflectRequest = [8]string{ + 0: "budget", + 1: "context", + 2: "include", + 3: "max_tokens", + 4: "query", + 5: "response_schema", + 6: "tags", + 7: "tags_match", +} + +// Decode decodes ReflectRequest from json. +func (s *ReflectRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectRequest to nil") + } + var requiredBitSet [1]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "budget": + if err := func() error { + s.Budget.Reset() + if err := s.Budget.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"budget\"") + } + case "context": + if err := func() error { + s.Context.Reset() + if err := s.Context.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"context\"") + } + case "include": + if err := func() error { + s.Include.Reset() + if err := s.Include.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"include\"") + } + case "max_tokens": + if err := func() error { + s.MaxTokens.Reset() + if err := s.MaxTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_tokens\"") + } + case "query": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.Query = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"query\"") + } + case "response_schema": + if err := func() error { + s.ResponseSchema.Reset() + if err := s.ResponseSchema.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"response_schema\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + case "tags_match": + if err := func() error { + s.TagsMatch.Reset() + if err := s.TagsMatch.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags_match\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectRequest") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00010000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfReflectRequest) { + name = jsonFieldsNameOfReflectRequest[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s ReflectRequestResponseSchema) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s ReflectRequestResponseSchema) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes ReflectRequestResponseSchema from json. +func (s *ReflectRequestResponseSchema) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectRequestResponseSchema to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectRequestResponseSchema") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ReflectRequestResponseSchema) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectRequestResponseSchema) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ReflectRequestTagsMatch as json. +func (s ReflectRequestTagsMatch) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes ReflectRequestTagsMatch from json. +func (s *ReflectRequestTagsMatch) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectRequestTagsMatch to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch ReflectRequestTagsMatch(v) { + case ReflectRequestTagsMatchAny: + *s = ReflectRequestTagsMatchAny + case ReflectRequestTagsMatchAll: + *s = ReflectRequestTagsMatchAll + case ReflectRequestTagsMatchAnyStrict: + *s = ReflectRequestTagsMatchAnyStrict + case ReflectRequestTagsMatchAllStrict: + *s = ReflectRequestTagsMatchAllStrict + default: + *s = ReflectRequestTagsMatch(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ReflectRequestTagsMatch) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectRequestTagsMatch) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectResponse) encodeFields(e *jx.Encoder) { + { + if s.BasedOn.Set { + e.FieldStart("based_on") + s.BasedOn.Encode(e) + } + } + { + if s.StructuredOutput.Set { + e.FieldStart("structured_output") + s.StructuredOutput.Encode(e) + } + } + { + e.FieldStart("text") + e.Str(s.Text) + } + { + if s.Trace.Set { + e.FieldStart("trace") + s.Trace.Encode(e) + } + } + { + if s.Usage.Set { + e.FieldStart("usage") + s.Usage.Encode(e) + } + } +} + +var jsonFieldsNameOfReflectResponse = [5]string{ + 0: "based_on", + 1: "structured_output", + 2: "text", + 3: "trace", + 4: "usage", +} + +// Decode decodes ReflectResponse from json. +func (s *ReflectResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "based_on": + if err := func() error { + s.BasedOn.Reset() + if err := s.BasedOn.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"based_on\"") + } + case "structured_output": + if err := func() error { + s.StructuredOutput.Reset() + if err := s.StructuredOutput.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"structured_output\"") + } + case "text": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Text = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"text\"") + } + case "trace": + if err := func() error { + s.Trace.Reset() + if err := s.Trace.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"trace\"") + } + case "usage": + if err := func() error { + s.Usage.Reset() + if err := s.Usage.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"usage\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000100, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfReflectResponse) { + name = jsonFieldsNameOfReflectResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s ReflectResponseStructuredOutput) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s ReflectResponseStructuredOutput) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes ReflectResponseStructuredOutput from json. +func (s *ReflectResponseStructuredOutput) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectResponseStructuredOutput to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectResponseStructuredOutput") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ReflectResponseStructuredOutput) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectResponseStructuredOutput) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectToolCall) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectToolCall) encodeFields(e *jx.Encoder) { + { + e.FieldStart("duration_ms") + e.Int(s.DurationMs) + } + { + e.FieldStart("input") + s.Input.Encode(e) + } + { + if s.Iteration.Set { + e.FieldStart("iteration") + s.Iteration.Encode(e) + } + } + { + if s.Output.Set { + e.FieldStart("output") + s.Output.Encode(e) + } + } + { + e.FieldStart("tool") + e.Str(s.Tool) + } +} + +var jsonFieldsNameOfReflectToolCall = [5]string{ + 0: "duration_ms", + 1: "input", + 2: "iteration", + 3: "output", + 4: "tool", +} + +// Decode decodes ReflectToolCall from json. +func (s *ReflectToolCall) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectToolCall to nil") + } + var requiredBitSet [1]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "duration_ms": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.DurationMs = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"duration_ms\"") + } + case "input": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Input.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"input\"") + } + case "iteration": + if err := func() error { + s.Iteration.Reset() + if err := s.Iteration.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"iteration\"") + } + case "output": + if err := func() error { + s.Output.Reset() + if err := s.Output.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"output\"") + } + case "tool": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.Tool = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tool\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectToolCall") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00010011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfReflectToolCall) { + name = jsonFieldsNameOfReflectToolCall[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectToolCall) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectToolCall) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s ReflectToolCallInput) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s ReflectToolCallInput) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes ReflectToolCallInput from json. +func (s *ReflectToolCallInput) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectToolCallInput to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectToolCallInput") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ReflectToolCallInput) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectToolCallInput) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s ReflectToolCallOutput) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s ReflectToolCallOutput) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes ReflectToolCallOutput from json. +func (s *ReflectToolCallOutput) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectToolCallOutput to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectToolCallOutput") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ReflectToolCallOutput) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectToolCallOutput) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ReflectTrace) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ReflectTrace) encodeFields(e *jx.Encoder) { + { + if s.LlmCalls != nil { + e.FieldStart("llm_calls") + e.ArrStart() + for _, elem := range s.LlmCalls { + elem.Encode(e) + } + e.ArrEnd() + } + } + { + if s.ToolCalls != nil { + e.FieldStart("tool_calls") + e.ArrStart() + for _, elem := range s.ToolCalls { + elem.Encode(e) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfReflectTrace = [2]string{ + 0: "llm_calls", + 1: "tool_calls", +} + +// Decode decodes ReflectTrace from json. +func (s *ReflectTrace) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ReflectTrace to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "llm_calls": + if err := func() error { + s.LlmCalls = make([]ReflectLLMCall, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ReflectLLMCall + if err := elem.Decode(d); err != nil { + return err + } + s.LlmCalls = append(s.LlmCalls, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"llm_calls\"") + } + case "tool_calls": + if err := func() error { + s.ToolCalls = make([]ReflectToolCall, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ReflectToolCall + if err := elem.Decode(d); err != nil { + return err + } + s.ToolCalls = append(s.ToolCalls, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tool_calls\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ReflectTrace") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ReflectTrace) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ReflectTrace) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *RetainRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *RetainRequest) encodeFields(e *jx.Encoder) { + { + if s.Async.Set { + e.FieldStart("async") + s.Async.Encode(e) + } + } + { + if s.DocumentTags != nil { + e.FieldStart("document_tags") + e.ArrStart() + for _, elem := range s.DocumentTags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + e.FieldStart("items") + e.ArrStart() + for _, elem := range s.Items { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfRetainRequest = [3]string{ + 0: "async", + 1: "document_tags", + 2: "items", +} + +// Decode decodes RetainRequest from json. +func (s *RetainRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RetainRequest to nil") + } + var requiredBitSet [1]uint8 + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "async": + if err := func() error { + s.Async.Reset() + if err := s.Async.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"async\"") + } + case "document_tags": + if err := func() error { + s.DocumentTags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.DocumentTags = append(s.DocumentTags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"document_tags\"") + } + case "items": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.Items = make([]MemoryItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem MemoryItem + if err := elem.Decode(d); err != nil { + return err + } + s.Items = append(s.Items, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"items\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode RetainRequest") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000100, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfRetainRequest) { + name = jsonFieldsNameOfRetainRequest[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *RetainRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RetainRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *RetainResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *RetainResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("async") + e.Bool(s.Async) + } + { + e.FieldStart("bank_id") + e.Str(s.BankID) + } + { + e.FieldStart("items_count") + e.Int(s.ItemsCount) + } + { + if s.OperationID.Set { + e.FieldStart("operation_id") + s.OperationID.Encode(e) + } + } + { + e.FieldStart("success") + e.Bool(s.Success) + } + { + if s.Usage.Set { + e.FieldStart("usage") + s.Usage.Encode(e) + } + } +} + +var jsonFieldsNameOfRetainResponse = [6]string{ + 0: "async", + 1: "bank_id", + 2: "items_count", + 3: "operation_id", + 4: "success", + 5: "usage", +} + +// Decode decodes RetainResponse from json. +func (s *RetainResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RetainResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "async": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Bool() + s.Async = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"async\"") + } + case "bank_id": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.BankID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bank_id\"") + } + case "items_count": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.ItemsCount = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"items_count\"") + } + case "operation_id": + if err := func() error { + s.OperationID.Reset() + if err := s.OperationID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operation_id\"") + } + case "success": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Bool() + s.Success = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"success\"") + } + case "usage": + if err := func() error { + s.Usage.Reset() + if err := s.Usage.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"usage\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode RetainResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00010111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfRetainResponse) { + name = jsonFieldsNameOfRetainResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *RetainResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RetainResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TagItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TagItem) encodeFields(e *jx.Encoder) { + { + e.FieldStart("count") + e.Int(s.Count) + } + { + e.FieldStart("tag") + e.Str(s.Tag) + } +} + +var jsonFieldsNameOfTagItem = [2]string{ + 0: "count", + 1: "tag", +} + +// Decode decodes TagItem from json. +func (s *TagItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TagItem to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "count": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.Count = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"count\"") + } + case "tag": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Tag = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tag\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode TagItem") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfTagItem) { + name = jsonFieldsNameOfTagItem[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *TagItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TagItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TokenUsage) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TokenUsage) encodeFields(e *jx.Encoder) { + { + if s.InputTokens.Set { + e.FieldStart("input_tokens") + s.InputTokens.Encode(e) + } + } + { + if s.OutputTokens.Set { + e.FieldStart("output_tokens") + s.OutputTokens.Encode(e) + } + } + { + if s.TotalTokens.Set { + e.FieldStart("total_tokens") + s.TotalTokens.Encode(e) + } + } +} + +var jsonFieldsNameOfTokenUsage = [3]string{ + 0: "input_tokens", + 1: "output_tokens", + 2: "total_tokens", +} + +// Decode decodes TokenUsage from json. +func (s *TokenUsage) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TokenUsage to nil") + } + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "input_tokens": + if err := func() error { + s.InputTokens.Reset() + if err := s.InputTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"input_tokens\"") + } + case "output_tokens": + if err := func() error { + s.OutputTokens.Reset() + if err := s.OutputTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"output_tokens\"") + } + case "total_tokens": + if err := func() error { + s.TotalTokens.Reset() + if err := s.TotalTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total_tokens\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode TokenUsage") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *TokenUsage) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TokenUsage) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ToolCallsIncludeOptions) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ToolCallsIncludeOptions) encodeFields(e *jx.Encoder) { + { + if s.Output.Set { + e.FieldStart("output") + s.Output.Encode(e) + } + } +} + +var jsonFieldsNameOfToolCallsIncludeOptions = [1]string{ + 0: "output", +} + +// Decode decodes ToolCallsIncludeOptions from json. +func (s *ToolCallsIncludeOptions) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ToolCallsIncludeOptions to nil") + } + s.setDefaults() + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "output": + if err := func() error { + s.Output.Reset() + if err := s.Output.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"output\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ToolCallsIncludeOptions") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ToolCallsIncludeOptions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ToolCallsIncludeOptions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UpdateDirectiveRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UpdateDirectiveRequest) encodeFields(e *jx.Encoder) { + { + if s.Content.Set { + e.FieldStart("content") + s.Content.Encode(e) + } + } + { + if s.IsActive.Set { + e.FieldStart("is_active") + s.IsActive.Encode(e) + } + } + { + if s.Name.Set { + e.FieldStart("name") + s.Name.Encode(e) + } + } + { + if s.Priority.Set { + e.FieldStart("priority") + s.Priority.Encode(e) + } + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfUpdateDirectiveRequest = [5]string{ + 0: "content", + 1: "is_active", + 2: "name", + 3: "priority", + 4: "tags", +} + +// Decode decodes UpdateDirectiveRequest from json. +func (s *UpdateDirectiveRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UpdateDirectiveRequest to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "content": + if err := func() error { + s.Content.Reset() + if err := s.Content.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"content\"") + } + case "is_active": + if err := func() error { + s.IsActive.Reset() + if err := s.IsActive.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"is_active\"") + } + case "name": + if err := func() error { + s.Name.Reset() + if err := s.Name.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "priority": + if err := func() error { + s.Priority.Reset() + if err := s.Priority.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"priority\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UpdateDirectiveRequest") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UpdateDirectiveRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UpdateDirectiveRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UpdateDispositionRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UpdateDispositionRequest) encodeFields(e *jx.Encoder) { + { + e.FieldStart("disposition") + s.Disposition.Encode(e) + } +} + +var jsonFieldsNameOfUpdateDispositionRequest = [1]string{ + 0: "disposition", +} + +// Decode decodes UpdateDispositionRequest from json. +func (s *UpdateDispositionRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UpdateDispositionRequest to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "disposition": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Disposition.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"disposition\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UpdateDispositionRequest") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfUpdateDispositionRequest) { + name = jsonFieldsNameOfUpdateDispositionRequest[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UpdateDispositionRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UpdateDispositionRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UpdateMentalModelRequest) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UpdateMentalModelRequest) encodeFields(e *jx.Encoder) { + { + if s.MaxTokens.Set { + e.FieldStart("max_tokens") + s.MaxTokens.Encode(e) + } + } + { + if s.Name.Set { + e.FieldStart("name") + s.Name.Encode(e) + } + } + { + if s.SourceQuery.Set { + e.FieldStart("source_query") + s.SourceQuery.Encode(e) + } + } + { + if s.Tags != nil { + e.FieldStart("tags") + e.ArrStart() + for _, elem := range s.Tags { + e.Str(elem) + } + e.ArrEnd() + } + } + { + if s.Trigger.Set { + e.FieldStart("trigger") + s.Trigger.Encode(e) + } + } +} + +var jsonFieldsNameOfUpdateMentalModelRequest = [5]string{ + 0: "max_tokens", + 1: "name", + 2: "source_query", + 3: "tags", + 4: "trigger", +} + +// Decode decodes UpdateMentalModelRequest from json. +func (s *UpdateMentalModelRequest) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UpdateMentalModelRequest to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "max_tokens": + if err := func() error { + s.MaxTokens.Reset() + if err := s.MaxTokens.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_tokens\"") + } + case "name": + if err := func() error { + s.Name.Reset() + if err := s.Name.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "source_query": + if err := func() error { + s.SourceQuery.Reset() + if err := s.SourceQuery.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"source_query\"") + } + case "tags": + if err := func() error { + s.Tags = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Tags = append(s.Tags, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tags\"") + } + case "trigger": + if err := func() error { + s.Trigger.Reset() + if err := s.Trigger.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"trigger\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UpdateMentalModelRequest") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UpdateMentalModelRequest) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UpdateMentalModelRequest) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ValidationError) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ValidationError) encodeFields(e *jx.Encoder) { + { + e.FieldStart("loc") + e.ArrStart() + for _, elem := range s.Loc { + e.Int(elem) + } + e.ArrEnd() + } + { + e.FieldStart("msg") + e.Str(s.Msg) + } + { + e.FieldStart("type") + e.Str(s.Type) + } +} + +var jsonFieldsNameOfValidationError = [3]string{ + 0: "loc", + 1: "msg", + 2: "type", +} + +// Decode decodes ValidationError from json. +func (s *ValidationError) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ValidationError to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "loc": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Loc = make([]int, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + s.Loc = append(s.Loc, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"loc\"") + } + case "msg": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Msg = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"msg\"") + } + case "type": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Type = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"type\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ValidationError") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfValidationError) { + name = jsonFieldsNameOfValidationError[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *ValidationError) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ValidationError) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *VersionResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *VersionResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("api_version") + e.Str(s.APIVersion) + } + { + e.FieldStart("features") + s.Features.Encode(e) + } +} + +var jsonFieldsNameOfVersionResponse = [2]string{ + 0: "api_version", + 1: "features", +} + +// Decode decodes VersionResponse from json. +func (s *VersionResponse) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode VersionResponse to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "api_version": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.APIVersion = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"api_version\"") + } + case "features": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Features.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"features\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode VersionResponse") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfVersionResponse) { + name = jsonFieldsNameOfVersionResponse[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *VersionResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *VersionResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} diff --git a/hindsight-clients/go/internal/ogenapi/oas_operations_gen.go b/hindsight-clients/go/internal/ogenapi/oas_operations_gen.go new file mode 100644 index 00000000..16cda15c --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_operations_gen.go @@ -0,0 +1,54 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +// OperationName is the ogen operation name +type OperationName = string + +const ( + AddBankBackgroundOperation OperationName = "AddBankBackground" + CancelOperationOperation OperationName = "CancelOperation" + ClearBankMemoriesOperation OperationName = "ClearBankMemories" + ClearObservationsOperation OperationName = "ClearObservations" + CreateDirectiveOperation OperationName = "CreateDirective" + CreateMentalModelOperation OperationName = "CreateMentalModel" + CreateOrUpdateBankOperation OperationName = "CreateOrUpdateBank" + DeleteBankOperation OperationName = "DeleteBank" + DeleteDirectiveOperation OperationName = "DeleteDirective" + DeleteDocumentOperation OperationName = "DeleteDocument" + DeleteMentalModelOperation OperationName = "DeleteMentalModel" + GetAgentStatsOperation OperationName = "GetAgentStats" + GetBankConfigOperation OperationName = "GetBankConfig" + GetBankProfileOperation OperationName = "GetBankProfile" + GetChunkOperation OperationName = "GetChunk" + GetDirectiveOperation OperationName = "GetDirective" + GetDocumentOperation OperationName = "GetDocument" + GetEntityOperation OperationName = "GetEntity" + GetGraphOperation OperationName = "GetGraph" + GetMemoryOperation OperationName = "GetMemory" + GetMentalModelOperation OperationName = "GetMentalModel" + GetOperationStatusOperation OperationName = "GetOperationStatus" + GetVersionOperation OperationName = "GetVersion" + HealthEndpointHealthGetOperation OperationName = "HealthEndpointHealthGet" + ListBanksOperation OperationName = "ListBanks" + ListDirectivesOperation OperationName = "ListDirectives" + ListDocumentsOperation OperationName = "ListDocuments" + ListEntitiesOperation OperationName = "ListEntities" + ListMemoriesOperation OperationName = "ListMemories" + ListMentalModelsOperation OperationName = "ListMentalModels" + ListOperationsOperation OperationName = "ListOperations" + ListTagsOperation OperationName = "ListTags" + MetricsEndpointMetricsGetOperation OperationName = "MetricsEndpointMetricsGet" + RecallMemoriesOperation OperationName = "RecallMemories" + ReflectOperation OperationName = "Reflect" + RefreshMentalModelOperation OperationName = "RefreshMentalModel" + RegenerateEntityObservationsOperation OperationName = "RegenerateEntityObservations" + ResetBankConfigOperation OperationName = "ResetBankConfig" + RetainMemoriesOperation OperationName = "RetainMemories" + TriggerConsolidationOperation OperationName = "TriggerConsolidation" + UpdateBankOperation OperationName = "UpdateBank" + UpdateBankConfigOperation OperationName = "UpdateBankConfig" + UpdateBankDispositionOperation OperationName = "UpdateBankDisposition" + UpdateDirectiveOperation OperationName = "UpdateDirective" + UpdateMentalModelOperation OperationName = "UpdateMentalModel" +) diff --git a/hindsight-clients/go/internal/ogenapi/oas_parameters_gen.go b/hindsight-clients/go/internal/ogenapi/oas_parameters_gen.go new file mode 100644 index 00000000..ac32bcee --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_parameters_gen.go @@ -0,0 +1,264 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +// AddBankBackgroundParams is parameters of add_bank_background operation. +type AddBankBackgroundParams struct { + BankID string +} + +// CancelOperationParams is parameters of cancel_operation operation. +type CancelOperationParams struct { + BankID string + OperationID string +} + +// ClearBankMemoriesParams is parameters of clear_bank_memories operation. +type ClearBankMemoriesParams struct { + BankID string + // Optional fact type filter (world, experience, opinion). + Type OptString `json:",omitempty,omitzero"` +} + +// ClearObservationsParams is parameters of clear_observations operation. +type ClearObservationsParams struct { + BankID string +} + +// CreateDirectiveParams is parameters of create_directive operation. +type CreateDirectiveParams struct { + BankID string +} + +// CreateMentalModelParams is parameters of create_mental_model operation. +type CreateMentalModelParams struct { + BankID string +} + +// CreateOrUpdateBankParams is parameters of create_or_update_bank operation. +type CreateOrUpdateBankParams struct { + BankID string +} + +// DeleteBankParams is parameters of delete_bank operation. +type DeleteBankParams struct { + BankID string +} + +// DeleteDirectiveParams is parameters of delete_directive operation. +type DeleteDirectiveParams struct { + BankID string + DirectiveID string +} + +// DeleteDocumentParams is parameters of delete_document operation. +type DeleteDocumentParams struct { + BankID string + DocumentID string +} + +// DeleteMentalModelParams is parameters of delete_mental_model operation. +type DeleteMentalModelParams struct { + BankID string + MentalModelID string +} + +// GetAgentStatsParams is parameters of get_agent_stats operation. +type GetAgentStatsParams struct { + BankID string +} + +// GetBankConfigParams is parameters of get_bank_config operation. +type GetBankConfigParams struct { + BankID string +} + +// GetBankProfileParams is parameters of get_bank_profile operation. +type GetBankProfileParams struct { + BankID string +} + +// GetChunkParams is parameters of get_chunk operation. +type GetChunkParams struct { + ChunkID string +} + +// GetDirectiveParams is parameters of get_directive operation. +type GetDirectiveParams struct { + BankID string + DirectiveID string +} + +// GetDocumentParams is parameters of get_document operation. +type GetDocumentParams struct { + BankID string + DocumentID string +} + +// GetEntityParams is parameters of get_entity operation. +type GetEntityParams struct { + BankID string + EntityID string +} + +// GetGraphParams is parameters of get_graph operation. +type GetGraphParams struct { + BankID string + Type OptString `json:",omitempty,omitzero"` + Limit OptInt `json:",omitempty,omitzero"` +} + +// GetMemoryParams is parameters of get_memory operation. +type GetMemoryParams struct { + BankID string + MemoryID string +} + +// GetMentalModelParams is parameters of get_mental_model operation. +type GetMentalModelParams struct { + BankID string + MentalModelID string +} + +// GetOperationStatusParams is parameters of get_operation_status operation. +type GetOperationStatusParams struct { + BankID string + OperationID string +} + +// ListDirectivesParams is parameters of list_directives operation. +type ListDirectivesParams struct { + BankID string + // Filter by tags. + Tags []string `json:",omitempty"` + // How to match tags. + TagsMatch OptListDirectivesTagsMatch `json:",omitempty,omitzero"` + // Only return active directives. + ActiveOnly OptBool `json:",omitempty,omitzero"` + Limit OptInt `json:",omitempty,omitzero"` + Offset OptInt `json:",omitempty,omitzero"` +} + +// ListDocumentsParams is parameters of list_documents operation. +type ListDocumentsParams struct { + BankID string + Q OptString `json:",omitempty,omitzero"` + Limit OptInt `json:",omitempty,omitzero"` + Offset OptInt `json:",omitempty,omitzero"` +} + +// ListEntitiesParams is parameters of list_entities operation. +type ListEntitiesParams struct { + BankID string + // Maximum number of entities to return. + Limit OptInt `json:",omitempty,omitzero"` + // Offset for pagination. + Offset OptInt `json:",omitempty,omitzero"` +} + +// ListMemoriesParams is parameters of list_memories operation. +type ListMemoriesParams struct { + BankID string + Type OptString `json:",omitempty,omitzero"` + Q OptString `json:",omitempty,omitzero"` + Limit OptInt `json:",omitempty,omitzero"` + Offset OptInt `json:",omitempty,omitzero"` +} + +// ListMentalModelsParams is parameters of list_mental_models operation. +type ListMentalModelsParams struct { + BankID string + // Filter by tags. + Tags []string `json:",omitempty"` + // How to match tags. + TagsMatch OptListMentalModelsTagsMatch `json:",omitempty,omitzero"` + Limit OptInt `json:",omitempty,omitzero"` + Offset OptInt `json:",omitempty,omitzero"` +} + +// ListOperationsParams is parameters of list_operations operation. +type ListOperationsParams struct { + BankID string + // Filter by status: pending, completed, or failed. + Status OptString `json:",omitempty,omitzero"` + // Maximum number of operations to return. + Limit OptInt `json:",omitempty,omitzero"` + // Number of operations to skip. + Offset OptInt `json:",omitempty,omitzero"` +} + +// ListTagsParams is parameters of list_tags operation. +type ListTagsParams struct { + BankID string + // Wildcard pattern to filter tags (e.g., 'user:*' for user:alice, '*-admin' for role-admin). Use '*' + // as wildcard. Case-insensitive. + Q OptString `json:",omitempty,omitzero"` + // Maximum number of tags to return. + Limit OptInt `json:",omitempty,omitzero"` + // Offset for pagination. + Offset OptInt `json:",omitempty,omitzero"` +} + +// RecallMemoriesParams is parameters of recall_memories operation. +type RecallMemoriesParams struct { + BankID string +} + +// ReflectParams is parameters of reflect operation. +type ReflectParams struct { + BankID string +} + +// RefreshMentalModelParams is parameters of refresh_mental_model operation. +type RefreshMentalModelParams struct { + BankID string + MentalModelID string +} + +// RegenerateEntityObservationsParams is parameters of regenerate_entity_observations operation. +type RegenerateEntityObservationsParams struct { + BankID string + EntityID string +} + +// ResetBankConfigParams is parameters of reset_bank_config operation. +type ResetBankConfigParams struct { + BankID string +} + +// RetainMemoriesParams is parameters of retain_memories operation. +type RetainMemoriesParams struct { + BankID string +} + +// TriggerConsolidationParams is parameters of trigger_consolidation operation. +type TriggerConsolidationParams struct { + BankID string +} + +// UpdateBankParams is parameters of update_bank operation. +type UpdateBankParams struct { + BankID string +} + +// UpdateBankConfigParams is parameters of update_bank_config operation. +type UpdateBankConfigParams struct { + BankID string +} + +// UpdateBankDispositionParams is parameters of update_bank_disposition operation. +type UpdateBankDispositionParams struct { + BankID string +} + +// UpdateDirectiveParams is parameters of update_directive operation. +type UpdateDirectiveParams struct { + BankID string + DirectiveID string +} + +// UpdateMentalModelParams is parameters of update_mental_model operation. +type UpdateMentalModelParams struct { + BankID string + MentalModelID string +} diff --git a/hindsight-clients/go/internal/ogenapi/oas_request_encoders_gen.go b/hindsight-clients/go/internal/ogenapi/oas_request_encoders_gen.go new file mode 100644 index 00000000..c7c9e755 --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_request_encoders_gen.go @@ -0,0 +1,179 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +import ( + "bytes" + "net/http" + + "github.com/go-faster/jx" + ht "github.com/ogen-go/ogen/http" +) + +func encodeAddBankBackgroundRequest( + req *AddBackgroundRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeCreateDirectiveRequest( + req *CreateDirectiveRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeCreateMentalModelRequest( + req *CreateMentalModelRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeCreateOrUpdateBankRequest( + req *CreateBankRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeRecallMemoriesRequest( + req *RecallRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeReflectRequest( + req *ReflectRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeRetainMemoriesRequest( + req *RetainRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeUpdateBankRequest( + req *CreateBankRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeUpdateBankConfigRequest( + req *BankConfigUpdate, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeUpdateBankDispositionRequest( + req *UpdateDispositionRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeUpdateDirectiveRequest( + req *UpdateDirectiveRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeUpdateMentalModelRequest( + req *UpdateMentalModelRequest, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} diff --git a/hindsight-clients/go/internal/ogenapi/oas_response_decoders_gen.go b/hindsight-clients/go/internal/ogenapi/oas_response_decoders_gen.go new file mode 100644 index 00000000..cd441acb --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_response_decoders_gen.go @@ -0,0 +1,3873 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +import ( + "io" + "mime" + "net/http" + + "github.com/go-faster/errors" + "github.com/go-faster/jx" + "github.com/ogen-go/ogen/ogenerrors" + "github.com/ogen-go/ogen/validate" +) + +func decodeAddBankBackgroundResponse(resp *http.Response) (res AddBankBackgroundRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BackgroundResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeCancelOperationResponse(resp *http.Response) (res CancelOperationRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response CancelOperationResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeClearBankMemoriesResponse(resp *http.Response) (res ClearBankMemoriesRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DeleteResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeClearObservationsResponse(resp *http.Response) (res ClearObservationsRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DeleteResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeCreateDirectiveResponse(resp *http.Response) (res CreateDirectiveRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DirectiveResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeCreateMentalModelResponse(resp *http.Response) (res CreateMentalModelRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response CreateMentalModelResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeCreateOrUpdateBankResponse(resp *http.Response) (res CreateOrUpdateBankRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BankProfileResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeDeleteBankResponse(resp *http.Response) (res DeleteBankRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DeleteResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeDeleteDirectiveResponse(resp *http.Response) (res DeleteDirectiveRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DeleteDirectiveOKApplicationJSON + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeDeleteDocumentResponse(resp *http.Response) (res DeleteDocumentRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DeleteDocumentResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeDeleteMentalModelResponse(resp *http.Response) (res DeleteMentalModelRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DeleteMentalModelOKApplicationJSON + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetAgentStatsResponse(resp *http.Response) (res GetAgentStatsRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BankStatsResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetBankConfigResponse(resp *http.Response) (res GetBankConfigRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BankConfigResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetBankProfileResponse(resp *http.Response) (res GetBankProfileRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BankProfileResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetChunkResponse(resp *http.Response) (res GetChunkRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ChunkResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetDirectiveResponse(resp *http.Response) (res GetDirectiveRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DirectiveResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetDocumentResponse(resp *http.Response) (res GetDocumentRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DocumentResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetEntityResponse(resp *http.Response) (res GetEntityRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response EntityDetailResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetGraphResponse(resp *http.Response) (res GetGraphRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response GraphDataResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetMemoryResponse(resp *http.Response) (res GetMemoryRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response GetMemoryOKApplicationJSON + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetMentalModelResponse(resp *http.Response) (res GetMentalModelRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response MentalModelResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetOperationStatusResponse(resp *http.Response) (res GetOperationStatusRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response OperationStatusResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeGetVersionResponse(resp *http.Response) (res *VersionResponse, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response VersionResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeHealthEndpointHealthGetResponse(resp *http.Response) (res jx.Raw, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + response = jx.Raw(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeListBanksResponse(resp *http.Response) (res ListBanksRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BankListResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeListDirectivesResponse(resp *http.Response) (res ListDirectivesRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DirectiveListResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeListDocumentsResponse(resp *http.Response) (res ListDocumentsRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ListDocumentsResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeListEntitiesResponse(resp *http.Response) (res ListEntitiesRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response EntityListResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeListMemoriesResponse(resp *http.Response) (res ListMemoriesRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ListMemoryUnitsResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeListMentalModelsResponse(resp *http.Response) (res ListMentalModelsRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response MentalModelListResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeListOperationsResponse(resp *http.Response) (res ListOperationsRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response OperationsListResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeListTagsResponse(resp *http.Response) (res ListTagsRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ListTagsResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeMetricsEndpointMetricsGetResponse(resp *http.Response) (res jx.Raw, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + response = jx.Raw(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeRecallMemoriesResponse(resp *http.Response) (res RecallMemoriesRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response RecallResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeReflectResponse(resp *http.Response) (res ReflectRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ReflectResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeRefreshMentalModelResponse(resp *http.Response) (res RefreshMentalModelRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response AsyncOperationSubmitResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeRegenerateEntityObservationsResponse(resp *http.Response) (res RegenerateEntityObservationsRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response EntityDetailResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeResetBankConfigResponse(resp *http.Response) (res ResetBankConfigRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BankConfigResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeRetainMemoriesResponse(resp *http.Response) (res RetainMemoriesRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response RetainResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeTriggerConsolidationResponse(resp *http.Response) (res TriggerConsolidationRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ConsolidationResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeUpdateBankResponse(resp *http.Response) (res UpdateBankRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BankProfileResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeUpdateBankConfigResponse(resp *http.Response) (res UpdateBankConfigRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BankConfigResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeUpdateBankDispositionResponse(resp *http.Response) (res UpdateBankDispositionRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response BankProfileResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeUpdateDirectiveResponse(resp *http.Response) (res UpdateDirectiveRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response DirectiveResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} + +func decodeUpdateMentalModelResponse(resp *http.Response) (res UpdateMentalModelRes, _ error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response MentalModelResponse + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 422: + // Code 422. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response HTTPValidationError + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCodeWithResponse(resp) +} diff --git a/hindsight-clients/go/internal/ogenapi/oas_schemas_gen.go b/hindsight-clients/go/internal/ogenapi/oas_schemas_gen.go new file mode 100644 index 00000000..1ab1f97c --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_schemas_gen.go @@ -0,0 +1,5666 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +import ( + "time" + + "github.com/go-faster/errors" + "github.com/go-faster/jx" +) + +// Request model for adding/merging background information. Deprecated: use SetMissionRequest instead. +// Ref: #/components/schemas/AddBackgroundRequest +type AddBackgroundRequest struct { + // New background information to add or merge. + Content string `json:"content"` + // Deprecated - disposition is no longer auto-inferred from mission. + UpdateDisposition OptBool `json:"update_disposition"` +} + +// GetContent returns the value of Content. +func (s *AddBackgroundRequest) GetContent() string { + return s.Content +} + +// GetUpdateDisposition returns the value of UpdateDisposition. +func (s *AddBackgroundRequest) GetUpdateDisposition() OptBool { + return s.UpdateDisposition +} + +// SetContent sets the value of Content. +func (s *AddBackgroundRequest) SetContent(val string) { + s.Content = val +} + +// SetUpdateDisposition sets the value of UpdateDisposition. +func (s *AddBackgroundRequest) SetUpdateDisposition(val OptBool) { + s.UpdateDisposition = val +} + +// Response model for submitting an async operation. +// Ref: #/components/schemas/AsyncOperationSubmitResponse +type AsyncOperationSubmitResponse struct { + OperationID string `json:"operation_id"` + Status string `json:"status"` +} + +// GetOperationID returns the value of OperationID. +func (s *AsyncOperationSubmitResponse) GetOperationID() string { + return s.OperationID +} + +// GetStatus returns the value of Status. +func (s *AsyncOperationSubmitResponse) GetStatus() string { + return s.Status +} + +// SetOperationID sets the value of OperationID. +func (s *AsyncOperationSubmitResponse) SetOperationID(val string) { + s.OperationID = val +} + +// SetStatus sets the value of Status. +func (s *AsyncOperationSubmitResponse) SetStatus(val string) { + s.Status = val +} + +func (*AsyncOperationSubmitResponse) refreshMentalModelRes() {} + +// Response model for background update. Deprecated: use MissionResponse instead. +// Ref: #/components/schemas/BackgroundResponse +type BackgroundResponse struct { + // Deprecated: same as mission. + Background OptString `json:"background"` + Disposition OptDispositionTraits `json:"disposition"` + Mission string `json:"mission"` +} + +// GetBackground returns the value of Background. +func (s *BackgroundResponse) GetBackground() OptString { + return s.Background +} + +// GetDisposition returns the value of Disposition. +func (s *BackgroundResponse) GetDisposition() OptDispositionTraits { + return s.Disposition +} + +// GetMission returns the value of Mission. +func (s *BackgroundResponse) GetMission() string { + return s.Mission +} + +// SetBackground sets the value of Background. +func (s *BackgroundResponse) SetBackground(val OptString) { + s.Background = val +} + +// SetDisposition sets the value of Disposition. +func (s *BackgroundResponse) SetDisposition(val OptDispositionTraits) { + s.Disposition = val +} + +// SetMission sets the value of Mission. +func (s *BackgroundResponse) SetMission(val string) { + s.Mission = val +} + +func (*BackgroundResponse) addBankBackgroundRes() {} + +// Response model for bank configuration. +// Ref: #/components/schemas/BankConfigResponse +type BankConfigResponse struct { + // Bank identifier. + BankID string `json:"bank_id"` + // Fully resolved configuration with all hierarchical overrides applied (Python field names). + Config BankConfigResponseConfig `json:"config"` + // Bank-specific configuration overrides only (Python field names). + Overrides BankConfigResponseOverrides `json:"overrides"` +} + +// GetBankID returns the value of BankID. +func (s *BankConfigResponse) GetBankID() string { + return s.BankID +} + +// GetConfig returns the value of Config. +func (s *BankConfigResponse) GetConfig() BankConfigResponseConfig { + return s.Config +} + +// GetOverrides returns the value of Overrides. +func (s *BankConfigResponse) GetOverrides() BankConfigResponseOverrides { + return s.Overrides +} + +// SetBankID sets the value of BankID. +func (s *BankConfigResponse) SetBankID(val string) { + s.BankID = val +} + +// SetConfig sets the value of Config. +func (s *BankConfigResponse) SetConfig(val BankConfigResponseConfig) { + s.Config = val +} + +// SetOverrides sets the value of Overrides. +func (s *BankConfigResponse) SetOverrides(val BankConfigResponseOverrides) { + s.Overrides = val +} + +func (*BankConfigResponse) getBankConfigRes() {} +func (*BankConfigResponse) resetBankConfigRes() {} +func (*BankConfigResponse) updateBankConfigRes() {} + +// Fully resolved configuration with all hierarchical overrides applied (Python field names). +type BankConfigResponseConfig map[string]jx.Raw + +func (s *BankConfigResponseConfig) init() BankConfigResponseConfig { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Bank-specific configuration overrides only (Python field names). +type BankConfigResponseOverrides map[string]jx.Raw + +func (s *BankConfigResponseOverrides) init() BankConfigResponseOverrides { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Request model for updating bank configuration. +// Ref: #/components/schemas/BankConfigUpdate +type BankConfigUpdate struct { + // Configuration overrides. Keys can be in Python field format (llm_provider) or environment variable + // format (HINDSIGHT_API_LLM_PROVIDER). Only hierarchical fields can be overridden per-bank. + Updates BankConfigUpdateUpdates `json:"updates"` +} + +// GetUpdates returns the value of Updates. +func (s *BankConfigUpdate) GetUpdates() BankConfigUpdateUpdates { + return s.Updates +} + +// SetUpdates sets the value of Updates. +func (s *BankConfigUpdate) SetUpdates(val BankConfigUpdateUpdates) { + s.Updates = val +} + +// Configuration overrides. Keys can be in Python field format (llm_provider) or environment variable +// format (HINDSIGHT_API_LLM_PROVIDER). Only hierarchical fields can be overridden per-bank. +type BankConfigUpdateUpdates map[string]jx.Raw + +func (s *BankConfigUpdateUpdates) init() BankConfigUpdateUpdates { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Bank list item with profile summary. +// Ref: #/components/schemas/BankListItem +type BankListItem struct { + BankID string `json:"bank_id"` + CreatedAt OptString `json:"created_at"` + Disposition DispositionTraits `json:"disposition"` + Mission OptString `json:"mission"` + Name OptString `json:"name"` + UpdatedAt OptString `json:"updated_at"` +} + +// GetBankID returns the value of BankID. +func (s *BankListItem) GetBankID() string { + return s.BankID +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *BankListItem) GetCreatedAt() OptString { + return s.CreatedAt +} + +// GetDisposition returns the value of Disposition. +func (s *BankListItem) GetDisposition() DispositionTraits { + return s.Disposition +} + +// GetMission returns the value of Mission. +func (s *BankListItem) GetMission() OptString { + return s.Mission +} + +// GetName returns the value of Name. +func (s *BankListItem) GetName() OptString { + return s.Name +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *BankListItem) GetUpdatedAt() OptString { + return s.UpdatedAt +} + +// SetBankID sets the value of BankID. +func (s *BankListItem) SetBankID(val string) { + s.BankID = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *BankListItem) SetCreatedAt(val OptString) { + s.CreatedAt = val +} + +// SetDisposition sets the value of Disposition. +func (s *BankListItem) SetDisposition(val DispositionTraits) { + s.Disposition = val +} + +// SetMission sets the value of Mission. +func (s *BankListItem) SetMission(val OptString) { + s.Mission = val +} + +// SetName sets the value of Name. +func (s *BankListItem) SetName(val OptString) { + s.Name = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *BankListItem) SetUpdatedAt(val OptString) { + s.UpdatedAt = val +} + +// Response model for listing all banks. +// Ref: #/components/schemas/BankListResponse +type BankListResponse struct { + Banks []BankListItem `json:"banks"` +} + +// GetBanks returns the value of Banks. +func (s *BankListResponse) GetBanks() []BankListItem { + return s.Banks +} + +// SetBanks sets the value of Banks. +func (s *BankListResponse) SetBanks(val []BankListItem) { + s.Banks = val +} + +func (*BankListResponse) listBanksRes() {} + +// Response model for bank profile. +// Ref: #/components/schemas/BankProfileResponse +type BankProfileResponse struct { + // Deprecated: use mission instead. + Background OptString `json:"background"` + BankID string `json:"bank_id"` + Disposition DispositionTraits `json:"disposition"` + // The agent's mission - who they are and what they're trying to accomplish. + Mission string `json:"mission"` + Name string `json:"name"` +} + +// GetBackground returns the value of Background. +func (s *BankProfileResponse) GetBackground() OptString { + return s.Background +} + +// GetBankID returns the value of BankID. +func (s *BankProfileResponse) GetBankID() string { + return s.BankID +} + +// GetDisposition returns the value of Disposition. +func (s *BankProfileResponse) GetDisposition() DispositionTraits { + return s.Disposition +} + +// GetMission returns the value of Mission. +func (s *BankProfileResponse) GetMission() string { + return s.Mission +} + +// GetName returns the value of Name. +func (s *BankProfileResponse) GetName() string { + return s.Name +} + +// SetBackground sets the value of Background. +func (s *BankProfileResponse) SetBackground(val OptString) { + s.Background = val +} + +// SetBankID sets the value of BankID. +func (s *BankProfileResponse) SetBankID(val string) { + s.BankID = val +} + +// SetDisposition sets the value of Disposition. +func (s *BankProfileResponse) SetDisposition(val DispositionTraits) { + s.Disposition = val +} + +// SetMission sets the value of Mission. +func (s *BankProfileResponse) SetMission(val string) { + s.Mission = val +} + +// SetName sets the value of Name. +func (s *BankProfileResponse) SetName(val string) { + s.Name = val +} + +func (*BankProfileResponse) createOrUpdateBankRes() {} +func (*BankProfileResponse) getBankProfileRes() {} +func (*BankProfileResponse) updateBankDispositionRes() {} +func (*BankProfileResponse) updateBankRes() {} + +// Response model for bank statistics endpoint. +// Ref: #/components/schemas/BankStatsResponse +type BankStatsResponse struct { + BankID string `json:"bank_id"` + FailedOperations int `json:"failed_operations"` + // When consolidation last ran (ISO format). + LastConsolidatedAt OptString `json:"last_consolidated_at"` + LinksBreakdown BankStatsResponseLinksBreakdown `json:"links_breakdown"` + LinksByFactType BankStatsResponseLinksByFactType `json:"links_by_fact_type"` + LinksByLinkType BankStatsResponseLinksByLinkType `json:"links_by_link_type"` + NodesByFactType BankStatsResponseNodesByFactType `json:"nodes_by_fact_type"` + // Number of memories not yet processed into observations. + PendingConsolidation OptInt `json:"pending_consolidation"` + PendingOperations int `json:"pending_operations"` + TotalDocuments int `json:"total_documents"` + TotalLinks int `json:"total_links"` + TotalNodes int `json:"total_nodes"` + // Total number of observations. + TotalObservations OptInt `json:"total_observations"` +} + +// GetBankID returns the value of BankID. +func (s *BankStatsResponse) GetBankID() string { + return s.BankID +} + +// GetFailedOperations returns the value of FailedOperations. +func (s *BankStatsResponse) GetFailedOperations() int { + return s.FailedOperations +} + +// GetLastConsolidatedAt returns the value of LastConsolidatedAt. +func (s *BankStatsResponse) GetLastConsolidatedAt() OptString { + return s.LastConsolidatedAt +} + +// GetLinksBreakdown returns the value of LinksBreakdown. +func (s *BankStatsResponse) GetLinksBreakdown() BankStatsResponseLinksBreakdown { + return s.LinksBreakdown +} + +// GetLinksByFactType returns the value of LinksByFactType. +func (s *BankStatsResponse) GetLinksByFactType() BankStatsResponseLinksByFactType { + return s.LinksByFactType +} + +// GetLinksByLinkType returns the value of LinksByLinkType. +func (s *BankStatsResponse) GetLinksByLinkType() BankStatsResponseLinksByLinkType { + return s.LinksByLinkType +} + +// GetNodesByFactType returns the value of NodesByFactType. +func (s *BankStatsResponse) GetNodesByFactType() BankStatsResponseNodesByFactType { + return s.NodesByFactType +} + +// GetPendingConsolidation returns the value of PendingConsolidation. +func (s *BankStatsResponse) GetPendingConsolidation() OptInt { + return s.PendingConsolidation +} + +// GetPendingOperations returns the value of PendingOperations. +func (s *BankStatsResponse) GetPendingOperations() int { + return s.PendingOperations +} + +// GetTotalDocuments returns the value of TotalDocuments. +func (s *BankStatsResponse) GetTotalDocuments() int { + return s.TotalDocuments +} + +// GetTotalLinks returns the value of TotalLinks. +func (s *BankStatsResponse) GetTotalLinks() int { + return s.TotalLinks +} + +// GetTotalNodes returns the value of TotalNodes. +func (s *BankStatsResponse) GetTotalNodes() int { + return s.TotalNodes +} + +// GetTotalObservations returns the value of TotalObservations. +func (s *BankStatsResponse) GetTotalObservations() OptInt { + return s.TotalObservations +} + +// SetBankID sets the value of BankID. +func (s *BankStatsResponse) SetBankID(val string) { + s.BankID = val +} + +// SetFailedOperations sets the value of FailedOperations. +func (s *BankStatsResponse) SetFailedOperations(val int) { + s.FailedOperations = val +} + +// SetLastConsolidatedAt sets the value of LastConsolidatedAt. +func (s *BankStatsResponse) SetLastConsolidatedAt(val OptString) { + s.LastConsolidatedAt = val +} + +// SetLinksBreakdown sets the value of LinksBreakdown. +func (s *BankStatsResponse) SetLinksBreakdown(val BankStatsResponseLinksBreakdown) { + s.LinksBreakdown = val +} + +// SetLinksByFactType sets the value of LinksByFactType. +func (s *BankStatsResponse) SetLinksByFactType(val BankStatsResponseLinksByFactType) { + s.LinksByFactType = val +} + +// SetLinksByLinkType sets the value of LinksByLinkType. +func (s *BankStatsResponse) SetLinksByLinkType(val BankStatsResponseLinksByLinkType) { + s.LinksByLinkType = val +} + +// SetNodesByFactType sets the value of NodesByFactType. +func (s *BankStatsResponse) SetNodesByFactType(val BankStatsResponseNodesByFactType) { + s.NodesByFactType = val +} + +// SetPendingConsolidation sets the value of PendingConsolidation. +func (s *BankStatsResponse) SetPendingConsolidation(val OptInt) { + s.PendingConsolidation = val +} + +// SetPendingOperations sets the value of PendingOperations. +func (s *BankStatsResponse) SetPendingOperations(val int) { + s.PendingOperations = val +} + +// SetTotalDocuments sets the value of TotalDocuments. +func (s *BankStatsResponse) SetTotalDocuments(val int) { + s.TotalDocuments = val +} + +// SetTotalLinks sets the value of TotalLinks. +func (s *BankStatsResponse) SetTotalLinks(val int) { + s.TotalLinks = val +} + +// SetTotalNodes sets the value of TotalNodes. +func (s *BankStatsResponse) SetTotalNodes(val int) { + s.TotalNodes = val +} + +// SetTotalObservations sets the value of TotalObservations. +func (s *BankStatsResponse) SetTotalObservations(val OptInt) { + s.TotalObservations = val +} + +func (*BankStatsResponse) getAgentStatsRes() {} + +type BankStatsResponseLinksBreakdown map[string]BankStatsResponseLinksBreakdownItem + +func (s *BankStatsResponseLinksBreakdown) init() BankStatsResponseLinksBreakdown { + m := *s + if m == nil { + m = map[string]BankStatsResponseLinksBreakdownItem{} + *s = m + } + return m +} + +type BankStatsResponseLinksBreakdownItem map[string]int + +func (s *BankStatsResponseLinksBreakdownItem) init() BankStatsResponseLinksBreakdownItem { + m := *s + if m == nil { + m = map[string]int{} + *s = m + } + return m +} + +type BankStatsResponseLinksByFactType map[string]int + +func (s *BankStatsResponseLinksByFactType) init() BankStatsResponseLinksByFactType { + m := *s + if m == nil { + m = map[string]int{} + *s = m + } + return m +} + +type BankStatsResponseLinksByLinkType map[string]int + +func (s *BankStatsResponseLinksByLinkType) init() BankStatsResponseLinksByLinkType { + m := *s + if m == nil { + m = map[string]int{} + *s = m + } + return m +} + +type BankStatsResponseNodesByFactType map[string]int + +func (s *BankStatsResponseNodesByFactType) init() BankStatsResponseNodesByFactType { + m := *s + if m == nil { + m = map[string]int{} + *s = m + } + return m +} + +// Budget levels for recall/reflect operations. +// Ref: #/components/schemas/Budget +type Budget string + +const ( + BudgetLow Budget = "low" + BudgetMid Budget = "mid" + BudgetHigh Budget = "high" +) + +// AllValues returns all Budget values. +func (Budget) AllValues() []Budget { + return []Budget{ + BudgetLow, + BudgetMid, + BudgetHigh, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s Budget) MarshalText() ([]byte, error) { + switch s { + case BudgetLow: + return []byte(s), nil + case BudgetMid: + return []byte(s), nil + case BudgetHigh: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *Budget) UnmarshalText(data []byte) error { + switch Budget(data) { + case BudgetLow: + *s = BudgetLow + return nil + case BudgetMid: + *s = BudgetMid + return nil + case BudgetHigh: + *s = BudgetHigh + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +// Response model for cancel operation endpoint. +// Ref: #/components/schemas/CancelOperationResponse +type CancelOperationResponse struct { + Message string `json:"message"` + OperationID string `json:"operation_id"` + Success bool `json:"success"` +} + +// GetMessage returns the value of Message. +func (s *CancelOperationResponse) GetMessage() string { + return s.Message +} + +// GetOperationID returns the value of OperationID. +func (s *CancelOperationResponse) GetOperationID() string { + return s.OperationID +} + +// GetSuccess returns the value of Success. +func (s *CancelOperationResponse) GetSuccess() bool { + return s.Success +} + +// SetMessage sets the value of Message. +func (s *CancelOperationResponse) SetMessage(val string) { + s.Message = val +} + +// SetOperationID sets the value of OperationID. +func (s *CancelOperationResponse) SetOperationID(val string) { + s.OperationID = val +} + +// SetSuccess sets the value of Success. +func (s *CancelOperationResponse) SetSuccess(val bool) { + s.Success = val +} + +func (*CancelOperationResponse) cancelOperationRes() {} + +// Chunk data for a single chunk. +// Ref: #/components/schemas/ChunkData +type ChunkData struct { + ChunkIndex int `json:"chunk_index"` + ID string `json:"id"` + Text string `json:"text"` + // Whether the chunk text was truncated due to token limits. + Truncated OptBool `json:"truncated"` +} + +// GetChunkIndex returns the value of ChunkIndex. +func (s *ChunkData) GetChunkIndex() int { + return s.ChunkIndex +} + +// GetID returns the value of ID. +func (s *ChunkData) GetID() string { + return s.ID +} + +// GetText returns the value of Text. +func (s *ChunkData) GetText() string { + return s.Text +} + +// GetTruncated returns the value of Truncated. +func (s *ChunkData) GetTruncated() OptBool { + return s.Truncated +} + +// SetChunkIndex sets the value of ChunkIndex. +func (s *ChunkData) SetChunkIndex(val int) { + s.ChunkIndex = val +} + +// SetID sets the value of ID. +func (s *ChunkData) SetID(val string) { + s.ID = val +} + +// SetText sets the value of Text. +func (s *ChunkData) SetText(val string) { + s.Text = val +} + +// SetTruncated sets the value of Truncated. +func (s *ChunkData) SetTruncated(val OptBool) { + s.Truncated = val +} + +// Options for including chunks in recall results. +// Ref: #/components/schemas/ChunkIncludeOptions +type ChunkIncludeOptions struct { + // Maximum tokens for chunks (chunks may be truncated). + MaxTokens OptInt `json:"max_tokens"` +} + +// GetMaxTokens returns the value of MaxTokens. +func (s *ChunkIncludeOptions) GetMaxTokens() OptInt { + return s.MaxTokens +} + +// SetMaxTokens sets the value of MaxTokens. +func (s *ChunkIncludeOptions) SetMaxTokens(val OptInt) { + s.MaxTokens = val +} + +// Response model for get chunk endpoint. +// Ref: #/components/schemas/ChunkResponse +type ChunkResponse struct { + BankID string `json:"bank_id"` + ChunkID string `json:"chunk_id"` + ChunkIndex int `json:"chunk_index"` + ChunkText string `json:"chunk_text"` + CreatedAt string `json:"created_at"` + DocumentID string `json:"document_id"` +} + +// GetBankID returns the value of BankID. +func (s *ChunkResponse) GetBankID() string { + return s.BankID +} + +// GetChunkID returns the value of ChunkID. +func (s *ChunkResponse) GetChunkID() string { + return s.ChunkID +} + +// GetChunkIndex returns the value of ChunkIndex. +func (s *ChunkResponse) GetChunkIndex() int { + return s.ChunkIndex +} + +// GetChunkText returns the value of ChunkText. +func (s *ChunkResponse) GetChunkText() string { + return s.ChunkText +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *ChunkResponse) GetCreatedAt() string { + return s.CreatedAt +} + +// GetDocumentID returns the value of DocumentID. +func (s *ChunkResponse) GetDocumentID() string { + return s.DocumentID +} + +// SetBankID sets the value of BankID. +func (s *ChunkResponse) SetBankID(val string) { + s.BankID = val +} + +// SetChunkID sets the value of ChunkID. +func (s *ChunkResponse) SetChunkID(val string) { + s.ChunkID = val +} + +// SetChunkIndex sets the value of ChunkIndex. +func (s *ChunkResponse) SetChunkIndex(val int) { + s.ChunkIndex = val +} + +// SetChunkText sets the value of ChunkText. +func (s *ChunkResponse) SetChunkText(val string) { + s.ChunkText = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *ChunkResponse) SetCreatedAt(val string) { + s.CreatedAt = val +} + +// SetDocumentID sets the value of DocumentID. +func (s *ChunkResponse) SetDocumentID(val string) { + s.DocumentID = val +} + +func (*ChunkResponse) getChunkRes() {} + +// Response model for consolidation trigger endpoint. +// Ref: #/components/schemas/ConsolidationResponse +type ConsolidationResponse struct { + // True if an existing pending task was reused. + Deduplicated OptBool `json:"deduplicated"` + // ID of the async consolidation operation. + OperationID string `json:"operation_id"` +} + +// GetDeduplicated returns the value of Deduplicated. +func (s *ConsolidationResponse) GetDeduplicated() OptBool { + return s.Deduplicated +} + +// GetOperationID returns the value of OperationID. +func (s *ConsolidationResponse) GetOperationID() string { + return s.OperationID +} + +// SetDeduplicated sets the value of Deduplicated. +func (s *ConsolidationResponse) SetDeduplicated(val OptBool) { + s.Deduplicated = val +} + +// SetOperationID sets the value of OperationID. +func (s *ConsolidationResponse) SetOperationID(val string) { + s.OperationID = val +} + +func (*ConsolidationResponse) triggerConsolidationRes() {} + +// Request model for creating/updating a bank. +// Ref: #/components/schemas/CreateBankRequest +type CreateBankRequest struct { + // Deprecated: use mission instead. + Background OptString `json:"background"` + Disposition OptDispositionTraits `json:"disposition"` + // The agent's mission. + Mission OptString `json:"mission"` + Name OptString `json:"name"` +} + +// GetBackground returns the value of Background. +func (s *CreateBankRequest) GetBackground() OptString { + return s.Background +} + +// GetDisposition returns the value of Disposition. +func (s *CreateBankRequest) GetDisposition() OptDispositionTraits { + return s.Disposition +} + +// GetMission returns the value of Mission. +func (s *CreateBankRequest) GetMission() OptString { + return s.Mission +} + +// GetName returns the value of Name. +func (s *CreateBankRequest) GetName() OptString { + return s.Name +} + +// SetBackground sets the value of Background. +func (s *CreateBankRequest) SetBackground(val OptString) { + s.Background = val +} + +// SetDisposition sets the value of Disposition. +func (s *CreateBankRequest) SetDisposition(val OptDispositionTraits) { + s.Disposition = val +} + +// SetMission sets the value of Mission. +func (s *CreateBankRequest) SetMission(val OptString) { + s.Mission = val +} + +// SetName sets the value of Name. +func (s *CreateBankRequest) SetName(val OptString) { + s.Name = val +} + +// Request model for creating a directive. +// Ref: #/components/schemas/CreateDirectiveRequest +type CreateDirectiveRequest struct { + // The directive text to inject into prompts. + Content string `json:"content"` + // Whether this directive is active. + IsActive OptBool `json:"is_active"` + // Human-readable name for the directive. + Name string `json:"name"` + // Higher priority directives are injected first. + Priority OptInt `json:"priority"` + // Tags for filtering. + Tags []string `json:"tags"` +} + +// GetContent returns the value of Content. +func (s *CreateDirectiveRequest) GetContent() string { + return s.Content +} + +// GetIsActive returns the value of IsActive. +func (s *CreateDirectiveRequest) GetIsActive() OptBool { + return s.IsActive +} + +// GetName returns the value of Name. +func (s *CreateDirectiveRequest) GetName() string { + return s.Name +} + +// GetPriority returns the value of Priority. +func (s *CreateDirectiveRequest) GetPriority() OptInt { + return s.Priority +} + +// GetTags returns the value of Tags. +func (s *CreateDirectiveRequest) GetTags() []string { + return s.Tags +} + +// SetContent sets the value of Content. +func (s *CreateDirectiveRequest) SetContent(val string) { + s.Content = val +} + +// SetIsActive sets the value of IsActive. +func (s *CreateDirectiveRequest) SetIsActive(val OptBool) { + s.IsActive = val +} + +// SetName sets the value of Name. +func (s *CreateDirectiveRequest) SetName(val string) { + s.Name = val +} + +// SetPriority sets the value of Priority. +func (s *CreateDirectiveRequest) SetPriority(val OptInt) { + s.Priority = val +} + +// SetTags sets the value of Tags. +func (s *CreateDirectiveRequest) SetTags(val []string) { + s.Tags = val +} + +// Request model for creating a mental model. +// Ref: #/components/schemas/CreateMentalModelRequest +type CreateMentalModelRequest struct { + // Optional custom ID for the mental model (alphanumeric lowercase with hyphens). + ID OptString `json:"id"` + // Maximum tokens for generated content. + MaxTokens OptInt `json:"max_tokens"` + // Human-readable name for the mental model. + Name string `json:"name"` + // The query to run to generate content. + SourceQuery string `json:"source_query"` + // Tags for scoped visibility. + Tags []string `json:"tags"` + // Trigger settings. + Trigger OptMentalModelTrigger `json:"trigger"` +} + +// GetID returns the value of ID. +func (s *CreateMentalModelRequest) GetID() OptString { + return s.ID +} + +// GetMaxTokens returns the value of MaxTokens. +func (s *CreateMentalModelRequest) GetMaxTokens() OptInt { + return s.MaxTokens +} + +// GetName returns the value of Name. +func (s *CreateMentalModelRequest) GetName() string { + return s.Name +} + +// GetSourceQuery returns the value of SourceQuery. +func (s *CreateMentalModelRequest) GetSourceQuery() string { + return s.SourceQuery +} + +// GetTags returns the value of Tags. +func (s *CreateMentalModelRequest) GetTags() []string { + return s.Tags +} + +// GetTrigger returns the value of Trigger. +func (s *CreateMentalModelRequest) GetTrigger() OptMentalModelTrigger { + return s.Trigger +} + +// SetID sets the value of ID. +func (s *CreateMentalModelRequest) SetID(val OptString) { + s.ID = val +} + +// SetMaxTokens sets the value of MaxTokens. +func (s *CreateMentalModelRequest) SetMaxTokens(val OptInt) { + s.MaxTokens = val +} + +// SetName sets the value of Name. +func (s *CreateMentalModelRequest) SetName(val string) { + s.Name = val +} + +// SetSourceQuery sets the value of SourceQuery. +func (s *CreateMentalModelRequest) SetSourceQuery(val string) { + s.SourceQuery = val +} + +// SetTags sets the value of Tags. +func (s *CreateMentalModelRequest) SetTags(val []string) { + s.Tags = val +} + +// SetTrigger sets the value of Trigger. +func (s *CreateMentalModelRequest) SetTrigger(val OptMentalModelTrigger) { + s.Trigger = val +} + +// Response model for mental model creation. +// Ref: #/components/schemas/CreateMentalModelResponse +type CreateMentalModelResponse struct { + // ID of the created mental model. + MentalModelID OptString `json:"mental_model_id"` + // Operation ID to track refresh progress. + OperationID string `json:"operation_id"` +} + +// GetMentalModelID returns the value of MentalModelID. +func (s *CreateMentalModelResponse) GetMentalModelID() OptString { + return s.MentalModelID +} + +// GetOperationID returns the value of OperationID. +func (s *CreateMentalModelResponse) GetOperationID() string { + return s.OperationID +} + +// SetMentalModelID sets the value of MentalModelID. +func (s *CreateMentalModelResponse) SetMentalModelID(val OptString) { + s.MentalModelID = val +} + +// SetOperationID sets the value of OperationID. +func (s *CreateMentalModelResponse) SetOperationID(val string) { + s.OperationID = val +} + +func (*CreateMentalModelResponse) createMentalModelRes() {} + +type DeleteDirectiveOKApplicationJSON jx.Raw + +func (*DeleteDirectiveOKApplicationJSON) deleteDirectiveRes() {} + +// Response model for delete document endpoint. +// Ref: #/components/schemas/DeleteDocumentResponse +type DeleteDocumentResponse struct { + DocumentID string `json:"document_id"` + MemoryUnitsDeleted int `json:"memory_units_deleted"` + Message string `json:"message"` + Success bool `json:"success"` +} + +// GetDocumentID returns the value of DocumentID. +func (s *DeleteDocumentResponse) GetDocumentID() string { + return s.DocumentID +} + +// GetMemoryUnitsDeleted returns the value of MemoryUnitsDeleted. +func (s *DeleteDocumentResponse) GetMemoryUnitsDeleted() int { + return s.MemoryUnitsDeleted +} + +// GetMessage returns the value of Message. +func (s *DeleteDocumentResponse) GetMessage() string { + return s.Message +} + +// GetSuccess returns the value of Success. +func (s *DeleteDocumentResponse) GetSuccess() bool { + return s.Success +} + +// SetDocumentID sets the value of DocumentID. +func (s *DeleteDocumentResponse) SetDocumentID(val string) { + s.DocumentID = val +} + +// SetMemoryUnitsDeleted sets the value of MemoryUnitsDeleted. +func (s *DeleteDocumentResponse) SetMemoryUnitsDeleted(val int) { + s.MemoryUnitsDeleted = val +} + +// SetMessage sets the value of Message. +func (s *DeleteDocumentResponse) SetMessage(val string) { + s.Message = val +} + +// SetSuccess sets the value of Success. +func (s *DeleteDocumentResponse) SetSuccess(val bool) { + s.Success = val +} + +func (*DeleteDocumentResponse) deleteDocumentRes() {} + +type DeleteMentalModelOKApplicationJSON jx.Raw + +func (*DeleteMentalModelOKApplicationJSON) deleteMentalModelRes() {} + +// Response model for delete operations. +// Ref: #/components/schemas/DeleteResponse +type DeleteResponse struct { + DeletedCount OptInt `json:"deleted_count"` + Message OptString `json:"message"` + Success bool `json:"success"` +} + +// GetDeletedCount returns the value of DeletedCount. +func (s *DeleteResponse) GetDeletedCount() OptInt { + return s.DeletedCount +} + +// GetMessage returns the value of Message. +func (s *DeleteResponse) GetMessage() OptString { + return s.Message +} + +// GetSuccess returns the value of Success. +func (s *DeleteResponse) GetSuccess() bool { + return s.Success +} + +// SetDeletedCount sets the value of DeletedCount. +func (s *DeleteResponse) SetDeletedCount(val OptInt) { + s.DeletedCount = val +} + +// SetMessage sets the value of Message. +func (s *DeleteResponse) SetMessage(val OptString) { + s.Message = val +} + +// SetSuccess sets the value of Success. +func (s *DeleteResponse) SetSuccess(val bool) { + s.Success = val +} + +func (*DeleteResponse) clearBankMemoriesRes() {} +func (*DeleteResponse) clearObservationsRes() {} +func (*DeleteResponse) deleteBankRes() {} + +// Response model for listing directives. +// Ref: #/components/schemas/DirectiveListResponse +type DirectiveListResponse struct { + Items []DirectiveResponse `json:"items"` +} + +// GetItems returns the value of Items. +func (s *DirectiveListResponse) GetItems() []DirectiveResponse { + return s.Items +} + +// SetItems sets the value of Items. +func (s *DirectiveListResponse) SetItems(val []DirectiveResponse) { + s.Items = val +} + +func (*DirectiveListResponse) listDirectivesRes() {} + +// Response model for a directive. +// Ref: #/components/schemas/DirectiveResponse +type DirectiveResponse struct { + BankID string `json:"bank_id"` + Content string `json:"content"` + CreatedAt OptString `json:"created_at"` + ID string `json:"id"` + IsActive OptBool `json:"is_active"` + Name string `json:"name"` + Priority OptInt `json:"priority"` + Tags []string `json:"tags"` + UpdatedAt OptString `json:"updated_at"` +} + +// GetBankID returns the value of BankID. +func (s *DirectiveResponse) GetBankID() string { + return s.BankID +} + +// GetContent returns the value of Content. +func (s *DirectiveResponse) GetContent() string { + return s.Content +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *DirectiveResponse) GetCreatedAt() OptString { + return s.CreatedAt +} + +// GetID returns the value of ID. +func (s *DirectiveResponse) GetID() string { + return s.ID +} + +// GetIsActive returns the value of IsActive. +func (s *DirectiveResponse) GetIsActive() OptBool { + return s.IsActive +} + +// GetName returns the value of Name. +func (s *DirectiveResponse) GetName() string { + return s.Name +} + +// GetPriority returns the value of Priority. +func (s *DirectiveResponse) GetPriority() OptInt { + return s.Priority +} + +// GetTags returns the value of Tags. +func (s *DirectiveResponse) GetTags() []string { + return s.Tags +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *DirectiveResponse) GetUpdatedAt() OptString { + return s.UpdatedAt +} + +// SetBankID sets the value of BankID. +func (s *DirectiveResponse) SetBankID(val string) { + s.BankID = val +} + +// SetContent sets the value of Content. +func (s *DirectiveResponse) SetContent(val string) { + s.Content = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *DirectiveResponse) SetCreatedAt(val OptString) { + s.CreatedAt = val +} + +// SetID sets the value of ID. +func (s *DirectiveResponse) SetID(val string) { + s.ID = val +} + +// SetIsActive sets the value of IsActive. +func (s *DirectiveResponse) SetIsActive(val OptBool) { + s.IsActive = val +} + +// SetName sets the value of Name. +func (s *DirectiveResponse) SetName(val string) { + s.Name = val +} + +// SetPriority sets the value of Priority. +func (s *DirectiveResponse) SetPriority(val OptInt) { + s.Priority = val +} + +// SetTags sets the value of Tags. +func (s *DirectiveResponse) SetTags(val []string) { + s.Tags = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *DirectiveResponse) SetUpdatedAt(val OptString) { + s.UpdatedAt = val +} + +func (*DirectiveResponse) createDirectiveRes() {} +func (*DirectiveResponse) getDirectiveRes() {} +func (*DirectiveResponse) updateDirectiveRes() {} + +// Disposition traits that influence how memories are formed and interpreted. +// Ref: #/components/schemas/DispositionTraits +type DispositionTraits struct { + // How much to consider emotional context (1=detached, 5=empathetic). + Empathy int `json:"empathy"` + // How literally to interpret information (1=flexible, 5=literal). + Literalism int `json:"literalism"` + // How skeptical vs trusting (1=trusting, 5=skeptical). + Skepticism int `json:"skepticism"` +} + +// GetEmpathy returns the value of Empathy. +func (s *DispositionTraits) GetEmpathy() int { + return s.Empathy +} + +// GetLiteralism returns the value of Literalism. +func (s *DispositionTraits) GetLiteralism() int { + return s.Literalism +} + +// GetSkepticism returns the value of Skepticism. +func (s *DispositionTraits) GetSkepticism() int { + return s.Skepticism +} + +// SetEmpathy sets the value of Empathy. +func (s *DispositionTraits) SetEmpathy(val int) { + s.Empathy = val +} + +// SetLiteralism sets the value of Literalism. +func (s *DispositionTraits) SetLiteralism(val int) { + s.Literalism = val +} + +// SetSkepticism sets the value of Skepticism. +func (s *DispositionTraits) SetSkepticism(val int) { + s.Skepticism = val +} + +// Response model for get document endpoint. +// Ref: #/components/schemas/DocumentResponse +type DocumentResponse struct { + BankID string `json:"bank_id"` + ContentHash string `json:"content_hash"` + CreatedAt string `json:"created_at"` + ID string `json:"id"` + MemoryUnitCount int `json:"memory_unit_count"` + OriginalText string `json:"original_text"` + // Tags associated with this document. + Tags []string `json:"tags"` + UpdatedAt string `json:"updated_at"` +} + +// GetBankID returns the value of BankID. +func (s *DocumentResponse) GetBankID() string { + return s.BankID +} + +// GetContentHash returns the value of ContentHash. +func (s *DocumentResponse) GetContentHash() string { + return s.ContentHash +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *DocumentResponse) GetCreatedAt() string { + return s.CreatedAt +} + +// GetID returns the value of ID. +func (s *DocumentResponse) GetID() string { + return s.ID +} + +// GetMemoryUnitCount returns the value of MemoryUnitCount. +func (s *DocumentResponse) GetMemoryUnitCount() int { + return s.MemoryUnitCount +} + +// GetOriginalText returns the value of OriginalText. +func (s *DocumentResponse) GetOriginalText() string { + return s.OriginalText +} + +// GetTags returns the value of Tags. +func (s *DocumentResponse) GetTags() []string { + return s.Tags +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *DocumentResponse) GetUpdatedAt() string { + return s.UpdatedAt +} + +// SetBankID sets the value of BankID. +func (s *DocumentResponse) SetBankID(val string) { + s.BankID = val +} + +// SetContentHash sets the value of ContentHash. +func (s *DocumentResponse) SetContentHash(val string) { + s.ContentHash = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *DocumentResponse) SetCreatedAt(val string) { + s.CreatedAt = val +} + +// SetID sets the value of ID. +func (s *DocumentResponse) SetID(val string) { + s.ID = val +} + +// SetMemoryUnitCount sets the value of MemoryUnitCount. +func (s *DocumentResponse) SetMemoryUnitCount(val int) { + s.MemoryUnitCount = val +} + +// SetOriginalText sets the value of OriginalText. +func (s *DocumentResponse) SetOriginalText(val string) { + s.OriginalText = val +} + +// SetTags sets the value of Tags. +func (s *DocumentResponse) SetTags(val []string) { + s.Tags = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *DocumentResponse) SetUpdatedAt(val string) { + s.UpdatedAt = val +} + +func (*DocumentResponse) getDocumentRes() {} + +// Response model for entity detail endpoint. +// Ref: #/components/schemas/EntityDetailResponse +type EntityDetailResponse struct { + CanonicalName string `json:"canonical_name"` + FirstSeen OptString `json:"first_seen"` + ID string `json:"id"` + LastSeen OptString `json:"last_seen"` + MentionCount int `json:"mention_count"` + Metadata OptEntityDetailResponseMetadata `json:"metadata"` + Observations []EntityObservationResponse `json:"observations"` +} + +// GetCanonicalName returns the value of CanonicalName. +func (s *EntityDetailResponse) GetCanonicalName() string { + return s.CanonicalName +} + +// GetFirstSeen returns the value of FirstSeen. +func (s *EntityDetailResponse) GetFirstSeen() OptString { + return s.FirstSeen +} + +// GetID returns the value of ID. +func (s *EntityDetailResponse) GetID() string { + return s.ID +} + +// GetLastSeen returns the value of LastSeen. +func (s *EntityDetailResponse) GetLastSeen() OptString { + return s.LastSeen +} + +// GetMentionCount returns the value of MentionCount. +func (s *EntityDetailResponse) GetMentionCount() int { + return s.MentionCount +} + +// GetMetadata returns the value of Metadata. +func (s *EntityDetailResponse) GetMetadata() OptEntityDetailResponseMetadata { + return s.Metadata +} + +// GetObservations returns the value of Observations. +func (s *EntityDetailResponse) GetObservations() []EntityObservationResponse { + return s.Observations +} + +// SetCanonicalName sets the value of CanonicalName. +func (s *EntityDetailResponse) SetCanonicalName(val string) { + s.CanonicalName = val +} + +// SetFirstSeen sets the value of FirstSeen. +func (s *EntityDetailResponse) SetFirstSeen(val OptString) { + s.FirstSeen = val +} + +// SetID sets the value of ID. +func (s *EntityDetailResponse) SetID(val string) { + s.ID = val +} + +// SetLastSeen sets the value of LastSeen. +func (s *EntityDetailResponse) SetLastSeen(val OptString) { + s.LastSeen = val +} + +// SetMentionCount sets the value of MentionCount. +func (s *EntityDetailResponse) SetMentionCount(val int) { + s.MentionCount = val +} + +// SetMetadata sets the value of Metadata. +func (s *EntityDetailResponse) SetMetadata(val OptEntityDetailResponseMetadata) { + s.Metadata = val +} + +// SetObservations sets the value of Observations. +func (s *EntityDetailResponse) SetObservations(val []EntityObservationResponse) { + s.Observations = val +} + +func (*EntityDetailResponse) getEntityRes() {} +func (*EntityDetailResponse) regenerateEntityObservationsRes() {} + +type EntityDetailResponseMetadata map[string]jx.Raw + +func (s *EntityDetailResponseMetadata) init() EntityDetailResponseMetadata { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Options for including entity observations in recall results. +// Ref: #/components/schemas/EntityIncludeOptions +type EntityIncludeOptions struct { + // Maximum tokens for entity observations. + MaxTokens OptInt `json:"max_tokens"` +} + +// GetMaxTokens returns the value of MaxTokens. +func (s *EntityIncludeOptions) GetMaxTokens() OptInt { + return s.MaxTokens +} + +// SetMaxTokens sets the value of MaxTokens. +func (s *EntityIncludeOptions) SetMaxTokens(val OptInt) { + s.MaxTokens = val +} + +// Entity to associate with retained content. +// Ref: #/components/schemas/EntityInput +type EntityInput struct { + // The entity name/text. + Text string `json:"text"` + // Optional entity type (e.g., 'PERSON', 'ORG', 'CONCEPT'). + Type OptString `json:"type"` +} + +// GetText returns the value of Text. +func (s *EntityInput) GetText() string { + return s.Text +} + +// GetType returns the value of Type. +func (s *EntityInput) GetType() OptString { + return s.Type +} + +// SetText sets the value of Text. +func (s *EntityInput) SetText(val string) { + s.Text = val +} + +// SetType sets the value of Type. +func (s *EntityInput) SetType(val OptString) { + s.Type = val +} + +// Entity list item with summary. +// Ref: #/components/schemas/EntityListItem +type EntityListItem struct { + CanonicalName string `json:"canonical_name"` + FirstSeen OptString `json:"first_seen"` + ID string `json:"id"` + LastSeen OptString `json:"last_seen"` + MentionCount int `json:"mention_count"` + Metadata OptEntityListItemMetadata `json:"metadata"` +} + +// GetCanonicalName returns the value of CanonicalName. +func (s *EntityListItem) GetCanonicalName() string { + return s.CanonicalName +} + +// GetFirstSeen returns the value of FirstSeen. +func (s *EntityListItem) GetFirstSeen() OptString { + return s.FirstSeen +} + +// GetID returns the value of ID. +func (s *EntityListItem) GetID() string { + return s.ID +} + +// GetLastSeen returns the value of LastSeen. +func (s *EntityListItem) GetLastSeen() OptString { + return s.LastSeen +} + +// GetMentionCount returns the value of MentionCount. +func (s *EntityListItem) GetMentionCount() int { + return s.MentionCount +} + +// GetMetadata returns the value of Metadata. +func (s *EntityListItem) GetMetadata() OptEntityListItemMetadata { + return s.Metadata +} + +// SetCanonicalName sets the value of CanonicalName. +func (s *EntityListItem) SetCanonicalName(val string) { + s.CanonicalName = val +} + +// SetFirstSeen sets the value of FirstSeen. +func (s *EntityListItem) SetFirstSeen(val OptString) { + s.FirstSeen = val +} + +// SetID sets the value of ID. +func (s *EntityListItem) SetID(val string) { + s.ID = val +} + +// SetLastSeen sets the value of LastSeen. +func (s *EntityListItem) SetLastSeen(val OptString) { + s.LastSeen = val +} + +// SetMentionCount sets the value of MentionCount. +func (s *EntityListItem) SetMentionCount(val int) { + s.MentionCount = val +} + +// SetMetadata sets the value of Metadata. +func (s *EntityListItem) SetMetadata(val OptEntityListItemMetadata) { + s.Metadata = val +} + +type EntityListItemMetadata map[string]jx.Raw + +func (s *EntityListItemMetadata) init() EntityListItemMetadata { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Response model for entity list endpoint. +// Ref: #/components/schemas/EntityListResponse +type EntityListResponse struct { + Items []EntityListItem `json:"items"` + Limit int `json:"limit"` + Offset int `json:"offset"` + Total int `json:"total"` +} + +// GetItems returns the value of Items. +func (s *EntityListResponse) GetItems() []EntityListItem { + return s.Items +} + +// GetLimit returns the value of Limit. +func (s *EntityListResponse) GetLimit() int { + return s.Limit +} + +// GetOffset returns the value of Offset. +func (s *EntityListResponse) GetOffset() int { + return s.Offset +} + +// GetTotal returns the value of Total. +func (s *EntityListResponse) GetTotal() int { + return s.Total +} + +// SetItems sets the value of Items. +func (s *EntityListResponse) SetItems(val []EntityListItem) { + s.Items = val +} + +// SetLimit sets the value of Limit. +func (s *EntityListResponse) SetLimit(val int) { + s.Limit = val +} + +// SetOffset sets the value of Offset. +func (s *EntityListResponse) SetOffset(val int) { + s.Offset = val +} + +// SetTotal sets the value of Total. +func (s *EntityListResponse) SetTotal(val int) { + s.Total = val +} + +func (*EntityListResponse) listEntitiesRes() {} + +// An observation about an entity. +// Ref: #/components/schemas/EntityObservationResponse +type EntityObservationResponse struct { + MentionedAt OptString `json:"mentioned_at"` + Text string `json:"text"` +} + +// GetMentionedAt returns the value of MentionedAt. +func (s *EntityObservationResponse) GetMentionedAt() OptString { + return s.MentionedAt +} + +// GetText returns the value of Text. +func (s *EntityObservationResponse) GetText() string { + return s.Text +} + +// SetMentionedAt sets the value of MentionedAt. +func (s *EntityObservationResponse) SetMentionedAt(val OptString) { + s.MentionedAt = val +} + +// SetText sets the value of Text. +func (s *EntityObservationResponse) SetText(val string) { + s.Text = val +} + +// Current mental model of an entity. +// Ref: #/components/schemas/EntityStateResponse +type EntityStateResponse struct { + CanonicalName string `json:"canonical_name"` + EntityID string `json:"entity_id"` + Observations []EntityObservationResponse `json:"observations"` +} + +// GetCanonicalName returns the value of CanonicalName. +func (s *EntityStateResponse) GetCanonicalName() string { + return s.CanonicalName +} + +// GetEntityID returns the value of EntityID. +func (s *EntityStateResponse) GetEntityID() string { + return s.EntityID +} + +// GetObservations returns the value of Observations. +func (s *EntityStateResponse) GetObservations() []EntityObservationResponse { + return s.Observations +} + +// SetCanonicalName sets the value of CanonicalName. +func (s *EntityStateResponse) SetCanonicalName(val string) { + s.CanonicalName = val +} + +// SetEntityID sets the value of EntityID. +func (s *EntityStateResponse) SetEntityID(val string) { + s.EntityID = val +} + +// SetObservations sets the value of Observations. +func (s *EntityStateResponse) SetObservations(val []EntityObservationResponse) { + s.Observations = val +} + +// Options for including facts (based_on) in reflect results. +// Ref: #/components/schemas/FactsIncludeOptions +type FactsIncludeOptions struct{} + +// Feature flags indicating which capabilities are enabled. +// Ref: #/components/schemas/FeaturesInfo +type FeaturesInfo struct { + // Whether per-bank configuration API is enabled. + BankConfigAPI bool `json:"bank_config_api"` + // Whether MCP (Model Context Protocol) server is enabled. + Mcp bool `json:"mcp"` + // Whether observations (auto-consolidation) are enabled. + Observations bool `json:"observations"` + // Whether the background worker is enabled. + Worker bool `json:"worker"` +} + +// GetBankConfigAPI returns the value of BankConfigAPI. +func (s *FeaturesInfo) GetBankConfigAPI() bool { + return s.BankConfigAPI +} + +// GetMcp returns the value of Mcp. +func (s *FeaturesInfo) GetMcp() bool { + return s.Mcp +} + +// GetObservations returns the value of Observations. +func (s *FeaturesInfo) GetObservations() bool { + return s.Observations +} + +// GetWorker returns the value of Worker. +func (s *FeaturesInfo) GetWorker() bool { + return s.Worker +} + +// SetBankConfigAPI sets the value of BankConfigAPI. +func (s *FeaturesInfo) SetBankConfigAPI(val bool) { + s.BankConfigAPI = val +} + +// SetMcp sets the value of Mcp. +func (s *FeaturesInfo) SetMcp(val bool) { + s.Mcp = val +} + +// SetObservations sets the value of Observations. +func (s *FeaturesInfo) SetObservations(val bool) { + s.Observations = val +} + +// SetWorker sets the value of Worker. +func (s *FeaturesInfo) SetWorker(val bool) { + s.Worker = val +} + +type GetMemoryOKApplicationJSON jx.Raw + +func (*GetMemoryOKApplicationJSON) getMemoryRes() {} + +// Response model for graph data endpoint. +// Ref: #/components/schemas/GraphDataResponse +type GraphDataResponse struct { + Edges []GraphDataResponseEdgesItem `json:"edges"` + Limit int `json:"limit"` + Nodes []GraphDataResponseNodesItem `json:"nodes"` + TableRows []GraphDataResponseTableRowsItem `json:"table_rows"` + TotalUnits int `json:"total_units"` +} + +// GetEdges returns the value of Edges. +func (s *GraphDataResponse) GetEdges() []GraphDataResponseEdgesItem { + return s.Edges +} + +// GetLimit returns the value of Limit. +func (s *GraphDataResponse) GetLimit() int { + return s.Limit +} + +// GetNodes returns the value of Nodes. +func (s *GraphDataResponse) GetNodes() []GraphDataResponseNodesItem { + return s.Nodes +} + +// GetTableRows returns the value of TableRows. +func (s *GraphDataResponse) GetTableRows() []GraphDataResponseTableRowsItem { + return s.TableRows +} + +// GetTotalUnits returns the value of TotalUnits. +func (s *GraphDataResponse) GetTotalUnits() int { + return s.TotalUnits +} + +// SetEdges sets the value of Edges. +func (s *GraphDataResponse) SetEdges(val []GraphDataResponseEdgesItem) { + s.Edges = val +} + +// SetLimit sets the value of Limit. +func (s *GraphDataResponse) SetLimit(val int) { + s.Limit = val +} + +// SetNodes sets the value of Nodes. +func (s *GraphDataResponse) SetNodes(val []GraphDataResponseNodesItem) { + s.Nodes = val +} + +// SetTableRows sets the value of TableRows. +func (s *GraphDataResponse) SetTableRows(val []GraphDataResponseTableRowsItem) { + s.TableRows = val +} + +// SetTotalUnits sets the value of TotalUnits. +func (s *GraphDataResponse) SetTotalUnits(val int) { + s.TotalUnits = val +} + +func (*GraphDataResponse) getGraphRes() {} + +type GraphDataResponseEdgesItem map[string]jx.Raw + +func (s *GraphDataResponseEdgesItem) init() GraphDataResponseEdgesItem { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +type GraphDataResponseNodesItem map[string]jx.Raw + +func (s *GraphDataResponseNodesItem) init() GraphDataResponseNodesItem { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +type GraphDataResponseTableRowsItem map[string]jx.Raw + +func (s *GraphDataResponseTableRowsItem) init() GraphDataResponseTableRowsItem { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Ref: #/components/schemas/HTTPValidationError +type HTTPValidationError struct { + Detail []ValidationError `json:"detail"` +} + +// GetDetail returns the value of Detail. +func (s *HTTPValidationError) GetDetail() []ValidationError { + return s.Detail +} + +// SetDetail sets the value of Detail. +func (s *HTTPValidationError) SetDetail(val []ValidationError) { + s.Detail = val +} + +func (*HTTPValidationError) addBankBackgroundRes() {} +func (*HTTPValidationError) cancelOperationRes() {} +func (*HTTPValidationError) clearBankMemoriesRes() {} +func (*HTTPValidationError) clearObservationsRes() {} +func (*HTTPValidationError) createDirectiveRes() {} +func (*HTTPValidationError) createMentalModelRes() {} +func (*HTTPValidationError) createOrUpdateBankRes() {} +func (*HTTPValidationError) deleteBankRes() {} +func (*HTTPValidationError) deleteDirectiveRes() {} +func (*HTTPValidationError) deleteDocumentRes() {} +func (*HTTPValidationError) deleteMentalModelRes() {} +func (*HTTPValidationError) getAgentStatsRes() {} +func (*HTTPValidationError) getBankConfigRes() {} +func (*HTTPValidationError) getBankProfileRes() {} +func (*HTTPValidationError) getChunkRes() {} +func (*HTTPValidationError) getDirectiveRes() {} +func (*HTTPValidationError) getDocumentRes() {} +func (*HTTPValidationError) getEntityRes() {} +func (*HTTPValidationError) getGraphRes() {} +func (*HTTPValidationError) getMemoryRes() {} +func (*HTTPValidationError) getMentalModelRes() {} +func (*HTTPValidationError) getOperationStatusRes() {} +func (*HTTPValidationError) listBanksRes() {} +func (*HTTPValidationError) listDirectivesRes() {} +func (*HTTPValidationError) listDocumentsRes() {} +func (*HTTPValidationError) listEntitiesRes() {} +func (*HTTPValidationError) listMemoriesRes() {} +func (*HTTPValidationError) listMentalModelsRes() {} +func (*HTTPValidationError) listOperationsRes() {} +func (*HTTPValidationError) listTagsRes() {} +func (*HTTPValidationError) recallMemoriesRes() {} +func (*HTTPValidationError) reflectRes() {} +func (*HTTPValidationError) refreshMentalModelRes() {} +func (*HTTPValidationError) regenerateEntityObservationsRes() {} +func (*HTTPValidationError) resetBankConfigRes() {} +func (*HTTPValidationError) retainMemoriesRes() {} +func (*HTTPValidationError) triggerConsolidationRes() {} +func (*HTTPValidationError) updateBankConfigRes() {} +func (*HTTPValidationError) updateBankDispositionRes() {} +func (*HTTPValidationError) updateBankRes() {} +func (*HTTPValidationError) updateDirectiveRes() {} +func (*HTTPValidationError) updateMentalModelRes() {} + +// Options for including additional data in recall results. +// Ref: #/components/schemas/IncludeOptions +type IncludeOptions struct { + // Include raw chunks. Set to {} to enable, null to disable (default: disabled). + Chunks OptChunkIncludeOptions `json:"chunks"` + // Include entity observations. Set to null to disable entity inclusion. + Entities OptEntityIncludeOptions `json:"entities"` +} + +// GetChunks returns the value of Chunks. +func (s *IncludeOptions) GetChunks() OptChunkIncludeOptions { + return s.Chunks +} + +// GetEntities returns the value of Entities. +func (s *IncludeOptions) GetEntities() OptEntityIncludeOptions { + return s.Entities +} + +// SetChunks sets the value of Chunks. +func (s *IncludeOptions) SetChunks(val OptChunkIncludeOptions) { + s.Chunks = val +} + +// SetEntities sets the value of Entities. +func (s *IncludeOptions) SetEntities(val OptEntityIncludeOptions) { + s.Entities = val +} + +// How to match tags. +type ListDirectivesTagsMatch string + +const ( + ListDirectivesTagsMatchAny ListDirectivesTagsMatch = "any" + ListDirectivesTagsMatchAll ListDirectivesTagsMatch = "all" + ListDirectivesTagsMatchExact ListDirectivesTagsMatch = "exact" +) + +// AllValues returns all ListDirectivesTagsMatch values. +func (ListDirectivesTagsMatch) AllValues() []ListDirectivesTagsMatch { + return []ListDirectivesTagsMatch{ + ListDirectivesTagsMatchAny, + ListDirectivesTagsMatchAll, + ListDirectivesTagsMatchExact, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s ListDirectivesTagsMatch) MarshalText() ([]byte, error) { + switch s { + case ListDirectivesTagsMatchAny: + return []byte(s), nil + case ListDirectivesTagsMatchAll: + return []byte(s), nil + case ListDirectivesTagsMatchExact: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *ListDirectivesTagsMatch) UnmarshalText(data []byte) error { + switch ListDirectivesTagsMatch(data) { + case ListDirectivesTagsMatchAny: + *s = ListDirectivesTagsMatchAny + return nil + case ListDirectivesTagsMatchAll: + *s = ListDirectivesTagsMatchAll + return nil + case ListDirectivesTagsMatchExact: + *s = ListDirectivesTagsMatchExact + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +// Response model for list documents endpoint. +// Ref: #/components/schemas/ListDocumentsResponse +type ListDocumentsResponse struct { + Items []ListDocumentsResponseItemsItem `json:"items"` + Limit int `json:"limit"` + Offset int `json:"offset"` + Total int `json:"total"` +} + +// GetItems returns the value of Items. +func (s *ListDocumentsResponse) GetItems() []ListDocumentsResponseItemsItem { + return s.Items +} + +// GetLimit returns the value of Limit. +func (s *ListDocumentsResponse) GetLimit() int { + return s.Limit +} + +// GetOffset returns the value of Offset. +func (s *ListDocumentsResponse) GetOffset() int { + return s.Offset +} + +// GetTotal returns the value of Total. +func (s *ListDocumentsResponse) GetTotal() int { + return s.Total +} + +// SetItems sets the value of Items. +func (s *ListDocumentsResponse) SetItems(val []ListDocumentsResponseItemsItem) { + s.Items = val +} + +// SetLimit sets the value of Limit. +func (s *ListDocumentsResponse) SetLimit(val int) { + s.Limit = val +} + +// SetOffset sets the value of Offset. +func (s *ListDocumentsResponse) SetOffset(val int) { + s.Offset = val +} + +// SetTotal sets the value of Total. +func (s *ListDocumentsResponse) SetTotal(val int) { + s.Total = val +} + +func (*ListDocumentsResponse) listDocumentsRes() {} + +type ListDocumentsResponseItemsItem map[string]jx.Raw + +func (s *ListDocumentsResponseItemsItem) init() ListDocumentsResponseItemsItem { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Response model for list memory units endpoint. +// Ref: #/components/schemas/ListMemoryUnitsResponse +type ListMemoryUnitsResponse struct { + Items []ListMemoryUnitsResponseItemsItem `json:"items"` + Limit int `json:"limit"` + Offset int `json:"offset"` + Total int `json:"total"` +} + +// GetItems returns the value of Items. +func (s *ListMemoryUnitsResponse) GetItems() []ListMemoryUnitsResponseItemsItem { + return s.Items +} + +// GetLimit returns the value of Limit. +func (s *ListMemoryUnitsResponse) GetLimit() int { + return s.Limit +} + +// GetOffset returns the value of Offset. +func (s *ListMemoryUnitsResponse) GetOffset() int { + return s.Offset +} + +// GetTotal returns the value of Total. +func (s *ListMemoryUnitsResponse) GetTotal() int { + return s.Total +} + +// SetItems sets the value of Items. +func (s *ListMemoryUnitsResponse) SetItems(val []ListMemoryUnitsResponseItemsItem) { + s.Items = val +} + +// SetLimit sets the value of Limit. +func (s *ListMemoryUnitsResponse) SetLimit(val int) { + s.Limit = val +} + +// SetOffset sets the value of Offset. +func (s *ListMemoryUnitsResponse) SetOffset(val int) { + s.Offset = val +} + +// SetTotal sets the value of Total. +func (s *ListMemoryUnitsResponse) SetTotal(val int) { + s.Total = val +} + +func (*ListMemoryUnitsResponse) listMemoriesRes() {} + +type ListMemoryUnitsResponseItemsItem map[string]jx.Raw + +func (s *ListMemoryUnitsResponseItemsItem) init() ListMemoryUnitsResponseItemsItem { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// How to match tags. +type ListMentalModelsTagsMatch string + +const ( + ListMentalModelsTagsMatchAny ListMentalModelsTagsMatch = "any" + ListMentalModelsTagsMatchAll ListMentalModelsTagsMatch = "all" + ListMentalModelsTagsMatchExact ListMentalModelsTagsMatch = "exact" +) + +// AllValues returns all ListMentalModelsTagsMatch values. +func (ListMentalModelsTagsMatch) AllValues() []ListMentalModelsTagsMatch { + return []ListMentalModelsTagsMatch{ + ListMentalModelsTagsMatchAny, + ListMentalModelsTagsMatchAll, + ListMentalModelsTagsMatchExact, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s ListMentalModelsTagsMatch) MarshalText() ([]byte, error) { + switch s { + case ListMentalModelsTagsMatchAny: + return []byte(s), nil + case ListMentalModelsTagsMatchAll: + return []byte(s), nil + case ListMentalModelsTagsMatchExact: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *ListMentalModelsTagsMatch) UnmarshalText(data []byte) error { + switch ListMentalModelsTagsMatch(data) { + case ListMentalModelsTagsMatchAny: + *s = ListMentalModelsTagsMatchAny + return nil + case ListMentalModelsTagsMatchAll: + *s = ListMentalModelsTagsMatchAll + return nil + case ListMentalModelsTagsMatchExact: + *s = ListMentalModelsTagsMatchExact + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +// Response model for list tags endpoint. +// Ref: #/components/schemas/ListTagsResponse +type ListTagsResponse struct { + Items []TagItem `json:"items"` + Limit int `json:"limit"` + Offset int `json:"offset"` + Total int `json:"total"` +} + +// GetItems returns the value of Items. +func (s *ListTagsResponse) GetItems() []TagItem { + return s.Items +} + +// GetLimit returns the value of Limit. +func (s *ListTagsResponse) GetLimit() int { + return s.Limit +} + +// GetOffset returns the value of Offset. +func (s *ListTagsResponse) GetOffset() int { + return s.Offset +} + +// GetTotal returns the value of Total. +func (s *ListTagsResponse) GetTotal() int { + return s.Total +} + +// SetItems sets the value of Items. +func (s *ListTagsResponse) SetItems(val []TagItem) { + s.Items = val +} + +// SetLimit sets the value of Limit. +func (s *ListTagsResponse) SetLimit(val int) { + s.Limit = val +} + +// SetOffset sets the value of Offset. +func (s *ListTagsResponse) SetOffset(val int) { + s.Offset = val +} + +// SetTotal sets the value of Total. +func (s *ListTagsResponse) SetTotal(val int) { + s.Total = val +} + +func (*ListTagsResponse) listTagsRes() {} + +// Single memory item for retain. +// Ref: #/components/schemas/MemoryItem +type MemoryItem struct { + Content string `json:"content"` + Context OptString `json:"context"` + // Optional document ID for this memory item. + DocumentID OptString `json:"document_id"` + // Optional entities to combine with auto-extracted entities. + Entities []EntityInput `json:"entities"` + Metadata OptMemoryItemMetadata `json:"metadata"` + // Optional tags for visibility scoping. Memories with tags can be filtered during recall. + Tags []string `json:"tags"` + Timestamp OptDateTime `json:"timestamp"` +} + +// GetContent returns the value of Content. +func (s *MemoryItem) GetContent() string { + return s.Content +} + +// GetContext returns the value of Context. +func (s *MemoryItem) GetContext() OptString { + return s.Context +} + +// GetDocumentID returns the value of DocumentID. +func (s *MemoryItem) GetDocumentID() OptString { + return s.DocumentID +} + +// GetEntities returns the value of Entities. +func (s *MemoryItem) GetEntities() []EntityInput { + return s.Entities +} + +// GetMetadata returns the value of Metadata. +func (s *MemoryItem) GetMetadata() OptMemoryItemMetadata { + return s.Metadata +} + +// GetTags returns the value of Tags. +func (s *MemoryItem) GetTags() []string { + return s.Tags +} + +// GetTimestamp returns the value of Timestamp. +func (s *MemoryItem) GetTimestamp() OptDateTime { + return s.Timestamp +} + +// SetContent sets the value of Content. +func (s *MemoryItem) SetContent(val string) { + s.Content = val +} + +// SetContext sets the value of Context. +func (s *MemoryItem) SetContext(val OptString) { + s.Context = val +} + +// SetDocumentID sets the value of DocumentID. +func (s *MemoryItem) SetDocumentID(val OptString) { + s.DocumentID = val +} + +// SetEntities sets the value of Entities. +func (s *MemoryItem) SetEntities(val []EntityInput) { + s.Entities = val +} + +// SetMetadata sets the value of Metadata. +func (s *MemoryItem) SetMetadata(val OptMemoryItemMetadata) { + s.Metadata = val +} + +// SetTags sets the value of Tags. +func (s *MemoryItem) SetTags(val []string) { + s.Tags = val +} + +// SetTimestamp sets the value of Timestamp. +func (s *MemoryItem) SetTimestamp(val OptDateTime) { + s.Timestamp = val +} + +type MemoryItemMetadata map[string]string + +func (s *MemoryItemMetadata) init() MemoryItemMetadata { + m := *s + if m == nil { + m = map[string]string{} + *s = m + } + return m +} + +// Response model for listing mental models. +// Ref: #/components/schemas/MentalModelListResponse +type MentalModelListResponse struct { + Items []MentalModelResponse `json:"items"` +} + +// GetItems returns the value of Items. +func (s *MentalModelListResponse) GetItems() []MentalModelResponse { + return s.Items +} + +// SetItems sets the value of Items. +func (s *MentalModelListResponse) SetItems(val []MentalModelResponse) { + s.Items = val +} + +func (*MentalModelListResponse) listMentalModelsRes() {} + +// Response model for a mental model (stored reflect response). +// Ref: #/components/schemas/MentalModelResponse +type MentalModelResponse struct { + BankID string `json:"bank_id"` + // The mental model content as well-formatted markdown (auto-generated from reflect endpoint). + Content string `json:"content"` + CreatedAt OptString `json:"created_at"` + ID string `json:"id"` + LastRefreshedAt OptString `json:"last_refreshed_at"` + MaxTokens OptInt `json:"max_tokens"` + Name string `json:"name"` + // Full reflect API response payload including based_on facts and observations. + ReflectResponse OptMentalModelResponseReflectResponse `json:"reflect_response"` + SourceQuery string `json:"source_query"` + Tags []string `json:"tags"` + Trigger OptMentalModelTrigger `json:"trigger"` +} + +// GetBankID returns the value of BankID. +func (s *MentalModelResponse) GetBankID() string { + return s.BankID +} + +// GetContent returns the value of Content. +func (s *MentalModelResponse) GetContent() string { + return s.Content +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *MentalModelResponse) GetCreatedAt() OptString { + return s.CreatedAt +} + +// GetID returns the value of ID. +func (s *MentalModelResponse) GetID() string { + return s.ID +} + +// GetLastRefreshedAt returns the value of LastRefreshedAt. +func (s *MentalModelResponse) GetLastRefreshedAt() OptString { + return s.LastRefreshedAt +} + +// GetMaxTokens returns the value of MaxTokens. +func (s *MentalModelResponse) GetMaxTokens() OptInt { + return s.MaxTokens +} + +// GetName returns the value of Name. +func (s *MentalModelResponse) GetName() string { + return s.Name +} + +// GetReflectResponse returns the value of ReflectResponse. +func (s *MentalModelResponse) GetReflectResponse() OptMentalModelResponseReflectResponse { + return s.ReflectResponse +} + +// GetSourceQuery returns the value of SourceQuery. +func (s *MentalModelResponse) GetSourceQuery() string { + return s.SourceQuery +} + +// GetTags returns the value of Tags. +func (s *MentalModelResponse) GetTags() []string { + return s.Tags +} + +// GetTrigger returns the value of Trigger. +func (s *MentalModelResponse) GetTrigger() OptMentalModelTrigger { + return s.Trigger +} + +// SetBankID sets the value of BankID. +func (s *MentalModelResponse) SetBankID(val string) { + s.BankID = val +} + +// SetContent sets the value of Content. +func (s *MentalModelResponse) SetContent(val string) { + s.Content = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *MentalModelResponse) SetCreatedAt(val OptString) { + s.CreatedAt = val +} + +// SetID sets the value of ID. +func (s *MentalModelResponse) SetID(val string) { + s.ID = val +} + +// SetLastRefreshedAt sets the value of LastRefreshedAt. +func (s *MentalModelResponse) SetLastRefreshedAt(val OptString) { + s.LastRefreshedAt = val +} + +// SetMaxTokens sets the value of MaxTokens. +func (s *MentalModelResponse) SetMaxTokens(val OptInt) { + s.MaxTokens = val +} + +// SetName sets the value of Name. +func (s *MentalModelResponse) SetName(val string) { + s.Name = val +} + +// SetReflectResponse sets the value of ReflectResponse. +func (s *MentalModelResponse) SetReflectResponse(val OptMentalModelResponseReflectResponse) { + s.ReflectResponse = val +} + +// SetSourceQuery sets the value of SourceQuery. +func (s *MentalModelResponse) SetSourceQuery(val string) { + s.SourceQuery = val +} + +// SetTags sets the value of Tags. +func (s *MentalModelResponse) SetTags(val []string) { + s.Tags = val +} + +// SetTrigger sets the value of Trigger. +func (s *MentalModelResponse) SetTrigger(val OptMentalModelTrigger) { + s.Trigger = val +} + +func (*MentalModelResponse) getMentalModelRes() {} +func (*MentalModelResponse) updateMentalModelRes() {} + +// Full reflect API response payload including based_on facts and observations. +type MentalModelResponseReflectResponse map[string]jx.Raw + +func (s *MentalModelResponseReflectResponse) init() MentalModelResponseReflectResponse { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Trigger settings for a mental model. +// Ref: #/components/schemas/MentalModelTrigger +type MentalModelTrigger struct { + // If true, refresh this mental model after observations consolidation (real-time mode). + RefreshAfterConsolidation OptBool `json:"refresh_after_consolidation"` +} + +// GetRefreshAfterConsolidation returns the value of RefreshAfterConsolidation. +func (s *MentalModelTrigger) GetRefreshAfterConsolidation() OptBool { + return s.RefreshAfterConsolidation +} + +// SetRefreshAfterConsolidation sets the value of RefreshAfterConsolidation. +func (s *MentalModelTrigger) SetRefreshAfterConsolidation(val OptBool) { + s.RefreshAfterConsolidation = val +} + +// Response model for a single async operation. +// Ref: #/components/schemas/OperationResponse +type OperationResponse struct { + CreatedAt string `json:"created_at"` + DocumentID OptString `json:"document_id"` + ErrorMessage string `json:"error_message"` + ID string `json:"id"` + ItemsCount int `json:"items_count"` + Status string `json:"status"` + TaskType string `json:"task_type"` +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *OperationResponse) GetCreatedAt() string { + return s.CreatedAt +} + +// GetDocumentID returns the value of DocumentID. +func (s *OperationResponse) GetDocumentID() OptString { + return s.DocumentID +} + +// GetErrorMessage returns the value of ErrorMessage. +func (s *OperationResponse) GetErrorMessage() string { + return s.ErrorMessage +} + +// GetID returns the value of ID. +func (s *OperationResponse) GetID() string { + return s.ID +} + +// GetItemsCount returns the value of ItemsCount. +func (s *OperationResponse) GetItemsCount() int { + return s.ItemsCount +} + +// GetStatus returns the value of Status. +func (s *OperationResponse) GetStatus() string { + return s.Status +} + +// GetTaskType returns the value of TaskType. +func (s *OperationResponse) GetTaskType() string { + return s.TaskType +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *OperationResponse) SetCreatedAt(val string) { + s.CreatedAt = val +} + +// SetDocumentID sets the value of DocumentID. +func (s *OperationResponse) SetDocumentID(val OptString) { + s.DocumentID = val +} + +// SetErrorMessage sets the value of ErrorMessage. +func (s *OperationResponse) SetErrorMessage(val string) { + s.ErrorMessage = val +} + +// SetID sets the value of ID. +func (s *OperationResponse) SetID(val string) { + s.ID = val +} + +// SetItemsCount sets the value of ItemsCount. +func (s *OperationResponse) SetItemsCount(val int) { + s.ItemsCount = val +} + +// SetStatus sets the value of Status. +func (s *OperationResponse) SetStatus(val string) { + s.Status = val +} + +// SetTaskType sets the value of TaskType. +func (s *OperationResponse) SetTaskType(val string) { + s.TaskType = val +} + +// Response model for getting a single operation status. +// Ref: #/components/schemas/OperationStatusResponse +type OperationStatusResponse struct { + CompletedAt OptString `json:"completed_at"` + CreatedAt OptString `json:"created_at"` + ErrorMessage OptString `json:"error_message"` + OperationID string `json:"operation_id"` + OperationType OptString `json:"operation_type"` + Status OperationStatusResponseStatus `json:"status"` + UpdatedAt OptString `json:"updated_at"` +} + +// GetCompletedAt returns the value of CompletedAt. +func (s *OperationStatusResponse) GetCompletedAt() OptString { + return s.CompletedAt +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *OperationStatusResponse) GetCreatedAt() OptString { + return s.CreatedAt +} + +// GetErrorMessage returns the value of ErrorMessage. +func (s *OperationStatusResponse) GetErrorMessage() OptString { + return s.ErrorMessage +} + +// GetOperationID returns the value of OperationID. +func (s *OperationStatusResponse) GetOperationID() string { + return s.OperationID +} + +// GetOperationType returns the value of OperationType. +func (s *OperationStatusResponse) GetOperationType() OptString { + return s.OperationType +} + +// GetStatus returns the value of Status. +func (s *OperationStatusResponse) GetStatus() OperationStatusResponseStatus { + return s.Status +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *OperationStatusResponse) GetUpdatedAt() OptString { + return s.UpdatedAt +} + +// SetCompletedAt sets the value of CompletedAt. +func (s *OperationStatusResponse) SetCompletedAt(val OptString) { + s.CompletedAt = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *OperationStatusResponse) SetCreatedAt(val OptString) { + s.CreatedAt = val +} + +// SetErrorMessage sets the value of ErrorMessage. +func (s *OperationStatusResponse) SetErrorMessage(val OptString) { + s.ErrorMessage = val +} + +// SetOperationID sets the value of OperationID. +func (s *OperationStatusResponse) SetOperationID(val string) { + s.OperationID = val +} + +// SetOperationType sets the value of OperationType. +func (s *OperationStatusResponse) SetOperationType(val OptString) { + s.OperationType = val +} + +// SetStatus sets the value of Status. +func (s *OperationStatusResponse) SetStatus(val OperationStatusResponseStatus) { + s.Status = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *OperationStatusResponse) SetUpdatedAt(val OptString) { + s.UpdatedAt = val +} + +func (*OperationStatusResponse) getOperationStatusRes() {} + +type OperationStatusResponseStatus string + +const ( + OperationStatusResponseStatusPending OperationStatusResponseStatus = "pending" + OperationStatusResponseStatusCompleted OperationStatusResponseStatus = "completed" + OperationStatusResponseStatusFailed OperationStatusResponseStatus = "failed" + OperationStatusResponseStatusNotFound OperationStatusResponseStatus = "not_found" +) + +// AllValues returns all OperationStatusResponseStatus values. +func (OperationStatusResponseStatus) AllValues() []OperationStatusResponseStatus { + return []OperationStatusResponseStatus{ + OperationStatusResponseStatusPending, + OperationStatusResponseStatusCompleted, + OperationStatusResponseStatusFailed, + OperationStatusResponseStatusNotFound, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s OperationStatusResponseStatus) MarshalText() ([]byte, error) { + switch s { + case OperationStatusResponseStatusPending: + return []byte(s), nil + case OperationStatusResponseStatusCompleted: + return []byte(s), nil + case OperationStatusResponseStatusFailed: + return []byte(s), nil + case OperationStatusResponseStatusNotFound: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *OperationStatusResponseStatus) UnmarshalText(data []byte) error { + switch OperationStatusResponseStatus(data) { + case OperationStatusResponseStatusPending: + *s = OperationStatusResponseStatusPending + return nil + case OperationStatusResponseStatusCompleted: + *s = OperationStatusResponseStatusCompleted + return nil + case OperationStatusResponseStatusFailed: + *s = OperationStatusResponseStatusFailed + return nil + case OperationStatusResponseStatusNotFound: + *s = OperationStatusResponseStatusNotFound + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +// Response model for list operations endpoint. +// Ref: #/components/schemas/OperationsListResponse +type OperationsListResponse struct { + BankID string `json:"bank_id"` + Limit int `json:"limit"` + Offset int `json:"offset"` + Operations []OperationResponse `json:"operations"` + Total int `json:"total"` +} + +// GetBankID returns the value of BankID. +func (s *OperationsListResponse) GetBankID() string { + return s.BankID +} + +// GetLimit returns the value of Limit. +func (s *OperationsListResponse) GetLimit() int { + return s.Limit +} + +// GetOffset returns the value of Offset. +func (s *OperationsListResponse) GetOffset() int { + return s.Offset +} + +// GetOperations returns the value of Operations. +func (s *OperationsListResponse) GetOperations() []OperationResponse { + return s.Operations +} + +// GetTotal returns the value of Total. +func (s *OperationsListResponse) GetTotal() int { + return s.Total +} + +// SetBankID sets the value of BankID. +func (s *OperationsListResponse) SetBankID(val string) { + s.BankID = val +} + +// SetLimit sets the value of Limit. +func (s *OperationsListResponse) SetLimit(val int) { + s.Limit = val +} + +// SetOffset sets the value of Offset. +func (s *OperationsListResponse) SetOffset(val int) { + s.Offset = val +} + +// SetOperations sets the value of Operations. +func (s *OperationsListResponse) SetOperations(val []OperationResponse) { + s.Operations = val +} + +// SetTotal sets the value of Total. +func (s *OperationsListResponse) SetTotal(val int) { + s.Total = val +} + +func (*OperationsListResponse) listOperationsRes() {} + +// NewOptBool returns new OptBool with value set to v. +func NewOptBool(v bool) OptBool { + return OptBool{ + Value: v, + Set: true, + } +} + +// OptBool is optional bool. +type OptBool struct { + Value bool + Set bool +} + +// IsSet returns true if OptBool was set. +func (o OptBool) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptBool) Reset() { + var v bool + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptBool) SetTo(v bool) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptBool) Get() (v bool, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptBool) Or(d bool) bool { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptBudget returns new OptBudget with value set to v. +func NewOptBudget(v Budget) OptBudget { + return OptBudget{ + Value: v, + Set: true, + } +} + +// OptBudget is optional Budget. +type OptBudget struct { + Value Budget + Set bool +} + +// IsSet returns true if OptBudget was set. +func (o OptBudget) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptBudget) Reset() { + var v Budget + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptBudget) SetTo(v Budget) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptBudget) Get() (v Budget, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptBudget) Or(d Budget) Budget { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptChunkIncludeOptions returns new OptChunkIncludeOptions with value set to v. +func NewOptChunkIncludeOptions(v ChunkIncludeOptions) OptChunkIncludeOptions { + return OptChunkIncludeOptions{ + Value: v, + Set: true, + } +} + +// OptChunkIncludeOptions is optional ChunkIncludeOptions. +type OptChunkIncludeOptions struct { + Value ChunkIncludeOptions + Set bool +} + +// IsSet returns true if OptChunkIncludeOptions was set. +func (o OptChunkIncludeOptions) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptChunkIncludeOptions) Reset() { + var v ChunkIncludeOptions + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptChunkIncludeOptions) SetTo(v ChunkIncludeOptions) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptChunkIncludeOptions) Get() (v ChunkIncludeOptions, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptChunkIncludeOptions) Or(d ChunkIncludeOptions) ChunkIncludeOptions { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptDateTime returns new OptDateTime with value set to v. +func NewOptDateTime(v time.Time) OptDateTime { + return OptDateTime{ + Value: v, + Set: true, + } +} + +// OptDateTime is optional time.Time. +type OptDateTime struct { + Value time.Time + Set bool +} + +// IsSet returns true if OptDateTime was set. +func (o OptDateTime) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDateTime) Reset() { + var v time.Time + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDateTime) SetTo(v time.Time) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDateTime) Get() (v time.Time, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptDateTime) Or(d time.Time) time.Time { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptDispositionTraits returns new OptDispositionTraits with value set to v. +func NewOptDispositionTraits(v DispositionTraits) OptDispositionTraits { + return OptDispositionTraits{ + Value: v, + Set: true, + } +} + +// OptDispositionTraits is optional DispositionTraits. +type OptDispositionTraits struct { + Value DispositionTraits + Set bool +} + +// IsSet returns true if OptDispositionTraits was set. +func (o OptDispositionTraits) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDispositionTraits) Reset() { + var v DispositionTraits + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDispositionTraits) SetTo(v DispositionTraits) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDispositionTraits) Get() (v DispositionTraits, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptDispositionTraits) Or(d DispositionTraits) DispositionTraits { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptEntityDetailResponseMetadata returns new OptEntityDetailResponseMetadata with value set to v. +func NewOptEntityDetailResponseMetadata(v EntityDetailResponseMetadata) OptEntityDetailResponseMetadata { + return OptEntityDetailResponseMetadata{ + Value: v, + Set: true, + } +} + +// OptEntityDetailResponseMetadata is optional EntityDetailResponseMetadata. +type OptEntityDetailResponseMetadata struct { + Value EntityDetailResponseMetadata + Set bool +} + +// IsSet returns true if OptEntityDetailResponseMetadata was set. +func (o OptEntityDetailResponseMetadata) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptEntityDetailResponseMetadata) Reset() { + var v EntityDetailResponseMetadata + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptEntityDetailResponseMetadata) SetTo(v EntityDetailResponseMetadata) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptEntityDetailResponseMetadata) Get() (v EntityDetailResponseMetadata, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptEntityDetailResponseMetadata) Or(d EntityDetailResponseMetadata) EntityDetailResponseMetadata { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptEntityIncludeOptions returns new OptEntityIncludeOptions with value set to v. +func NewOptEntityIncludeOptions(v EntityIncludeOptions) OptEntityIncludeOptions { + return OptEntityIncludeOptions{ + Value: v, + Set: true, + } +} + +// OptEntityIncludeOptions is optional EntityIncludeOptions. +type OptEntityIncludeOptions struct { + Value EntityIncludeOptions + Set bool +} + +// IsSet returns true if OptEntityIncludeOptions was set. +func (o OptEntityIncludeOptions) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptEntityIncludeOptions) Reset() { + var v EntityIncludeOptions + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptEntityIncludeOptions) SetTo(v EntityIncludeOptions) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptEntityIncludeOptions) Get() (v EntityIncludeOptions, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptEntityIncludeOptions) Or(d EntityIncludeOptions) EntityIncludeOptions { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptEntityListItemMetadata returns new OptEntityListItemMetadata with value set to v. +func NewOptEntityListItemMetadata(v EntityListItemMetadata) OptEntityListItemMetadata { + return OptEntityListItemMetadata{ + Value: v, + Set: true, + } +} + +// OptEntityListItemMetadata is optional EntityListItemMetadata. +type OptEntityListItemMetadata struct { + Value EntityListItemMetadata + Set bool +} + +// IsSet returns true if OptEntityListItemMetadata was set. +func (o OptEntityListItemMetadata) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptEntityListItemMetadata) Reset() { + var v EntityListItemMetadata + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptEntityListItemMetadata) SetTo(v EntityListItemMetadata) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptEntityListItemMetadata) Get() (v EntityListItemMetadata, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptEntityListItemMetadata) Or(d EntityListItemMetadata) EntityListItemMetadata { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptIncludeOptions returns new OptIncludeOptions with value set to v. +func NewOptIncludeOptions(v IncludeOptions) OptIncludeOptions { + return OptIncludeOptions{ + Value: v, + Set: true, + } +} + +// OptIncludeOptions is optional IncludeOptions. +type OptIncludeOptions struct { + Value IncludeOptions + Set bool +} + +// IsSet returns true if OptIncludeOptions was set. +func (o OptIncludeOptions) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptIncludeOptions) Reset() { + var v IncludeOptions + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptIncludeOptions) SetTo(v IncludeOptions) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptIncludeOptions) Get() (v IncludeOptions, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptIncludeOptions) Or(d IncludeOptions) IncludeOptions { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptInt returns new OptInt with value set to v. +func NewOptInt(v int) OptInt { + return OptInt{ + Value: v, + Set: true, + } +} + +// OptInt is optional int. +type OptInt struct { + Value int + Set bool +} + +// IsSet returns true if OptInt was set. +func (o OptInt) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptInt) Reset() { + var v int + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptInt) SetTo(v int) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptInt) Get() (v int, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptInt) Or(d int) int { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptListDirectivesTagsMatch returns new OptListDirectivesTagsMatch with value set to v. +func NewOptListDirectivesTagsMatch(v ListDirectivesTagsMatch) OptListDirectivesTagsMatch { + return OptListDirectivesTagsMatch{ + Value: v, + Set: true, + } +} + +// OptListDirectivesTagsMatch is optional ListDirectivesTagsMatch. +type OptListDirectivesTagsMatch struct { + Value ListDirectivesTagsMatch + Set bool +} + +// IsSet returns true if OptListDirectivesTagsMatch was set. +func (o OptListDirectivesTagsMatch) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptListDirectivesTagsMatch) Reset() { + var v ListDirectivesTagsMatch + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptListDirectivesTagsMatch) SetTo(v ListDirectivesTagsMatch) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptListDirectivesTagsMatch) Get() (v ListDirectivesTagsMatch, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptListDirectivesTagsMatch) Or(d ListDirectivesTagsMatch) ListDirectivesTagsMatch { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptListMentalModelsTagsMatch returns new OptListMentalModelsTagsMatch with value set to v. +func NewOptListMentalModelsTagsMatch(v ListMentalModelsTagsMatch) OptListMentalModelsTagsMatch { + return OptListMentalModelsTagsMatch{ + Value: v, + Set: true, + } +} + +// OptListMentalModelsTagsMatch is optional ListMentalModelsTagsMatch. +type OptListMentalModelsTagsMatch struct { + Value ListMentalModelsTagsMatch + Set bool +} + +// IsSet returns true if OptListMentalModelsTagsMatch was set. +func (o OptListMentalModelsTagsMatch) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptListMentalModelsTagsMatch) Reset() { + var v ListMentalModelsTagsMatch + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptListMentalModelsTagsMatch) SetTo(v ListMentalModelsTagsMatch) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptListMentalModelsTagsMatch) Get() (v ListMentalModelsTagsMatch, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptListMentalModelsTagsMatch) Or(d ListMentalModelsTagsMatch) ListMentalModelsTagsMatch { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptMemoryItemMetadata returns new OptMemoryItemMetadata with value set to v. +func NewOptMemoryItemMetadata(v MemoryItemMetadata) OptMemoryItemMetadata { + return OptMemoryItemMetadata{ + Value: v, + Set: true, + } +} + +// OptMemoryItemMetadata is optional MemoryItemMetadata. +type OptMemoryItemMetadata struct { + Value MemoryItemMetadata + Set bool +} + +// IsSet returns true if OptMemoryItemMetadata was set. +func (o OptMemoryItemMetadata) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptMemoryItemMetadata) Reset() { + var v MemoryItemMetadata + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptMemoryItemMetadata) SetTo(v MemoryItemMetadata) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptMemoryItemMetadata) Get() (v MemoryItemMetadata, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptMemoryItemMetadata) Or(d MemoryItemMetadata) MemoryItemMetadata { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptMentalModelResponseReflectResponse returns new OptMentalModelResponseReflectResponse with value set to v. +func NewOptMentalModelResponseReflectResponse(v MentalModelResponseReflectResponse) OptMentalModelResponseReflectResponse { + return OptMentalModelResponseReflectResponse{ + Value: v, + Set: true, + } +} + +// OptMentalModelResponseReflectResponse is optional MentalModelResponseReflectResponse. +type OptMentalModelResponseReflectResponse struct { + Value MentalModelResponseReflectResponse + Set bool +} + +// IsSet returns true if OptMentalModelResponseReflectResponse was set. +func (o OptMentalModelResponseReflectResponse) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptMentalModelResponseReflectResponse) Reset() { + var v MentalModelResponseReflectResponse + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptMentalModelResponseReflectResponse) SetTo(v MentalModelResponseReflectResponse) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptMentalModelResponseReflectResponse) Get() (v MentalModelResponseReflectResponse, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptMentalModelResponseReflectResponse) Or(d MentalModelResponseReflectResponse) MentalModelResponseReflectResponse { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptMentalModelTrigger returns new OptMentalModelTrigger with value set to v. +func NewOptMentalModelTrigger(v MentalModelTrigger) OptMentalModelTrigger { + return OptMentalModelTrigger{ + Value: v, + Set: true, + } +} + +// OptMentalModelTrigger is optional MentalModelTrigger. +type OptMentalModelTrigger struct { + Value MentalModelTrigger + Set bool +} + +// IsSet returns true if OptMentalModelTrigger was set. +func (o OptMentalModelTrigger) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptMentalModelTrigger) Reset() { + var v MentalModelTrigger + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptMentalModelTrigger) SetTo(v MentalModelTrigger) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptMentalModelTrigger) Get() (v MentalModelTrigger, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptMentalModelTrigger) Or(d MentalModelTrigger) MentalModelTrigger { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptRecallRequestTagsMatch returns new OptRecallRequestTagsMatch with value set to v. +func NewOptRecallRequestTagsMatch(v RecallRequestTagsMatch) OptRecallRequestTagsMatch { + return OptRecallRequestTagsMatch{ + Value: v, + Set: true, + } +} + +// OptRecallRequestTagsMatch is optional RecallRequestTagsMatch. +type OptRecallRequestTagsMatch struct { + Value RecallRequestTagsMatch + Set bool +} + +// IsSet returns true if OptRecallRequestTagsMatch was set. +func (o OptRecallRequestTagsMatch) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptRecallRequestTagsMatch) Reset() { + var v RecallRequestTagsMatch + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptRecallRequestTagsMatch) SetTo(v RecallRequestTagsMatch) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptRecallRequestTagsMatch) Get() (v RecallRequestTagsMatch, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptRecallRequestTagsMatch) Or(d RecallRequestTagsMatch) RecallRequestTagsMatch { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptRecallResponseChunks returns new OptRecallResponseChunks with value set to v. +func NewOptRecallResponseChunks(v RecallResponseChunks) OptRecallResponseChunks { + return OptRecallResponseChunks{ + Value: v, + Set: true, + } +} + +// OptRecallResponseChunks is optional RecallResponseChunks. +type OptRecallResponseChunks struct { + Value RecallResponseChunks + Set bool +} + +// IsSet returns true if OptRecallResponseChunks was set. +func (o OptRecallResponseChunks) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptRecallResponseChunks) Reset() { + var v RecallResponseChunks + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptRecallResponseChunks) SetTo(v RecallResponseChunks) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptRecallResponseChunks) Get() (v RecallResponseChunks, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptRecallResponseChunks) Or(d RecallResponseChunks) RecallResponseChunks { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptRecallResponseEntities returns new OptRecallResponseEntities with value set to v. +func NewOptRecallResponseEntities(v RecallResponseEntities) OptRecallResponseEntities { + return OptRecallResponseEntities{ + Value: v, + Set: true, + } +} + +// OptRecallResponseEntities is optional RecallResponseEntities. +type OptRecallResponseEntities struct { + Value RecallResponseEntities + Set bool +} + +// IsSet returns true if OptRecallResponseEntities was set. +func (o OptRecallResponseEntities) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptRecallResponseEntities) Reset() { + var v RecallResponseEntities + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptRecallResponseEntities) SetTo(v RecallResponseEntities) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptRecallResponseEntities) Get() (v RecallResponseEntities, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptRecallResponseEntities) Or(d RecallResponseEntities) RecallResponseEntities { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptRecallResponseTrace returns new OptRecallResponseTrace with value set to v. +func NewOptRecallResponseTrace(v RecallResponseTrace) OptRecallResponseTrace { + return OptRecallResponseTrace{ + Value: v, + Set: true, + } +} + +// OptRecallResponseTrace is optional RecallResponseTrace. +type OptRecallResponseTrace struct { + Value RecallResponseTrace + Set bool +} + +// IsSet returns true if OptRecallResponseTrace was set. +func (o OptRecallResponseTrace) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptRecallResponseTrace) Reset() { + var v RecallResponseTrace + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptRecallResponseTrace) SetTo(v RecallResponseTrace) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptRecallResponseTrace) Get() (v RecallResponseTrace, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptRecallResponseTrace) Or(d RecallResponseTrace) RecallResponseTrace { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptRecallResultMetadata returns new OptRecallResultMetadata with value set to v. +func NewOptRecallResultMetadata(v RecallResultMetadata) OptRecallResultMetadata { + return OptRecallResultMetadata{ + Value: v, + Set: true, + } +} + +// OptRecallResultMetadata is optional RecallResultMetadata. +type OptRecallResultMetadata struct { + Value RecallResultMetadata + Set bool +} + +// IsSet returns true if OptRecallResultMetadata was set. +func (o OptRecallResultMetadata) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptRecallResultMetadata) Reset() { + var v RecallResultMetadata + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptRecallResultMetadata) SetTo(v RecallResultMetadata) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptRecallResultMetadata) Get() (v RecallResultMetadata, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptRecallResultMetadata) Or(d RecallResultMetadata) RecallResultMetadata { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptReflectBasedOn returns new OptReflectBasedOn with value set to v. +func NewOptReflectBasedOn(v ReflectBasedOn) OptReflectBasedOn { + return OptReflectBasedOn{ + Value: v, + Set: true, + } +} + +// OptReflectBasedOn is optional ReflectBasedOn. +type OptReflectBasedOn struct { + Value ReflectBasedOn + Set bool +} + +// IsSet returns true if OptReflectBasedOn was set. +func (o OptReflectBasedOn) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptReflectBasedOn) Reset() { + var v ReflectBasedOn + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptReflectBasedOn) SetTo(v ReflectBasedOn) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptReflectBasedOn) Get() (v ReflectBasedOn, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptReflectBasedOn) Or(d ReflectBasedOn) ReflectBasedOn { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptReflectIncludeOptions returns new OptReflectIncludeOptions with value set to v. +func NewOptReflectIncludeOptions(v ReflectIncludeOptions) OptReflectIncludeOptions { + return OptReflectIncludeOptions{ + Value: v, + Set: true, + } +} + +// OptReflectIncludeOptions is optional ReflectIncludeOptions. +type OptReflectIncludeOptions struct { + Value ReflectIncludeOptions + Set bool +} + +// IsSet returns true if OptReflectIncludeOptions was set. +func (o OptReflectIncludeOptions) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptReflectIncludeOptions) Reset() { + var v ReflectIncludeOptions + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptReflectIncludeOptions) SetTo(v ReflectIncludeOptions) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptReflectIncludeOptions) Get() (v ReflectIncludeOptions, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptReflectIncludeOptions) Or(d ReflectIncludeOptions) ReflectIncludeOptions { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptReflectRequestResponseSchema returns new OptReflectRequestResponseSchema with value set to v. +func NewOptReflectRequestResponseSchema(v ReflectRequestResponseSchema) OptReflectRequestResponseSchema { + return OptReflectRequestResponseSchema{ + Value: v, + Set: true, + } +} + +// OptReflectRequestResponseSchema is optional ReflectRequestResponseSchema. +type OptReflectRequestResponseSchema struct { + Value ReflectRequestResponseSchema + Set bool +} + +// IsSet returns true if OptReflectRequestResponseSchema was set. +func (o OptReflectRequestResponseSchema) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptReflectRequestResponseSchema) Reset() { + var v ReflectRequestResponseSchema + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptReflectRequestResponseSchema) SetTo(v ReflectRequestResponseSchema) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptReflectRequestResponseSchema) Get() (v ReflectRequestResponseSchema, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptReflectRequestResponseSchema) Or(d ReflectRequestResponseSchema) ReflectRequestResponseSchema { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptReflectRequestTagsMatch returns new OptReflectRequestTagsMatch with value set to v. +func NewOptReflectRequestTagsMatch(v ReflectRequestTagsMatch) OptReflectRequestTagsMatch { + return OptReflectRequestTagsMatch{ + Value: v, + Set: true, + } +} + +// OptReflectRequestTagsMatch is optional ReflectRequestTagsMatch. +type OptReflectRequestTagsMatch struct { + Value ReflectRequestTagsMatch + Set bool +} + +// IsSet returns true if OptReflectRequestTagsMatch was set. +func (o OptReflectRequestTagsMatch) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptReflectRequestTagsMatch) Reset() { + var v ReflectRequestTagsMatch + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptReflectRequestTagsMatch) SetTo(v ReflectRequestTagsMatch) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptReflectRequestTagsMatch) Get() (v ReflectRequestTagsMatch, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptReflectRequestTagsMatch) Or(d ReflectRequestTagsMatch) ReflectRequestTagsMatch { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptReflectResponseStructuredOutput returns new OptReflectResponseStructuredOutput with value set to v. +func NewOptReflectResponseStructuredOutput(v ReflectResponseStructuredOutput) OptReflectResponseStructuredOutput { + return OptReflectResponseStructuredOutput{ + Value: v, + Set: true, + } +} + +// OptReflectResponseStructuredOutput is optional ReflectResponseStructuredOutput. +type OptReflectResponseStructuredOutput struct { + Value ReflectResponseStructuredOutput + Set bool +} + +// IsSet returns true if OptReflectResponseStructuredOutput was set. +func (o OptReflectResponseStructuredOutput) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptReflectResponseStructuredOutput) Reset() { + var v ReflectResponseStructuredOutput + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptReflectResponseStructuredOutput) SetTo(v ReflectResponseStructuredOutput) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptReflectResponseStructuredOutput) Get() (v ReflectResponseStructuredOutput, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptReflectResponseStructuredOutput) Or(d ReflectResponseStructuredOutput) ReflectResponseStructuredOutput { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptReflectToolCallOutput returns new OptReflectToolCallOutput with value set to v. +func NewOptReflectToolCallOutput(v ReflectToolCallOutput) OptReflectToolCallOutput { + return OptReflectToolCallOutput{ + Value: v, + Set: true, + } +} + +// OptReflectToolCallOutput is optional ReflectToolCallOutput. +type OptReflectToolCallOutput struct { + Value ReflectToolCallOutput + Set bool +} + +// IsSet returns true if OptReflectToolCallOutput was set. +func (o OptReflectToolCallOutput) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptReflectToolCallOutput) Reset() { + var v ReflectToolCallOutput + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptReflectToolCallOutput) SetTo(v ReflectToolCallOutput) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptReflectToolCallOutput) Get() (v ReflectToolCallOutput, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptReflectToolCallOutput) Or(d ReflectToolCallOutput) ReflectToolCallOutput { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptReflectTrace returns new OptReflectTrace with value set to v. +func NewOptReflectTrace(v ReflectTrace) OptReflectTrace { + return OptReflectTrace{ + Value: v, + Set: true, + } +} + +// OptReflectTrace is optional ReflectTrace. +type OptReflectTrace struct { + Value ReflectTrace + Set bool +} + +// IsSet returns true if OptReflectTrace was set. +func (o OptReflectTrace) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptReflectTrace) Reset() { + var v ReflectTrace + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptReflectTrace) SetTo(v ReflectTrace) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptReflectTrace) Get() (v ReflectTrace, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptReflectTrace) Or(d ReflectTrace) ReflectTrace { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptString returns new OptString with value set to v. +func NewOptString(v string) OptString { + return OptString{ + Value: v, + Set: true, + } +} + +// OptString is optional string. +type OptString struct { + Value string + Set bool +} + +// IsSet returns true if OptString was set. +func (o OptString) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptString) Reset() { + var v string + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptString) SetTo(v string) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptString) Get() (v string, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptString) Or(d string) string { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptTokenUsage returns new OptTokenUsage with value set to v. +func NewOptTokenUsage(v TokenUsage) OptTokenUsage { + return OptTokenUsage{ + Value: v, + Set: true, + } +} + +// OptTokenUsage is optional TokenUsage. +type OptTokenUsage struct { + Value TokenUsage + Set bool +} + +// IsSet returns true if OptTokenUsage was set. +func (o OptTokenUsage) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptTokenUsage) Reset() { + var v TokenUsage + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptTokenUsage) SetTo(v TokenUsage) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptTokenUsage) Get() (v TokenUsage, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptTokenUsage) Or(d TokenUsage) TokenUsage { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptToolCallsIncludeOptions returns new OptToolCallsIncludeOptions with value set to v. +func NewOptToolCallsIncludeOptions(v ToolCallsIncludeOptions) OptToolCallsIncludeOptions { + return OptToolCallsIncludeOptions{ + Value: v, + Set: true, + } +} + +// OptToolCallsIncludeOptions is optional ToolCallsIncludeOptions. +type OptToolCallsIncludeOptions struct { + Value ToolCallsIncludeOptions + Set bool +} + +// IsSet returns true if OptToolCallsIncludeOptions was set. +func (o OptToolCallsIncludeOptions) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptToolCallsIncludeOptions) Reset() { + var v ToolCallsIncludeOptions + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptToolCallsIncludeOptions) SetTo(v ToolCallsIncludeOptions) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptToolCallsIncludeOptions) Get() (v ToolCallsIncludeOptions, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptToolCallsIncludeOptions) Or(d ToolCallsIncludeOptions) ToolCallsIncludeOptions { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// Request model for recall endpoint. +// Ref: #/components/schemas/RecallRequest +type RecallRequest struct { + Budget OptBudget `json:"budget"` + // Options for including additional data (entities are included by default). + Include OptIncludeOptions `json:"include"` + MaxTokens OptInt `json:"max_tokens"` + Query string `json:"query"` + // ISO format date string (e.g., '2023-05-30T23:40:00'). + QueryTimestamp OptString `json:"query_timestamp"` + // Filter memories by tags. If not specified, all memories are returned. + Tags []string `json:"tags"` + // How to match tags: 'any' (OR, includes untagged), 'all' (AND, includes untagged), 'any_strict' (OR, + // excludes untagged), 'all_strict' (AND, excludes untagged). + TagsMatch OptRecallRequestTagsMatch `json:"tags_match"` + Trace OptBool `json:"trace"` + // List of fact types to recall: 'world', 'experience', 'observation'. Defaults to world and + // experience if not specified. + Types []string `json:"types"` +} + +// GetBudget returns the value of Budget. +func (s *RecallRequest) GetBudget() OptBudget { + return s.Budget +} + +// GetInclude returns the value of Include. +func (s *RecallRequest) GetInclude() OptIncludeOptions { + return s.Include +} + +// GetMaxTokens returns the value of MaxTokens. +func (s *RecallRequest) GetMaxTokens() OptInt { + return s.MaxTokens +} + +// GetQuery returns the value of Query. +func (s *RecallRequest) GetQuery() string { + return s.Query +} + +// GetQueryTimestamp returns the value of QueryTimestamp. +func (s *RecallRequest) GetQueryTimestamp() OptString { + return s.QueryTimestamp +} + +// GetTags returns the value of Tags. +func (s *RecallRequest) GetTags() []string { + return s.Tags +} + +// GetTagsMatch returns the value of TagsMatch. +func (s *RecallRequest) GetTagsMatch() OptRecallRequestTagsMatch { + return s.TagsMatch +} + +// GetTrace returns the value of Trace. +func (s *RecallRequest) GetTrace() OptBool { + return s.Trace +} + +// GetTypes returns the value of Types. +func (s *RecallRequest) GetTypes() []string { + return s.Types +} + +// SetBudget sets the value of Budget. +func (s *RecallRequest) SetBudget(val OptBudget) { + s.Budget = val +} + +// SetInclude sets the value of Include. +func (s *RecallRequest) SetInclude(val OptIncludeOptions) { + s.Include = val +} + +// SetMaxTokens sets the value of MaxTokens. +func (s *RecallRequest) SetMaxTokens(val OptInt) { + s.MaxTokens = val +} + +// SetQuery sets the value of Query. +func (s *RecallRequest) SetQuery(val string) { + s.Query = val +} + +// SetQueryTimestamp sets the value of QueryTimestamp. +func (s *RecallRequest) SetQueryTimestamp(val OptString) { + s.QueryTimestamp = val +} + +// SetTags sets the value of Tags. +func (s *RecallRequest) SetTags(val []string) { + s.Tags = val +} + +// SetTagsMatch sets the value of TagsMatch. +func (s *RecallRequest) SetTagsMatch(val OptRecallRequestTagsMatch) { + s.TagsMatch = val +} + +// SetTrace sets the value of Trace. +func (s *RecallRequest) SetTrace(val OptBool) { + s.Trace = val +} + +// SetTypes sets the value of Types. +func (s *RecallRequest) SetTypes(val []string) { + s.Types = val +} + +// How to match tags: 'any' (OR, includes untagged), 'all' (AND, includes untagged), 'any_strict' (OR, +// +// excludes untagged), 'all_strict' (AND, excludes untagged). +type RecallRequestTagsMatch string + +const ( + RecallRequestTagsMatchAny RecallRequestTagsMatch = "any" + RecallRequestTagsMatchAll RecallRequestTagsMatch = "all" + RecallRequestTagsMatchAnyStrict RecallRequestTagsMatch = "any_strict" + RecallRequestTagsMatchAllStrict RecallRequestTagsMatch = "all_strict" +) + +// AllValues returns all RecallRequestTagsMatch values. +func (RecallRequestTagsMatch) AllValues() []RecallRequestTagsMatch { + return []RecallRequestTagsMatch{ + RecallRequestTagsMatchAny, + RecallRequestTagsMatchAll, + RecallRequestTagsMatchAnyStrict, + RecallRequestTagsMatchAllStrict, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s RecallRequestTagsMatch) MarshalText() ([]byte, error) { + switch s { + case RecallRequestTagsMatchAny: + return []byte(s), nil + case RecallRequestTagsMatchAll: + return []byte(s), nil + case RecallRequestTagsMatchAnyStrict: + return []byte(s), nil + case RecallRequestTagsMatchAllStrict: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *RecallRequestTagsMatch) UnmarshalText(data []byte) error { + switch RecallRequestTagsMatch(data) { + case RecallRequestTagsMatchAny: + *s = RecallRequestTagsMatchAny + return nil + case RecallRequestTagsMatchAll: + *s = RecallRequestTagsMatchAll + return nil + case RecallRequestTagsMatchAnyStrict: + *s = RecallRequestTagsMatchAnyStrict + return nil + case RecallRequestTagsMatchAllStrict: + *s = RecallRequestTagsMatchAllStrict + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +// Response model for recall endpoints. +// Ref: #/components/schemas/RecallResponse +type RecallResponse struct { + // Chunks for facts, keyed by chunk_id. + Chunks OptRecallResponseChunks `json:"chunks"` + // Entity states for entities mentioned in results. + Entities OptRecallResponseEntities `json:"entities"` + Results []RecallResult `json:"results"` + Trace OptRecallResponseTrace `json:"trace"` +} + +// GetChunks returns the value of Chunks. +func (s *RecallResponse) GetChunks() OptRecallResponseChunks { + return s.Chunks +} + +// GetEntities returns the value of Entities. +func (s *RecallResponse) GetEntities() OptRecallResponseEntities { + return s.Entities +} + +// GetResults returns the value of Results. +func (s *RecallResponse) GetResults() []RecallResult { + return s.Results +} + +// GetTrace returns the value of Trace. +func (s *RecallResponse) GetTrace() OptRecallResponseTrace { + return s.Trace +} + +// SetChunks sets the value of Chunks. +func (s *RecallResponse) SetChunks(val OptRecallResponseChunks) { + s.Chunks = val +} + +// SetEntities sets the value of Entities. +func (s *RecallResponse) SetEntities(val OptRecallResponseEntities) { + s.Entities = val +} + +// SetResults sets the value of Results. +func (s *RecallResponse) SetResults(val []RecallResult) { + s.Results = val +} + +// SetTrace sets the value of Trace. +func (s *RecallResponse) SetTrace(val OptRecallResponseTrace) { + s.Trace = val +} + +func (*RecallResponse) recallMemoriesRes() {} + +// Chunks for facts, keyed by chunk_id. +type RecallResponseChunks map[string]ChunkData + +func (s *RecallResponseChunks) init() RecallResponseChunks { + m := *s + if m == nil { + m = map[string]ChunkData{} + *s = m + } + return m +} + +// Entity states for entities mentioned in results. +type RecallResponseEntities map[string]EntityStateResponse + +func (s *RecallResponseEntities) init() RecallResponseEntities { + m := *s + if m == nil { + m = map[string]EntityStateResponse{} + *s = m + } + return m +} + +type RecallResponseTrace map[string]jx.Raw + +func (s *RecallResponseTrace) init() RecallResponseTrace { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Single recall result item. +// Ref: #/components/schemas/RecallResult +type RecallResult struct { + ChunkID OptString `json:"chunk_id"` + Context OptString `json:"context"` + DocumentID OptString `json:"document_id"` + Entities []string `json:"entities"` + ID string `json:"id"` + MentionedAt OptString `json:"mentioned_at"` + Metadata OptRecallResultMetadata `json:"metadata"` + OccurredEnd OptString `json:"occurred_end"` + OccurredStart OptString `json:"occurred_start"` + Tags []string `json:"tags"` + Text string `json:"text"` + Type OptString `json:"type"` +} + +// GetChunkID returns the value of ChunkID. +func (s *RecallResult) GetChunkID() OptString { + return s.ChunkID +} + +// GetContext returns the value of Context. +func (s *RecallResult) GetContext() OptString { + return s.Context +} + +// GetDocumentID returns the value of DocumentID. +func (s *RecallResult) GetDocumentID() OptString { + return s.DocumentID +} + +// GetEntities returns the value of Entities. +func (s *RecallResult) GetEntities() []string { + return s.Entities +} + +// GetID returns the value of ID. +func (s *RecallResult) GetID() string { + return s.ID +} + +// GetMentionedAt returns the value of MentionedAt. +func (s *RecallResult) GetMentionedAt() OptString { + return s.MentionedAt +} + +// GetMetadata returns the value of Metadata. +func (s *RecallResult) GetMetadata() OptRecallResultMetadata { + return s.Metadata +} + +// GetOccurredEnd returns the value of OccurredEnd. +func (s *RecallResult) GetOccurredEnd() OptString { + return s.OccurredEnd +} + +// GetOccurredStart returns the value of OccurredStart. +func (s *RecallResult) GetOccurredStart() OptString { + return s.OccurredStart +} + +// GetTags returns the value of Tags. +func (s *RecallResult) GetTags() []string { + return s.Tags +} + +// GetText returns the value of Text. +func (s *RecallResult) GetText() string { + return s.Text +} + +// GetType returns the value of Type. +func (s *RecallResult) GetType() OptString { + return s.Type +} + +// SetChunkID sets the value of ChunkID. +func (s *RecallResult) SetChunkID(val OptString) { + s.ChunkID = val +} + +// SetContext sets the value of Context. +func (s *RecallResult) SetContext(val OptString) { + s.Context = val +} + +// SetDocumentID sets the value of DocumentID. +func (s *RecallResult) SetDocumentID(val OptString) { + s.DocumentID = val +} + +// SetEntities sets the value of Entities. +func (s *RecallResult) SetEntities(val []string) { + s.Entities = val +} + +// SetID sets the value of ID. +func (s *RecallResult) SetID(val string) { + s.ID = val +} + +// SetMentionedAt sets the value of MentionedAt. +func (s *RecallResult) SetMentionedAt(val OptString) { + s.MentionedAt = val +} + +// SetMetadata sets the value of Metadata. +func (s *RecallResult) SetMetadata(val OptRecallResultMetadata) { + s.Metadata = val +} + +// SetOccurredEnd sets the value of OccurredEnd. +func (s *RecallResult) SetOccurredEnd(val OptString) { + s.OccurredEnd = val +} + +// SetOccurredStart sets the value of OccurredStart. +func (s *RecallResult) SetOccurredStart(val OptString) { + s.OccurredStart = val +} + +// SetTags sets the value of Tags. +func (s *RecallResult) SetTags(val []string) { + s.Tags = val +} + +// SetText sets the value of Text. +func (s *RecallResult) SetText(val string) { + s.Text = val +} + +// SetType sets the value of Type. +func (s *RecallResult) SetType(val OptString) { + s.Type = val +} + +type RecallResultMetadata map[string]string + +func (s *RecallResultMetadata) init() RecallResultMetadata { + m := *s + if m == nil { + m = map[string]string{} + *s = m + } + return m +} + +// Evidence the response is based on: memories, mental models, and directives. +// Ref: #/components/schemas/ReflectBasedOn +type ReflectBasedOn struct { + // Directives applied during reflection. + Directives []ReflectDirective `json:"directives"` + // Memory facts used to generate the response. + Memories []ReflectFact `json:"memories"` + // Mental models used during reflection. + MentalModels []ReflectMentalModel `json:"mental_models"` +} + +// GetDirectives returns the value of Directives. +func (s *ReflectBasedOn) GetDirectives() []ReflectDirective { + return s.Directives +} + +// GetMemories returns the value of Memories. +func (s *ReflectBasedOn) GetMemories() []ReflectFact { + return s.Memories +} + +// GetMentalModels returns the value of MentalModels. +func (s *ReflectBasedOn) GetMentalModels() []ReflectMentalModel { + return s.MentalModels +} + +// SetDirectives sets the value of Directives. +func (s *ReflectBasedOn) SetDirectives(val []ReflectDirective) { + s.Directives = val +} + +// SetMemories sets the value of Memories. +func (s *ReflectBasedOn) SetMemories(val []ReflectFact) { + s.Memories = val +} + +// SetMentalModels sets the value of MentalModels. +func (s *ReflectBasedOn) SetMentalModels(val []ReflectMentalModel) { + s.MentalModels = val +} + +// A directive applied during reflect. +// Ref: #/components/schemas/ReflectDirective +type ReflectDirective struct { + // Directive content. + Content string `json:"content"` + // Directive ID. + ID string `json:"id"` + // Directive name. + Name string `json:"name"` +} + +// GetContent returns the value of Content. +func (s *ReflectDirective) GetContent() string { + return s.Content +} + +// GetID returns the value of ID. +func (s *ReflectDirective) GetID() string { + return s.ID +} + +// GetName returns the value of Name. +func (s *ReflectDirective) GetName() string { + return s.Name +} + +// SetContent sets the value of Content. +func (s *ReflectDirective) SetContent(val string) { + s.Content = val +} + +// SetID sets the value of ID. +func (s *ReflectDirective) SetID(val string) { + s.ID = val +} + +// SetName sets the value of Name. +func (s *ReflectDirective) SetName(val string) { + s.Name = val +} + +// A fact used in think response. +// Ref: #/components/schemas/ReflectFact +type ReflectFact struct { + Context OptString `json:"context"` + ID OptString `json:"id"` + OccurredEnd OptString `json:"occurred_end"` + OccurredStart OptString `json:"occurred_start"` + // Fact text. When type='observation', this contains markdown-formatted consolidated knowledge. + Text string `json:"text"` + Type OptString `json:"type"` +} + +// GetContext returns the value of Context. +func (s *ReflectFact) GetContext() OptString { + return s.Context +} + +// GetID returns the value of ID. +func (s *ReflectFact) GetID() OptString { + return s.ID +} + +// GetOccurredEnd returns the value of OccurredEnd. +func (s *ReflectFact) GetOccurredEnd() OptString { + return s.OccurredEnd +} + +// GetOccurredStart returns the value of OccurredStart. +func (s *ReflectFact) GetOccurredStart() OptString { + return s.OccurredStart +} + +// GetText returns the value of Text. +func (s *ReflectFact) GetText() string { + return s.Text +} + +// GetType returns the value of Type. +func (s *ReflectFact) GetType() OptString { + return s.Type +} + +// SetContext sets the value of Context. +func (s *ReflectFact) SetContext(val OptString) { + s.Context = val +} + +// SetID sets the value of ID. +func (s *ReflectFact) SetID(val OptString) { + s.ID = val +} + +// SetOccurredEnd sets the value of OccurredEnd. +func (s *ReflectFact) SetOccurredEnd(val OptString) { + s.OccurredEnd = val +} + +// SetOccurredStart sets the value of OccurredStart. +func (s *ReflectFact) SetOccurredStart(val OptString) { + s.OccurredStart = val +} + +// SetText sets the value of Text. +func (s *ReflectFact) SetText(val string) { + s.Text = val +} + +// SetType sets the value of Type. +func (s *ReflectFact) SetType(val OptString) { + s.Type = val +} + +// Options for including additional data in reflect results. +// Ref: #/components/schemas/ReflectIncludeOptions +type ReflectIncludeOptions struct { + // Include facts that the answer is based on. Set to {} to enable, null to disable (default: + // disabled). + Facts *FactsIncludeOptions `json:"facts"` + // Include tool calls trace. Set to {} for full trace (input+output), {output: false} for inputs only. + ToolCalls OptToolCallsIncludeOptions `json:"tool_calls"` +} + +// GetFacts returns the value of Facts. +func (s *ReflectIncludeOptions) GetFacts() *FactsIncludeOptions { + return s.Facts +} + +// GetToolCalls returns the value of ToolCalls. +func (s *ReflectIncludeOptions) GetToolCalls() OptToolCallsIncludeOptions { + return s.ToolCalls +} + +// SetFacts sets the value of Facts. +func (s *ReflectIncludeOptions) SetFacts(val *FactsIncludeOptions) { + s.Facts = val +} + +// SetToolCalls sets the value of ToolCalls. +func (s *ReflectIncludeOptions) SetToolCalls(val OptToolCallsIncludeOptions) { + s.ToolCalls = val +} + +// An LLM call made during reflect agent execution. +// Ref: #/components/schemas/ReflectLLMCall +type ReflectLLMCall struct { + // Execution time in milliseconds. + DurationMs int `json:"duration_ms"` + // Call scope: agent_1, agent_2, final, etc. + Scope string `json:"scope"` +} + +// GetDurationMs returns the value of DurationMs. +func (s *ReflectLLMCall) GetDurationMs() int { + return s.DurationMs +} + +// GetScope returns the value of Scope. +func (s *ReflectLLMCall) GetScope() string { + return s.Scope +} + +// SetDurationMs sets the value of DurationMs. +func (s *ReflectLLMCall) SetDurationMs(val int) { + s.DurationMs = val +} + +// SetScope sets the value of Scope. +func (s *ReflectLLMCall) SetScope(val string) { + s.Scope = val +} + +// A mental model used during reflect. +// Ref: #/components/schemas/ReflectMentalModel +type ReflectMentalModel struct { + // Additional context. + Context OptString `json:"context"` + // Mental model ID. + ID string `json:"id"` + // Mental model content. + Text string `json:"text"` +} + +// GetContext returns the value of Context. +func (s *ReflectMentalModel) GetContext() OptString { + return s.Context +} + +// GetID returns the value of ID. +func (s *ReflectMentalModel) GetID() string { + return s.ID +} + +// GetText returns the value of Text. +func (s *ReflectMentalModel) GetText() string { + return s.Text +} + +// SetContext sets the value of Context. +func (s *ReflectMentalModel) SetContext(val OptString) { + s.Context = val +} + +// SetID sets the value of ID. +func (s *ReflectMentalModel) SetID(val string) { + s.ID = val +} + +// SetText sets the value of Text. +func (s *ReflectMentalModel) SetText(val string) { + s.Text = val +} + +// Request model for reflect endpoint. +// Ref: #/components/schemas/ReflectRequest +type ReflectRequest struct { + Budget OptBudget `json:"budget"` + // DEPRECATED: Additional context is now concatenated with the query. Pass context directly in the + // query field instead. If provided, it will be appended to the query for backward compatibility. + // + // Deprecated: schema marks this property as deprecated. + Context OptString `json:"context"` + // Options for including additional data (disabled by default). + Include OptReflectIncludeOptions `json:"include"` + // Maximum tokens for the response. + MaxTokens OptInt `json:"max_tokens"` + Query string `json:"query"` + // Optional JSON Schema for structured output. When provided, the response will include a + // 'structured_output' field with the LLM response parsed according to this schema. + ResponseSchema OptReflectRequestResponseSchema `json:"response_schema"` + // Filter memories by tags during reflection. If not specified, all memories are considered. + Tags []string `json:"tags"` + // How to match tags: 'any' (OR, includes untagged), 'all' (AND, includes untagged), 'any_strict' (OR, + // excludes untagged), 'all_strict' (AND, excludes untagged). + TagsMatch OptReflectRequestTagsMatch `json:"tags_match"` +} + +// GetBudget returns the value of Budget. +func (s *ReflectRequest) GetBudget() OptBudget { + return s.Budget +} + +// GetContext returns the value of Context. +func (s *ReflectRequest) GetContext() OptString { + return s.Context +} + +// GetInclude returns the value of Include. +func (s *ReflectRequest) GetInclude() OptReflectIncludeOptions { + return s.Include +} + +// GetMaxTokens returns the value of MaxTokens. +func (s *ReflectRequest) GetMaxTokens() OptInt { + return s.MaxTokens +} + +// GetQuery returns the value of Query. +func (s *ReflectRequest) GetQuery() string { + return s.Query +} + +// GetResponseSchema returns the value of ResponseSchema. +func (s *ReflectRequest) GetResponseSchema() OptReflectRequestResponseSchema { + return s.ResponseSchema +} + +// GetTags returns the value of Tags. +func (s *ReflectRequest) GetTags() []string { + return s.Tags +} + +// GetTagsMatch returns the value of TagsMatch. +func (s *ReflectRequest) GetTagsMatch() OptReflectRequestTagsMatch { + return s.TagsMatch +} + +// SetBudget sets the value of Budget. +func (s *ReflectRequest) SetBudget(val OptBudget) { + s.Budget = val +} + +// SetContext sets the value of Context. +func (s *ReflectRequest) SetContext(val OptString) { + s.Context = val +} + +// SetInclude sets the value of Include. +func (s *ReflectRequest) SetInclude(val OptReflectIncludeOptions) { + s.Include = val +} + +// SetMaxTokens sets the value of MaxTokens. +func (s *ReflectRequest) SetMaxTokens(val OptInt) { + s.MaxTokens = val +} + +// SetQuery sets the value of Query. +func (s *ReflectRequest) SetQuery(val string) { + s.Query = val +} + +// SetResponseSchema sets the value of ResponseSchema. +func (s *ReflectRequest) SetResponseSchema(val OptReflectRequestResponseSchema) { + s.ResponseSchema = val +} + +// SetTags sets the value of Tags. +func (s *ReflectRequest) SetTags(val []string) { + s.Tags = val +} + +// SetTagsMatch sets the value of TagsMatch. +func (s *ReflectRequest) SetTagsMatch(val OptReflectRequestTagsMatch) { + s.TagsMatch = val +} + +// Optional JSON Schema for structured output. When provided, the response will include a +// 'structured_output' field with the LLM response parsed according to this schema. +type ReflectRequestResponseSchema map[string]jx.Raw + +func (s *ReflectRequestResponseSchema) init() ReflectRequestResponseSchema { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// How to match tags: 'any' (OR, includes untagged), 'all' (AND, includes untagged), 'any_strict' (OR, +// +// excludes untagged), 'all_strict' (AND, excludes untagged). +type ReflectRequestTagsMatch string + +const ( + ReflectRequestTagsMatchAny ReflectRequestTagsMatch = "any" + ReflectRequestTagsMatchAll ReflectRequestTagsMatch = "all" + ReflectRequestTagsMatchAnyStrict ReflectRequestTagsMatch = "any_strict" + ReflectRequestTagsMatchAllStrict ReflectRequestTagsMatch = "all_strict" +) + +// AllValues returns all ReflectRequestTagsMatch values. +func (ReflectRequestTagsMatch) AllValues() []ReflectRequestTagsMatch { + return []ReflectRequestTagsMatch{ + ReflectRequestTagsMatchAny, + ReflectRequestTagsMatchAll, + ReflectRequestTagsMatchAnyStrict, + ReflectRequestTagsMatchAllStrict, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s ReflectRequestTagsMatch) MarshalText() ([]byte, error) { + switch s { + case ReflectRequestTagsMatchAny: + return []byte(s), nil + case ReflectRequestTagsMatchAll: + return []byte(s), nil + case ReflectRequestTagsMatchAnyStrict: + return []byte(s), nil + case ReflectRequestTagsMatchAllStrict: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *ReflectRequestTagsMatch) UnmarshalText(data []byte) error { + switch ReflectRequestTagsMatch(data) { + case ReflectRequestTagsMatchAny: + *s = ReflectRequestTagsMatchAny + return nil + case ReflectRequestTagsMatchAll: + *s = ReflectRequestTagsMatchAll + return nil + case ReflectRequestTagsMatchAnyStrict: + *s = ReflectRequestTagsMatchAnyStrict + return nil + case ReflectRequestTagsMatchAllStrict: + *s = ReflectRequestTagsMatchAllStrict + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +// Response model for think endpoint. +// Ref: #/components/schemas/ReflectResponse +type ReflectResponse struct { + // Evidence used to generate the response. Only present when include.facts is set. + BasedOn OptReflectBasedOn `json:"based_on"` + // Structured output parsed according to the request's response_schema. Only present when + // response_schema was provided in the request. + StructuredOutput OptReflectResponseStructuredOutput `json:"structured_output"` + // The reflect response as well-formatted markdown (headers, lists, bold/italic, code blocks, etc.). + Text string `json:"text"` + // Execution trace of tool and LLM calls. Only present when include.tool_calls is set. + Trace OptReflectTrace `json:"trace"` + // Token usage metrics for LLM calls during reflection. + Usage OptTokenUsage `json:"usage"` +} + +// GetBasedOn returns the value of BasedOn. +func (s *ReflectResponse) GetBasedOn() OptReflectBasedOn { + return s.BasedOn +} + +// GetStructuredOutput returns the value of StructuredOutput. +func (s *ReflectResponse) GetStructuredOutput() OptReflectResponseStructuredOutput { + return s.StructuredOutput +} + +// GetText returns the value of Text. +func (s *ReflectResponse) GetText() string { + return s.Text +} + +// GetTrace returns the value of Trace. +func (s *ReflectResponse) GetTrace() OptReflectTrace { + return s.Trace +} + +// GetUsage returns the value of Usage. +func (s *ReflectResponse) GetUsage() OptTokenUsage { + return s.Usage +} + +// SetBasedOn sets the value of BasedOn. +func (s *ReflectResponse) SetBasedOn(val OptReflectBasedOn) { + s.BasedOn = val +} + +// SetStructuredOutput sets the value of StructuredOutput. +func (s *ReflectResponse) SetStructuredOutput(val OptReflectResponseStructuredOutput) { + s.StructuredOutput = val +} + +// SetText sets the value of Text. +func (s *ReflectResponse) SetText(val string) { + s.Text = val +} + +// SetTrace sets the value of Trace. +func (s *ReflectResponse) SetTrace(val OptReflectTrace) { + s.Trace = val +} + +// SetUsage sets the value of Usage. +func (s *ReflectResponse) SetUsage(val OptTokenUsage) { + s.Usage = val +} + +func (*ReflectResponse) reflectRes() {} + +// Structured output parsed according to the request's response_schema. Only present when +// response_schema was provided in the request. +type ReflectResponseStructuredOutput map[string]jx.Raw + +func (s *ReflectResponseStructuredOutput) init() ReflectResponseStructuredOutput { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// A tool call made during reflect agent execution. +// Ref: #/components/schemas/ReflectToolCall +type ReflectToolCall struct { + // Execution time in milliseconds. + DurationMs int `json:"duration_ms"` + // Tool input parameters. + Input ReflectToolCallInput `json:"input"` + // Iteration number (1-based) when this tool was called. + Iteration OptInt `json:"iteration"` + // Tool output (only included when include.tool_calls.output is true). + Output OptReflectToolCallOutput `json:"output"` + // Tool name: lookup, recall, learn, expand. + Tool string `json:"tool"` +} + +// GetDurationMs returns the value of DurationMs. +func (s *ReflectToolCall) GetDurationMs() int { + return s.DurationMs +} + +// GetInput returns the value of Input. +func (s *ReflectToolCall) GetInput() ReflectToolCallInput { + return s.Input +} + +// GetIteration returns the value of Iteration. +func (s *ReflectToolCall) GetIteration() OptInt { + return s.Iteration +} + +// GetOutput returns the value of Output. +func (s *ReflectToolCall) GetOutput() OptReflectToolCallOutput { + return s.Output +} + +// GetTool returns the value of Tool. +func (s *ReflectToolCall) GetTool() string { + return s.Tool +} + +// SetDurationMs sets the value of DurationMs. +func (s *ReflectToolCall) SetDurationMs(val int) { + s.DurationMs = val +} + +// SetInput sets the value of Input. +func (s *ReflectToolCall) SetInput(val ReflectToolCallInput) { + s.Input = val +} + +// SetIteration sets the value of Iteration. +func (s *ReflectToolCall) SetIteration(val OptInt) { + s.Iteration = val +} + +// SetOutput sets the value of Output. +func (s *ReflectToolCall) SetOutput(val OptReflectToolCallOutput) { + s.Output = val +} + +// SetTool sets the value of Tool. +func (s *ReflectToolCall) SetTool(val string) { + s.Tool = val +} + +// Tool input parameters. +type ReflectToolCallInput map[string]jx.Raw + +func (s *ReflectToolCallInput) init() ReflectToolCallInput { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Tool output (only included when include.tool_calls.output is true). +type ReflectToolCallOutput map[string]jx.Raw + +func (s *ReflectToolCallOutput) init() ReflectToolCallOutput { + m := *s + if m == nil { + m = map[string]jx.Raw{} + *s = m + } + return m +} + +// Execution trace of LLM and tool calls during reflection. +// Ref: #/components/schemas/ReflectTrace +type ReflectTrace struct { + // LLM calls made during reflection. + LlmCalls []ReflectLLMCall `json:"llm_calls"` + // Tool calls made during reflection. + ToolCalls []ReflectToolCall `json:"tool_calls"` +} + +// GetLlmCalls returns the value of LlmCalls. +func (s *ReflectTrace) GetLlmCalls() []ReflectLLMCall { + return s.LlmCalls +} + +// GetToolCalls returns the value of ToolCalls. +func (s *ReflectTrace) GetToolCalls() []ReflectToolCall { + return s.ToolCalls +} + +// SetLlmCalls sets the value of LlmCalls. +func (s *ReflectTrace) SetLlmCalls(val []ReflectLLMCall) { + s.LlmCalls = val +} + +// SetToolCalls sets the value of ToolCalls. +func (s *ReflectTrace) SetToolCalls(val []ReflectToolCall) { + s.ToolCalls = val +} + +// Request model for retain endpoint. +// Ref: #/components/schemas/RetainRequest +type RetainRequest struct { + // If true, process asynchronously in background. If false, wait for completion (default: false). + Async OptBool `json:"async"` + // Tags applied to all items in this request. These are merged with any item-level tags. + DocumentTags []string `json:"document_tags"` + Items []MemoryItem `json:"items"` +} + +// GetAsync returns the value of Async. +func (s *RetainRequest) GetAsync() OptBool { + return s.Async +} + +// GetDocumentTags returns the value of DocumentTags. +func (s *RetainRequest) GetDocumentTags() []string { + return s.DocumentTags +} + +// GetItems returns the value of Items. +func (s *RetainRequest) GetItems() []MemoryItem { + return s.Items +} + +// SetAsync sets the value of Async. +func (s *RetainRequest) SetAsync(val OptBool) { + s.Async = val +} + +// SetDocumentTags sets the value of DocumentTags. +func (s *RetainRequest) SetDocumentTags(val []string) { + s.DocumentTags = val +} + +// SetItems sets the value of Items. +func (s *RetainRequest) SetItems(val []MemoryItem) { + s.Items = val +} + +// Response model for retain endpoint. +// Ref: #/components/schemas/RetainResponse +type RetainResponse struct { + // Whether the operation was processed asynchronously. + Async bool `json:"async"` + BankID string `json:"bank_id"` + ItemsCount int `json:"items_count"` + // Operation ID for tracking async operations. Use GET /v1/default/banks/{bank_id}/operations to list + // operations and find this ID. Only present when async=true. + OperationID OptString `json:"operation_id"` + Success bool `json:"success"` + // Token usage metrics for LLM calls during fact extraction (only present for synchronous operations). + Usage OptTokenUsage `json:"usage"` +} + +// GetAsync returns the value of Async. +func (s *RetainResponse) GetAsync() bool { + return s.Async +} + +// GetBankID returns the value of BankID. +func (s *RetainResponse) GetBankID() string { + return s.BankID +} + +// GetItemsCount returns the value of ItemsCount. +func (s *RetainResponse) GetItemsCount() int { + return s.ItemsCount +} + +// GetOperationID returns the value of OperationID. +func (s *RetainResponse) GetOperationID() OptString { + return s.OperationID +} + +// GetSuccess returns the value of Success. +func (s *RetainResponse) GetSuccess() bool { + return s.Success +} + +// GetUsage returns the value of Usage. +func (s *RetainResponse) GetUsage() OptTokenUsage { + return s.Usage +} + +// SetAsync sets the value of Async. +func (s *RetainResponse) SetAsync(val bool) { + s.Async = val +} + +// SetBankID sets the value of BankID. +func (s *RetainResponse) SetBankID(val string) { + s.BankID = val +} + +// SetItemsCount sets the value of ItemsCount. +func (s *RetainResponse) SetItemsCount(val int) { + s.ItemsCount = val +} + +// SetOperationID sets the value of OperationID. +func (s *RetainResponse) SetOperationID(val OptString) { + s.OperationID = val +} + +// SetSuccess sets the value of Success. +func (s *RetainResponse) SetSuccess(val bool) { + s.Success = val +} + +// SetUsage sets the value of Usage. +func (s *RetainResponse) SetUsage(val OptTokenUsage) { + s.Usage = val +} + +func (*RetainResponse) retainMemoriesRes() {} + +// Single tag with usage count. +// Ref: #/components/schemas/TagItem +type TagItem struct { + // Number of memories with this tag. + Count int `json:"count"` + // The tag value. + Tag string `json:"tag"` +} + +// GetCount returns the value of Count. +func (s *TagItem) GetCount() int { + return s.Count +} + +// GetTag returns the value of Tag. +func (s *TagItem) GetTag() string { + return s.Tag +} + +// SetCount sets the value of Count. +func (s *TagItem) SetCount(val int) { + s.Count = val +} + +// SetTag sets the value of Tag. +func (s *TagItem) SetTag(val string) { + s.Tag = val +} + +// Token usage metrics for LLM calls. +// Tracks input/output tokens for a single request to enable +// per-request cost tracking and monitoring. +// Ref: #/components/schemas/TokenUsage +type TokenUsage struct { + // Number of input/prompt tokens consumed. + InputTokens OptInt `json:"input_tokens"` + // Number of output/completion tokens generated. + OutputTokens OptInt `json:"output_tokens"` + // Total tokens (input + output). + TotalTokens OptInt `json:"total_tokens"` +} + +// GetInputTokens returns the value of InputTokens. +func (s *TokenUsage) GetInputTokens() OptInt { + return s.InputTokens +} + +// GetOutputTokens returns the value of OutputTokens. +func (s *TokenUsage) GetOutputTokens() OptInt { + return s.OutputTokens +} + +// GetTotalTokens returns the value of TotalTokens. +func (s *TokenUsage) GetTotalTokens() OptInt { + return s.TotalTokens +} + +// SetInputTokens sets the value of InputTokens. +func (s *TokenUsage) SetInputTokens(val OptInt) { + s.InputTokens = val +} + +// SetOutputTokens sets the value of OutputTokens. +func (s *TokenUsage) SetOutputTokens(val OptInt) { + s.OutputTokens = val +} + +// SetTotalTokens sets the value of TotalTokens. +func (s *TokenUsage) SetTotalTokens(val OptInt) { + s.TotalTokens = val +} + +// Options for including tool calls in reflect results. +// Ref: #/components/schemas/ToolCallsIncludeOptions +type ToolCallsIncludeOptions struct { + // Include tool outputs in the trace. Set to false to only include inputs (smaller payload). + Output OptBool `json:"output"` +} + +// GetOutput returns the value of Output. +func (s *ToolCallsIncludeOptions) GetOutput() OptBool { + return s.Output +} + +// SetOutput sets the value of Output. +func (s *ToolCallsIncludeOptions) SetOutput(val OptBool) { + s.Output = val +} + +// Request model for updating a directive. +// Ref: #/components/schemas/UpdateDirectiveRequest +type UpdateDirectiveRequest struct { + // New content. + Content OptString `json:"content"` + // New active status. + IsActive OptBool `json:"is_active"` + // New name. + Name OptString `json:"name"` + // New priority. + Priority OptInt `json:"priority"` + // New tags. + Tags []string `json:"tags"` +} + +// GetContent returns the value of Content. +func (s *UpdateDirectiveRequest) GetContent() OptString { + return s.Content +} + +// GetIsActive returns the value of IsActive. +func (s *UpdateDirectiveRequest) GetIsActive() OptBool { + return s.IsActive +} + +// GetName returns the value of Name. +func (s *UpdateDirectiveRequest) GetName() OptString { + return s.Name +} + +// GetPriority returns the value of Priority. +func (s *UpdateDirectiveRequest) GetPriority() OptInt { + return s.Priority +} + +// GetTags returns the value of Tags. +func (s *UpdateDirectiveRequest) GetTags() []string { + return s.Tags +} + +// SetContent sets the value of Content. +func (s *UpdateDirectiveRequest) SetContent(val OptString) { + s.Content = val +} + +// SetIsActive sets the value of IsActive. +func (s *UpdateDirectiveRequest) SetIsActive(val OptBool) { + s.IsActive = val +} + +// SetName sets the value of Name. +func (s *UpdateDirectiveRequest) SetName(val OptString) { + s.Name = val +} + +// SetPriority sets the value of Priority. +func (s *UpdateDirectiveRequest) SetPriority(val OptInt) { + s.Priority = val +} + +// SetTags sets the value of Tags. +func (s *UpdateDirectiveRequest) SetTags(val []string) { + s.Tags = val +} + +// Request model for updating disposition traits. +// Ref: #/components/schemas/UpdateDispositionRequest +type UpdateDispositionRequest struct { + Disposition DispositionTraits `json:"disposition"` +} + +// GetDisposition returns the value of Disposition. +func (s *UpdateDispositionRequest) GetDisposition() DispositionTraits { + return s.Disposition +} + +// SetDisposition sets the value of Disposition. +func (s *UpdateDispositionRequest) SetDisposition(val DispositionTraits) { + s.Disposition = val +} + +// Request model for updating a mental model. +// Ref: #/components/schemas/UpdateMentalModelRequest +type UpdateMentalModelRequest struct { + // Maximum tokens for generated content. + MaxTokens OptInt `json:"max_tokens"` + // New name for the mental model. + Name OptString `json:"name"` + // New source query for the mental model. + SourceQuery OptString `json:"source_query"` + // Tags for scoped visibility. + Tags []string `json:"tags"` + // Trigger settings. + Trigger OptMentalModelTrigger `json:"trigger"` +} + +// GetMaxTokens returns the value of MaxTokens. +func (s *UpdateMentalModelRequest) GetMaxTokens() OptInt { + return s.MaxTokens +} + +// GetName returns the value of Name. +func (s *UpdateMentalModelRequest) GetName() OptString { + return s.Name +} + +// GetSourceQuery returns the value of SourceQuery. +func (s *UpdateMentalModelRequest) GetSourceQuery() OptString { + return s.SourceQuery +} + +// GetTags returns the value of Tags. +func (s *UpdateMentalModelRequest) GetTags() []string { + return s.Tags +} + +// GetTrigger returns the value of Trigger. +func (s *UpdateMentalModelRequest) GetTrigger() OptMentalModelTrigger { + return s.Trigger +} + +// SetMaxTokens sets the value of MaxTokens. +func (s *UpdateMentalModelRequest) SetMaxTokens(val OptInt) { + s.MaxTokens = val +} + +// SetName sets the value of Name. +func (s *UpdateMentalModelRequest) SetName(val OptString) { + s.Name = val +} + +// SetSourceQuery sets the value of SourceQuery. +func (s *UpdateMentalModelRequest) SetSourceQuery(val OptString) { + s.SourceQuery = val +} + +// SetTags sets the value of Tags. +func (s *UpdateMentalModelRequest) SetTags(val []string) { + s.Tags = val +} + +// SetTrigger sets the value of Trigger. +func (s *UpdateMentalModelRequest) SetTrigger(val OptMentalModelTrigger) { + s.Trigger = val +} + +// Ref: #/components/schemas/ValidationError +type ValidationError struct { + Loc []int `json:"loc"` + Msg string `json:"msg"` + Type string `json:"type"` +} + +// GetLoc returns the value of Loc. +func (s *ValidationError) GetLoc() []int { + return s.Loc +} + +// GetMsg returns the value of Msg. +func (s *ValidationError) GetMsg() string { + return s.Msg +} + +// GetType returns the value of Type. +func (s *ValidationError) GetType() string { + return s.Type +} + +// SetLoc sets the value of Loc. +func (s *ValidationError) SetLoc(val []int) { + s.Loc = val +} + +// SetMsg sets the value of Msg. +func (s *ValidationError) SetMsg(val string) { + s.Msg = val +} + +// SetType sets the value of Type. +func (s *ValidationError) SetType(val string) { + s.Type = val +} + +// Response model for the version/info endpoint. +// Ref: #/components/schemas/VersionResponse +type VersionResponse struct { + // API version string. + APIVersion string `json:"api_version"` + // Enabled feature flags. + Features FeaturesInfo `json:"features"` +} + +// GetAPIVersion returns the value of APIVersion. +func (s *VersionResponse) GetAPIVersion() string { + return s.APIVersion +} + +// GetFeatures returns the value of Features. +func (s *VersionResponse) GetFeatures() FeaturesInfo { + return s.Features +} + +// SetAPIVersion sets the value of APIVersion. +func (s *VersionResponse) SetAPIVersion(val string) { + s.APIVersion = val +} + +// SetFeatures sets the value of Features. +func (s *VersionResponse) SetFeatures(val FeaturesInfo) { + s.Features = val +} diff --git a/hindsight-clients/go/internal/ogenapi/oas_validators_gen.go b/hindsight-clients/go/internal/ogenapi/oas_validators_gen.go new file mode 100644 index 00000000..de367519 --- /dev/null +++ b/hindsight-clients/go/internal/ogenapi/oas_validators_gen.go @@ -0,0 +1,935 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogenapi + +import ( + "fmt" + + "github.com/go-faster/errors" + "github.com/ogen-go/ogen/validate" +) + +func (s *BackgroundResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.Disposition.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "disposition", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *BankListItem) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Disposition.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "disposition", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *BankListResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Banks == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Banks { + if err := func() error { + if err := elem.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "banks", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *BankProfileResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Disposition.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "disposition", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s Budget) Validate() error { + switch s { + case "low": + return nil + case "mid": + return nil + case "high": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *CreateBankRequest) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.Disposition.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "disposition", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *CreateMentalModelRequest) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.MaxTokens.Get(); ok { + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 256, + MaxSet: true, + Max: 8192, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(value)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "max_tokens", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *DirectiveListResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Items == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "items", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *DispositionTraits) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: true, + Max: 5, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.Empathy)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "empathy", + Error: err, + }) + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: true, + Max: 5, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.Literalism)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "literalism", + Error: err, + }) + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: true, + Max: 5, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.Skepticism)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "skepticism", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *EntityDetailResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Observations == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "observations", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *EntityListResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Items == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "items", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *EntityStateResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Observations == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "observations", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *GraphDataResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Edges == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "edges", + Error: err, + }) + } + if err := func() error { + if s.Nodes == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "nodes", + Error: err, + }) + } + if err := func() error { + if s.TableRows == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "table_rows", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *HTTPValidationError) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.Detail { + if err := func() error { + if err := elem.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "detail", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s ListDirectivesTagsMatch) Validate() error { + switch s { + case "any": + return nil + case "all": + return nil + case "exact": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *ListDocumentsResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Items == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "items", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *ListMemoryUnitsResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Items == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "items", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s ListMentalModelsTagsMatch) Validate() error { + switch s { + case "any": + return nil + case "all": + return nil + case "exact": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *ListTagsResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Items == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "items", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *MentalModelListResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Items == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "items", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *OperationStatusResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Status.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "status", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s OperationStatusResponseStatus) Validate() error { + switch s { + case "pending": + return nil + case "completed": + return nil + case "failed": + return nil + case "not_found": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *OperationsListResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Operations == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "operations", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *RecallRequest) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.Budget.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "budget", + Error: err, + }) + } + if err := func() error { + if value, ok := s.TagsMatch.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "tags_match", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s RecallRequestTagsMatch) Validate() error { + switch s { + case "any": + return nil + case "all": + return nil + case "any_strict": + return nil + case "all_strict": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *RecallResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.Entities.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "entities", + Error: err, + }) + } + if err := func() error { + if s.Results == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "results", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s RecallResponseEntities) Validate() error { + var failures []validate.FieldError + for key, elem := range s { + if err := func() error { + if err := elem.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: key, + Error: err, + }) + } + } + + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *ReflectRequest) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.Budget.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "budget", + Error: err, + }) + } + if err := func() error { + if value, ok := s.TagsMatch.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "tags_match", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s ReflectRequestTagsMatch) Validate() error { + switch s { + case "any": + return nil + case "all": + return nil + case "any_strict": + return nil + case "all_strict": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *RetainRequest) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Items == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "items", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *UpdateDispositionRequest) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Disposition.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "disposition", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *UpdateMentalModelRequest) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.MaxTokens.Get(); ok { + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 256, + MaxSet: true, + Max: 8192, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(value)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "max_tokens", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *ValidationError) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Loc == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "loc", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} diff --git a/hindsight-clients/go/ogen.yml b/hindsight-clients/go/ogen.yml new file mode 100644 index 00000000..a8bfa3f0 --- /dev/null +++ b/hindsight-clients/go/ogen.yml @@ -0,0 +1,9 @@ +generator: + ignore_not_implemented: ["all"] + features: + disable: + - paths/server + - webhooks/server + - webhooks/client + - ogen/otel + - ogen/unimplemented diff --git a/hindsight-clients/go/options.go b/hindsight-clients/go/options.go new file mode 100644 index 00000000..94e6ebfa --- /dev/null +++ b/hindsight-clients/go/options.go @@ -0,0 +1,321 @@ +package hindsight + +import ( + "net/http" + "time" + + "github.com/vectorize-io/hindsight-client-go/internal/ogenapi" +) + +// --- Client options --- + +type clientConfig struct { + apiKey string + httpClient *http.Client +} + +// Option configures a [Client]. +type Option func(*clientConfig) + +// WithAPIKey sets the Bearer token used for authentication. +func WithAPIKey(key string) Option { + return func(c *clientConfig) { c.apiKey = key } +} + +// WithHTTPClient sets a custom [http.Client] for all requests. +// If combined with [WithAPIKey], the API key transport wraps this client's transport. +func WithHTTPClient(hc *http.Client) Option { + return func(c *clientConfig) { c.httpClient = hc } +} + +// --- Re-exported types --- + +// Budget controls the computation budget for recall and reflect operations. +type Budget = ogenapi.Budget + +const ( + BudgetLow = ogenapi.BudgetLow + BudgetMid = ogenapi.BudgetMid + BudgetHigh = ogenapi.BudgetHigh +) + +// TagsMatch controls how tag filtering works. +type TagsMatch string + +const ( + TagsMatchAny TagsMatch = "any" + TagsMatchAll TagsMatch = "all" + TagsMatchAnyStrict TagsMatch = "any_strict" + TagsMatchAllStrict TagsMatch = "all_strict" +) + +type ( + // RetainResponse is the response from a retain operation. + RetainResponse = ogenapi.RetainResponse + + // RecallResponse is the response from a recall operation. + RecallResponse = ogenapi.RecallResponse + + // RecallResult is a single memory result from recall. + RecallResult = ogenapi.RecallResult + + // ReflectResponse is the response from a reflect operation. + ReflectResponse = ogenapi.ReflectResponse + + // MemoryItem is a single memory item for retain operations. + MemoryItem = ogenapi.MemoryItem + + // EntityInput provides entity hints for retain. + EntityInput = ogenapi.EntityInput + + // BankProfileResponse is the response for bank profile operations. + BankProfileResponse = ogenapi.BankProfileResponse + + // BankListResponse is the response for listing banks. + BankListResponse = ogenapi.BankListResponse + + // DispositionTraits configures personality traits for a bank. + DispositionTraits = ogenapi.DispositionTraits + + // TokenUsage reports LLM token consumption. + TokenUsage = ogenapi.TokenUsage + + // ReflectBasedOn contains the evidence used for a reflect response. + ReflectBasedOn = ogenapi.ReflectBasedOn + + // IncludeOptions controls what extra data is returned from recall. + IncludeOptions = ogenapi.IncludeOptions + + // ReflectIncludeOptions controls what extra data is returned from reflect. + ReflectIncludeOptions = ogenapi.ReflectIncludeOptions +) + +// --- Retain options --- + +// RetainOption configures a [Client.Retain] call. +type RetainOption func(*retainConfig) + +type retainConfig struct { + timestamp *time.Time + context *string + documentID *string + metadata map[string]string + entities []EntityInput + tags []string +} + +// WithTimestamp sets the timestamp for a retained memory. +func WithTimestamp(t time.Time) RetainOption { + return func(c *retainConfig) { c.timestamp = &t } +} + +// WithContext sets additional context for a retained memory. +func WithContext(ctx string) RetainOption { + return func(c *retainConfig) { c.context = &ctx } +} + +// WithDocumentID groups retained memories under a document. +func WithDocumentID(id string) RetainOption { + return func(c *retainConfig) { c.documentID = &id } +} + +// WithMetadata attaches key-value metadata to a retained memory. +func WithMetadata(m map[string]string) RetainOption { + return func(c *retainConfig) { c.metadata = m } +} + +// WithEntities provides entity hints for a retained memory. +func WithEntities(e []EntityInput) RetainOption { + return func(c *retainConfig) { c.entities = e } +} + +// WithTags attaches tags to a retained memory for filtering. +func WithTags(tags []string) RetainOption { + return func(c *retainConfig) { c.tags = tags } +} + +// RetainBatchOption configures a [Client.RetainBatch] call. +type RetainBatchOption func(*retainBatchConfig) + +type retainBatchConfig struct { + documentTags []string + async bool +} + +// WithDocumentTags sets tags applied to all items in a batch retain. +func WithDocumentTags(tags []string) RetainBatchOption { + return func(c *retainBatchConfig) { c.documentTags = tags } +} + +// WithAsync processes the retain batch asynchronously. +func WithAsync(async bool) RetainBatchOption { + return func(c *retainBatchConfig) { c.async = async } +} + +// --- Recall options --- + +// RecallOption configures a [Client.Recall] call. +type RecallOption func(*recallConfig) + +type recallConfig struct { + types []string + maxTokens *int + budget *Budget + trace *bool + queryTimestamp *string + includeOpts *IncludeOptions + tags []string + tagsMatch *TagsMatch +} + +// WithTypes filters recalled memories by type (e.g., "world", "experience"). +func WithTypes(types []string) RecallOption { + return func(c *recallConfig) { c.types = types } +} + +// WithMaxTokens sets the maximum tokens for recall results. +func WithMaxTokens(n int) RecallOption { + return func(c *recallConfig) { c.maxTokens = &n } +} + +// WithBudget sets the computation budget for recall. +func WithBudget(b Budget) RecallOption { + return func(c *recallConfig) { c.budget = &b } +} + +// WithTrace enables the execution trace in recall results. +func WithTrace(enabled bool) RecallOption { + return func(c *recallConfig) { c.trace = &enabled } +} + +// WithQueryTimestamp sets the temporal context for recall (ISO 8601 format). +func WithQueryTimestamp(ts string) RecallOption { + return func(c *recallConfig) { c.queryTimestamp = &ts } +} + +// WithInclude configures which additional data to include in recall results. +func WithInclude(opts IncludeOptions) RecallOption { + return func(c *recallConfig) { c.includeOpts = &opts } +} + +// WithRecallTags filters recalled memories by tags. +func WithRecallTags(tags []string) RecallOption { + return func(c *recallConfig) { c.tags = tags } +} + +// WithRecallTagsMatch sets how tags are matched during recall. +func WithRecallTagsMatch(m TagsMatch) RecallOption { + return func(c *recallConfig) { c.tagsMatch = &m } +} + +// --- Reflect options --- + +// ReflectOption configures a [Client.Reflect] call. +type ReflectOption func(*reflectConfig) + +type reflectConfig struct { + budget *Budget + maxTokens *int + includeOpts *ReflectIncludeOptions + responseSchema map[string]any + tags []string + tagsMatch *TagsMatch +} + +// WithReflectBudget sets the computation budget for reflect. +func WithReflectBudget(b Budget) ReflectOption { + return func(c *reflectConfig) { c.budget = &b } +} + +// WithReflectMaxTokens sets the maximum tokens for the reflect response. +func WithReflectMaxTokens(n int) ReflectOption { + return func(c *reflectConfig) { c.maxTokens = &n } +} + +// WithReflectInclude configures which additional data to include in reflect results. +func WithReflectInclude(opts ReflectIncludeOptions) ReflectOption { + return func(c *reflectConfig) { c.includeOpts = &opts } +} + +// WithResponseSchema sets a JSON Schema for structured output from reflect. +func WithResponseSchema(schema map[string]any) ReflectOption { + return func(c *reflectConfig) { c.responseSchema = schema } +} + +// WithReflectTags filters memories by tags during reflect. +func WithReflectTags(tags []string) ReflectOption { + return func(c *reflectConfig) { c.tags = tags } +} + +// WithReflectTagsMatch sets how tags are matched during reflect. +func WithReflectTagsMatch(m TagsMatch) ReflectOption { + return func(c *reflectConfig) { c.tagsMatch = &m } +} + +// --- Bank options --- + +// CreateBankOption configures a [Client.CreateBank] call. +type CreateBankOption func(*createBankConfig) + +type createBankConfig struct { + name *string + mission *string + disposition *DispositionTraits +} + +// WithBankName sets the display name for a bank. +func WithBankName(name string) CreateBankOption { + return func(c *createBankConfig) { c.name = &name } +} + +// WithMission sets the mission for a bank. +func WithMission(mission string) CreateBankOption { + return func(c *createBankConfig) { c.mission = &mission } +} + +// WithDisposition sets the personality traits for a bank. +func WithDisposition(d DispositionTraits) CreateBankOption { + return func(c *createBankConfig) { c.disposition = &d } +} + +// --- helpers --- + +func optString(s string) ogenapi.OptString { + return ogenapi.NewOptString(s) +} + +func optStringPtr(s *string) ogenapi.OptString { + if s == nil { + return ogenapi.OptString{} + } + return ogenapi.NewOptString(*s) +} + +func optInt(n int) ogenapi.OptInt { + return ogenapi.NewOptInt(n) +} + +func optIntPtr(n *int) ogenapi.OptInt { + if n == nil { + return ogenapi.OptInt{} + } + return ogenapi.NewOptInt(*n) +} + +func optBool(b bool) ogenapi.OptBool { + return ogenapi.NewOptBool(b) +} + +func optBoolPtr(b *bool) ogenapi.OptBool { + if b == nil { + return ogenapi.OptBool{} + } + return ogenapi.NewOptBool(*b) +} + +func optBudget(b *Budget) ogenapi.OptBudget { + if b == nil { + return ogenapi.OptBudget{} + } + return ogenapi.NewOptBudget(*b) +} diff --git a/hindsight-clients/go/recall.go b/hindsight-clients/go/recall.go new file mode 100644 index 00000000..7528e45f --- /dev/null +++ b/hindsight-clients/go/recall.go @@ -0,0 +1,59 @@ +package hindsight + +import ( + "context" + "fmt" + + "github.com/vectorize-io/hindsight-client-go/internal/ogenapi" +) + +// Recall retrieves memories from the given bank that match the query. +func (c *Client) Recall(ctx context.Context, bankID, query string, opts ...RecallOption) (*RecallResponse, error) { + var cfg recallConfig + for _, o := range opts { + o(&cfg) + } + + req := &ogenapi.RecallRequest{ + Query: query, + } + if cfg.budget != nil { + req.Budget = ogenapi.NewOptBudget(*cfg.budget) + } + if cfg.maxTokens != nil { + req.MaxTokens = ogenapi.NewOptInt(*cfg.maxTokens) + } + if cfg.trace != nil { + req.Trace = ogenapi.NewOptBool(*cfg.trace) + } + if cfg.queryTimestamp != nil { + req.QueryTimestamp = ogenapi.NewOptString(*cfg.queryTimestamp) + } + if cfg.types != nil { + req.Types = cfg.types + } + if cfg.includeOpts != nil { + req.Include = ogenapi.NewOptIncludeOptions(*cfg.includeOpts) + } + if cfg.tags != nil { + req.Tags = cfg.tags + } + if cfg.tagsMatch != nil { + req.TagsMatch = ogenapi.NewOptRecallRequestTagsMatch( + ogenapi.RecallRequestTagsMatch(*cfg.tagsMatch), + ) + } + + res, err := c.api.RecallMemories(ctx, req, ogenapi.RecallMemoriesParams{ + BankID: bankID, + }) + if err != nil { + return nil, err + } + + resp, ok := res.(*ogenapi.RecallResponse) + if !ok { + return nil, fmt.Errorf("hindsight: unexpected response type %T", res) + } + return resp, nil +} diff --git a/hindsight-clients/go/reflect.go b/hindsight-clients/go/reflect.go new file mode 100644 index 00000000..8f2276d7 --- /dev/null +++ b/hindsight-clients/go/reflect.go @@ -0,0 +1,74 @@ +package hindsight + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/go-faster/jx" + + "github.com/vectorize-io/hindsight-client-go/internal/ogenapi" +) + +// Reflect performs disposition-aware reasoning using the bank's memories and +// mental models. Returns a markdown-formatted response. +func (c *Client) Reflect(ctx context.Context, bankID, query string, opts ...ReflectOption) (*ReflectResponse, error) { + var cfg reflectConfig + for _, o := range opts { + o(&cfg) + } + + req := &ogenapi.ReflectRequest{ + Query: query, + } + if cfg.budget != nil { + req.Budget = ogenapi.NewOptBudget(*cfg.budget) + } + if cfg.maxTokens != nil { + req.MaxTokens = ogenapi.NewOptInt(*cfg.maxTokens) + } + if cfg.includeOpts != nil { + req.Include = ogenapi.NewOptReflectIncludeOptions(*cfg.includeOpts) + } + if cfg.responseSchema != nil { + schema, err := toResponseSchema(cfg.responseSchema) + if err != nil { + return nil, fmt.Errorf("hindsight: marshal response_schema: %w", err) + } + req.ResponseSchema = ogenapi.NewOptReflectRequestResponseSchema(schema) + } + if cfg.tags != nil { + req.Tags = cfg.tags + } + if cfg.tagsMatch != nil { + req.TagsMatch = ogenapi.NewOptReflectRequestTagsMatch( + ogenapi.ReflectRequestTagsMatch(*cfg.tagsMatch), + ) + } + + res, err := c.api.Reflect(ctx, req, ogenapi.ReflectParams{ + BankID: bankID, + }) + if err != nil { + return nil, err + } + + resp, ok := res.(*ogenapi.ReflectResponse) + if !ok { + return nil, fmt.Errorf("hindsight: unexpected response type %T", res) + } + return resp, nil +} + +// toResponseSchema converts a map[string]any JSON schema to the ogen type. +func toResponseSchema(schema map[string]any) (ogenapi.ReflectRequestResponseSchema, error) { + out := make(ogenapi.ReflectRequestResponseSchema, len(schema)) + for k, v := range schema { + data, err := json.Marshal(v) + if err != nil { + return nil, err + } + out[k] = jx.Raw(data) + } + return out, nil +} diff --git a/hindsight-clients/go/retain.go b/hindsight-clients/go/retain.go new file mode 100644 index 00000000..cf82c326 --- /dev/null +++ b/hindsight-clients/go/retain.go @@ -0,0 +1,73 @@ +package hindsight + +import ( + "context" + "fmt" + + "github.com/vectorize-io/hindsight-client-go/internal/ogenapi" +) + +// Retain stores a single memory in the given bank. +// It wraps [Client.RetainBatch] for convenience. +func (c *Client) Retain(ctx context.Context, bankID, content string, opts ...RetainOption) (*RetainResponse, error) { + var cfg retainConfig + for _, o := range opts { + o(&cfg) + } + + item := ogenapi.MemoryItem{ + Content: content, + } + if cfg.timestamp != nil { + item.Timestamp = ogenapi.NewOptDateTime(*cfg.timestamp) + } + if cfg.context != nil { + item.Context = ogenapi.NewOptString(*cfg.context) + } + if cfg.documentID != nil { + item.DocumentID = ogenapi.NewOptString(*cfg.documentID) + } + if cfg.metadata != nil { + m := ogenapi.MemoryItemMetadata(cfg.metadata) + item.Metadata = ogenapi.NewOptMemoryItemMetadata(m) + } + if cfg.entities != nil { + item.Entities = cfg.entities + } + if cfg.tags != nil { + item.Tags = cfg.tags + } + + return c.RetainBatch(ctx, bankID, []MemoryItem{item}) +} + +// RetainBatch stores multiple memories in the given bank. +func (c *Client) RetainBatch(ctx context.Context, bankID string, items []MemoryItem, opts ...RetainBatchOption) (*RetainResponse, error) { + var cfg retainBatchConfig + for _, o := range opts { + o(&cfg) + } + + req := &ogenapi.RetainRequest{ + Items: items, + } + if cfg.async { + req.Async = ogenapi.NewOptBool(true) + } + if cfg.documentTags != nil { + req.DocumentTags = cfg.documentTags + } + + res, err := c.api.RetainMemories(ctx, req, ogenapi.RetainMemoriesParams{ + BankID: bankID, + }) + if err != nil { + return nil, err + } + + resp, ok := res.(*ogenapi.RetainResponse) + if !ok { + return nil, fmt.Errorf("hindsight: unexpected response type %T", res) + } + return resp, nil +} diff --git a/hindsight-docs/docs/cookbook/applications/go-memory-service.md b/hindsight-docs/docs/cookbook/applications/go-memory-service.md new file mode 100644 index 00000000..b49a6297 --- /dev/null +++ b/hindsight-docs/docs/cookbook/applications/go-memory-service.md @@ -0,0 +1,345 @@ +--- +sidebar_position: 10 +--- + +# Go Memory-Augmented API + +:::info Complete Application +This is a complete, runnable Go application demonstrating Hindsight integration. +::: + +A Go HTTP microservice that combines a domain API with Hindsight memory. Each API user gets a personal memory bank. The service remembers past interactions and uses them to provide personalized responses. + +## Use Case + +A **developer knowledge assistant** that remembers what technologies each user works with, what problems they've solved, and provides personalized recommendations. + +## Features + +- Per-user memory banks (created on first interaction) +- Conversation history stored via retain +- Context-aware responses via recall + reflect +- Structured output for programmatic consumption +- Health check and bank stats endpoints + +## Project Structure + +``` +go-memory-service/ +├── main.go # HTTP server, routes, handlers +├── go.mod +└── go.sum +``` + +## The Code + +```go +package main + +import ( + "context" + "encoding/json" + "fmt" + "log" + "net/http" + "os" + "strings" + "time" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +var client *hindsight.Client + +func main() { + apiURL := envOr("HINDSIGHT_API_URL", "http://localhost:8888") + + var err error + client, err = hindsight.New(apiURL) + if err != nil { + log.Fatal(err) + } + + mux := http.NewServeMux() + mux.HandleFunc("POST /ask", handleAsk) + mux.HandleFunc("POST /learn", handleLearn) + mux.HandleFunc("GET /recall/{userID}", handleRecall) + mux.HandleFunc("GET /health", handleHealth) + + addr := envOr("ADDR", ":8080") + log.Printf("listening on %s (hindsight: %s)", addr, apiURL) + log.Fatal(http.ListenAndServe(addr, mux)) +} + +// --- Request/Response types --- + +type AskRequest struct { + UserID string `json:"user_id"` + Query string `json:"query"` +} + +type AskResponse struct { + Answer string `json:"answer"` + Facts []string `json:"facts,omitempty"` +} + +type LearnRequest struct { + UserID string `json:"user_id"` + Content string `json:"content"` + Tags []string `json:"tags,omitempty"` +} + +type RecallResponse struct { + Results []RecallFact `json:"results"` +} + +type RecallFact struct { + Text string `json:"text"` + Type string `json:"type"` +} + +// --- Handlers --- + +// handleLearn stores new information for a user. +func handleLearn(w http.ResponseWriter, r *http.Request) { + var req LearnRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + http.Error(w, "invalid JSON", http.StatusBadRequest) + return + } + + ctx := r.Context() + bankID := bankFor(req.UserID) + + // Ensure bank exists + ensureBank(ctx, bankID, req.UserID) + + // Store the memory + var opts []hindsight.RetainOption + if len(req.Tags) > 0 { + opts = append(opts, hindsight.WithTags(req.Tags)) + } + + resp, err := client.Retain(ctx, bankID, req.Content, opts...) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + writeJSON(w, map[string]any{ + "success": resp.Success, + "bank_id": bankID, + }) +} + +// handleAsk answers a question using the user's memories. +func handleAsk(w http.ResponseWriter, r *http.Request) { + var req AskRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + http.Error(w, "invalid JSON", http.StatusBadRequest) + return + } + + ctx := r.Context() + bankID := bankFor(req.UserID) + + // Ensure bank exists + ensureBank(ctx, bankID, req.UserID) + + // Recall relevant facts + recallResp, err := client.Recall(ctx, bankID, req.Query, + hindsight.WithBudget(hindsight.BudgetMid), + hindsight.WithMaxTokens(2048), + ) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + var facts []string + for _, result := range recallResp.Results { + facts = append(facts, result.Text) + } + + // Reflect to generate an answer + reflectResp, err := client.Reflect(ctx, bankID, req.Query, + hindsight.WithReflectBudget(hindsight.BudgetMid), + ) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + // Store this interaction as a new memory + interaction := fmt.Sprintf("User asked: %q\nAssistant answered: %s", req.Query, reflectResp.Text) + go func() { + bgCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + client.Retain(bgCtx, bankID, interaction, + hindsight.WithContext("Q&A interaction"), + ) + }() + + writeJSON(w, AskResponse{ + Answer: reflectResp.Text, + Facts: facts, + }) +} + +// handleRecall returns raw memories for a user. +func handleRecall(w http.ResponseWriter, r *http.Request) { + userID := r.PathValue("userID") + query := r.URL.Query().Get("q") + if query == "" { + query = "What do you know?" + } + + ctx := r.Context() + bankID := bankFor(userID) + + resp, err := client.Recall(ctx, bankID, query, + hindsight.WithBudget(hindsight.BudgetHigh), + ) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + var results []RecallFact + for _, result := range resp.Results { + results = append(results, RecallFact{ + Text: result.Text, + Type: result.Type.Or("unknown"), + }) + } + + writeJSON(w, RecallResponse{Results: results}) +} + +func handleHealth(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, map[string]string{"status": "ok"}) +} + +// --- Helpers --- + +func bankFor(userID string) string { + return "user-" + strings.ToLower(userID) +} + +func ensureBank(ctx context.Context, bankID, userID string) { + client.CreateBank(ctx, bankID, + hindsight.WithBankName(fmt.Sprintf("Memory for %s", userID)), + hindsight.WithMission("Developer knowledge assistant. Remember technologies, problems solved, and preferences."), + ) +} + +func writeJSON(w http.ResponseWriter, v any) { + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(v) +} + +func envOr(key, fallback string) string { + if v := os.Getenv(key); v != "" { + return v + } + return fallback +} +``` + +## Running + +### 1. Start Hindsight + +```bash +export OPENAI_API_KEY=your-key + +docker run --rm -it --pull always -p 8888:8888 -p 9999:9999 \ + -e HINDSIGHT_API_LLM_API_KEY=$OPENAI_API_KEY \ + -e HINDSIGHT_API_LLM_MODEL=o3-mini \ + -v $HOME/.hindsight-docker:/home/hindsight/.pg0 \ + ghcr.io/vectorize-io/hindsight:latest +``` + +### 2. Start the service + +```bash +go run main.go +``` + +### 3. Try it out + +```bash +# Teach it something +curl -s localhost:8080/learn -d '{ + "user_id": "alice", + "content": "I am building a Go microservice that uses gRPC and PostgreSQL", + "tags": ["project"] +}' | jq . + +# Teach it more +curl -s localhost:8080/learn -d '{ + "user_id": "alice", + "content": "I solved a connection pooling issue by switching from pgx to pgxpool", + "tags": ["debugging"] +}' + +curl -s localhost:8080/learn -d '{ + "user_id": "alice", + "content": "I prefer structured logging with slog over zerolog", + "tags": ["preferences"] +}' + +# Ask a question (uses recall + reflect) +curl -s localhost:8080/ask -d '{ + "user_id": "alice", + "query": "What tech stack am I using?" +}' | jq . + +# Raw recall +curl -s "localhost:8080/recall/alice?q=database" | jq . +``` + +## How It Works + +1. **`/learn`** - Stores information using `Retain`. Each piece of info becomes searchable facts, entities, and relationships. + +2. **`/ask`** - Two-phase retrieval: + - **Recall**: Finds relevant facts from the user's memory bank + - **Reflect**: Synthesizes a response using those facts plus disposition-aware reasoning + - The Q&A interaction itself is stored as a new memory (fire-and-forget goroutine) + +3. **`/recall/{userID}`** - Direct access to raw recalled facts for debugging or building custom UIs. + +## Key Patterns + +### Per-User Isolation + +Each user gets their own bank (`user-alice`, `user-bob`). Banks are created lazily on first interaction via `CreateBank` (idempotent - safe to call repeatedly). + +### Fire-and-Forget Memory + +The `/ask` handler stores the interaction in a background goroutine so the response isn't delayed by the retain call: + +```go +go func() { + bgCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + client.Retain(bgCtx, bankID, interaction) +}() +``` + +### Tag-Based Scoping + +Tags partition memories within a bank. Query only `debugging` memories, or only `preferences`: + +```bash +# The /recall endpoint could be extended to support tag filtering: +curl "localhost:8080/recall/alice?q=issues&tags=debugging" +``` + +## Next Steps + +- [Go Quickstart](/cookbook/recipes/go-quickstart) - Core operations walkthrough +- [Go Concurrent Pipeline](/cookbook/recipes/go-concurrent-pipeline) - Bulk data ingestion +- [Per-User Memory](/cookbook/recipes/per-user-memory) - The pattern in depth +- [Go SDK Reference](/sdks/go) - Full API documentation diff --git a/hindsight-docs/docs/cookbook/index.mdx b/hindsight-docs/docs/cookbook/index.mdx index cb22bd4d..c3d20351 100644 --- a/hindsight-docs/docs/cookbook/index.mdx +++ b/hindsight-docs/docs/cookbook/index.mdx @@ -86,6 +86,18 @@ Learn how to build with Hindsight through practical examples: href: "/cookbook/recipes/study_buddy", description: "Track study sessions, identify knowledge gaps, and get personalized review suggestions", tags: { sdk: "hindsight-client", topic: "Learning" } + }, + { + title: "Go Quickstart", + href: "/cookbook/recipes/go-quickstart", + description: "Get started with the Go client: retain, recall, and reflect", + tags: { sdk: "hindsight-go", topic: "Quick Start" } + }, + { + title: "Go Concurrent Pipeline", + href: "/cookbook/recipes/go-concurrent-pipeline", + description: "Build a concurrent memory ingestion pipeline with goroutines", + tags: { sdk: "hindsight-go", topic: "Learning" } } ]} /> @@ -140,6 +152,12 @@ Learn how to build with Hindsight through practical examples: href: "/cookbook/applications/taste-ai", description: "Personal food assistant with AI SDK v6 showcasing recall, mental models, and directives", tags: { sdk: "@vectorize-io/hindsight-ai-sdk", topic: "Recommendation" } + }, + { + title: "Go Memory-Augmented API", + href: "/cookbook/applications/go-memory-service", + description: "Go HTTP microservice with per-user memory banks for a developer knowledge assistant", + tags: { sdk: "hindsight-go", topic: "Learning" } } ]} /> diff --git a/hindsight-docs/docs/cookbook/recipes/go-concurrent-pipeline.md b/hindsight-docs/docs/cookbook/recipes/go-concurrent-pipeline.md new file mode 100644 index 00000000..158627b7 --- /dev/null +++ b/hindsight-docs/docs/cookbook/recipes/go-concurrent-pipeline.md @@ -0,0 +1,272 @@ +--- +sidebar_position: 13 +--- + +# Go Concurrent Pipeline + +Build a concurrent memory ingestion pipeline in Go. This recipe demonstrates how to use Go's concurrency primitives with the Hindsight client to ingest large datasets efficiently, then query them with recall and reflect. + +## The Problem + +You have a large dataset (log files, chat transcripts, documents) that needs to be ingested into Hindsight. Sequential ingestion is slow. Go's goroutines make it straightforward to parallelize. + +## Architecture + +``` + ┌──────────┐ + │ Source │ + │ (files, │ + │ API, DB) │ + └────┬─────┘ + │ + ┌────▼─────┐ + │ Producer │ reads data, sends to channel + └────┬─────┘ + │ + ┌──────────┼──────────┐ + │ │ │ + ┌────▼───┐ ┌───▼────┐ ┌──▼─────┐ + │Worker 1│ │Worker 2│ │Worker N│ concurrent RetainBatch + └────┬───┘ └───┬────┘ └──┬─────┘ + │ │ │ + └─────────┼─────────┘ + │ + ┌─────▼─────┐ + │ Hindsight │ + │ API │ + └───────────┘ +``` + +## Prerequisites + +Hindsight server running (see [Go Quickstart](/cookbook/recipes/go-quickstart) for setup). + +## The Pipeline + +```go +package main + +import ( + "bufio" + "context" + "fmt" + "log" + "os" + "sync" + "sync/atomic" + "time" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +const ( + batchSize = 10 // memories per batch + numWorkers = 4 // concurrent workers +) + +func main() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + bankID := "pipeline-demo" + + // Create the bank + client.CreateBank(ctx, bankID, + hindsight.WithBankName("Pipeline Demo"), + hindsight.WithMission("Knowledge base ingested from documents"), + ) + + // Ingest from a file (one line = one memory) + if len(os.Args) < 2 { + fmt.Println("usage: pipeline ") + os.Exit(1) + } + + start := time.Now() + count := ingest(ctx, client, bankID, os.Args[1]) + elapsed := time.Since(start) + + fmt.Printf("\nIngested %d memories in %s (%.1f/sec)\n", + count, elapsed, float64(count)/elapsed.Seconds()) + + // Query the ingested data + fmt.Println("\n--- Recall ---") + resp, _ := client.Recall(ctx, bankID, "What are the key topics?", + hindsight.WithBudget(hindsight.BudgetHigh), + ) + for _, r := range resp.Results { + fmt.Printf(" - %s\n", r.Text) + } + + fmt.Println("\n--- Reflect ---") + answer, _ := client.Reflect(ctx, bankID, "Summarize everything you know") + fmt.Println(answer.Text) +} + +func ingest(ctx context.Context, client *hindsight.Client, bankID, filename string) int64 { + f, err := os.Open(filename) + if err != nil { + log.Fatal(err) + } + defer f.Close() + + // Channel for batches + batches := make(chan []hindsight.MemoryItem, numWorkers*2) + var ingested atomic.Int64 + + // Start workers + var wg sync.WaitGroup + for i := range numWorkers { + wg.Add(1) + go func(id int) { + defer wg.Done() + for batch := range batches { + _, err := client.RetainBatch(ctx, bankID, batch) + if err != nil { + log.Printf("worker %d: batch failed: %v", id, err) + continue + } + n := ingested.Add(int64(len(batch))) + if n%100 == 0 { + fmt.Printf(" ingested %d memories...\n", n) + } + } + }(i) + } + + // Producer: read lines and batch them + scanner := bufio.NewScanner(f) + var batch []hindsight.MemoryItem + + for scanner.Scan() { + line := scanner.Text() + if line == "" { + continue + } + batch = append(batch, hindsight.MemoryItem{Content: line}) + + if len(batch) >= batchSize { + batches <- batch + batch = nil + } + } + + // Flush remaining + if len(batch) > 0 { + batches <- batch + } + + close(batches) + wg.Wait() + + return ingested.Load() +} +``` + +## Running It + +Create a sample data file: + +```bash +cat > sample_data.txt << 'EOF' +The Go programming language was created at Google in 2007 +Go's concurrency model is based on CSP (Communicating Sequential Processes) +Goroutines are lightweight threads managed by the Go runtime +Channels provide typed conduits for communication between goroutines +The sync package provides mutexes, wait groups, and other synchronization primitives +Go modules were introduced in Go 1.11 for dependency management +The context package provides cancellation and deadline propagation +Go compiles to a single static binary with no external dependencies +The standard library includes an HTTP server, JSON parser, and crypto packages +Go 1.18 introduced generics with type parameters +EOF +``` + +```bash +go run . sample_data.txt +``` + +## Adding Tags for Partitioning + +For larger datasets, use tags to partition memories by source or topic: + +```go +func ingestWithTags(ctx context.Context, client *hindsight.Client, bankID, source string, lines []string) { + var items []hindsight.MemoryItem + for _, line := range lines { + items = append(items, hindsight.MemoryItem{ + Content: line, + Tags: []string{source}, + }) + } + + _, err := client.RetainBatch(ctx, bankID, items, + hindsight.WithDocumentTags([]string{"bulk-import", source}), + ) + if err != nil { + log.Printf("ingest %s failed: %v", source, err) + } +} + +// Later, recall only from a specific source +resp, _ := client.Recall(ctx, bankID, "What are the key concepts?", + hindsight.WithRecallTags([]string{"go-docs"}), + hindsight.WithRecallTagsMatch(hindsight.TagsMatchAnyStrict), +) +``` + +## Async Ingestion + +For very large datasets, use async mode to avoid waiting for fact extraction: + +```go +// Async retain returns immediately; processing happens in background +_, err := client.RetainBatch(ctx, bankID, items, + hindsight.WithAsync(true), +) + +// Check operation status via the ogen client +ogen := client.OgenClient() +ops, _ := ogen.ListOperations(ctx, ogenapi.ListOperationsParams{ + BankID: bankID, +}) +``` + +## Graceful Shutdown + +Use `context.WithCancel` for clean cancellation: + +```go +ctx, cancel := context.WithCancel(context.Background()) +defer cancel() + +// In a signal handler: +sigCh := make(chan os.Signal, 1) +signal.Notify(sigCh, os.Interrupt) +go func() { + <-sigCh + fmt.Println("\nShutting down gracefully...") + cancel() +}() + +// Workers will stop when ctx is cancelled +``` + +## Performance Tips + +| Tip | Why | +|-----|-----| +| Use `RetainBatch` over individual `Retain` | Fewer HTTP round trips | +| Set `batchSize` to 10-50 | Balances throughput vs. memory | +| Use 4-8 workers | Matches typical API concurrency limits | +| Use `WithAsync(true)` for bulk imports | Returns immediately, processes in background | +| Tag your data | Enables scoped recall without reingesting | + +## Next Steps + +- [Go Quickstart](/cookbook/recipes/go-quickstart) - Basic retain, recall, reflect +- [Per-User Memory](/cookbook/recipes/per-user-memory) - One bank per user pattern +- [Go SDK Reference](/sdks/go) - Full API reference diff --git a/hindsight-docs/docs/cookbook/recipes/go-quickstart.md b/hindsight-docs/docs/cookbook/recipes/go-quickstart.md new file mode 100644 index 00000000..acc21e2e --- /dev/null +++ b/hindsight-docs/docs/cookbook/recipes/go-quickstart.md @@ -0,0 +1,216 @@ +--- +sidebar_position: 12 +--- + +# Go Quickstart + +Get started with the Hindsight Go client in under 5 minutes. This recipe covers the three core operations: **retain**, **recall**, and **reflect**. + +## Prerequisites + +Make sure you have Hindsight running. The easiest way is via Docker: + +```bash +export OPENAI_API_KEY=your-key + +docker run --rm -it --pull always -p 8888:8888 -p 9999:9999 \ + -e HINDSIGHT_API_LLM_API_KEY=$OPENAI_API_KEY \ + -e HINDSIGHT_API_LLM_MODEL=o3-mini \ + -v $HOME/.hindsight-docker:/home/hindsight/.pg0 \ + ghcr.io/vectorize-io/hindsight:latest +``` + +- API: http://localhost:8888 +- UI: http://localhost:9999 + +## Installation + +```bash +go get github.com/vectorize-io/hindsight-client-go +``` + +## Connect to Hindsight + +```go +package main + +import ( + "context" + "fmt" + "log" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +func main() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + bankID := "go-quickstart" +``` + +## Retain: Store Information + +The `Retain` operation pushes new memories into Hindsight. Behind the scenes, an LLM extracts key facts, temporal data, entities, and relationships. + +```go + // Simple retain + _, err = client.Retain(ctx, bankID, + "Alice works at Google as a software engineer", + ) + if err != nil { + log.Fatal(err) + } + fmt.Println("Stored memory about Alice's job") + + // Retain with context and timestamp + _, err = client.Retain(ctx, bankID, + "Alice got promoted to senior engineer", + hindsight.WithContext("career update"), + hindsight.WithTimestamp(time.Date(2025, 6, 15, 10, 0, 0, 0, time.UTC)), + ) + if err != nil { + log.Fatal(err) + } + fmt.Println("Stored memory about Alice's promotion") +``` + +## Retain Batch: Store Multiple Memories + +```go + items := []hindsight.MemoryItem{ + {Content: "Bob is a data scientist who works with Alice"}, + {Content: "Charlie manages the team and reports to the VP of Engineering"}, + {Content: "The team is working on a recommendation engine using Go"}, + } + + resp, err := client.RetainBatch(ctx, bankID, items) + if err != nil { + log.Fatal(err) + } + fmt.Printf("Stored %d memories\n", resp.ItemsCount) +``` + +## Recall: Retrieve Memories + +`Recall` retrieves memories matching a query using four parallel strategies: semantic similarity, keyword matching, entity/relationship graph traversal, and temporal filtering. + +```go + // Simple recall + results, err := client.Recall(ctx, bankID, "What does Alice do?") + if err != nil { + log.Fatal(err) + } + + fmt.Println("\nMemories about Alice:") + for _, r := range results.Results { + fmt.Printf(" - %s\n", r.Text) + } +``` + +```go + // Recall with options + results, err = client.Recall(ctx, bankID, "Who works on the team?", + hindsight.WithBudget(hindsight.BudgetHigh), + hindsight.WithMaxTokens(2048), + hindsight.WithTypes([]string{"world"}), + ) + if err != nil { + log.Fatal(err) + } + + fmt.Println("\nTeam memories (world facts only):") + for _, r := range results.Results { + fmt.Printf(" - [%s] %s\n", r.Type.Or("?"), r.Text) + } +``` + +## Reflect: Generate Insights + +`Reflect` performs disposition-aware reasoning over stored memories. It retrieves relevant context, then uses an LLM to synthesize a response. Great for summarization, analysis, and Q&A. + +```go + answer, err := client.Reflect(ctx, bankID, + "What should I know about this team?", + ) + if err != nil { + log.Fatal(err) + } + + fmt.Println("\nReflection:") + fmt.Println(answer.Text) +``` + +## Full Program + +Here's the complete program: + +```go +package main + +import ( + "context" + "fmt" + "log" + "time" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +func main() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + bankID := "go-quickstart" + + // 1. Store memories + client.Retain(ctx, bankID, "Alice works at Google as a software engineer") + client.Retain(ctx, bankID, "Alice got promoted to senior engineer", + hindsight.WithContext("career update"), + hindsight.WithTimestamp(time.Date(2025, 6, 15, 10, 0, 0, 0, time.UTC)), + ) + + items := []hindsight.MemoryItem{ + {Content: "Bob is a data scientist who works with Alice"}, + {Content: "Charlie manages the team and reports to the VP of Engineering"}, + {Content: "The team is working on a recommendation engine using Go"}, + } + client.RetainBatch(ctx, bankID, items) + + // 2. Recall memories + results, _ := client.Recall(ctx, bankID, "What does Alice do?") + fmt.Println("Memories about Alice:") + for _, r := range results.Results { + fmt.Printf(" - %s\n", r.Text) + } + + // 3. Reflect + answer, _ := client.Reflect(ctx, bankID, "What should I know about this team?") + fmt.Printf("\nReflection:\n%s\n", answer.Text) + + // 4. Cleanup + client.DeleteBank(ctx, bankID) +} +``` + +## Memory Types + +Hindsight organizes memory into distinct networks: + +| Type | Description | Example | +|------|-------------|---------| +| **World** | Facts about the world | "Alice works at Google" | +| **Experience** | Agent's own experiences | "I helped Alice debug her code" | +| **Observation** | Complex models from reflection | "Alice is a senior IC focused on ML" | + +## Next Steps + +- [Go Concurrent Pipeline](/cookbook/recipes/go-concurrent-pipeline) - Build a concurrent ingestion pipeline +- [Per-User Memory](/cookbook/recipes/per-user-memory) - One bank per user pattern +- [Go SDK Reference](/sdks/go) - Full API reference diff --git a/hindsight-docs/docs/sdks/cli.md b/hindsight-docs/docs/sdks/cli.md index 4578def7..36380ff6 100644 --- a/hindsight-docs/docs/sdks/cli.md +++ b/hindsight-docs/docs/sdks/cli.md @@ -1,5 +1,5 @@ --- -sidebar_position: 3 +sidebar_position: 4 --- # CLI Reference diff --git a/hindsight-docs/docs/sdks/embed.md b/hindsight-docs/docs/sdks/embed.md index 3eb5d140..f94dd8e1 100644 --- a/hindsight-docs/docs/sdks/embed.md +++ b/hindsight-docs/docs/sdks/embed.md @@ -1,5 +1,5 @@ --- -sidebar_position: 4 +sidebar_position: 5 --- # Embedded SDK (hindsight-embed) diff --git a/hindsight-docs/docs/sdks/go.md b/hindsight-docs/docs/sdks/go.md new file mode 100644 index 00000000..8b60a1db --- /dev/null +++ b/hindsight-docs/docs/sdks/go.md @@ -0,0 +1,294 @@ +--- +sidebar_position: 3 +--- + +# Go Client + +Official Go client for the Hindsight API, built on [ogen](https://github.com/ogen-go/ogen) for strongly-typed code generation from the OpenAPI 3.1 spec. + +## Installation + +```bash +go get github.com/vectorize-io/hindsight-client-go +``` + +Requires Go 1.25+. + +## Quick Start + +```go +package main + +import ( + "context" + "fmt" + "log" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +func main() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + + // Retain a memory + client.Retain(ctx, "my-bank", "Alice works at Google") + + // Recall memories + resp, _ := client.Recall(ctx, "my-bank", "What does Alice do?") + for _, r := range resp.Results { + fmt.Println(r.Text) + } + + // Reflect - generate response with disposition + answer, _ := client.Reflect(ctx, "my-bank", "Tell me about Alice") + fmt.Println(answer.Text) +} +``` + +## Client Initialization + +```go +import hindsight "github.com/vectorize-io/hindsight-client-go" + +// Default client +client, err := hindsight.New("http://localhost:8888") + +// With API key authentication +client, err := hindsight.New("http://localhost:8888", + hindsight.WithAPIKey("your-api-key"), +) + +// With custom HTTP client +client, err := hindsight.New("http://localhost:8888", + hindsight.WithHTTPClient(&http.Client{Timeout: 30 * time.Second}), +) +``` + +## Core Operations + +### Retain (Store Memory) + +```go +// Simple +_, err := client.Retain(ctx, "my-bank", "Alice works at Google as a software engineer") + +// With options +_, err := client.Retain(ctx, "my-bank", "Alice got promoted", + hindsight.WithContext("career update"), + hindsight.WithTimestamp(time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)), + hindsight.WithDocumentID("conversation_001"), + hindsight.WithMetadata(map[string]string{"source": "slack"}), + hindsight.WithTags([]string{"career", "updates"}), +) +``` + +### Retain Batch + +```go +items := []hindsight.MemoryItem{ + {Content: "Alice works at Google"}, + {Content: "Bob is a data scientist"}, +} + +_, err := client.RetainBatch(ctx, "my-bank", items, + hindsight.WithDocumentTags([]string{"team-info"}), + hindsight.WithAsync(false), // Set true for background processing +) +``` + +### Recall (Search) + +```go +// Simple +resp, err := client.Recall(ctx, "my-bank", "What does Alice do?") + +for _, r := range resp.Results { + fmt.Printf(" %s (type: %s)\n", r.Text, r.Type.Or("unknown")) +} + +// With options +resp, err := client.Recall(ctx, "my-bank", "What does Alice do?", + hindsight.WithTypes([]string{"world", "experience"}), // Filter by fact type + hindsight.WithMaxTokens(4096), + hindsight.WithBudget(hindsight.BudgetHigh), // BudgetLow, BudgetMid, BudgetHigh + hindsight.WithTrace(true), // Include execution trace + hindsight.WithRecallTags([]string{"career"}), + hindsight.WithRecallTagsMatch(hindsight.TagsMatchAnyStrict), +) +``` + +### Reflect (Generate Response) + +```go +resp, err := client.Reflect(ctx, "my-bank", "What should I know about Alice?", + hindsight.WithReflectBudget(hindsight.BudgetMid), + hindsight.WithReflectMaxTokens(2048), +) + +fmt.Println(resp.Text) // Generated markdown response +``` + +### Reflect with Structured Output + +```go +resp, err := client.Reflect(ctx, "my-bank", + "What programming language should I learn for data science?", + hindsight.WithResponseSchema(map[string]any{ + "type": "object", + "properties": map[string]any{ + "recommendation": map[string]any{"type": "string"}, + "reasons": map[string]any{"type": "array", "items": map[string]any{"type": "string"}}, + "confidence": map[string]any{"type": "string"}, + }, + "required": []any{"recommendation", "reasons"}, + }), + hindsight.WithReflectMaxTokens(4096), +) + +// resp.StructuredOutput contains the parsed JSON schema result +``` + +## Bank Management + +### Create Bank + +```go +_, err := client.CreateBank(ctx, "my-bank", + hindsight.WithBankName("Assistant"), + hindsight.WithMission("Helpful AI assistant tracking user preferences."), + hindsight.WithDisposition(hindsight.DispositionTraits{ + Skepticism: 3, // 1-5: trusting to skeptical + Literalism: 3, // 1-5: flexible to literal + Empathy: 3, // 1-5: detached to empathetic + }), +) +``` + +### Other Bank Operations + +```go +// Get bank profile +profile, err := client.GetBankProfile(ctx, "my-bank") +fmt.Println(profile.Mission) + +// List all banks +banks, err := client.ListBanks(ctx) +for _, b := range banks.Banks { + fmt.Println(b.BankID) +} + +// Update mission +_, err = client.SetMission(ctx, "my-bank", "New mission statement") + +// Update disposition +_, err = client.UpdateDisposition(ctx, "my-bank", hindsight.DispositionTraits{ + Skepticism: 4, + Literalism: 2, + Empathy: 5, +}) + +// Delete bank (destructive, cannot be undone) +err = client.DeleteBank(ctx, "my-bank") +``` + +## Tag Filtering + +Tags provide visibility scoping for memories. Use them to partition memories within a bank. + +```go +// Store tagged memories +client.Retain(ctx, "my-bank", "Project X meeting notes", + hindsight.WithTags([]string{"project_x", "meetings"}), +) + +// Recall only project_x memories (strict - excludes untagged) +resp, _ := client.Recall(ctx, "my-bank", "What happened in meetings?", + hindsight.WithRecallTags([]string{"project_x"}), + hindsight.WithRecallTagsMatch(hindsight.TagsMatchAnyStrict), +) + +// Reflect scoped to tags +resp, _ := client.Reflect(ctx, "my-bank", "Summarize project X", + hindsight.WithReflectTags([]string{"project_x"}), + hindsight.WithReflectTagsMatch(hindsight.TagsMatchAnyStrict), +) +``` + +| Match Mode | Behavior | +|-----------|----------| +| `TagsMatchAny` | OR matching, includes untagged memories | +| `TagsMatchAll` | AND matching, includes untagged memories | +| `TagsMatchAnyStrict` | OR matching, excludes untagged memories | +| `TagsMatchAllStrict` | AND matching, excludes untagged memories | + +## Advanced Usage (ogen Client) + +For operations not covered by the high-level wrapper (documents, entities, mental models, directives, operations), access the generated ogen client directly: + +```go +import "github.com/vectorize-io/hindsight-client-go/internal/ogenapi" + +ogen := client.OgenClient() + +// List entities +entities, err := ogen.ListEntities(ctx, ogenapi.ListEntitiesParams{ + BankID: "my-bank", +}) + +// Create a mental model +model, err := ogen.CreateMentalModel(ctx, + &ogenapi.CreateMentalModelRequest{ + Name: ogenapi.NewOptString("User Preferences"), + SourceQuery: "What are this user's preferences and habits?", + }, + ogenapi.CreateMentalModelParams{BankID: "my-bank"}, +) + +// Create a directive +directive, err := ogen.CreateDirective(ctx, + &ogenapi.CreateDirectiveRequest{ + Name: "Response Style", + Content: "Always respond in a friendly, concise manner", + }, + ogenapi.CreateDirectiveParams{BankID: "my-bank"}, +) + +// List operations (async tasks) +ops, err := ogen.ListOperations(ctx, ogenapi.ListOperationsParams{ + BankID: "my-bank", +}) + +// Get bank stats +stats, err := ogen.GetAgentStats(ctx, ogenapi.GetAgentStatsParams{ + BankID: "my-bank", +}) +``` + +## Error Handling + +The client returns standard Go errors. HTTP errors from the API are returned as ogen error types: + +```go +resp, err := client.Recall(ctx, "nonexistent-bank", "query") +if err != nil { + // Handle error - could be network, HTTP 4xx/5xx, etc. + log.Printf("recall failed: %v", err) +} +``` + +## Code Generation + +The Go client is built on [ogen](https://github.com/ogen-go/ogen). The generated code lives in `internal/ogenapi/` and provides full type safety with no `interface{}` or reflection. + +To regenerate after API changes: + +```bash +cd hindsight-clients/go +go generate ./... +go build ./... +``` diff --git a/hindsight-docs/versioned_docs/version-0.4/cookbook/applications/go-memory-service.md b/hindsight-docs/versioned_docs/version-0.4/cookbook/applications/go-memory-service.md new file mode 100644 index 00000000..b49a6297 --- /dev/null +++ b/hindsight-docs/versioned_docs/version-0.4/cookbook/applications/go-memory-service.md @@ -0,0 +1,345 @@ +--- +sidebar_position: 10 +--- + +# Go Memory-Augmented API + +:::info Complete Application +This is a complete, runnable Go application demonstrating Hindsight integration. +::: + +A Go HTTP microservice that combines a domain API with Hindsight memory. Each API user gets a personal memory bank. The service remembers past interactions and uses them to provide personalized responses. + +## Use Case + +A **developer knowledge assistant** that remembers what technologies each user works with, what problems they've solved, and provides personalized recommendations. + +## Features + +- Per-user memory banks (created on first interaction) +- Conversation history stored via retain +- Context-aware responses via recall + reflect +- Structured output for programmatic consumption +- Health check and bank stats endpoints + +## Project Structure + +``` +go-memory-service/ +├── main.go # HTTP server, routes, handlers +├── go.mod +└── go.sum +``` + +## The Code + +```go +package main + +import ( + "context" + "encoding/json" + "fmt" + "log" + "net/http" + "os" + "strings" + "time" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +var client *hindsight.Client + +func main() { + apiURL := envOr("HINDSIGHT_API_URL", "http://localhost:8888") + + var err error + client, err = hindsight.New(apiURL) + if err != nil { + log.Fatal(err) + } + + mux := http.NewServeMux() + mux.HandleFunc("POST /ask", handleAsk) + mux.HandleFunc("POST /learn", handleLearn) + mux.HandleFunc("GET /recall/{userID}", handleRecall) + mux.HandleFunc("GET /health", handleHealth) + + addr := envOr("ADDR", ":8080") + log.Printf("listening on %s (hindsight: %s)", addr, apiURL) + log.Fatal(http.ListenAndServe(addr, mux)) +} + +// --- Request/Response types --- + +type AskRequest struct { + UserID string `json:"user_id"` + Query string `json:"query"` +} + +type AskResponse struct { + Answer string `json:"answer"` + Facts []string `json:"facts,omitempty"` +} + +type LearnRequest struct { + UserID string `json:"user_id"` + Content string `json:"content"` + Tags []string `json:"tags,omitempty"` +} + +type RecallResponse struct { + Results []RecallFact `json:"results"` +} + +type RecallFact struct { + Text string `json:"text"` + Type string `json:"type"` +} + +// --- Handlers --- + +// handleLearn stores new information for a user. +func handleLearn(w http.ResponseWriter, r *http.Request) { + var req LearnRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + http.Error(w, "invalid JSON", http.StatusBadRequest) + return + } + + ctx := r.Context() + bankID := bankFor(req.UserID) + + // Ensure bank exists + ensureBank(ctx, bankID, req.UserID) + + // Store the memory + var opts []hindsight.RetainOption + if len(req.Tags) > 0 { + opts = append(opts, hindsight.WithTags(req.Tags)) + } + + resp, err := client.Retain(ctx, bankID, req.Content, opts...) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + writeJSON(w, map[string]any{ + "success": resp.Success, + "bank_id": bankID, + }) +} + +// handleAsk answers a question using the user's memories. +func handleAsk(w http.ResponseWriter, r *http.Request) { + var req AskRequest + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { + http.Error(w, "invalid JSON", http.StatusBadRequest) + return + } + + ctx := r.Context() + bankID := bankFor(req.UserID) + + // Ensure bank exists + ensureBank(ctx, bankID, req.UserID) + + // Recall relevant facts + recallResp, err := client.Recall(ctx, bankID, req.Query, + hindsight.WithBudget(hindsight.BudgetMid), + hindsight.WithMaxTokens(2048), + ) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + var facts []string + for _, result := range recallResp.Results { + facts = append(facts, result.Text) + } + + // Reflect to generate an answer + reflectResp, err := client.Reflect(ctx, bankID, req.Query, + hindsight.WithReflectBudget(hindsight.BudgetMid), + ) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + // Store this interaction as a new memory + interaction := fmt.Sprintf("User asked: %q\nAssistant answered: %s", req.Query, reflectResp.Text) + go func() { + bgCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + client.Retain(bgCtx, bankID, interaction, + hindsight.WithContext("Q&A interaction"), + ) + }() + + writeJSON(w, AskResponse{ + Answer: reflectResp.Text, + Facts: facts, + }) +} + +// handleRecall returns raw memories for a user. +func handleRecall(w http.ResponseWriter, r *http.Request) { + userID := r.PathValue("userID") + query := r.URL.Query().Get("q") + if query == "" { + query = "What do you know?" + } + + ctx := r.Context() + bankID := bankFor(userID) + + resp, err := client.Recall(ctx, bankID, query, + hindsight.WithBudget(hindsight.BudgetHigh), + ) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + var results []RecallFact + for _, result := range resp.Results { + results = append(results, RecallFact{ + Text: result.Text, + Type: result.Type.Or("unknown"), + }) + } + + writeJSON(w, RecallResponse{Results: results}) +} + +func handleHealth(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, map[string]string{"status": "ok"}) +} + +// --- Helpers --- + +func bankFor(userID string) string { + return "user-" + strings.ToLower(userID) +} + +func ensureBank(ctx context.Context, bankID, userID string) { + client.CreateBank(ctx, bankID, + hindsight.WithBankName(fmt.Sprintf("Memory for %s", userID)), + hindsight.WithMission("Developer knowledge assistant. Remember technologies, problems solved, and preferences."), + ) +} + +func writeJSON(w http.ResponseWriter, v any) { + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(v) +} + +func envOr(key, fallback string) string { + if v := os.Getenv(key); v != "" { + return v + } + return fallback +} +``` + +## Running + +### 1. Start Hindsight + +```bash +export OPENAI_API_KEY=your-key + +docker run --rm -it --pull always -p 8888:8888 -p 9999:9999 \ + -e HINDSIGHT_API_LLM_API_KEY=$OPENAI_API_KEY \ + -e HINDSIGHT_API_LLM_MODEL=o3-mini \ + -v $HOME/.hindsight-docker:/home/hindsight/.pg0 \ + ghcr.io/vectorize-io/hindsight:latest +``` + +### 2. Start the service + +```bash +go run main.go +``` + +### 3. Try it out + +```bash +# Teach it something +curl -s localhost:8080/learn -d '{ + "user_id": "alice", + "content": "I am building a Go microservice that uses gRPC and PostgreSQL", + "tags": ["project"] +}' | jq . + +# Teach it more +curl -s localhost:8080/learn -d '{ + "user_id": "alice", + "content": "I solved a connection pooling issue by switching from pgx to pgxpool", + "tags": ["debugging"] +}' + +curl -s localhost:8080/learn -d '{ + "user_id": "alice", + "content": "I prefer structured logging with slog over zerolog", + "tags": ["preferences"] +}' + +# Ask a question (uses recall + reflect) +curl -s localhost:8080/ask -d '{ + "user_id": "alice", + "query": "What tech stack am I using?" +}' | jq . + +# Raw recall +curl -s "localhost:8080/recall/alice?q=database" | jq . +``` + +## How It Works + +1. **`/learn`** - Stores information using `Retain`. Each piece of info becomes searchable facts, entities, and relationships. + +2. **`/ask`** - Two-phase retrieval: + - **Recall**: Finds relevant facts from the user's memory bank + - **Reflect**: Synthesizes a response using those facts plus disposition-aware reasoning + - The Q&A interaction itself is stored as a new memory (fire-and-forget goroutine) + +3. **`/recall/{userID}`** - Direct access to raw recalled facts for debugging or building custom UIs. + +## Key Patterns + +### Per-User Isolation + +Each user gets their own bank (`user-alice`, `user-bob`). Banks are created lazily on first interaction via `CreateBank` (idempotent - safe to call repeatedly). + +### Fire-and-Forget Memory + +The `/ask` handler stores the interaction in a background goroutine so the response isn't delayed by the retain call: + +```go +go func() { + bgCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + client.Retain(bgCtx, bankID, interaction) +}() +``` + +### Tag-Based Scoping + +Tags partition memories within a bank. Query only `debugging` memories, or only `preferences`: + +```bash +# The /recall endpoint could be extended to support tag filtering: +curl "localhost:8080/recall/alice?q=issues&tags=debugging" +``` + +## Next Steps + +- [Go Quickstart](/cookbook/recipes/go-quickstart) - Core operations walkthrough +- [Go Concurrent Pipeline](/cookbook/recipes/go-concurrent-pipeline) - Bulk data ingestion +- [Per-User Memory](/cookbook/recipes/per-user-memory) - The pattern in depth +- [Go SDK Reference](/sdks/go) - Full API documentation diff --git a/hindsight-docs/versioned_docs/version-0.4/cookbook/index.mdx b/hindsight-docs/versioned_docs/version-0.4/cookbook/index.mdx index cb22bd4d..c3d20351 100644 --- a/hindsight-docs/versioned_docs/version-0.4/cookbook/index.mdx +++ b/hindsight-docs/versioned_docs/version-0.4/cookbook/index.mdx @@ -86,6 +86,18 @@ Learn how to build with Hindsight through practical examples: href: "/cookbook/recipes/study_buddy", description: "Track study sessions, identify knowledge gaps, and get personalized review suggestions", tags: { sdk: "hindsight-client", topic: "Learning" } + }, + { + title: "Go Quickstart", + href: "/cookbook/recipes/go-quickstart", + description: "Get started with the Go client: retain, recall, and reflect", + tags: { sdk: "hindsight-go", topic: "Quick Start" } + }, + { + title: "Go Concurrent Pipeline", + href: "/cookbook/recipes/go-concurrent-pipeline", + description: "Build a concurrent memory ingestion pipeline with goroutines", + tags: { sdk: "hindsight-go", topic: "Learning" } } ]} /> @@ -140,6 +152,12 @@ Learn how to build with Hindsight through practical examples: href: "/cookbook/applications/taste-ai", description: "Personal food assistant with AI SDK v6 showcasing recall, mental models, and directives", tags: { sdk: "@vectorize-io/hindsight-ai-sdk", topic: "Recommendation" } + }, + { + title: "Go Memory-Augmented API", + href: "/cookbook/applications/go-memory-service", + description: "Go HTTP microservice with per-user memory banks for a developer knowledge assistant", + tags: { sdk: "hindsight-go", topic: "Learning" } } ]} /> diff --git a/hindsight-docs/versioned_docs/version-0.4/cookbook/recipes/go-concurrent-pipeline.md b/hindsight-docs/versioned_docs/version-0.4/cookbook/recipes/go-concurrent-pipeline.md new file mode 100644 index 00000000..158627b7 --- /dev/null +++ b/hindsight-docs/versioned_docs/version-0.4/cookbook/recipes/go-concurrent-pipeline.md @@ -0,0 +1,272 @@ +--- +sidebar_position: 13 +--- + +# Go Concurrent Pipeline + +Build a concurrent memory ingestion pipeline in Go. This recipe demonstrates how to use Go's concurrency primitives with the Hindsight client to ingest large datasets efficiently, then query them with recall and reflect. + +## The Problem + +You have a large dataset (log files, chat transcripts, documents) that needs to be ingested into Hindsight. Sequential ingestion is slow. Go's goroutines make it straightforward to parallelize. + +## Architecture + +``` + ┌──────────┐ + │ Source │ + │ (files, │ + │ API, DB) │ + └────┬─────┘ + │ + ┌────▼─────┐ + │ Producer │ reads data, sends to channel + └────┬─────┘ + │ + ┌──────────┼──────────┐ + │ │ │ + ┌────▼───┐ ┌───▼────┐ ┌──▼─────┐ + │Worker 1│ │Worker 2│ │Worker N│ concurrent RetainBatch + └────┬───┘ └───┬────┘ └──┬─────┘ + │ │ │ + └─────────┼─────────┘ + │ + ┌─────▼─────┐ + │ Hindsight │ + │ API │ + └───────────┘ +``` + +## Prerequisites + +Hindsight server running (see [Go Quickstart](/cookbook/recipes/go-quickstart) for setup). + +## The Pipeline + +```go +package main + +import ( + "bufio" + "context" + "fmt" + "log" + "os" + "sync" + "sync/atomic" + "time" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +const ( + batchSize = 10 // memories per batch + numWorkers = 4 // concurrent workers +) + +func main() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + bankID := "pipeline-demo" + + // Create the bank + client.CreateBank(ctx, bankID, + hindsight.WithBankName("Pipeline Demo"), + hindsight.WithMission("Knowledge base ingested from documents"), + ) + + // Ingest from a file (one line = one memory) + if len(os.Args) < 2 { + fmt.Println("usage: pipeline ") + os.Exit(1) + } + + start := time.Now() + count := ingest(ctx, client, bankID, os.Args[1]) + elapsed := time.Since(start) + + fmt.Printf("\nIngested %d memories in %s (%.1f/sec)\n", + count, elapsed, float64(count)/elapsed.Seconds()) + + // Query the ingested data + fmt.Println("\n--- Recall ---") + resp, _ := client.Recall(ctx, bankID, "What are the key topics?", + hindsight.WithBudget(hindsight.BudgetHigh), + ) + for _, r := range resp.Results { + fmt.Printf(" - %s\n", r.Text) + } + + fmt.Println("\n--- Reflect ---") + answer, _ := client.Reflect(ctx, bankID, "Summarize everything you know") + fmt.Println(answer.Text) +} + +func ingest(ctx context.Context, client *hindsight.Client, bankID, filename string) int64 { + f, err := os.Open(filename) + if err != nil { + log.Fatal(err) + } + defer f.Close() + + // Channel for batches + batches := make(chan []hindsight.MemoryItem, numWorkers*2) + var ingested atomic.Int64 + + // Start workers + var wg sync.WaitGroup + for i := range numWorkers { + wg.Add(1) + go func(id int) { + defer wg.Done() + for batch := range batches { + _, err := client.RetainBatch(ctx, bankID, batch) + if err != nil { + log.Printf("worker %d: batch failed: %v", id, err) + continue + } + n := ingested.Add(int64(len(batch))) + if n%100 == 0 { + fmt.Printf(" ingested %d memories...\n", n) + } + } + }(i) + } + + // Producer: read lines and batch them + scanner := bufio.NewScanner(f) + var batch []hindsight.MemoryItem + + for scanner.Scan() { + line := scanner.Text() + if line == "" { + continue + } + batch = append(batch, hindsight.MemoryItem{Content: line}) + + if len(batch) >= batchSize { + batches <- batch + batch = nil + } + } + + // Flush remaining + if len(batch) > 0 { + batches <- batch + } + + close(batches) + wg.Wait() + + return ingested.Load() +} +``` + +## Running It + +Create a sample data file: + +```bash +cat > sample_data.txt << 'EOF' +The Go programming language was created at Google in 2007 +Go's concurrency model is based on CSP (Communicating Sequential Processes) +Goroutines are lightweight threads managed by the Go runtime +Channels provide typed conduits for communication between goroutines +The sync package provides mutexes, wait groups, and other synchronization primitives +Go modules were introduced in Go 1.11 for dependency management +The context package provides cancellation and deadline propagation +Go compiles to a single static binary with no external dependencies +The standard library includes an HTTP server, JSON parser, and crypto packages +Go 1.18 introduced generics with type parameters +EOF +``` + +```bash +go run . sample_data.txt +``` + +## Adding Tags for Partitioning + +For larger datasets, use tags to partition memories by source or topic: + +```go +func ingestWithTags(ctx context.Context, client *hindsight.Client, bankID, source string, lines []string) { + var items []hindsight.MemoryItem + for _, line := range lines { + items = append(items, hindsight.MemoryItem{ + Content: line, + Tags: []string{source}, + }) + } + + _, err := client.RetainBatch(ctx, bankID, items, + hindsight.WithDocumentTags([]string{"bulk-import", source}), + ) + if err != nil { + log.Printf("ingest %s failed: %v", source, err) + } +} + +// Later, recall only from a specific source +resp, _ := client.Recall(ctx, bankID, "What are the key concepts?", + hindsight.WithRecallTags([]string{"go-docs"}), + hindsight.WithRecallTagsMatch(hindsight.TagsMatchAnyStrict), +) +``` + +## Async Ingestion + +For very large datasets, use async mode to avoid waiting for fact extraction: + +```go +// Async retain returns immediately; processing happens in background +_, err := client.RetainBatch(ctx, bankID, items, + hindsight.WithAsync(true), +) + +// Check operation status via the ogen client +ogen := client.OgenClient() +ops, _ := ogen.ListOperations(ctx, ogenapi.ListOperationsParams{ + BankID: bankID, +}) +``` + +## Graceful Shutdown + +Use `context.WithCancel` for clean cancellation: + +```go +ctx, cancel := context.WithCancel(context.Background()) +defer cancel() + +// In a signal handler: +sigCh := make(chan os.Signal, 1) +signal.Notify(sigCh, os.Interrupt) +go func() { + <-sigCh + fmt.Println("\nShutting down gracefully...") + cancel() +}() + +// Workers will stop when ctx is cancelled +``` + +## Performance Tips + +| Tip | Why | +|-----|-----| +| Use `RetainBatch` over individual `Retain` | Fewer HTTP round trips | +| Set `batchSize` to 10-50 | Balances throughput vs. memory | +| Use 4-8 workers | Matches typical API concurrency limits | +| Use `WithAsync(true)` for bulk imports | Returns immediately, processes in background | +| Tag your data | Enables scoped recall without reingesting | + +## Next Steps + +- [Go Quickstart](/cookbook/recipes/go-quickstart) - Basic retain, recall, reflect +- [Per-User Memory](/cookbook/recipes/per-user-memory) - One bank per user pattern +- [Go SDK Reference](/sdks/go) - Full API reference diff --git a/hindsight-docs/versioned_docs/version-0.4/cookbook/recipes/go-quickstart.md b/hindsight-docs/versioned_docs/version-0.4/cookbook/recipes/go-quickstart.md new file mode 100644 index 00000000..acc21e2e --- /dev/null +++ b/hindsight-docs/versioned_docs/version-0.4/cookbook/recipes/go-quickstart.md @@ -0,0 +1,216 @@ +--- +sidebar_position: 12 +--- + +# Go Quickstart + +Get started with the Hindsight Go client in under 5 minutes. This recipe covers the three core operations: **retain**, **recall**, and **reflect**. + +## Prerequisites + +Make sure you have Hindsight running. The easiest way is via Docker: + +```bash +export OPENAI_API_KEY=your-key + +docker run --rm -it --pull always -p 8888:8888 -p 9999:9999 \ + -e HINDSIGHT_API_LLM_API_KEY=$OPENAI_API_KEY \ + -e HINDSIGHT_API_LLM_MODEL=o3-mini \ + -v $HOME/.hindsight-docker:/home/hindsight/.pg0 \ + ghcr.io/vectorize-io/hindsight:latest +``` + +- API: http://localhost:8888 +- UI: http://localhost:9999 + +## Installation + +```bash +go get github.com/vectorize-io/hindsight-client-go +``` + +## Connect to Hindsight + +```go +package main + +import ( + "context" + "fmt" + "log" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +func main() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + bankID := "go-quickstart" +``` + +## Retain: Store Information + +The `Retain` operation pushes new memories into Hindsight. Behind the scenes, an LLM extracts key facts, temporal data, entities, and relationships. + +```go + // Simple retain + _, err = client.Retain(ctx, bankID, + "Alice works at Google as a software engineer", + ) + if err != nil { + log.Fatal(err) + } + fmt.Println("Stored memory about Alice's job") + + // Retain with context and timestamp + _, err = client.Retain(ctx, bankID, + "Alice got promoted to senior engineer", + hindsight.WithContext("career update"), + hindsight.WithTimestamp(time.Date(2025, 6, 15, 10, 0, 0, 0, time.UTC)), + ) + if err != nil { + log.Fatal(err) + } + fmt.Println("Stored memory about Alice's promotion") +``` + +## Retain Batch: Store Multiple Memories + +```go + items := []hindsight.MemoryItem{ + {Content: "Bob is a data scientist who works with Alice"}, + {Content: "Charlie manages the team and reports to the VP of Engineering"}, + {Content: "The team is working on a recommendation engine using Go"}, + } + + resp, err := client.RetainBatch(ctx, bankID, items) + if err != nil { + log.Fatal(err) + } + fmt.Printf("Stored %d memories\n", resp.ItemsCount) +``` + +## Recall: Retrieve Memories + +`Recall` retrieves memories matching a query using four parallel strategies: semantic similarity, keyword matching, entity/relationship graph traversal, and temporal filtering. + +```go + // Simple recall + results, err := client.Recall(ctx, bankID, "What does Alice do?") + if err != nil { + log.Fatal(err) + } + + fmt.Println("\nMemories about Alice:") + for _, r := range results.Results { + fmt.Printf(" - %s\n", r.Text) + } +``` + +```go + // Recall with options + results, err = client.Recall(ctx, bankID, "Who works on the team?", + hindsight.WithBudget(hindsight.BudgetHigh), + hindsight.WithMaxTokens(2048), + hindsight.WithTypes([]string{"world"}), + ) + if err != nil { + log.Fatal(err) + } + + fmt.Println("\nTeam memories (world facts only):") + for _, r := range results.Results { + fmt.Printf(" - [%s] %s\n", r.Type.Or("?"), r.Text) + } +``` + +## Reflect: Generate Insights + +`Reflect` performs disposition-aware reasoning over stored memories. It retrieves relevant context, then uses an LLM to synthesize a response. Great for summarization, analysis, and Q&A. + +```go + answer, err := client.Reflect(ctx, bankID, + "What should I know about this team?", + ) + if err != nil { + log.Fatal(err) + } + + fmt.Println("\nReflection:") + fmt.Println(answer.Text) +``` + +## Full Program + +Here's the complete program: + +```go +package main + +import ( + "context" + "fmt" + "log" + "time" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +func main() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + bankID := "go-quickstart" + + // 1. Store memories + client.Retain(ctx, bankID, "Alice works at Google as a software engineer") + client.Retain(ctx, bankID, "Alice got promoted to senior engineer", + hindsight.WithContext("career update"), + hindsight.WithTimestamp(time.Date(2025, 6, 15, 10, 0, 0, 0, time.UTC)), + ) + + items := []hindsight.MemoryItem{ + {Content: "Bob is a data scientist who works with Alice"}, + {Content: "Charlie manages the team and reports to the VP of Engineering"}, + {Content: "The team is working on a recommendation engine using Go"}, + } + client.RetainBatch(ctx, bankID, items) + + // 2. Recall memories + results, _ := client.Recall(ctx, bankID, "What does Alice do?") + fmt.Println("Memories about Alice:") + for _, r := range results.Results { + fmt.Printf(" - %s\n", r.Text) + } + + // 3. Reflect + answer, _ := client.Reflect(ctx, bankID, "What should I know about this team?") + fmt.Printf("\nReflection:\n%s\n", answer.Text) + + // 4. Cleanup + client.DeleteBank(ctx, bankID) +} +``` + +## Memory Types + +Hindsight organizes memory into distinct networks: + +| Type | Description | Example | +|------|-------------|---------| +| **World** | Facts about the world | "Alice works at Google" | +| **Experience** | Agent's own experiences | "I helped Alice debug her code" | +| **Observation** | Complex models from reflection | "Alice is a senior IC focused on ML" | + +## Next Steps + +- [Go Concurrent Pipeline](/cookbook/recipes/go-concurrent-pipeline) - Build a concurrent ingestion pipeline +- [Per-User Memory](/cookbook/recipes/per-user-memory) - One bank per user pattern +- [Go SDK Reference](/sdks/go) - Full API reference diff --git a/hindsight-docs/versioned_docs/version-0.4/sdks/cli.md b/hindsight-docs/versioned_docs/version-0.4/sdks/cli.md index 4578def7..36380ff6 100644 --- a/hindsight-docs/versioned_docs/version-0.4/sdks/cli.md +++ b/hindsight-docs/versioned_docs/version-0.4/sdks/cli.md @@ -1,5 +1,5 @@ --- -sidebar_position: 3 +sidebar_position: 4 --- # CLI Reference diff --git a/hindsight-docs/versioned_docs/version-0.4/sdks/embed.md b/hindsight-docs/versioned_docs/version-0.4/sdks/embed.md index 3eb5d140..f94dd8e1 100644 --- a/hindsight-docs/versioned_docs/version-0.4/sdks/embed.md +++ b/hindsight-docs/versioned_docs/version-0.4/sdks/embed.md @@ -1,5 +1,5 @@ --- -sidebar_position: 4 +sidebar_position: 5 --- # Embedded SDK (hindsight-embed) diff --git a/hindsight-docs/versioned_docs/version-0.4/sdks/go.md b/hindsight-docs/versioned_docs/version-0.4/sdks/go.md new file mode 100644 index 00000000..8b60a1db --- /dev/null +++ b/hindsight-docs/versioned_docs/version-0.4/sdks/go.md @@ -0,0 +1,294 @@ +--- +sidebar_position: 3 +--- + +# Go Client + +Official Go client for the Hindsight API, built on [ogen](https://github.com/ogen-go/ogen) for strongly-typed code generation from the OpenAPI 3.1 spec. + +## Installation + +```bash +go get github.com/vectorize-io/hindsight-client-go +``` + +Requires Go 1.25+. + +## Quick Start + +```go +package main + +import ( + "context" + "fmt" + "log" + + hindsight "github.com/vectorize-io/hindsight-client-go" +) + +func main() { + client, err := hindsight.New("http://localhost:8888") + if err != nil { + log.Fatal(err) + } + + ctx := context.Background() + + // Retain a memory + client.Retain(ctx, "my-bank", "Alice works at Google") + + // Recall memories + resp, _ := client.Recall(ctx, "my-bank", "What does Alice do?") + for _, r := range resp.Results { + fmt.Println(r.Text) + } + + // Reflect - generate response with disposition + answer, _ := client.Reflect(ctx, "my-bank", "Tell me about Alice") + fmt.Println(answer.Text) +} +``` + +## Client Initialization + +```go +import hindsight "github.com/vectorize-io/hindsight-client-go" + +// Default client +client, err := hindsight.New("http://localhost:8888") + +// With API key authentication +client, err := hindsight.New("http://localhost:8888", + hindsight.WithAPIKey("your-api-key"), +) + +// With custom HTTP client +client, err := hindsight.New("http://localhost:8888", + hindsight.WithHTTPClient(&http.Client{Timeout: 30 * time.Second}), +) +``` + +## Core Operations + +### Retain (Store Memory) + +```go +// Simple +_, err := client.Retain(ctx, "my-bank", "Alice works at Google as a software engineer") + +// With options +_, err := client.Retain(ctx, "my-bank", "Alice got promoted", + hindsight.WithContext("career update"), + hindsight.WithTimestamp(time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)), + hindsight.WithDocumentID("conversation_001"), + hindsight.WithMetadata(map[string]string{"source": "slack"}), + hindsight.WithTags([]string{"career", "updates"}), +) +``` + +### Retain Batch + +```go +items := []hindsight.MemoryItem{ + {Content: "Alice works at Google"}, + {Content: "Bob is a data scientist"}, +} + +_, err := client.RetainBatch(ctx, "my-bank", items, + hindsight.WithDocumentTags([]string{"team-info"}), + hindsight.WithAsync(false), // Set true for background processing +) +``` + +### Recall (Search) + +```go +// Simple +resp, err := client.Recall(ctx, "my-bank", "What does Alice do?") + +for _, r := range resp.Results { + fmt.Printf(" %s (type: %s)\n", r.Text, r.Type.Or("unknown")) +} + +// With options +resp, err := client.Recall(ctx, "my-bank", "What does Alice do?", + hindsight.WithTypes([]string{"world", "experience"}), // Filter by fact type + hindsight.WithMaxTokens(4096), + hindsight.WithBudget(hindsight.BudgetHigh), // BudgetLow, BudgetMid, BudgetHigh + hindsight.WithTrace(true), // Include execution trace + hindsight.WithRecallTags([]string{"career"}), + hindsight.WithRecallTagsMatch(hindsight.TagsMatchAnyStrict), +) +``` + +### Reflect (Generate Response) + +```go +resp, err := client.Reflect(ctx, "my-bank", "What should I know about Alice?", + hindsight.WithReflectBudget(hindsight.BudgetMid), + hindsight.WithReflectMaxTokens(2048), +) + +fmt.Println(resp.Text) // Generated markdown response +``` + +### Reflect with Structured Output + +```go +resp, err := client.Reflect(ctx, "my-bank", + "What programming language should I learn for data science?", + hindsight.WithResponseSchema(map[string]any{ + "type": "object", + "properties": map[string]any{ + "recommendation": map[string]any{"type": "string"}, + "reasons": map[string]any{"type": "array", "items": map[string]any{"type": "string"}}, + "confidence": map[string]any{"type": "string"}, + }, + "required": []any{"recommendation", "reasons"}, + }), + hindsight.WithReflectMaxTokens(4096), +) + +// resp.StructuredOutput contains the parsed JSON schema result +``` + +## Bank Management + +### Create Bank + +```go +_, err := client.CreateBank(ctx, "my-bank", + hindsight.WithBankName("Assistant"), + hindsight.WithMission("Helpful AI assistant tracking user preferences."), + hindsight.WithDisposition(hindsight.DispositionTraits{ + Skepticism: 3, // 1-5: trusting to skeptical + Literalism: 3, // 1-5: flexible to literal + Empathy: 3, // 1-5: detached to empathetic + }), +) +``` + +### Other Bank Operations + +```go +// Get bank profile +profile, err := client.GetBankProfile(ctx, "my-bank") +fmt.Println(profile.Mission) + +// List all banks +banks, err := client.ListBanks(ctx) +for _, b := range banks.Banks { + fmt.Println(b.BankID) +} + +// Update mission +_, err = client.SetMission(ctx, "my-bank", "New mission statement") + +// Update disposition +_, err = client.UpdateDisposition(ctx, "my-bank", hindsight.DispositionTraits{ + Skepticism: 4, + Literalism: 2, + Empathy: 5, +}) + +// Delete bank (destructive, cannot be undone) +err = client.DeleteBank(ctx, "my-bank") +``` + +## Tag Filtering + +Tags provide visibility scoping for memories. Use them to partition memories within a bank. + +```go +// Store tagged memories +client.Retain(ctx, "my-bank", "Project X meeting notes", + hindsight.WithTags([]string{"project_x", "meetings"}), +) + +// Recall only project_x memories (strict - excludes untagged) +resp, _ := client.Recall(ctx, "my-bank", "What happened in meetings?", + hindsight.WithRecallTags([]string{"project_x"}), + hindsight.WithRecallTagsMatch(hindsight.TagsMatchAnyStrict), +) + +// Reflect scoped to tags +resp, _ := client.Reflect(ctx, "my-bank", "Summarize project X", + hindsight.WithReflectTags([]string{"project_x"}), + hindsight.WithReflectTagsMatch(hindsight.TagsMatchAnyStrict), +) +``` + +| Match Mode | Behavior | +|-----------|----------| +| `TagsMatchAny` | OR matching, includes untagged memories | +| `TagsMatchAll` | AND matching, includes untagged memories | +| `TagsMatchAnyStrict` | OR matching, excludes untagged memories | +| `TagsMatchAllStrict` | AND matching, excludes untagged memories | + +## Advanced Usage (ogen Client) + +For operations not covered by the high-level wrapper (documents, entities, mental models, directives, operations), access the generated ogen client directly: + +```go +import "github.com/vectorize-io/hindsight-client-go/internal/ogenapi" + +ogen := client.OgenClient() + +// List entities +entities, err := ogen.ListEntities(ctx, ogenapi.ListEntitiesParams{ + BankID: "my-bank", +}) + +// Create a mental model +model, err := ogen.CreateMentalModel(ctx, + &ogenapi.CreateMentalModelRequest{ + Name: ogenapi.NewOptString("User Preferences"), + SourceQuery: "What are this user's preferences and habits?", + }, + ogenapi.CreateMentalModelParams{BankID: "my-bank"}, +) + +// Create a directive +directive, err := ogen.CreateDirective(ctx, + &ogenapi.CreateDirectiveRequest{ + Name: "Response Style", + Content: "Always respond in a friendly, concise manner", + }, + ogenapi.CreateDirectiveParams{BankID: "my-bank"}, +) + +// List operations (async tasks) +ops, err := ogen.ListOperations(ctx, ogenapi.ListOperationsParams{ + BankID: "my-bank", +}) + +// Get bank stats +stats, err := ogen.GetAgentStats(ctx, ogenapi.GetAgentStatsParams{ + BankID: "my-bank", +}) +``` + +## Error Handling + +The client returns standard Go errors. HTTP errors from the API are returned as ogen error types: + +```go +resp, err := client.Recall(ctx, "nonexistent-bank", "query") +if err != nil { + // Handle error - could be network, HTTP 4xx/5xx, etc. + log.Printf("recall failed: %v", err) +} +``` + +## Code Generation + +The Go client is built on [ogen](https://github.com/ogen-go/ogen). The generated code lives in `internal/ogenapi/` and provides full type safety with no `interface{}` or reflection. + +To regenerate after API changes: + +```bash +cd hindsight-clients/go +go generate ./... +go build ./... +``` diff --git a/scripts/generate-clients.sh b/scripts/generate-clients.sh index 4a272c6e..7fa4bf27 100755 --- a/scripts/generate-clients.sh +++ b/scripts/generate-clients.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash set -e -# Script to generate Python and TypeScript clients from OpenAPI spec using openapi-generator +# Script to generate Python, TypeScript, and Go clients from OpenAPI spec # Note: Rust client is auto-generated at build time via build.rs (uses progenitor) # Usage: ./scripts/generate-clients.sh @@ -24,6 +24,7 @@ echo "This script generates clients for:" echo " - Rust (via progenitor in build.rs)" echo " - Python (via openapi-generator)" echo " - TypeScript (via @hey-api/openapi-ts)" +echo " - Go (via ogen)" echo "" # Check if OpenAPI spec exists @@ -333,6 +334,25 @@ npm run generate echo "✓ TypeScript client generated at $TYPESCRIPT_CLIENT_DIR" echo "" +# Generate Go client +echo "==================================================" +echo "Generating Go client..." +echo "==================================================" + +GO_CLIENT_DIR="$CLIENTS_DIR/go" + +if ! command -v go &> /dev/null; then + echo "⚠ Go not found, skipping Go client generation" + echo " Install Go 1.25+ from https://go.dev/dl/" +else + echo "Regenerating Go client (via ogen)..." + cd "$GO_CLIENT_DIR" + go generate ./... + go build ./... + echo "✓ Go client generated at $GO_CLIENT_DIR" +fi +echo "" + echo "==================================================" echo "✅ Client generation complete!" echo "==================================================" @@ -340,6 +360,7 @@ echo "" echo "Rust client: $RUST_CLIENT_DIR" echo "Python client: $PYTHON_CLIENT_DIR" echo "TypeScript client: $TYPESCRIPT_CLIENT_DIR" +echo "Go client: $GO_CLIENT_DIR" echo "" echo "⚠️ Important: The maintained wrapper hindsight_client.py and README.md were preserved" echo ""