chore: delete code no binary reaches
Removes the Kit task-tool result shim (and with it the MCP go-sdk dependency), the messaging enable/disable/restart helpers and channel rebuild closures nothing calls since channels became extensions, the unused messaging capability, ephemeral and text-fallback types, and single stragglers in telemetry, releaseupdate, skill, storepkg and webui. The egress sandbox relay stays for #1867.
This commit is contained in:
23 files changed
+41
-743
No files matched your search
@@ -46,13 +46,10 @@ require (
|
||||
github.com/philhofer/fwd v1.2.1 // indirect
|
||||
github.com/pjbgf/sha1cd v0.7.0 // indirect
|
||||
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
|
||||
github.com/segmentio/asm v1.2.1 // indirect
|
||||
github.com/segmentio/encoding v0.5.4 // indirect
|
||||
github.com/sergi/go-diff v1.4.0 // indirect
|
||||
github.com/sethvargo/go-retry v0.5.0 // indirect
|
||||
github.com/tinylib/msgp v1.6.5 // indirect
|
||||
github.com/x448/float16 v0.8.4 // indirect
|
||||
github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
|
||||
go.opentelemetry.io/auto/sdk v1.2.1 // indirect
|
||||
go.opentelemetry.io/otel/log v1.47.0 // indirect
|
||||
go.opentelemetry.io/otel/metric v1.47.0 // indirect
|
||||
@@ -85,7 +82,6 @@ require (
|
||||
github.com/klauspost/compress v1.20.4
|
||||
github.com/moby/moby/api v1.56.1
|
||||
github.com/moby/moby/client v0.6.2
|
||||
github.com/modelcontextprotocol/go-sdk v1.8.0
|
||||
github.com/nats-io/nats-server/v2 v2.15.3
|
||||
github.com/nats-io/nats.go v1.55.0
|
||||
github.com/opencontainers/go-digest v1.0.0
|
||||
|
||||
@@ -139,8 +139,6 @@ github.com/moby/moby/api v1.56.1 h1:PpWkvVPB7Fr/No8w+TfyJ/I6rWZ2YPZhT3JorIg+06c=
|
||||
github.com/moby/moby/api v1.56.1/go.mod h1:sZ+THbVWkjOmBPPfbnzdD/G1LuIexWhqlSHHPTDQ1Uk=
|
||||
github.com/moby/moby/client v0.6.2 h1:ekSPlMccrZGcw6Scb8T9D39qE0mB+XupU/yS0zNw9N4=
|
||||
github.com/moby/moby/client v0.6.2/go.mod h1:DGcnO7qmPJrqobx/ggQgQ/AUk+2wgVdQv7uxB0/mEsc=
|
||||
github.com/modelcontextprotocol/go-sdk v1.8.0 h1:KIvahhYqwtbeniWVPs3TcXEA7b8jEtwfBpOTAI+Urx4=
|
||||
github.com/modelcontextprotocol/go-sdk v1.8.0/go.mod h1:dL7u98E/zjJTGzEq+j30jQ8K2k1mb6LeAH4inEcSGts=
|
||||
github.com/nats-io/jwt/v2 v2.8.3 h1:pqImTmlqH2zPHKNdRXO0YRyWif2diGRlrtLFJ2RxM2I=
|
||||
github.com/nats-io/jwt/v2 v2.8.3/go.mod h1:OOY2rP/UU8tcfoqhbHmBKcNdpFMKvmxIkmFFa16M4wI=
|
||||
github.com/nats-io/nats-server/v2 v2.15.3 h1:IgHIKL4DYN9mEfwtPcdM39muvXG8v9FBADQn0f4Whs0=
|
||||
@@ -174,10 +172,6 @@ github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0t
|
||||
github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
|
||||
github.com/samcharles93/ai-sdk v0.6.0 h1:ANHutwvl/K233Dkflc2vKT48qsXRT1iRwjL5S1Dm+jY=
|
||||
github.com/samcharles93/ai-sdk v0.6.0/go.mod h1:NNkiUZ2qfezDHhmF8zHibKsPgpU8b5jphDQ0n2t1KL0=
|
||||
github.com/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0=
|
||||
github.com/segmentio/asm v1.2.1/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=
|
||||
github.com/segmentio/encoding v0.5.4 h1:OW1VRern8Nw6ITAtwSZ7Idrl3MXCFwXHPgqESYfvNt0=
|
||||
github.com/segmentio/encoding v0.5.4/go.mod h1:HS1ZKa3kSN32ZHVZ7ZLPLXWvOVIiZtyJnO1gPH1sKt0=
|
||||
github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw=
|
||||
github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
|
||||
github.com/sethvargo/go-retry v0.5.0 h1:JYfFKmVJ8ER06GReN1efzc5cm52BrVsFVzmcHiKJwfY=
|
||||
@@ -193,8 +187,6 @@ github.com/tinylib/msgp v1.6.5 h1:iAH6XTP7BpzErjBZlujJQXxA+GmRi2YWs6M4KdLtNbE=
|
||||
github.com/tinylib/msgp v1.6.5/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA=
|
||||
github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
|
||||
github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
|
||||
github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zIM+UJPGz4=
|
||||
github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
|
||||
go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
|
||||
go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
|
||||
go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.72.0 h1:Tq+E65HaNbZTeqcLw6QUhsV+/EIWdkfUH2CQzcrlE5M=
|
||||
@@ -254,8 +246,6 @@ golang.org/x/text v0.44.0 h1:YItdp/mQNGnsmrgpcdA5yQ3bnRxCfo/Tj/iByGW9GGo=
|
||||
golang.org/x/text v0.44.0/go.mod h1:S4FR1waQ9LbjQTls97SyRjDaUUVkaM+cXwwuG/G+MwY=
|
||||
golang.org/x/time v0.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE=
|
||||
golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s=
|
||||
golang.org/x/tools v0.52.1-0.20261106145633-d407941a339a h1:Yqozs0FNPRoPGS4hNGlrNwRENWr5H5nVG9sN/f+5640=
|
||||
golang.org/x/tools v0.52.1-0.20261106145633-d407941a339a/go.mod h1:ItcP5UNaVGG+Yc4eIYmaFLNJ4soEopkx5Y2d4lcEurs=
|
||||
gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
|
||||
gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20261110000943-09e21b237f2c h1:ofk4SEqvpf6M5VWh88xRp42IYgdVOh7gffebnDj3OqU=
|
||||
|
||||
@@ -1,94 +0,0 @@
|
||||
package archiegateway
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"mime"
|
||||
"os"
|
||||
"path/filepath"
|
||||
|
||||
"github.com/modelcontextprotocol/go-sdk/mcp"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/agentexec"
|
||||
"github.com/samcharles93/archie-core/internal/domain/agentrun"
|
||||
"github.com/samcharles93/archie-core/internal/tools"
|
||||
)
|
||||
|
||||
func executeTaskTool(ctx context.Context, entry tools.ToolEntry, input json.RawMessage, limit int) (result *mcp.CallToolResult, err error) {
|
||||
defer func() {
|
||||
if recover() != nil {
|
||||
result = nil
|
||||
err = fmt.Errorf("tool execution failed")
|
||||
}
|
||||
}()
|
||||
if !entry.Available() {
|
||||
return nil, fmt.Errorf("tool is unavailable")
|
||||
}
|
||||
schema, err := json.Marshal(taskToolSchema(entry))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("tool schema unavailable")
|
||||
}
|
||||
if len(input) == 0 {
|
||||
input = json.RawMessage(`{}`)
|
||||
}
|
||||
if reason, ok := agentexec.ValidateCaptureArgs(agentrun.CaptureTool{Name: entry.Name, Parameters: schema}, input); !ok {
|
||||
return nil, fmt.Errorf("%s", reason)
|
||||
}
|
||||
var args map[string]any
|
||||
if err := json.Unmarshal(input, &args); err != nil {
|
||||
return nil, fmt.Errorf("arguments must be an object")
|
||||
}
|
||||
out, err := entry.Handler(ctx, args)
|
||||
if err != nil {
|
||||
return &mcp.CallToolResult{IsError: true, Content: []mcp.Content{&mcp.TextContent{Text: "tool execution failed"}}}, nil
|
||||
}
|
||||
if entry.MaxResultSizeChars != 0 {
|
||||
limit = entry.MaxResultSizeChars
|
||||
}
|
||||
if media, ok := out.(tools.MultimodalResult); ok {
|
||||
return taskToolMedia(entry.Name, media, limit)
|
||||
}
|
||||
raw, err := json.Marshal(out)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("encode tool result")
|
||||
}
|
||||
return &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: tools.CapPayload(entry.Name, string(raw), limit, "")}}}, nil
|
||||
}
|
||||
|
||||
func taskToolMedia(name string, media tools.MultimodalResult, limit int) (*mcp.CallToolResult, error) {
|
||||
result := &mcp.CallToolResult{Content: []mcp.Content{&mcp.TextContent{Text: tools.CapPayload(name, media.Summary, limit, "")}}}
|
||||
root, err := os.OpenRoot(media.SubdirHint)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("tool media unavailable")
|
||||
}
|
||||
defer root.Close()
|
||||
for _, file := range media.Files {
|
||||
relative, err := filepath.Rel(media.SubdirHint, file)
|
||||
if err != nil || !filepath.IsLocal(relative) {
|
||||
return nil, fmt.Errorf("tool media outside provider directory")
|
||||
}
|
||||
raw, err := root.ReadFile(relative)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read tool media")
|
||||
}
|
||||
mimeType := mime.TypeByExtension(filepath.Ext(file))
|
||||
switch mimeType {
|
||||
case "image/png", "image/jpeg", "image/gif", "image/webp":
|
||||
result.Content = append(result.Content, &mcp.ImageContent{Data: raw, MIMEType: mimeType})
|
||||
case "audio/wav", "audio/mpeg":
|
||||
result.Content = append(result.Content, &mcp.AudioContent{Data: raw, MIMEType: mimeType})
|
||||
default:
|
||||
result.Content = append(result.Content, &mcp.EmbeddedResource{Resource: &mcp.ResourceContents{URI: "archie-media:///" + filepath.Base(file), MIMEType: mimeType, Blob: raw}})
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func taskToolSchema(entry tools.ToolEntry) tools.JSONSchema {
|
||||
schema := entry.ResolvedSchema()
|
||||
if schema == nil {
|
||||
return tools.JSONSchema{"type": "object", "properties": map[string]any{}}
|
||||
}
|
||||
return schema
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
package archiegateway
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/modelcontextprotocol/go-sdk/mcp"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/tools"
|
||||
)
|
||||
|
||||
func TestTaskToolResults(t *testing.T) {
|
||||
for _, tt := range []struct {
|
||||
name, input string
|
||||
output any
|
||||
limit int
|
||||
badPath bool
|
||||
wantErr bool
|
||||
}{
|
||||
{name: "text limit", input: `{"value":"valid"}`, output: strings.Repeat("a", 200), limit: 40},
|
||||
{name: "schema enforced", input: `{"value":true}`, wantErr: true},
|
||||
{name: "media", input: `{"value":"valid"}`},
|
||||
{name: "media cannot escape", input: `{"value":"valid"}`, badPath: true, wantErr: true},
|
||||
} {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
file := filepath.Join(root, "image.png")
|
||||
if tt.badPath {
|
||||
file = filepath.Join(t.TempDir(), "outside.png")
|
||||
}
|
||||
if err := os.WriteFile(file, []byte("image-data"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
output := tt.output
|
||||
if output == nil {
|
||||
output = tools.MultimodalResult{Summary: "image", SubdirHint: root, Files: []string{file}}
|
||||
}
|
||||
called := false
|
||||
entry := tools.ToolEntry{Name: "tool", Schema: tools.JSONSchema{"type": "object", "properties": map[string]any{"value": map[string]any{"type": "string"}}, "required": []string{"value"}}, Handler: func(context.Context, map[string]any) (any, error) { called = true; return output, nil }}
|
||||
result, err := executeTaskTool(t.Context(), entry, json.RawMessage(tt.input), tt.limit)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Fatalf("error %v, want error %v", err, tt.wantErr)
|
||||
}
|
||||
if tt.name == "schema enforced" && called {
|
||||
t.Fatal("invalid arguments executed")
|
||||
}
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
raw, err := json.Marshal(result)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if strings.Contains(string(raw), root) {
|
||||
t.Fatal("host media path escaped")
|
||||
}
|
||||
if tt.name == "media" {
|
||||
image, ok := result.Content[1].(*mcp.ImageContent)
|
||||
if !ok || string(image.Data) != "image-data" {
|
||||
t.Fatalf("media result %s", raw)
|
||||
}
|
||||
}
|
||||
text, ok := result.Content[0].(*mcp.TextContent)
|
||||
if !ok {
|
||||
t.Fatal("missing text content")
|
||||
}
|
||||
if tt.limit > 0 && strings.Contains(text.Text, strings.Repeat("a", 200)) {
|
||||
t.Fatal("tool result limit was ignored")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -56,9 +56,8 @@ type channelInstance struct {
|
||||
// kind is the channel name a delivery or chat addresses, and owner the org
|
||||
// whose channel it is. The instance's built-in and extension channels belong
|
||||
// to the system org.
|
||||
kind string
|
||||
owner string
|
||||
rebuild func(ResolvedConfig) (channels.Channel, error)
|
||||
kind string
|
||||
owner string
|
||||
// chat, when set, is the contract this channel speaks to the Gateway
|
||||
// through; an org's channel acts as its agent. Nil uses the service's.
|
||||
chat messaging.ChatContract
|
||||
|
||||
@@ -9,7 +9,6 @@ import (
|
||||
"time"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/channels"
|
||||
"github.com/samcharles93/archie-core/internal/channels/status"
|
||||
"github.com/samcharles93/archie-core/internal/config"
|
||||
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
||||
)
|
||||
@@ -73,8 +72,7 @@ func startTestService(t *testing.T, ch *servingChannel) *Service {
|
||||
}
|
||||
inst := &channelInstance{
|
||||
name: "test", kind: "test",
|
||||
rebuild: func(ResolvedConfig) (channels.Channel, error) { return ch, nil },
|
||||
notify: make(chan struct{}, 1),
|
||||
notify: make(chan struct{}, 1),
|
||||
}
|
||||
srv.retry = channelRetryPolicy{attempts: 3, backoff: time.Millisecond, maxBackoff: time.Millisecond}
|
||||
|
||||
@@ -103,7 +101,7 @@ func waitSupervised(t *testing.T, srv *Service, id string) {
|
||||
t.Helper()
|
||||
deadline := time.Now().Add(5 * time.Second)
|
||||
for time.Now().Before(deadline) {
|
||||
inst := srv.instanceByID(id)
|
||||
inst := instanceByID(srv, id)
|
||||
inst.mu.Lock()
|
||||
supervised := inst.supervised
|
||||
inst.mu.Unlock()
|
||||
@@ -115,17 +113,6 @@ func waitSupervised(t *testing.T, srv *Service, id string) {
|
||||
t.Fatalf("channel %q was never supervised", id)
|
||||
}
|
||||
|
||||
func channelByID(t *testing.T, srv *Service, id string) status.Status {
|
||||
t.Helper()
|
||||
for _, st := range srv.ChannelStatus() {
|
||||
if st.ID == id {
|
||||
return st
|
||||
}
|
||||
}
|
||||
t.Fatalf("no channel %q in status", id)
|
||||
return status.Status{}
|
||||
}
|
||||
|
||||
// waitCount blocks until count reaches want, so an async start is observed
|
||||
// rather than slept for.
|
||||
func waitCount(t *testing.T, count func() int, want int) {
|
||||
@@ -140,34 +127,6 @@ func waitCount(t *testing.T, count func() int, want int) {
|
||||
t.Fatalf("channel started %d times, want at least %d", count(), want)
|
||||
}
|
||||
|
||||
// TestChannelEnableDisableLive pins that enabling and disabling a channel
|
||||
// starts and stops it without a service restart, and that its declaration
|
||||
// follows: a channel that was never configured is not reported as configured,
|
||||
// and one that enablement stopped is reported stopped and unconfigured.
|
||||
func TestChannelEnableDisableLive(t *testing.T) {
|
||||
ch := &servingChannel{}
|
||||
srv := startTestService(t, ch)
|
||||
|
||||
if before := channelByID(t, srv, "test"); before.Configured || before.State != status.StateStopped {
|
||||
t.Fatalf("test before enable = %+v, want not configured and stopped", before)
|
||||
}
|
||||
|
||||
if err := srv.enableChannel("test", ResolvedConfig{}); err != nil {
|
||||
t.Fatalf("enable: %v", err)
|
||||
}
|
||||
waitCount(t, ch.count, 1)
|
||||
if enabled := channelByID(t, srv, "test"); !enabled.Configured || enabled.State != status.StateRunning {
|
||||
t.Fatalf("test after enable = %+v, want configured and running", enabled)
|
||||
}
|
||||
|
||||
if err := srv.disableChannel("test"); err != nil {
|
||||
t.Fatalf("disable: %v", err)
|
||||
}
|
||||
if disabled := channelByID(t, srv, "test"); disabled.Configured || disabled.State != status.StateStopped {
|
||||
t.Fatalf("test after disable = %+v, want not configured and stopped", disabled)
|
||||
}
|
||||
}
|
||||
|
||||
// fakeSettings serves a stored chat config at a version, the way the
|
||||
// control-plane client does.
|
||||
type fakeSettings struct {
|
||||
@@ -185,8 +144,8 @@ func (f fakeSettings) RuntimeChatConfig(context.Context, config.ChatConfig) (con
|
||||
func TestReconcileAppliesShowToolCalls(t *testing.T) {
|
||||
ch := &servingChannel{}
|
||||
srv := startTestService(t, ch)
|
||||
if err := srv.enableChannel("test", ResolvedConfig{}); err != nil {
|
||||
t.Fatalf("enable: %v", err)
|
||||
if err := restart(srv, "test", ch); err != nil {
|
||||
t.Fatalf("start: %v", err)
|
||||
}
|
||||
waitCount(t, ch.count, 1)
|
||||
|
||||
|
||||
@@ -2,7 +2,6 @@ package archiemessaging
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"maps"
|
||||
@@ -106,11 +105,7 @@ func openExtensionChannels(ctx context.Context, source extension.Source, secrets
|
||||
if missing := pkg.Descriptor.MissingSettings(setting.Settings); len(missing) > 0 {
|
||||
needs := "Missing " + strings.Join(missing, ", ")
|
||||
log.WarnContext(ctx, "channel extension not started: required settings missing", "channel", pkg.Name, "missing", missing)
|
||||
instances = append(instances, &channelInstance{
|
||||
name: pkg.Name,
|
||||
needs: needs,
|
||||
rebuild: func(ResolvedConfig) (channels.Channel, error) { return nil, errors.New(needs) },
|
||||
})
|
||||
instances = append(instances, &channelInstance{name: pkg.Name, needs: needs})
|
||||
built[pkg.Name] = true
|
||||
continue
|
||||
}
|
||||
@@ -128,24 +123,14 @@ func openExtensionChannels(ctx context.Context, source extension.Source, secrets
|
||||
continue
|
||||
}
|
||||
built[pkg.Name] = true
|
||||
instances = append(instances, &channelInstance{
|
||||
name: pkg.Name,
|
||||
channel: ch,
|
||||
rebuild: func(ResolvedConfig) (channels.Channel, error) { return ch, nil },
|
||||
})
|
||||
instances = append(instances, &channelInstance{name: pkg.Name, channel: ch})
|
||||
}
|
||||
if setting := settings[telegramChannel]; setting.Enabled && !slices.ContainsFunc(installed, func(pkg storepkg.Installed) bool { return pkg.Name == telegramChannel }) {
|
||||
// Report it as a channel, so the dashboard shows why the enabled
|
||||
// bot is not running instead of showing nothing.
|
||||
const needs = "The Telegram channel extension is not installed"
|
||||
log.WarnContext(ctx, "telegram is enabled but its channel extension is not installed")
|
||||
instances = append(instances, &channelInstance{
|
||||
name: telegramChannel,
|
||||
needs: needs,
|
||||
rebuild: func(ResolvedConfig) (channels.Channel, error) {
|
||||
return nil, errors.New("telegram channel extension is not installed")
|
||||
},
|
||||
})
|
||||
instances = append(instances, &channelInstance{name: telegramChannel, needs: needs})
|
||||
}
|
||||
go func() {
|
||||
<-ctx.Done()
|
||||
|
||||
@@ -7,7 +7,6 @@ import (
|
||||
"time"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/channels"
|
||||
"github.com/samcharles93/archie-core/internal/channels/status"
|
||||
)
|
||||
|
||||
// runChannel supervises one channel for the service's lifetime. It starts the
|
||||
@@ -221,31 +220,9 @@ func (c *channelInstance) supervisorExits() {
|
||||
c.mu.Unlock()
|
||||
}
|
||||
|
||||
// restartChannel builds a replacement for channel id from next and starts it in
|
||||
// place of the running one. A supervisor that is between runs -- backing off a
|
||||
// failure, or parked after giving up -- is woken to start the replacement; a
|
||||
// channel with no supervisor (never started, or shut down) is refused.
|
||||
func (s *Service) restartChannel(id string, next ResolvedConfig) error {
|
||||
c := s.instanceByID(id)
|
||||
if c == nil {
|
||||
return fmt.Errorf("no channel %q", id)
|
||||
}
|
||||
if c.rebuild == nil {
|
||||
return fmt.Errorf("channel %q cannot be rebuilt", id)
|
||||
}
|
||||
replacement, err := c.rebuild(next)
|
||||
if err != nil {
|
||||
return fmt.Errorf("rebuild %q: %w", id, err)
|
||||
}
|
||||
if replacement == nil {
|
||||
return fmt.Errorf("channel %q has no configuration", id)
|
||||
}
|
||||
return s.setChannelState(c, replacement)
|
||||
}
|
||||
|
||||
// setChannelState swaps the channel a supervisor runs; a nil replacement stops
|
||||
// it. It returns once the supervisor has been told, not once the channel is up:
|
||||
// a caller that needs the observable state awaits it (awaitChannelActive).
|
||||
// a caller that needs the observable state reads the channel status.
|
||||
func (s *Service) setChannelState(c *channelInstance, replacement channels.Channel) error {
|
||||
c.mu.Lock()
|
||||
if !c.supervised {
|
||||
@@ -275,91 +252,6 @@ func (s *Service) setChannelState(c *channelInstance, replacement channels.Chann
|
||||
return nil
|
||||
}
|
||||
|
||||
// enableChannel builds and starts a channel that a settings change turned on,
|
||||
// and reports only once it is no longer stopped.
|
||||
func (s *Service) enableChannel(id string, next ResolvedConfig) error {
|
||||
c := s.instanceByID(id)
|
||||
if c == nil {
|
||||
return fmt.Errorf("no channel %q", id)
|
||||
}
|
||||
if c.rebuild == nil {
|
||||
return fmt.Errorf("channel %q cannot be rebuilt", id)
|
||||
}
|
||||
replacement, err := c.rebuild(next)
|
||||
if err != nil {
|
||||
return fmt.Errorf("build %q: %w", id, err)
|
||||
}
|
||||
if replacement == nil {
|
||||
return fmt.Errorf("channel %q has no configuration", id)
|
||||
}
|
||||
if err := s.setChannelState(c, replacement); err != nil {
|
||||
return err
|
||||
}
|
||||
s.status.Declare(id, true, channelReloadable(replacement))
|
||||
s.signalPublish()
|
||||
return s.awaitChannelActive(id, true)
|
||||
}
|
||||
|
||||
// disableChannel stops a channel that a settings change turned off, and reports
|
||||
// only once it has stopped.
|
||||
func (s *Service) disableChannel(id string) error {
|
||||
c := s.instanceByID(id)
|
||||
if c == nil || c.current() == nil {
|
||||
return nil
|
||||
}
|
||||
if err := s.setChannelState(c, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
s.status.Declare(id, false, false)
|
||||
s.signalPublish()
|
||||
return s.awaitChannelActive(id, false)
|
||||
}
|
||||
|
||||
// channelApplyTimeout bounds how long reconcile waits for an enable or disable
|
||||
// to take effect before reporting it unapplied, which leaves the next tick to
|
||||
// retry it.
|
||||
const channelApplyTimeout = 5 * time.Second
|
||||
|
||||
// channelApplyPoll is how often that wait re-reads the channel's state.
|
||||
const channelApplyPoll = 10 * time.Millisecond
|
||||
|
||||
// awaitChannelActive waits, up to channelApplyTimeout, for a channel to leave
|
||||
// or reach the stopped state, so an enable or disable is reported applied only
|
||||
// once the channel is actually running (or not) rather than merely queued. A
|
||||
// failed channel is never active: reporting it so would mark the settings
|
||||
// version applied and retire a failure the next tick must retry. Only a
|
||||
// serving state counts, and a failed enable fails fast instead of burning the
|
||||
// timeout while no restart can succeed without one.
|
||||
func (s *Service) awaitChannelActive(id string, active bool) error {
|
||||
deadline := time.Now().Add(channelApplyTimeout)
|
||||
for {
|
||||
for _, st := range s.status.Snapshot() {
|
||||
if st.ID != id {
|
||||
continue
|
||||
}
|
||||
if active && st.State == status.StateFailed {
|
||||
return fmt.Errorf("channel %q failed to start", id)
|
||||
}
|
||||
// Serving counts, impaired or not; anything else is still in
|
||||
// flight, except a stopped channel answering a disable.
|
||||
if st.State == status.StateRunning || st.State == status.StateDegraded {
|
||||
if active {
|
||||
return nil
|
||||
}
|
||||
} else if !active && st.State == status.StateStopped {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
if time.Now().After(deadline) {
|
||||
if active {
|
||||
return fmt.Errorf("channel %q did not start", id)
|
||||
}
|
||||
return fmt.Errorf("channel %q did not stop", id)
|
||||
}
|
||||
time.Sleep(channelApplyPoll)
|
||||
}
|
||||
}
|
||||
|
||||
// stopChannel closes one channel's listener with its own bounded context, so a
|
||||
// stop that hangs cannot hold the shutdown past the configured timeout. The
|
||||
// parent context is stripped of its cancellation because this runs on the
|
||||
@@ -376,15 +268,6 @@ func (s *Service) stopChannel(ctx context.Context, name string, ch channels.Chan
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Service) instanceByID(id string) *channelInstance {
|
||||
for _, c := range s.instances() {
|
||||
if c.name == id {
|
||||
return c
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) currentConfig() ResolvedConfig {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
|
||||
@@ -10,7 +10,6 @@ import (
|
||||
"time"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/channels"
|
||||
"github.com/samcharles93/archie-core/internal/channels/status"
|
||||
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
||||
)
|
||||
|
||||
@@ -57,7 +56,6 @@ func startService(t *testing.T, ch *fakeChannel, retry channelRetryPolicy) *Serv
|
||||
inst := &channelInstance{
|
||||
name: "fake",
|
||||
channel: ch,
|
||||
rebuild: func(ResolvedConfig) (channels.Channel, error) { return ch, nil },
|
||||
}
|
||||
srv, err := compose(context.Background(), deps{Log: slog.Default(), ExtensionChannels: []*channelInstance{inst}})
|
||||
if err != nil {
|
||||
@@ -93,55 +91,6 @@ func waitStarts(t *testing.T, ch *fakeChannel, want int) {
|
||||
t.Fatalf("channel started %d times, want at least %d", ch.count(), want)
|
||||
}
|
||||
|
||||
// TestAwaitChannelActiveStates pins what counts as up: running and degraded
|
||||
// satisfy an enable, only stopped satisfies a disable, and a failed enable
|
||||
// fails fast instead of reporting success the next tick would never retry.
|
||||
func TestAwaitChannelActiveStates(t *testing.T) {
|
||||
mark := map[string]func(*status.Manager){
|
||||
"running": func(m *status.Manager) { m.MarkRunning("fake") },
|
||||
"degraded": func(m *status.Manager) { m.MarkDegraded("fake", "slow") },
|
||||
"failed": func(m *status.Manager) { m.MarkFailed("fake", "boom") },
|
||||
"starting": func(m *status.Manager) { m.MarkStarting("fake") },
|
||||
}
|
||||
// Refusals that wait out the 5s timeout (disable while failed or
|
||||
// running) are pre-existing behavior, unchanged here, and too slow to
|
||||
// pin; every case below answers at once.
|
||||
tests := []struct {
|
||||
name string
|
||||
state string
|
||||
active bool
|
||||
wantErr bool
|
||||
}{
|
||||
{name: "enable accepts running", state: "running", active: true},
|
||||
{name: "enable accepts degraded", state: "degraded", active: true},
|
||||
{name: "enable refuses failed", state: "failed", active: true, wantErr: true},
|
||||
{name: "disable accepts stopped", state: "", active: false},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
manager := status.NewManager([]status.Descriptor{{ID: "fake"}})
|
||||
if tt.state == "" {
|
||||
manager.MarkStopped("fake", "")
|
||||
} else {
|
||||
mark[tt.state](manager)
|
||||
}
|
||||
srv := &Service{status: manager}
|
||||
// Every case above answers at once: success and failed-enable
|
||||
// refusal never reach the timeout wait.
|
||||
done := make(chan error, 1)
|
||||
go func() { done <- srv.awaitChannelActive("fake", tt.active) }()
|
||||
select {
|
||||
case err := <-done:
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Fatalf("err = %v, wantErr %v", err, tt.wantErr)
|
||||
}
|
||||
case <-time.After(6 * time.Second):
|
||||
t.Fatal("await did not answer")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestChannelSupervisorRetriesAndRestarts pins that a channel that fails on its
|
||||
// own is retried with bounded backoff and, once the budget is spent, parked so
|
||||
// an explicit restart brings it back rather than being refused.
|
||||
@@ -152,7 +101,7 @@ func TestChannelSupervisorRetriesAndRestarts(t *testing.T) {
|
||||
// The supervisor retries the failed run instead of abandoning the channel.
|
||||
waitStarts(t, ch, 3)
|
||||
|
||||
if err := srv.restartChannel("fake", ResolvedConfig{}); err != nil {
|
||||
if err := restart(srv, "fake", ch); err != nil {
|
||||
t.Fatalf("restart after the retry budget was spent: %v", err)
|
||||
}
|
||||
waitStarts(t, ch, 4)
|
||||
@@ -166,7 +115,7 @@ func TestChannelSupervisorRestartReplacesRunningChannel(t *testing.T) {
|
||||
srv := startService(t, ch, channelRetryPolicy{attempts: 3, backoff: time.Hour, maxBackoff: time.Hour})
|
||||
|
||||
waitStarts(t, ch, 1)
|
||||
if err := srv.restartChannel("fake", ResolvedConfig{}); err != nil {
|
||||
if err := restart(srv, "fake", ch); err != nil {
|
||||
t.Fatalf("restart running channel: %v", err)
|
||||
}
|
||||
waitStarts(t, ch, 2)
|
||||
@@ -180,13 +129,12 @@ func TestChannelRestartRefusedWithoutSupervisor(t *testing.T) {
|
||||
inst := &channelInstance{
|
||||
name: "fake",
|
||||
channel: ch,
|
||||
rebuild: func(ResolvedConfig) (channels.Channel, error) { return ch, nil },
|
||||
}
|
||||
srv, err := compose(context.Background(), deps{Log: slog.Default(), ExtensionChannels: []*channelInstance{inst}})
|
||||
if err != nil {
|
||||
t.Fatalf("compose: %v", err)
|
||||
}
|
||||
if err := srv.restartChannel("fake", ResolvedConfig{}); err == nil {
|
||||
if err := restart(srv, "fake", ch); err == nil {
|
||||
t.Fatal("restart before the service started should be refused")
|
||||
}
|
||||
|
||||
@@ -203,7 +151,21 @@ func TestChannelRestartRefusedWithoutSupervisor(t *testing.T) {
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("service did not stop")
|
||||
}
|
||||
if err := srv.restartChannel("fake", ResolvedConfig{}); err == nil {
|
||||
if err := restart(srv, "fake", ch); err == nil {
|
||||
t.Fatal("restart after shutdown should be refused")
|
||||
}
|
||||
}
|
||||
|
||||
// restart swaps ch in as the channel id runs, the way a settings change does.
|
||||
func restart(srv *Service, id string, ch channels.Channel) error {
|
||||
return srv.setChannelState(instanceByID(srv, id), ch)
|
||||
}
|
||||
|
||||
func instanceByID(srv *Service, id string) *channelInstance {
|
||||
for _, c := range srv.instances() {
|
||||
if c.name == id {
|
||||
return c
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -48,13 +48,3 @@ func ApprovalFromContext(ctx context.Context) ApprovalRequester {
|
||||
a, _ := ctx.Value(approvalCtxKey{}).(ApprovalRequester)
|
||||
return a
|
||||
}
|
||||
|
||||
// ApproverOf returns sender's ApprovalRequester when it reports the
|
||||
// Approval capability and implements the interface.
|
||||
func ApproverOf(sender any) (ApprovalRequester, bool) {
|
||||
if !CapabilitiesOf(sender).Approval {
|
||||
return nil, false
|
||||
}
|
||||
approver, ok := sender.(ApprovalRequester)
|
||||
return approver, ok
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
package messaging
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
)
|
||||
|
||||
// EphemeralReply is a reply deleted after TTL from a successful send. A
|
||||
// non-positive TTL is never deleted.
|
||||
type EphemeralReply struct {
|
||||
Event MessageEvent
|
||||
TTL time.Duration
|
||||
}
|
||||
|
||||
// MessageDeleter deletes a message the sender sent, addressed by the
|
||||
// MessageEvent the send returned.
|
||||
type MessageDeleter interface {
|
||||
DeleteMessage(ctx context.Context, event MessageEvent) error
|
||||
}
|
||||
|
||||
// DeleterOf returns sender's MessageDeleter when it reports the Delete
|
||||
// capability and implements the interface.
|
||||
func DeleterOf(sender any) (MessageDeleter, bool) {
|
||||
if !CapabilitiesOf(sender).Delete {
|
||||
return nil, false
|
||||
}
|
||||
deleter, ok := sender.(MessageDeleter)
|
||||
return deleter, ok
|
||||
}
|
||||
@@ -148,34 +148,8 @@ var (
|
||||
// string is not an answer to a question, so it must not be mistaken
|
||||
// for one by a caller that only checks err.
|
||||
ErrEmptyReply = errors.New("interactive: reply was empty")
|
||||
|
||||
// ErrTextFallbackNotConfigured is returned when a TextFallback is used
|
||||
// without both transport halves. It is a construction defect, surfaced
|
||||
// rather than panicking inside a turn.
|
||||
ErrTextFallbackNotConfigured = errors.New("interactive: text fallback is missing Send or Reply")
|
||||
)
|
||||
|
||||
// ClarifierOf returns sender's ClarifyRequester when it reports the Clarify
|
||||
// capability and implements the interface.
|
||||
func ClarifierOf(sender any) (ClarifyRequester, bool) {
|
||||
if !CapabilitiesOf(sender).Clarify {
|
||||
return nil, false
|
||||
}
|
||||
clarifier, ok := sender.(ClarifyRequester)
|
||||
return clarifier, ok
|
||||
}
|
||||
|
||||
// PickerOf returns sender's PickerRequester only when sender reports the
|
||||
// Picker capability, with the same capability-over-method-set rule as
|
||||
// ClarifierOf.
|
||||
func PickerOf(sender any) (PickerRequester, bool) {
|
||||
if !CapabilitiesOf(sender).Picker {
|
||||
return nil, false
|
||||
}
|
||||
picker, ok := sender.(PickerRequester)
|
||||
return picker, ok
|
||||
}
|
||||
|
||||
// Interactive holds the interaction requesters a channel supports for one
|
||||
// turn. The zero value supports none.
|
||||
type Interactive struct {
|
||||
@@ -189,16 +163,6 @@ func (i Interactive) Carries() bool {
|
||||
return i.Clarifier != nil || i.Picker != nil || i.Questioner != nil
|
||||
}
|
||||
|
||||
// InteractiveOf resolves sender into the requesters it can carry, trusting the
|
||||
// capability report over the method set through ClarifierOf and PickerOf. A
|
||||
// sender that implements a method but denies the capability contributes
|
||||
// nothing, so a mis-reporting adapter degrades instead of being called.
|
||||
func InteractiveOf(sender any) Interactive {
|
||||
clarifier, _ := ClarifierOf(sender)
|
||||
picker, _ := PickerOf(sender)
|
||||
return Interactive{Clarifier: clarifier, Picker: picker}
|
||||
}
|
||||
|
||||
type interactiveCtxKey struct{}
|
||||
|
||||
// WithInteractive stores a channel's interactive requesters on ctx for one
|
||||
@@ -215,21 +179,6 @@ func InteractiveFromContext(ctx context.Context) Interactive {
|
||||
return i
|
||||
}
|
||||
|
||||
// FormatClarifyText renders a ClarifyRequest as a plain-text prompt for a
|
||||
// channel with no native question UI.
|
||||
func FormatClarifyText(req ClarifyRequest) string {
|
||||
var b strings.Builder
|
||||
b.WriteString(strings.TrimSpace(req.Question))
|
||||
if len(req.Suggestions) > 0 {
|
||||
b.WriteString("\n\nSuggestions:")
|
||||
for i, s := range req.Suggestions {
|
||||
fmt.Fprintf(&b, "\n%d) %s", i+1, s.Label)
|
||||
}
|
||||
}
|
||||
b.WriteString("\n\nReply with your answer.")
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// FormatPickerText renders a PickerRequest as a numbered plain-text prompt
|
||||
// for a channel with no native selection UI.
|
||||
func FormatPickerText(req PickerRequest) string {
|
||||
@@ -272,70 +221,3 @@ func ParsePickerReply(req PickerRequest, reply string) (InteractiveChoice, bool)
|
||||
}
|
||||
return InteractiveChoice{}, false
|
||||
}
|
||||
|
||||
// TextFallback asks clarify and picker questions as plain text and reads the
|
||||
// typed reply.
|
||||
type TextFallback struct {
|
||||
Send func(ctx context.Context, text string) error
|
||||
Reply func(ctx context.Context) (string, error)
|
||||
}
|
||||
|
||||
// Compile-time guards.
|
||||
var (
|
||||
_ ClarifyRequester = (*TextFallback)(nil)
|
||||
_ PickerRequester = (*TextFallback)(nil)
|
||||
)
|
||||
|
||||
// RequestClarification sends the rendered question and returns the user's
|
||||
// trimmed answer.
|
||||
func (f *TextFallback) RequestClarification(ctx context.Context, req ClarifyRequest) (string, error) {
|
||||
if err := f.ready(); err != nil {
|
||||
return "", err
|
||||
}
|
||||
if err := f.Send(ctx, FormatClarifyText(req)); err != nil {
|
||||
return "", err
|
||||
}
|
||||
answer, err := f.Reply(ctx)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
answer = strings.TrimSpace(answer)
|
||||
if answer == "" {
|
||||
return "", ErrEmptyReply
|
||||
}
|
||||
return answer, nil
|
||||
}
|
||||
|
||||
// RequestChoice sends the rendered options and returns the option the user
|
||||
// selected. A reply that matches no option is an error rather than a
|
||||
// zero-value guess.
|
||||
func (f *TextFallback) RequestChoice(ctx context.Context, req PickerRequest) (InteractiveChoice, error) {
|
||||
if len(req.Options) == 0 {
|
||||
return InteractiveChoice{}, ErrNoPickerOptions
|
||||
}
|
||||
if err := f.ready(); err != nil {
|
||||
return InteractiveChoice{}, err
|
||||
}
|
||||
if err := f.Send(ctx, FormatPickerText(req)); err != nil {
|
||||
return InteractiveChoice{}, err
|
||||
}
|
||||
reply, err := f.Reply(ctx)
|
||||
if err != nil {
|
||||
return InteractiveChoice{}, err
|
||||
}
|
||||
choice, ok := ParsePickerReply(req, reply)
|
||||
if !ok {
|
||||
return InteractiveChoice{}, fmt.Errorf("interactive: reply %q does not match any offered option", strings.TrimSpace(reply))
|
||||
}
|
||||
return choice, nil
|
||||
}
|
||||
|
||||
// ready reports whether both transport halves are present before any send is
|
||||
// attempted, so a half-built fallback fails at the call rather than
|
||||
// mid-interaction.
|
||||
func (f *TextFallback) ready() error {
|
||||
if f == nil || f.Send == nil || f.Reply == nil {
|
||||
return ErrTextFallbackNotConfigured
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
package messaging
|
||||
|
||||
import "context"
|
||||
|
||||
// SendResult captures the outcome of a platform media delivery.
|
||||
type SendResult struct {
|
||||
MessageID string
|
||||
Success bool
|
||||
Retryable bool
|
||||
Error error
|
||||
ErrorCode string
|
||||
}
|
||||
|
||||
// AdapterCapabilities reports which optional delivery behaviors a sender
|
||||
// implements.
|
||||
type AdapterCapabilities struct {
|
||||
Media bool
|
||||
// Delete reports whether the sender can delete messages it sent.
|
||||
Delete bool
|
||||
// Clarify reports whether the sender can ask a question and return the
|
||||
// answer.
|
||||
Clarify bool
|
||||
// Picker reports whether the sender can present a single-choice
|
||||
// selection and carry the chosen option back (PickerRequester), on the
|
||||
// same native-or-fallback rule as Clarify.
|
||||
Picker bool
|
||||
// Approval reports whether the sender renders approval prompts through
|
||||
// the ApprovalRequester contract, so a caller can know a sender can
|
||||
// present an approve/deny prompt before a gated action needs one.
|
||||
Approval bool
|
||||
}
|
||||
|
||||
// MediaSender delivers a MessageEvent carrying MediaAttachments through a
|
||||
// platform-specific media API.
|
||||
type MediaSender interface {
|
||||
SendMedia(ctx context.Context, event MessageEvent) (SendResult, error)
|
||||
}
|
||||
|
||||
// CapabilityReporter is the optional interface a sender implements to
|
||||
// self-report which optional behaviors it supports.
|
||||
type CapabilityReporter interface {
|
||||
Capabilities() AdapterCapabilities
|
||||
}
|
||||
|
||||
// CapabilitiesOf reports which optional behaviors sender supports.
|
||||
func CapabilitiesOf(sender any) AdapterCapabilities {
|
||||
if reporter, ok := sender.(CapabilityReporter); ok {
|
||||
return reporter.Capabilities()
|
||||
}
|
||||
return AdapterCapabilities{}
|
||||
}
|
||||
@@ -19,35 +19,6 @@ const (
|
||||
MsgSystem MessageType = "system"
|
||||
)
|
||||
|
||||
// IsMedia reports whether the type carries a media attachment.
|
||||
func (t MessageType) IsMedia() bool {
|
||||
switch t {
|
||||
case MsgImage, MsgVideo, MsgAudio, MsgDocument, MsgSticker:
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// IsEphemeral reports whether the type is a transient signal.
|
||||
func (t MessageType) IsEphemeral() bool {
|
||||
switch t {
|
||||
case MsgReaction, MsgDeleted:
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// IsRich reports whether the type requires a MessageEvent with
|
||||
// structured fields rather than a plain text fallback.
|
||||
func (t MessageType) IsRich() bool {
|
||||
switch t {
|
||||
case MsgText:
|
||||
return false
|
||||
default:
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
// MessageEvent is the rich message model for gateway channels.
|
||||
type MessageEvent struct {
|
||||
Type MessageType `json:"type"`
|
||||
@@ -67,6 +38,3 @@ type MessageEvent struct {
|
||||
Timestamp int64 `json:"timestamp,omitempty"`
|
||||
Raw map[string]any `json:"raw,omitempty"`
|
||||
}
|
||||
|
||||
// FromID returns the sender identifier.
|
||||
func (e MessageEvent) FromID() string { return e.SenderID }
|
||||
@@ -1,16 +0,0 @@
|
||||
package gateway
|
||||
|
||||
import "github.com/samcharles93/archie-core/internal/domain/messaging"
|
||||
|
||||
// SendResult captures the outcome of a platform media delivery.
|
||||
type SendResult = messaging.SendResult
|
||||
|
||||
// AdapterCapabilities reports which optional delivery behaviors a sender
|
||||
// implements.
|
||||
type AdapterCapabilities = messaging.AdapterCapabilities
|
||||
|
||||
// MediaSender delivers a MessageEvent carrying MediaAttachments.
|
||||
type MediaSender = messaging.MediaSender
|
||||
|
||||
// CapabilityReporter is the optional interface a sender implements.
|
||||
type CapabilityReporter = messaging.CapabilityReporter
|
||||
@@ -9,47 +9,19 @@ type (
|
||||
PickerRequest = messaging.PickerRequest
|
||||
)
|
||||
|
||||
// Optional interactive interfaces an adapter may implement.
|
||||
type (
|
||||
ClarifyRequester = messaging.ClarifyRequester
|
||||
PickerRequester = messaging.PickerRequester
|
||||
)
|
||||
|
||||
// Interactive is the per-turn bundle of requesters a channel adapter can
|
||||
// carry. WithInteractive stores it on a turn's context and
|
||||
// InteractiveFromContext reads it back, so the gateway can offer a question
|
||||
// tool only when the channel can answer it.
|
||||
type Interactive = messaging.Interactive
|
||||
|
||||
// InteractiveOf resolves the requesters a channel adapter supports.
|
||||
//
|
||||
// WithInteractive / InteractiveFromContext are the context carrier.
|
||||
var (
|
||||
InteractiveOf = messaging.InteractiveOf
|
||||
WithInteractive = messaging.WithInteractive
|
||||
InteractiveFromContext = messaging.InteractiveFromContext
|
||||
)
|
||||
|
||||
// TextFallback is the shared text-based degrade.
|
||||
type TextFallback = messaging.TextFallback
|
||||
|
||||
// Re-exported sentinel errors.
|
||||
var (
|
||||
ErrNoPickerOptions = messaging.ErrNoPickerOptions
|
||||
ErrEmptyReply = messaging.ErrEmptyReply
|
||||
ErrTextFallbackNotConfigured = messaging.ErrTextFallbackNotConfigured
|
||||
)
|
||||
|
||||
// Re-exported capability lookups.
|
||||
var (
|
||||
ClarifierOf = messaging.ClarifierOf
|
||||
PickerOf = messaging.PickerOf
|
||||
ApproverOf = messaging.ApproverOf
|
||||
)
|
||||
|
||||
// Re-exported text rendering and parsing helpers.
|
||||
var (
|
||||
FormatClarifyText = messaging.FormatClarifyText
|
||||
FormatPickerText = messaging.FormatPickerText
|
||||
ParsePickerReply = messaging.ParsePickerReply
|
||||
FormatPickerText = messaging.FormatPickerText
|
||||
ParsePickerReply = messaging.ParsePickerReply
|
||||
)
|
||||
@@ -3,12 +3,9 @@ package storepkg
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/ed25519"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
|
||||
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/domain/distribution"
|
||||
domain "github.com/samcharles93/archie-core/internal/domain/storepkg"
|
||||
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
|
||||
@@ -51,15 +48,6 @@ func (c OCICatalogue) Fetch(ctx context.Context) (domain.Catalogue, error) {
|
||||
return decodeCatalogue(artifact.Statement)
|
||||
}
|
||||
|
||||
// verifyCatalogue checks the layer is the one the manifest names and that the
|
||||
// key signed it, then decodes it.
|
||||
func verifyCatalogue(image ocispec.Manifest, layer []byte, key ed25519.PublicKey) (domain.Catalogue, error) {
|
||||
if err := signedoci.Verify(image, layer, key, SignatureAnnotation); err != nil {
|
||||
return domain.Catalogue{}, fmt.Errorf("catalogue: %w", err)
|
||||
}
|
||||
return decodeCatalogue(layer)
|
||||
}
|
||||
|
||||
// decodeCatalogue decodes a verified catalogue layer.
|
||||
func decodeCatalogue(layer []byte) (domain.Catalogue, error) {
|
||||
decoder := json.NewDecoder(bytes.NewReader(layer))
|
||||
|
||||
@@ -5,6 +5,7 @@ import (
|
||||
"crypto/ed25519"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
@@ -113,3 +114,12 @@ func TestFetchRefusesReplayedCatalogue(t *testing.T) {
|
||||
}
|
||||
|
||||
const zeros = "0000000000000000000000000000000000000000000000000000000000000000"
|
||||
|
||||
// verifyCatalogue checks, as signedoci.Fetch does, the layer is the one the manifest names and that the
|
||||
// key signed it, then decodes it.
|
||||
func verifyCatalogue(image ocispec.Manifest, layer []byte, key ed25519.PublicKey) (domain.Catalogue, error) {
|
||||
if err := signedoci.Verify(image, layer, key, SignatureAnnotation); err != nil {
|
||||
return domain.Catalogue{}, fmt.Errorf("catalogue: %w", err)
|
||||
}
|
||||
return decodeCatalogue(layer)
|
||||
}
|
||||
@@ -158,11 +158,6 @@ func isHealth(path string) bool {
|
||||
return strings.HasPrefix(path, "/health")
|
||||
}
|
||||
|
||||
// Transport traces outbound HTTP requests made through base.
|
||||
func Transport(base http.RoundTripper) http.RoundTripper {
|
||||
return otelhttp.NewTransport(base)
|
||||
}
|
||||
|
||||
// Routed names the request's server span after the mux pattern that serves
|
||||
// it. Middleware that copies the request hides the pattern from Handler, so
|
||||
// the inner mux reports it itself.
|
||||
|
||||
@@ -76,15 +76,6 @@ func (r Report) Verify(running map[string]string) Verification {
|
||||
return result
|
||||
}
|
||||
|
||||
// IsRecordedVersion reports whether version names an actual release rather
|
||||
// than a placeholder standing in for one. Renderers use it to avoid printing
|
||||
// a version change like "1.0.0 -> unknown", which reads as a downgrade to a
|
||||
// release by that name.
|
||||
func IsRecordedVersion(version string) bool {
|
||||
_, ok := comparableVersion(version)
|
||||
return ok
|
||||
}
|
||||
|
||||
// comparableVersion trims whitespace and a leading "v", and reports whether
|
||||
// the version is real.
|
||||
func comparableVersion(version string) (string, bool) {
|
||||
|
||||
@@ -178,9 +178,6 @@ func SkillForWorkflow(catalog []CatalogEntry, workflow string) *CatalogEntry {
|
||||
|
||||
const skillsDir = ".agents/skills"
|
||||
|
||||
// StoreDir is where root keeps its skills.
|
||||
func StoreDir(root string) string { return filepath.Join(root, skillsDir) }
|
||||
|
||||
// Parse extracts YAML frontmatter and body from SKILL.md content.
|
||||
// The frontmatter is delimited by "---" lines. If no frontmatter is found,
|
||||
// the entire content is returned as the body with a zero Frontmatter.
|
||||
|
||||
@@ -37,9 +37,6 @@ func (c *chatFiles) clock() time.Time {
|
||||
return time.Now()
|
||||
}
|
||||
|
||||
// offer registers path and returns the token that downloads it.
|
||||
func (c *chatFiles) offer(path, name string) string { return c.offerFor(path, name, "") }
|
||||
|
||||
func (c *chatFiles) offerFor(path, name, owner string) string {
|
||||
var b [16]byte
|
||||
_, _ = rand.Read(b[:])
|
||||
|
||||
@@ -21,7 +21,7 @@ func TestChatFileDownload(t *testing.T) {
|
||||
now := time.Now()
|
||||
srv := newChatAPI(&Server{})
|
||||
srv.files.now = func() time.Time { return now }
|
||||
token := srv.files.offer(path, "")
|
||||
token := srv.files.offerFor(path, "", "")
|
||||
private := srv.files.offerFor(path, "", "alice")
|
||||
|
||||
tests := []struct {
|
||||
|
||||
Reference in new issue
Block a user