prompt

type AgentDef ¶ added in v1.3.1

type AgentDef = packspec.AgentDef

AgentDef provides A2A Agent Card metadata for a single prompt.

Generated from the schema: this is an ALIAS for packspec.AgentDef, not a copy. An alias keeps every call site, tag and behavior identical while making the schema the single source of the shape — a defined type would not, and the two would be free to drift again.

The hand-written struct it replaced was already field-for-field identical to $defs/AgentDef, which is why it is first: the switch is provably a no-op.

type AgentsConfig ¶ added in v1.3.1

type AgentsConfig = packspec.AgentsConfig

AgentsConfig maps prompts to A2A-compatible agent definitions.

Generated from the schema: an ALIAS for packspec.AgentsConfig.

type AssembledPrompt ¶

type AssembledPrompt struct {
	TaskType     string            `json:"task_type"`
	SystemPrompt string            `json:"system_prompt"`
	AllowedTools []string          `json:"allowed_tools,omitempty"` // Tools this prompt can use
	Validators   []ValidatorConfig `json:"validators,omitempty"`    // Validators to apply at runtime
}

AssembledPrompt represents a complete prompt ready for LLM execution.

func (ap *AssembledPrompt) UsesTools() bool

type AudioConfig ¶ added in v1.1.0

type AudioConfig = packspec.AudioConfig

AudioConfig contains audio-specific configuration AudioConfig is generated from the schema: an ALIAS for packspec.AudioConfig, not a copy. The hand-written struct was field-for-field identical to $defs/AudioConfig.

func GetAudioConfig(config *MediaConfig) *AudioConfig

type ChangelogEntry ¶

type ChangelogEntry struct {
	// Version number
	Version string `yaml:"version" json:"version"`
	// Date of change (YYYY-MM-DD)
	Date string `yaml:"date" json:"date"`
	// Author of change
	Author string `yaml:"author,omitempty" json:"author,omitempty"`
	// Description of change
	Description string `yaml:"description" json:"description"`
}

ChangelogEntry records a change in the prompt configuration

func MetadataChangelog(m *Metadata) []ChangelogEntry

type CompilationInfo ¶

type CompilationInfo = packspec.PackCompilation

CompilationInfo records when and how a pack was compiled.

Generated. `compilation` is a spec property with a defined shape (compiled_with, created_at and schema are all required), not a promptkit extension — it was hand-written here on the false premise that it was one.

type CompileOption ¶ added in v1.3.1

type CompileOption func(*compileOptions)

CompileOption configures optional fields for CompileFromRegistryWithOptions.

func WithAgents(a *AgentsConfig) CompileOption

func WithCompositions(c map[string]*composition.Composition) CompileOption

func WithSkills(s []SkillSourceConfig) CompileOption

func WithWorkflow(w *workflow.Spec) CompileOption

type Config ¶ added in v1.1.3

type Config struct {
	APIVersion string            `yaml:"apiVersion" json:"apiVersion"`
	Kind       string            `yaml:"kind" json:"kind"`
	Metadata   metav1.ObjectMeta `yaml:"metadata,omitempty" json:"metadata,omitempty"`
	Spec       Spec              `yaml:"spec" json:"spec"`
}

Config represents a YAML prompt configuration file in K8s-style manifest format

func ParseConfig(data []byte) (*Config, error)

func ToConfig(pr *PackPrompt, taskType string) *Config

func (c *Config) GetAllowedTools() []string

func (c *Config) GetTaskType() string

type CostEstimate ¶

type CostEstimate = packspec.PackMetadataCostEstimate

CostEstimate provides estimated costs for prompt execution.

Generated, for the same reason as Metadata. Note the fields are *float64: the spec makes all three optional, and a plain float64 cannot tell "no estimate" from "estimated at zero".

type DocumentConfig ¶ added in v1.8.0

type DocumentConfig = packspec.DocumentConfig

DocumentConfig configures document media (PDFs, CAD files, spreadsheets). Reachable now that MediaConfig is the generated type.

type ExampleContentPart ¶ added in v1.1.0

type ExampleContentPart = packspec.ContentPart

ExampleContentPart is one content part of a multimodal example.

