engine

Documentation

Index

• func ResolveKey(explicit string, envVars ...string) (string, error)
• func ResolveKeyPair(ak, sk string, akEnvs, skEnvs []string) (string, string, error)
• type Cache
  • func WithCache(e Engine, ttl time.Duration, maxSize int) *Cache
  • func (c *Cache) Clear()
  • func (c *Cache) Execute(ctx context.Context, g workflow.Graph) (Result, error)
  • func (c *Cache) Len() int
• type Capability
• type ConfigField
• type Describer
• type Discoverer
• type DryRunResult
• type DryRunner
• type Engine
• type Entry
• type OutputKind
  • func ClassifyOutput(s string) OutputKind
• type Registry
  • func NewRegistry() *Registry
  • func (r *Registry) AllConfigSchemas() map[string][]ConfigField
  • func (r *Registry) AllModels() map[string]map[string][]string
  • func (r *Registry) FindByCapability(mediaType string) []Entry
  • func (r *Registry) Get(name string) (Entry, bool)
  • func (r *Registry) Len() int
  • func (r *Registry) List() []string
  • func (r *Registry) Register(name string, e Entry)
• type Result
• type ResultItem
• type Resumer
• type WebhookConfig

Functions

func ResolveKey

func ResolveKey(explicit string, envVars ...string) (string, error)

ResolveKey resolves an API key by checking the explicit value first, then falling back to the given environment variable names in order. Returns an error listing all checked sources if no key is found.

func ResolveKeyPair

func ResolveKeyPair(ak, sk string, akEnvs, skEnvs []string) (string, string, error)

ResolveKeyPair resolves a pair of keys (e.g. AccessKey + SecretKey). Each key is resolved independently via ResolveKey.

Types

type Cache

type Cache struct {
	// contains filtered or unexported fields
}

Cache wraps an Engine and caches successful results keyed by graph content.

func WithCache

func WithCache(e Engine, ttl time.Duration, maxSize int) *Cache

WithCache wraps an Engine with a result cache. ttl controls how long results are cached; maxSize limits the number of entries.

func (*Cache) Clear

func (c *Cache) Clear()

Clear removes all cached entries.

func (*Cache) Execute

func (c *Cache) Execute(ctx context.Context, g workflow.Graph) (Result, error)

Execute checks the cache before delegating to the underlying engine.

func (*Cache) Len

func (c *Cache) Len() int

Len returns the number of entries currently in the cache.

type Capability

type Capability struct {
	MediaTypes   []string // e.g. ["image", "video", "audio"]
	Models       []string
	Sizes        []string // e.g. ["1024x1024", "1280x720"]
	Voices       []string // supported voice identifiers for TTS engines
	MaxDuration  int      // max video/audio duration in seconds; 0 = not applicable
	SupportsSync bool
	SupportsPoll bool
}

Capability describes what an engine can do.

type ConfigField

type ConfigField struct {
	Key         string `json:"key"`   // field identifier, e.g. "apiKey", "appId"
	Label       string `json:"label"` // human-readable label, e.g. "API Key"
	Type        string `json:"type"`  // "string", "secret", "url"
	Required    bool   `json:"required"`
	EnvVar      string `json:"envVar,omitempty"` // fallback environment variable name
	Description string `json:"description,omitempty"`
	Default     string `json:"default,omitempty"`
}

ConfigField describes a single configuration parameter for an engine provider. Engine packages expose a package-level ConfigSchema() []ConfigField function so that UIs can dynamically render configuration forms.

type Describer

type Describer interface {
	Capabilities() Capability
}

Describer is an optional interface that engines can implement to advertise capabilities.

type Discoverer

type Discoverer interface {
	ModelsByCapability() map[string][]string
}

Discoverer is a package-level interface for providers that can enumerate all known models grouped by capability (e.g. "image", "video", "tts"). Unlike Engine (per-instance), Discoverer is a static catalog of models the provider SDK knows how to handle.

type DryRunResult

type DryRunResult struct {
	WillPoll      bool
	EstimatedTime string   // human-readable estimate, e.g. "30s-2m"
	Warnings      []string // potential issues with the request
}

DryRunResult is the outcome of a dry-run estimation.

type DryRunner

type DryRunner interface {
	DryRun(graph workflow.Graph) (DryRunResult, error)
}

DryRunner is an optional interface for engines that support dry-run estimation.

type Engine

type Engine interface {
	Execute(ctx context.Context, graph workflow.Graph) (Result, error)
}

Engine executes a workflow graph against a concrete backend.

type Entry

type Entry struct {
	Name               string
	Engine             Engine
	ConfigSchemaFunc   func() []ConfigField
	ModelsByCapability func() map[string][]string
}

Entry describes a registered engine provider.

type OutputKind

type OutputKind int

OutputKind classifies the string returned by an engine.

const (
	OutputUnknown OutputKind = iota
	OutputURL
	OutputDataURI
	OutputJSON
	OutputPlainText
)

func ClassifyOutput

func ClassifyOutput(s string) OutputKind

ClassifyOutput heuristically classifies a raw output string.

type Registry

type Registry struct {
	// contains filtered or unexported fields
}

Registry provides engine registration, lookup, and discovery.

func NewRegistry

func NewRegistry() *Registry

NewRegistry creates an empty engine registry.

func (*Registry) AllConfigSchemas

func (r *Registry) AllConfigSchemas() map[string][]ConfigField

AllConfigSchemas returns the configuration schema for each registered engine.

func (*Registry) AllModels

func (r *Registry) AllModels() map[string]map[string][]string

AllModels returns all registered models grouped by engine name and capability. Result: map[engineName]map[capability][]models

func (*Registry) FindByCapability

func (r *Registry) FindByCapability(mediaType string) []Entry

FindByCapability returns all entries whose ModelsByCapability includes the given media type.

func (*Registry) Get

func (r *Registry) Get(name string) (Entry, bool)

Get returns the entry for the given engine name.

func (*Registry) Len

func (r *Registry) Len() int

Len returns the number of registered engines.

func (*Registry) List

func (r *Registry) List() []string

List returns all registered engine names in sorted order.

func (*Registry) Register

func (r *Registry) Register(name string, e Entry)

Register adds an engine entry to the registry. If an entry with the same name exists, it is replaced.

type Result

type Result struct {
	Value   string
	Kind    OutputKind
	Results []ResultItem // multiple results for batch generation; may be nil for single-result engines
}

Result is the structured output of Engine.Execute.

type ResultItem

type ResultItem struct {
	Value    string            // output URL, data URI, or text
	Kind     OutputKind        // classification of Value
	Metadata map[string]string // engine-specific metadata (e.g. "seed", "index")
}

ResultItem represents a single output in a multi-result response.

type Resumer

type Resumer interface {
	Resume(ctx context.Context, remoteID string) (Result, error)
}

Resumer is an optional interface for engines that support resuming an already-submitted async task by its remote ID.

type WebhookConfig

type WebhookConfig struct {
	URL     string            // webhook endpoint
	Secret  string            // optional signing secret for verification
	Headers map[string]string // optional additional headers
}

WebhookConfig is a common webhook configuration for engines that support completion notifications via webhook.