560 lines
18 KiB
Go
560 lines
18 KiB
Go
package scriptorium_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/scriptorium"
|
|
)
|
|
|
|
func TestNewEngineRejectsMissingPromptDir(t *testing.T) {
|
|
_, err := scriptorium.NewEngine(scriptorium.Config{ProfileDir: "./examples/profiles"})
|
|
if !errors.Is(err, scriptorium.ErrInvalidConfig) {
|
|
t.Fatalf("expected ErrInvalidConfig, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNewEngineRejectsMissingProfileDir(t *testing.T) {
|
|
_, err := scriptorium.NewEngine(scriptorium.Config{PromptDir: "./examples/prompts"})
|
|
if !errors.Is(err, scriptorium.ErrInvalidConfig) {
|
|
t.Fatalf("expected ErrInvalidConfig, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPrepareWorksWithExampleDirectoriesAndFileInputs(t *testing.T) {
|
|
engine := newExampleEngine(t)
|
|
|
|
prepared, err := engine.Prepare(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.File("./examples/fixtures/transcript.md"),
|
|
"glossary": scriptorium.File("./examples/fixtures/glossary.yml"),
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected prepare to succeed, got %v", err)
|
|
}
|
|
if prepared.PromptID != "generic.markdown_summary" {
|
|
t.Fatalf("unexpected prompt id: %q", prepared.PromptID)
|
|
}
|
|
if prepared.SelectedProfileID != "local-fast" {
|
|
t.Fatalf("unexpected selected profile: %q", prepared.SelectedProfileID)
|
|
}
|
|
if prepared.EffectiveModelParams.Model != "gpt-4o-mini" {
|
|
t.Fatalf("unexpected effective model: %q", prepared.EffectiveModelParams.Model)
|
|
}
|
|
if len(prepared.Messages) != 2 {
|
|
t.Fatalf("expected rendered messages, got %d", len(prepared.Messages))
|
|
}
|
|
if prepared.InputHashes["transcript"] == "" || prepared.InputHashes["glossary"] == "" {
|
|
t.Fatalf("expected input hashes, got %#v", prepared.InputHashes)
|
|
}
|
|
}
|
|
|
|
func TestPrepareWorksWithInlineInputs(t *testing.T) {
|
|
engine := newExampleEngine(t)
|
|
|
|
prepared, err := engine.Prepare(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin scouts the tower.\nKara lights a lantern."),
|
|
"glossary": scriptorium.InlineWithURI("memory://glossary.yml", "party:\n - Rin\n - Kara\n"),
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected prepare to succeed, got %v", err)
|
|
}
|
|
if len(prepared.Messages) != 2 {
|
|
t.Fatalf("expected rendered messages, got %d", len(prepared.Messages))
|
|
}
|
|
rendered := prepared.Messages[1].Content
|
|
if !strings.Contains(rendered, "Rin scouts the tower.") || !strings.Contains(rendered, "party:") {
|
|
t.Fatalf("expected inline inputs in rendered prompt, got %q", rendered)
|
|
}
|
|
}
|
|
|
|
func TestPreparedRunJSONDoesNotExposeSecretOrTargetPresence(t *testing.T) {
|
|
const envName = "SCRIPTORIUM_API_KEY"
|
|
const secret = "public-api-test-secret"
|
|
t.Setenv(envName, secret)
|
|
|
|
engine := newExampleEngine(t)
|
|
prepared, err := engine.Prepare(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.structured_events",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.File("./examples/fixtures/transcript.md"),
|
|
"glossary": scriptorium.File("./examples/fixtures/glossary.yml"),
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected prepare to succeed, got %v", err)
|
|
}
|
|
|
|
payload, err := json.Marshal(prepared)
|
|
if err != nil {
|
|
t.Fatalf("expected prepared run to marshal, got %v", err)
|
|
}
|
|
out := string(payload)
|
|
if strings.Contains(out, secret) {
|
|
t.Fatalf("prepared run JSON leaked raw API key value: %s", out)
|
|
}
|
|
if !strings.Contains(out, envName) {
|
|
t.Fatalf("prepared run JSON should retain api_key_env name, got %s", out)
|
|
}
|
|
for _, forbidden := range []string{"TargetPresence", "target_presence"} {
|
|
if strings.Contains(out, forbidden) {
|
|
t.Fatalf("prepared run JSON exposed internal target presence metadata %q: %s", forbidden, out)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPreparePreservesExplicitZeroExecutionOverrides(t *testing.T) {
|
|
engine := newExampleEngine(t)
|
|
zeroFloat := 0.0
|
|
zeroInt := 0
|
|
|
|
prepared, err := engine.Prepare(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.File("./examples/fixtures/transcript.md"),
|
|
"glossary": scriptorium.File("./examples/fixtures/glossary.yml"),
|
|
},
|
|
Execution: &scriptorium.ExecutionTargetOverride{
|
|
Temperature: &zeroFloat,
|
|
MaxTokens: &zeroInt,
|
|
TopP: &zeroFloat,
|
|
TimeoutSeconds: &zeroInt,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected prepare to succeed, got %v", err)
|
|
}
|
|
target := prepared.EffectiveModelParams
|
|
if target.Temperature != 0 || target.MaxTokens != 0 || target.TopP != 0 || target.TimeoutSeconds != 0 {
|
|
t.Fatalf("expected explicit zero overrides in effective target, got %+v", target)
|
|
}
|
|
}
|
|
|
|
func TestRunSucceedsWithInjectedLLMClient(t *testing.T) {
|
|
const envName = "SCRIPTORIUM_API_KEY"
|
|
const secret = "run-secret-value"
|
|
t.Setenv(envName, secret)
|
|
|
|
fake := &fakeLLMClient{
|
|
response: &scriptorium.GenerateResponse{
|
|
Content: "# Summary\n\nDone.",
|
|
Usage: scriptorium.TokenUsage{
|
|
PromptTokens: 10,
|
|
CompletionTokens: 5,
|
|
TotalTokens: 15,
|
|
CachedTokens: 3,
|
|
CacheWriteTokens: 2,
|
|
},
|
|
},
|
|
}
|
|
engine := newExampleEngineWithOptions(t, "./examples/schemas", scriptorium.WithLLMClient(fake))
|
|
|
|
result, err := engine.Run(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin opens the gate."),
|
|
"glossary": scriptorium.Inline("gate: A guarded passage."),
|
|
},
|
|
Execution: &scriptorium.ExecutionTargetOverride{
|
|
APIKeyEnv: envName,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected run to succeed, got %v", err)
|
|
}
|
|
if result.RunID == "" {
|
|
t.Fatalf("expected run id")
|
|
}
|
|
if result.RawOutput != fake.response.Content {
|
|
t.Fatalf("unexpected raw output: %q", result.RawOutput)
|
|
}
|
|
if string(result.Artifact.Body) != fake.response.Content {
|
|
t.Fatalf("unexpected artifact body: %q", string(result.Artifact.Body))
|
|
}
|
|
if result.Artifact.ContentType != "text/markdown" {
|
|
t.Fatalf("unexpected artifact content type: %q", result.Artifact.ContentType)
|
|
}
|
|
if result.Validation.Status != scriptorium.ValidationPassed || !result.Validation.IsValid {
|
|
t.Fatalf("expected passed validation, got %+v", result.Validation)
|
|
}
|
|
if result.PromptID != "generic.markdown_summary" || result.SelectedProfileID != "local-fast" || result.ModelName != "gpt-4o-mini" {
|
|
t.Fatalf("unexpected run metadata: %+v", result)
|
|
}
|
|
if result.Usage.TotalTokens != 15 || result.Usage.CachedTokens != 3 || result.Usage.CacheWriteTokens != 2 {
|
|
t.Fatalf("unexpected usage: %+v", result.Usage)
|
|
}
|
|
|
|
payload, err := json.Marshal(result)
|
|
if err != nil {
|
|
t.Fatalf("expected run result to marshal, got %v", err)
|
|
}
|
|
if strings.Contains(string(payload), secret) {
|
|
t.Fatalf("run result JSON leaked raw API key value: %s", payload)
|
|
}
|
|
}
|
|
|
|
func TestRunPassesPreparedRequestToInjectedLLMClient(t *testing.T) {
|
|
fake := &fakeLLMClient{
|
|
response: &scriptorium.GenerateResponse{Content: "ok"},
|
|
}
|
|
engine := newExampleEngineWithOptions(t, "./examples/schemas", scriptorium.WithLLMClient(fake))
|
|
zeroFloat := 0.0
|
|
zeroInt := 0
|
|
|
|
_, err := engine.Run(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin opens the gate."),
|
|
"glossary": scriptorium.Inline("gate: A guarded passage."),
|
|
},
|
|
Execution: &scriptorium.ExecutionTargetOverride{
|
|
Temperature: &zeroFloat,
|
|
MaxTokens: &zeroInt,
|
|
TopP: &zeroFloat,
|
|
TimeoutSeconds: &zeroInt,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected run to succeed, got %v", err)
|
|
}
|
|
if len(fake.requests) != 1 {
|
|
t.Fatalf("expected one generate request, got %d", len(fake.requests))
|
|
}
|
|
req := fake.requests[0]
|
|
if len(req.Prompt.Messages) != 2 || !strings.Contains(req.Prompt.Messages[1].Content, "Rin opens the gate.") {
|
|
t.Fatalf("expected rendered prompt in generate request, got %+v", req.Prompt)
|
|
}
|
|
if req.Target.Model != "gpt-4o-mini" || req.Target.Temperature != 0 || req.Target.MaxTokens != 0 || req.Target.TopP != 0 || req.Target.TimeoutSeconds != 0 {
|
|
t.Fatalf("unexpected effective target: %+v", req.Target)
|
|
}
|
|
if !req.TargetPresence.Temperature || !req.TargetPresence.MaxTokens || !req.TargetPresence.TopP || !req.TargetPresence.TimeoutSeconds {
|
|
t.Fatalf("expected explicit zero target presence, got %+v", req.TargetPresence)
|
|
}
|
|
if req.StructuredOutput != nil {
|
|
t.Fatalf("did not expect structured output for markdown prompt: %+v", req.StructuredOutput)
|
|
}
|
|
}
|
|
|
|
func TestRunValidationFailureReturnsResult(t *testing.T) {
|
|
fake := &fakeLLMClient{
|
|
response: &scriptorium.GenerateResponse{Content: ""},
|
|
}
|
|
engine := newExampleEngineWithOptions(t, "./examples/schemas", scriptorium.WithLLMClient(fake))
|
|
|
|
result, err := engine.Run(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin opens the gate."),
|
|
"glossary": scriptorium.Inline("gate: A guarded passage."),
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected validation failure as successful result, got %v", err)
|
|
}
|
|
if result.Validation.Status != scriptorium.ValidationFailed || result.Validation.IsValid {
|
|
t.Fatalf("expected failed validation result, got %+v", result.Validation)
|
|
}
|
|
if len(result.Validation.Errors) == 0 {
|
|
t.Fatalf("expected validation errors")
|
|
}
|
|
}
|
|
|
|
func TestPublicErrorsSupportErrorsIs(t *testing.T) {
|
|
llmErr := errors.New("llm failed")
|
|
|
|
tests := []struct {
|
|
name string
|
|
req scriptorium.RunRequest
|
|
client scriptorium.LLMClient
|
|
schemaDir string
|
|
want error
|
|
}{
|
|
{
|
|
name: "invalid request",
|
|
req: scriptorium.RunRequest{},
|
|
client: &fakeLLMClient{response: &scriptorium.GenerateResponse{Content: "ok"}},
|
|
want: scriptorium.ErrInvalidRequest,
|
|
},
|
|
{
|
|
name: "prompt not found",
|
|
req: scriptorium.RunRequest{PromptID: "missing.prompt"},
|
|
client: &fakeLLMClient{response: &scriptorium.GenerateResponse{Content: "ok"}},
|
|
want: scriptorium.ErrPromptNotFound,
|
|
},
|
|
{
|
|
name: "profile not found",
|
|
req: scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
ProfileID: "missing-profile",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin opens the gate."),
|
|
},
|
|
},
|
|
client: &fakeLLMClient{response: &scriptorium.GenerateResponse{Content: "ok"}},
|
|
want: scriptorium.ErrProfileNotFound,
|
|
},
|
|
{
|
|
name: "artifact load",
|
|
req: scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.File("./examples/fixtures/does-not-exist.md"),
|
|
},
|
|
},
|
|
client: &fakeLLMClient{response: &scriptorium.GenerateResponse{Content: "ok"}},
|
|
want: scriptorium.ErrArtifactLoad,
|
|
},
|
|
{
|
|
name: "prompt render",
|
|
req: scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
},
|
|
client: &fakeLLMClient{response: &scriptorium.GenerateResponse{Content: "ok"}},
|
|
want: scriptorium.ErrPromptRender,
|
|
},
|
|
{
|
|
name: "llm failure",
|
|
req: scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin opens the gate."),
|
|
"glossary": scriptorium.Inline("gate: A guarded passage."),
|
|
},
|
|
},
|
|
client: &fakeLLMClient{err: llmErr},
|
|
want: scriptorium.ErrLLMGenerate,
|
|
},
|
|
{
|
|
name: "validation runtime failure",
|
|
req: scriptorium.RunRequest{
|
|
PromptID: "generic.structured_events",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin opens the gate."),
|
|
},
|
|
},
|
|
client: &fakeLLMClient{response: &scriptorium.GenerateResponse{Content: `{"events":[]}`}},
|
|
schemaDir: t.TempDir(),
|
|
want: scriptorium.ErrValidation,
|
|
},
|
|
}
|
|
|
|
t.Setenv("SCRIPTORIUM_API_KEY", "test-secret")
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
schemaDir := tc.schemaDir
|
|
if schemaDir == "" {
|
|
schemaDir = "./examples/schemas"
|
|
}
|
|
engine := newExampleEngineWithOptions(t, schemaDir, scriptorium.WithLLMClient(tc.client))
|
|
_, err := engine.Run(context.Background(), tc.req)
|
|
if !errors.Is(err, tc.want) {
|
|
t.Fatalf("expected errors.Is(%v), got %v", tc.want, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSelectedProfileRawAPIKeyMapsToProfileLoad(t *testing.T) {
|
|
profileDir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(profileDir, "raw.yaml"), []byte(`
|
|
id: raw-profile
|
|
endpoint: http://localhost:8000/v1
|
|
model: model
|
|
api_key: secret
|
|
`), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
engine, err := scriptorium.NewEngine(scriptorium.Config{
|
|
PromptDir: "./examples/prompts",
|
|
ProfileDir: profileDir,
|
|
SchemaDir: "./examples/schemas",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected engine construction to succeed, got %v", err)
|
|
}
|
|
|
|
_, err = engine.Prepare(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
ProfileID: "raw-profile",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin opens the gate."),
|
|
"glossary": scriptorium.Inline("gate: A guarded passage."),
|
|
},
|
|
})
|
|
if !errors.Is(err, scriptorium.ErrProfileLoad) {
|
|
t.Fatalf("expected ErrProfileLoad, got %v", err)
|
|
}
|
|
if errors.Is(err, scriptorium.ErrPromptLoad) {
|
|
t.Fatalf("did not expect ErrPromptLoad, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestSelectedProfileInvalidYAMLMapsToProfileLoad(t *testing.T) {
|
|
profileDir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(profileDir, "broken.yaml"), []byte(`
|
|
id: broken-profile
|
|
unknown_field: true
|
|
`), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
engine, err := scriptorium.NewEngine(scriptorium.Config{
|
|
PromptDir: "./examples/prompts",
|
|
ProfileDir: profileDir,
|
|
SchemaDir: "./examples/schemas",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected engine construction to succeed, got %v", err)
|
|
}
|
|
|
|
_, err = engine.Prepare(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
ProfileID: "broken-profile",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin opens the gate."),
|
|
"glossary": scriptorium.Inline("gate: A guarded passage."),
|
|
},
|
|
})
|
|
if !errors.Is(err, scriptorium.ErrProfileLoad) {
|
|
t.Fatalf("expected ErrProfileLoad, got %v", err)
|
|
}
|
|
if errors.Is(err, scriptorium.ErrPromptLoad) {
|
|
t.Fatalf("did not expect ErrPromptLoad, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestExtraParamsTypedNestedValuesAreCopiedAcrossPublicBoundary(t *testing.T) {
|
|
fake := &fakeLLMClient{response: &scriptorium.GenerateResponse{Content: "ok"}}
|
|
engine := newExampleEngineWithOptions(t, "./examples/schemas", scriptorium.WithLLMClient(fake))
|
|
|
|
labels := map[string]string{"route": "primary"}
|
|
counts := map[string]int{"retry_budget": 2}
|
|
weights := []float64{0.25, 0.75}
|
|
ids := []int{1, 2, 3}
|
|
nested := map[string]any{
|
|
"labels": labels,
|
|
"counts": counts,
|
|
"weights": weights,
|
|
"ids": ids,
|
|
}
|
|
extraParams := map[string]any{
|
|
"labels": labels,
|
|
"counts": counts,
|
|
"nested": nested,
|
|
}
|
|
|
|
_, err := engine.Run(context.Background(), scriptorium.RunRequest{
|
|
PromptID: "generic.markdown_summary",
|
|
Inputs: map[string]scriptorium.ArtifactRef{
|
|
"transcript": scriptorium.Inline("Rin opens the gate."),
|
|
"glossary": scriptorium.Inline("gate: A guarded passage."),
|
|
},
|
|
Execution: &scriptorium.ExecutionTargetOverride{ExtraParams: extraParams},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("expected run to succeed, got %v", err)
|
|
}
|
|
if len(fake.requests) != 1 {
|
|
t.Fatalf("expected one generate request, got %d", len(fake.requests))
|
|
}
|
|
|
|
captured := fake.requests[0].Target.ExtraParams
|
|
labels["route"] = "mutated"
|
|
counts["retry_budget"] = 99
|
|
weights[0] = 9.9
|
|
ids[0] = 99
|
|
nested["added"] = "mutated"
|
|
extraParams["new_top_level"] = "mutated"
|
|
|
|
want := map[string]any{
|
|
"labels": map[string]string{"route": "primary"},
|
|
"counts": map[string]int{"retry_budget": 2},
|
|
"nested": map[string]any{
|
|
"labels": map[string]string{"route": "primary"},
|
|
"counts": map[string]int{"retry_budget": 2},
|
|
"weights": []float64{0.25, 0.75},
|
|
"ids": []int{1, 2, 3},
|
|
},
|
|
}
|
|
if !reflect.DeepEqual(captured, want) {
|
|
t.Fatalf("captured extra_params changed after mutating source:\ngot=%#v\nwant=%#v", captured, want)
|
|
}
|
|
}
|
|
|
|
func TestWithLLMClientRejectsNilClient(t *testing.T) {
|
|
_, err := scriptorium.NewEngine(exampleConfig("./examples/schemas"), scriptorium.WithLLMClient(nil))
|
|
if !errors.Is(err, scriptorium.ErrInvalidConfig) {
|
|
t.Fatalf("expected ErrInvalidConfig, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNewEngineConstructsDefaultLLMClientWithoutCredentials(t *testing.T) {
|
|
if _, err := scriptorium.NewEngine(exampleConfig("./examples/schemas")); err != nil {
|
|
t.Fatalf("expected default engine construction without credentials to succeed, got %v", err)
|
|
}
|
|
}
|
|
|
|
func newExampleEngine(t *testing.T) *scriptorium.Engine {
|
|
t.Helper()
|
|
|
|
for _, path := range []string{
|
|
"./examples/prompts",
|
|
"./examples/profiles",
|
|
"./examples/schemas",
|
|
} {
|
|
if _, err := os.Stat(path); err != nil {
|
|
t.Fatalf("expected example path %s to exist: %v", path, err)
|
|
}
|
|
}
|
|
|
|
engine, err := scriptorium.NewEngine(exampleConfig("./examples/schemas"))
|
|
if err != nil {
|
|
t.Fatalf("expected engine construction to succeed, got %v", err)
|
|
}
|
|
return engine
|
|
}
|
|
|
|
func newExampleEngineWithOptions(t *testing.T, schemaDir string, opts ...scriptorium.Option) *scriptorium.Engine {
|
|
t.Helper()
|
|
|
|
engine, err := scriptorium.NewEngine(exampleConfig(schemaDir), opts...)
|
|
if err != nil {
|
|
t.Fatalf("expected engine construction to succeed, got %v", err)
|
|
}
|
|
return engine
|
|
}
|
|
|
|
func exampleConfig(schemaDir string) scriptorium.Config {
|
|
return scriptorium.Config{
|
|
PromptDir: "./examples/prompts",
|
|
ProfileDir: "./examples/profiles",
|
|
SchemaDir: schemaDir,
|
|
}
|
|
}
|
|
|
|
type fakeLLMClient struct {
|
|
response *scriptorium.GenerateResponse
|
|
err error
|
|
requests []scriptorium.GenerateRequest
|
|
}
|
|
|
|
func (f *fakeLLMClient) Generate(_ context.Context, req scriptorium.GenerateRequest) (*scriptorium.GenerateResponse, error) {
|
|
f.requests = append(f.requests, req)
|
|
if f.err != nil {
|
|
return nil, f.err
|
|
}
|
|
return f.response, nil
|
|
}
|