Generated. This is $defs/ContentPart, the PACK authoring type — distinct from types.ContentPart, which is the runtime message type and a different graph.

type ExampleMedia ¶ added in v1.1.0

type ExampleMedia = packspec.MediaReference

ExampleMedia is a media reference inside a multimodal example.

Generated. The hand-written version was identical property-for-property except that it lacked `base64`, so a pack embedding media inline lost it.

Note the Go field is MimeType, not MIMEType: the generator derives names from the schema, and renaming it by hand would put this type back outside the generated guarantee for the sake of two characters.

type FileWriter ¶ added in v1.1.0

type FileWriter interface {
	WriteFile(path string, data []byte, perm os.FileMode) error
}

FileWriter abstracts file writing for testing

type Fragment ¶

type Fragment struct {
	Type              string `yaml:"fragment_type"`
	Version           string `yaml:"version"`
	Description       string `yaml:"description"`
	Content           string `yaml:"content"`
	SourceFile        string `yaml:"source_file,omitempty"`         // Source file path (for pack compilation)
	ResolvedAtCompile bool   `yaml:"resolved_at_compile,omitempty"` // Whether resolved at compile time
}

Fragment represents a reusable prompt fragment

type FragmentRef ¶

type FragmentRef struct {
	Name     string `yaml:"name"`
	Path     string `yaml:"path,omitempty"` // Optional: relative path to fragment file
	Required bool   `yaml:"required"`
}

FragmentRef references a prompt fragment for assembly

type FragmentRepository ¶

type FragmentRepository interface {
	LoadFragment(name, relativePath, baseDir string) (*Fragment, error)
}

FragmentRepository interface for loading fragments (to avoid import cycles)

type FragmentResolver ¶

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

FragmentResolver handles fragment loading, resolution, and variable substitution using the repository pattern

func NewFragmentResolverWithRepository(repository FragmentRepository) *FragmentResolver

func (fr *FragmentResolver) AssembleFragments(
	fragments []FragmentRef,
	vars map[string]string,
	configFilePath string,
) (map[string]string, error)

func (fr *FragmentResolver) LoadFragment(name, relativePath, configFilePath string) (*Fragment, error)

type Governance ¶ added in v1.8.0

type Governance = packspec.Governance

Governance is a governance declaration, at pack or agent level.

func AgentGovernance(pack *Pack, agent string) (*Governance, error)

func PackGovernance(pack *Pack) *Governance

func ResolveGovernance(pack *Pack, agent string) (*Governance, error)

type ImageConfig ¶ added in v1.1.0

type ImageConfig = packspec.ImageConfig

ImageConfig contains image-specific configuration Generated from the schema: an ALIAS for packspec.ImageConfig. default_detail is *string: the spec defaults it to "auto", so absent and empty differ.

func GetImageConfig(config *MediaConfig) *ImageConfig

type Info ¶ added in v1.1.3

type Info struct {
	TaskType       string
	Version        string
	Description    string
	FragmentCount  int
	RequiredVars   []string
	OptionalVars   []string
	ToolAllowlist  []string
	ModelOverrides []string
}

Info provides summary information about a prompt configuration

type Loader ¶ added in v1.1.3

type Loader interface {
	LoadConfig(taskType string) (*Config, error)
	ListTaskTypes() []string
}

Loader interface abstracts the registry for testing

type MediaConfig ¶ added in v1.1.0

type MediaConfig = packspec.MediaConfig

MediaConfig configures multimodal support for a prompt.

Generated. It was hand-written, and dropped $defs/MediaConfig's `document` property entirely — a prompt declaring document media round-tripped to nothing. Same failure as metadata.governance, same fix.

type Metadata ¶ added in v1.1.3

type Metadata = packspec.PackMetadata

Metadata contains additional metadata for the pack format.

This is the generated type: metadata is where the PromptPack spec puts the facts a pack declares ABOUT itself rather than about its execution, so it is where formalization lands as the spec grows — v1.6.0 added `governance` (RFC 0013: accountable owner, autonomy level, risk classification), and more of that shape is coming. A hand-written struct here dropped `governance` silently on load: the field validated, round-tripped clean, and vanished.

Generated means new spec properties arrive by regeneration, and `make packspec-check` fails if they have not.

Performance and Changelog are NOT spec properties. They live in Extra, which the spec permits (metadata is additionalProperties:true), and are reached through the accessors below rather than as struct fields.

type MetadataBuilder ¶

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

MetadataBuilder helps construct pack format metadata from prompt configs and test results

func NewMetadataBuilder(spec *Spec) *MetadataBuilder

func (mb *MetadataBuilder) AddChangelogEntry(version, author, description string)

func (mb *MetadataBuilder) BuildCompilationInfo(compilerVersion string) *CompilationInfo

func (mb *MetadataBuilder) BuildMetadata(domain, language string, tags []string, testResults []TestResultSummary) *Metadata

func (mb *MetadataBuilder) SetDomain(domain string)

func (mb *MetadataBuilder) SetLanguage(language string)

func (mb *MetadataBuilder) SetTags(tags []string)

func (mb *MetadataBuilder) UpdateFromCostInfo(costs []types.CostInfo)

func (mb *MetadataBuilder) ValidateMetadata() []string

type ModelOverride ¶

type ModelOverride = packspec.ModelOverride

ModelOverride contains model-specific template modifications. Note: Temperature and MaxTokens should be configured at the scenario or provider level, not in the prompt configuration.

The spec's $defs/ModelOverride also defines system_template_prefix and parameters. Neither is added here: nothing in the runtime assembles a prefix or applies per-model parameters, so declaring them would be vocabulary with a consumer and no producer. They are recorded as codegen candidates in docs/local-backlog/PACK_TYPES_FROM_SCHEMA_CODEGEN.md rather than added blind. Generated from the schema: an ALIAS for packspec.ModelOverride. Gains system_template_prefix and parameters from the spec.

type ModelTestResultRef ¶

type ModelTestResultRef = packspec.TestedModel

ModelTestResultRef is a simplified reference to model test results The full ModelTestResult type is in pkg/engine for tracking test execution ModelTestResultRef is the Go form of the spec's $defs/TestedModel. It is pinned to that def by TestedModelStructMatchesPromptPackSpec.

provider, model and date are required by the spec, so they carry no omitempty — a required field that vanishes on serialize produces a pack that fails its own validation. Generated from the schema: an ALIAS for packspec.TestedModel. avg_tokens/avg_latency_ms are float64: the spec types them as number, not integer.

func AggregateTestResults(results []TestResultSummary, provider, model string) *ModelTestResultRef

type MultimodalExample ¶ added in v1.1.0

type MultimodalExample = packspec.MultimodalExample

MultimodalExample is a few-shot example carrying media.

Generated, so that MediaConfig.Examples is the generated slice type.

type Pack ¶

type Pack struct {
	packspec.Pack `yaml:",inline"`

	// FilePath is the on-disk path this pack was loaded from, if any. It is
	// never serialized; loaders set it so schema/fragment resolution can
	// resolve paths relative to the pack file.
	FilePath string `json:"-" yaml:"-"`
}

Pack represents a compiled PromptPack.

EMBEDS the generated type rather than aliasing it. Go has no partial classes, and a type alias cannot carry methods — but an embedded type can, and Pack has eighteen (Validate, ValidateWorkflow, ValidateAgents, GetPrompt, ...). Every spec property is promoted from packspec.Pack, so the properties cannot drift even though the methods live here.

This is the general answer for a pack type with behavior attached. An alias is still preferable where the methods are few enough to become free functions, because an alias gives true identity with the generated type; embedding needs .Pack to extract it. Types with a method set that IS their API embed instead.

FilePath is the only field of our own, and it is the reason a bare alias would not do even without the methods.

func LoadPack(filePath string) (*Pack, error)

func (p *Pack) GetOptionalVariables(taskType string) map[string]string

func (p *Pack) GetPrompt(taskType string) *PackPrompt

func (p *Pack) GetRequiredVariables(taskType string) []string

func (p *Pack) GetTool(name string) *PackTool

func (p *Pack) GetToolNames(taskType string) []string

func (p *Pack) ListPrompts() []string

func (p *Pack) ListTools() []string

func (p *Pack) Summary() string

func (p *Pack) Validate() []string

func (p *Pack) ValidateAgents() (errors, warnings []string)

func (p *Pack) ValidateCompositions() *composition.ValidationResult

func (p *Pack) ValidateWorkflow() *workflow.ValidationResult

type PackCompiler ¶

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

PackCompiler compiles Config to Pack format

func NewPackCompiler(registry *Registry) *PackCompiler

func NewPackCompilerWithDeps(loader Loader, timeProvider TimeProvider, fileWriter FileWriter) *PackCompiler

func (pc *PackCompiler) Compile(taskType, compilerVersion string) (*Pack, error)

func (pc *PackCompiler) CompileFromRegistry(packID, compilerVersion string) (*Pack, error)

func (pc *PackCompiler) CompileFromRegistryWithOptions(
	packID, compilerVersion string,
	parsedTools []ParsedTool,
	packEvals []evals.EvalDef,
	opts ...CompileOption,
) (*Pack, error)

func (pc *PackCompiler) CompileFromRegistryWithParsedTools(
	packID, compilerVersion string,
	parsedTools []ParsedTool,
) (*Pack, error)

func (pc *PackCompiler) CompileFromRegistryWithTools(
	packID, compilerVersion string,
	toolData []ToolData,
) (*Pack, error)

func (pc *PackCompiler) CompileToFile(taskType, outputPath, compilerVersion string) error

func (pc *PackCompiler) MarshalPack(pack *Pack) ([]byte, error)

func (pc *PackCompiler) WritePack(pack *Pack, outputPath string) error

type PackPrompt ¶

type PackPrompt = packspec.Prompt

PackPrompt is a single prompt definition within a pack.

Generated. It is the hub every prompt hangs off, so adopting it was left until everything reachable from it was generated first — validators, evals, variables, tested_models, model_overrides, media and parameters are all packspec types now, and the generated Prompt holds them as slices and maps of POINTERS, which is the shape the schema implies for optional objects.

ToPromptConfig() was a method. A type alias cannot carry methods, so it is the free function ToConfig below.

type PackTool ¶ added in v1.1.5

type PackTool = packspec.Tool

PackTool represents a tool definition in the pack (per PromptPack spec Section 9). Tools are defined at pack level and referenced by prompts via the tools array.

Generated from the schema: an ALIAS for packspec.Tool.

Parameters is *ToolParameters rather than the interface{} the hand-written type used. The spec defines a shape here (type/properties/required) and interface{} ignored it; the generated type keeps that shape while remaining extensible, since Tool.parameters omits additionalProperties and JSON Schema defaults it to true. So a tool schema using $defs, oneOf or any other keyword still round-trips, through ToolParameters.Extra.

func ConvertToolToPackTool(name, description string, inputSchema json.RawMessage) *PackTool

type ParametersPack ¶

type ParametersPack = packspec.Parameters

ParametersPack represents model parameters in pack format Generated from the schema: an ALIAS for packspec.Parameters. Gains frequency_penalty and presence_penalty, which the spec defines and the hand-written type omitted.

type ParsedTool ¶ added in v1.1.5

type ParsedTool struct {
	Name        string
	Description string
	InputSchema json.RawMessage
}

ParsedTool holds pre-parsed tool information for compilation Use this when YAML parsing happens in the calling package

type PerformanceMetrics ¶

type PerformanceMetrics struct {
	// Average latency in milliseconds
	AvgLatencyMs int `yaml:"avg_latency_ms" json:"avg_latency_ms"`
	// 95th percentile latency
	P95LatencyMs int `yaml:"p95_latency_ms" json:"p95_latency_ms"`
	// Average tokens used
	AvgTokens int `yaml:"avg_tokens" json:"avg_tokens"`
	// Success rate (0.0-1.0)
	SuccessRate float64 `yaml:"success_rate" json:"success_rate"`
}

PerformanceMetrics provides performance benchmarks

func MetadataPerformance(m *Metadata) *PerformanceMetrics

type ProviderInventory ¶ added in v1.8.0

type ProviderInventory map[string][]string

ProviderInventory is what a host can supply, as role -> available keys.

type ProviderRequirement ¶ added in v1.8.0

type ProviderRequirement = packspec.ProviderRequirement

ProviderRequirement is a single logical provider dependency.

type Registry ¶

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

Registry manages prompt templates, versions, and variable substitution.

func NewRegistryWithRepository(repository Repository) *Registry

func (r *Registry) ClearCache()

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

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

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

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

func (r *Registry) GetInfo(taskType string) (*Info, error)

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

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

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

func (r *Registry) Load(activity string) *AssembledPrompt

func (r *Registry) LoadConfig(activity string) (*Config, error)

func (r *Registry) LoadTemplate(activity string, vars map[string]string, model string) (*Template, error)

func (r *Registry) LoadWithVars(activity string, vars map[string]string, model string) *AssembledPrompt

func (r *Registry) RegisterConfig(taskType string, config *Config) error

type Repository ¶ added in v1.1.3

type Repository interface {
	LoadPrompt(taskType string) (*Config, error)
	LoadFragment(name, relativePath, baseDir string) (*Fragment, error)
	ListPrompts() ([]string, error)
	SavePrompt(config *Config) error
}

Repository interface defines methods for loading prompts (to avoid import cycles) This should match persistence.Repository interface

type Requires ¶ added in v1.8.0

type Requires = packspec.PackRequires

Requires is the pack-level requirements block.

type ResolvedRequirement ¶ added in v1.8.0

type ResolvedRequirement struct {
	Key         string
	Role        string
	Description string
	Required    bool
}

ResolvedRequirement is a requirement with the spec's defaults applied, so consumers never have to know which fields were written and which were implied.

func ResolveRequirements(p *Pack) ([]ResolvedRequirement, error)

func Unsatisfied(reqs []ResolvedRequirement, have ProviderInventory) (required, optional []ResolvedRequirement)

type SkillSourceConfig ¶ added in v1.3.1

type SkillSourceConfig = packspec.SkillSource

SkillSourceConfig declares a skill source for the pack.

Generated. $defs/SkillSource is a oneOf over a bare string, a SkillPathSource and an InlineSkill; the generator flattens that into one struct AND emits the Marshal/Unmarshal pair that keeps the scalar form in Shorthand, so the union needed no hand-written code at all.

The legacy `dir` alias is GONE. It was promptkit-only, and because $defs/SkillPathSource is additionalProperties:false and requires `path`, a pack emitted from `dir` failed validation three ways at once. No shipped pack used it. Author `path` instead, or the bare-string shorthand.

type Spec ¶ added in v1.1.3

type Spec struct {
	TaskType       string                   `yaml:"task_type" json:"task_type"`
	Version        string                   `yaml:"version" json:"version"`
	Description    string                   `yaml:"description" json:"description"`
	TemplateEngine *TemplateEngineInfo      `yaml:"template_engine,omitempty" json:"template_engine,omitempty"` // Template engine configuration
	Fragments      []FragmentRef            `yaml:"fragments,omitempty" json:"fragments,omitempty"`             // New: fragment assembly
	SystemTemplate string                   `yaml:"system_template" json:"system_template"`
	Variables      []VariableMetadata       `yaml:"variables,omitempty" json:"variables,omitempty"` // Variable definitions with rich metadata
	ModelOverrides map[string]ModelOverride `yaml:"model_overrides,omitempty" json:"model_overrides,omitempty"`
	AllowedTools   []string                 `yaml:"allowed_tools,omitempty" json:"allowed_tools,omitempty"` // Tools this prompt can use
	MediaConfig    *MediaConfig             `yaml:"media,omitempty" json:"media,omitempty"`                 // Multimodal media configuration
	Validators     []ValidatorConfig        `yaml:"validators,omitempty" json:"validators,omitempty"`       // Validators/Guardrails for production runtime
	TestedModels   []ModelTestResultRef     `yaml:"tested_models,omitempty" json:"tested_models,omitempty"` // Model testing metadata
	ToolPolicy     *ToolPolicyPack          `yaml:"tool_policy,omitempty" json:"tool_policy,omitempty"`
	Parameters     *ParametersPack          `yaml:"parameters,omitempty" json:"parameters,omitempty"`
	Evals          []evals.EvalDef          `yaml:"evals,omitempty" json:"evals,omitempty"`
	Metadata       *Metadata                `yaml:"metadata,omitempty" json:"metadata,omitempty"`
	Compilation    *CompilationInfo         `yaml:"compilation,omitempty" json:"compilation,omitempty"`
}

Spec contains the actual prompt configuration

type Template ¶ added in v1.3.26

type Template struct {
	TaskType      string            `json:"task_type"`
	RawTemplate   string            `json:"raw_template"`
	DefaultVars   map[string]string `json:"default_vars,omitempty"`
	RequiredVars  []string          `json:"required_vars,omitempty"`
	FragmentVars  map[string]string `json:"fragment_vars,omitempty"`
	AllowedTools  []string          `json:"allowed_tools,omitempty"`
	Validators    []ValidatorConfig `json:"validators,omitempty"`
	ModelOverride string            `json:"model_override,omitempty"`
}

Template holds an unrendered prompt template with all metadata required to render it later. This is the intermediate form produced by LoadTemplate, consumed by the TemplateStage to perform deferred variable substitution.

type TemplateEngineInfo ¶

type TemplateEngineInfo = packspec.PackTemplateEngine

TemplateEngineInfo is the pack's template engine configuration.

Generated. template_engine is an inline object under the root's properties rather than a $def, but the generator emits types for those too — this is packspec.PackTemplateEngine, and it was field-for-field identical to the hand-written struct it replaced.

type TestResultSummary ¶

type TestResultSummary struct {
	Success   bool
	Cost      float64
	LatencyMs int
	Tokens    int
}

TestResultSummary contains summarized test execution data

type TimeProvider ¶ added in v1.1.0

type TimeProvider interface {
	Now() time.Time
}

TimeProvider allows injecting time for deterministic tests

type ToolData ¶ added in v1.1.5

type ToolData struct {
	FilePath string
	Data     []byte
}

ToolData holds raw tool configuration data for compilation

type ToolPolicyPack ¶

type ToolPolicyPack = packspec.ToolPolicy

ToolPolicyPack represents tool policy in pack format Generated from the schema: an ALIAS for packspec.ToolPolicy. max_rounds, max_tool_calls_per_turn and tool_choice are pointers for the same reason.

type Validator ¶ added in v1.5.5

type Validator = packspec.Validator

Validator is a compiled pack validator.

Generated. It carries the spec's `message`, which the COMPILED form does not use — foldValidatorMessages folds it into params at compile time, so nothing populates it and omitempty keeps it out of the emitted pack. Carrying an unused field is cheaper than maintaining a second definition of this type.

func ValidatorValues(in []*Validator) []Validator

type ValidatorConfig ¶

type ValidatorConfig struct {
	Type   string                 `yaml:"type" json:"type"`
	Params map[string]interface{} `yaml:"params" json:"params"`
	// Enable/disable validator (default: true)
	Enabled *bool `yaml:"enabled,omitempty" json:"enabled,omitempty"`
	// FailOnViolation is part of the PromptPack spec but is ignored by
	// this runtime — guardrails always enforce. Authors wanting
	// observe-only behavior should declare an eval and assert on it
	// instead. Tracked upstream:
	// https://github.com/AltairaLabs/promptpack-spec/issues/46
	FailOnViolation *bool `yaml:"fail_on_violation,omitempty" json:"fail_on_violation,omitempty"`
	// User-facing message shown when content is blocked (default: DefaultBlockedMessage)
	Message string `yaml:"message,omitempty" json:"message,omitempty"`
}

ValidatorConfig describes a validator/guardrail configuration from a prompt pack.

type Variable ¶ added in v1.5.5

type Variable = packspec.Variable

Variable is a spec-exact compiled prompt template variable.

Generated. It deliberately omits nothing of its own: Binding IS on the generated type, but compileVariables never populates it, because variable binding (auto-population from platform resources) is a runtime concern resolved at compile time and not part of the portable pack. The authoring type VariableMetadata carries it; omitempty keeps it out of the emitted pack.

toMetadata() was a method. A type alias cannot carry methods, so it is VariableToMetadata below.

type VariableBinding ¶ added in v1.1.10

type VariableBinding struct {
	// Kind specifies the type of resource to bind to.
	Kind VariableBindingKind `yaml:"kind" json:"kind"`
	// Field specifies which field of the resource to bind (e.g., "name", "model").
	Field string `yaml:"field,omitempty" json:"field,omitempty"`
	// AutoPopulate enables automatic population of this variable from the bound resource.
	// When true, the variable may be auto-filled and optionally hidden from the wizard.
	AutoPopulate bool `yaml:"autoPopulate,omitempty" json:"autoPopulate,omitempty"`
	// Filter specifies criteria for filtering bound resources.
	Filter *VariableBindingFilter `yaml:"filter,omitempty" json:"filter,omitempty"`
}

VariableBinding defines how a variable binds to system resources. This enables automatic population from system resources and type-safe UI selection.

type VariableBindingFilter ¶ added in v1.1.10

type VariableBindingFilter struct {
	// Capability filters resources by capability (e.g., "chat", "embeddings").
	Capability string `yaml:"capability,omitempty" json:"capability,omitempty"`
	// Labels filters resources by label selectors.
	Labels map[string]string `yaml:"labels,omitempty" json:"labels,omitempty"`
}

VariableBindingFilter specifies criteria for filtering bound resources.

type VariableBindingKind ¶ added in v1.1.10

type VariableBindingKind string

VariableBindingKind defines the type of resource a variable binds to.

const (
	// BindingKindProject binds to project metadata (name, description, tags).
	BindingKindProject VariableBindingKind = "project"
	// BindingKindProvider binds to provider/model selection.
	BindingKindProvider VariableBindingKind = "provider"
	// BindingKindWorkspace binds to current workspace (name, namespace).
	BindingKindWorkspace VariableBindingKind = "workspace"
	// BindingKindSecret binds to Kubernetes Secret resources.
	BindingKindSecret VariableBindingKind = "secret"
	// BindingKindConfigMap binds to Kubernetes ConfigMap resources.
	BindingKindConfigMap VariableBindingKind = "configmap"
)

type VariableMetadata ¶

type VariableMetadata struct {
	Name        string                 `yaml:"name" json:"name"`
	Type        string                 `yaml:"type,omitempty" json:"type,omitempty"` // "string", "number", "boolean", "object", "array"
	Required    bool                   `yaml:"required" json:"required"`
	Default     interface{}            `yaml:"default,omitempty" json:"default,omitempty"`
	Description string                 `yaml:"description,omitempty" json:"description,omitempty"`
	Example     interface{}            `yaml:"example,omitempty" json:"example,omitempty"`
	Validation  map[string]interface{} `yaml:"validation,omitempty" json:"validation,omitempty"`
	// Binding enables automatic population from system resources and type-safe UI selection.
	// This allows prompts to declare semantic meaning for variables beyond just their data type.
	Binding *VariableBinding `yaml:"binding,omitempty" json:"binding,omitempty"`
}

VariableMetadata contains enhanced metadata for a variable VariableMetadata defines a template variable with validation rules This struct matches the SDK Variable type for PromptPack spec compliance

func VariableToMetadata(v Variable) VariableMetadata

type VariableValidation ¶

type VariableValidation = packspec.VariableValidation

VariableValidation is the validation rule set on a Variable.

type VideoConfig ¶ added in v1.1.0

type VideoConfig = packspec.VideoConfig

VideoConfig contains video-specific configuration Generated from the schema: an ALIAS for packspec.VideoConfig. Optional numeric and boolean fields are pointers: zero is a real setting.

func GetVideoConfig(config *MediaConfig) *VideoConfig

type WorkflowConfig ¶ added in v1.3.1

type WorkflowConfig = workflow.Spec

WorkflowConfig is an alias for workflow.Spec for backward compatibility.

type WorkflowState ¶ added in v1.3.1

type WorkflowState = workflow.State

WorkflowState is an alias for workflow.State for backward compatibility.