@pi-in-go/pigpen-a2a 0.1.0

package/extensions/a2a/executor.go

@@ -0,0 +1,318 @@
+package a2aext
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"iter"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/a2aproject/a2a-go/v2/a2a"
+	"github.com/a2aproject/a2a-go/v2/a2asrv"
+)
+
+const maxPromptBytes = 256 << 10
+
+type stopReason int32
+
+const (
+	stopNone stopReason = iota
+	stopCanceled
+	stopTimeout
+	stopShutdown
+)
+
+// running is one task between Execute's registration and its worker's exit.
+type running struct {
+	cancel context.CancelFunc
+	reason atomic.Int32
+	done   chan struct{}
+}
+
+// executor is the a2asrv.AgentExecutor that runs A2A tasks as PiG turns.
+type executor struct {
+	worker  Worker
+	timeout time.Duration
+	base    context.Context
+	sem     chan struct{}
+	logf    func(format string, args ...any)
+
+	mu       sync.Mutex
+	tasks    map[a2a.TaskID]*running
+	ctxLocks map[string]*ctxLock
+	active   atomic.Int32
+}
+
+type ctxLock struct {
+	ch   chan struct{}
+	refs int
+}
+
+func newExecutor(base context.Context, w Worker, maxConcurrent int, timeout time.Duration, logf func(string, ...any)) *executor {
+	return &executor{worker: w, timeout: timeout, base: base, sem: make(chan struct{}, maxConcurrent), logf: logf,
+		tasks: map[a2a.TaskID]*running{}, ctxLocks: map[string]*ctxLock{}}
+}
+
+func principalOf(ec *a2asrv.ExecutorContext) (Principal, error) {
+	if ec.User == nil || !ec.User.Authenticated {
+		return Principal{}, a2a.ErrUnauthenticated
+	}
+	name, _ := ec.User.Attributes["name"].(string)
+	tenant, _ := ec.User.Attributes["tenant"].(string)
+	p := Principal{Name: name, Tenant: tenant}
+	if p.Key() != ec.User.Name {
+		return Principal{}, a2a.ErrUnauthenticated
+	}
+	return p, nil
+}
+
+// promptOf accepts text parts only. A part it cannot represent is refused, never dropped.
+func promptOf(m *a2a.Message) (string, error) {
+	if m == nil {
+		return "", fmt.Errorf("message is required: %w", a2a.ErrInvalidParams)
+	}
+	var texts []string
+	for _, p := range m.Parts {
+		if p == nil {
+			continue
+		}
+		if _, ok := p.Content.(a2a.Text); !ok {
+			return "", fmt.Errorf("only text parts are supported: %w", a2a.ErrUnsupportedContentType)
+		}
+		texts = append(texts, p.Text())
+	}
+	prompt := strings.Join(texts, "\n")
+	if strings.TrimSpace(prompt) == "" {
+		return "", fmt.Errorf("the message has no text: %w", a2a.ErrInvalidParams)
+	}
+	if len(prompt) > maxPromptBytes {
+		return "", fmt.Errorf("the message exceeds %d bytes: %w", maxPromptBytes, a2a.ErrInvalidParams)
+	}
+	return prompt, nil
+}
+
+func (e *executor) lockContext(ctx context.Context, key string) (func(), error) {
+	e.mu.Lock()
+	l := e.ctxLocks[key]
+	if l == nil {
+		l = &ctxLock{ch: make(chan struct{}, 1)}
+		e.ctxLocks[key] = l
+	}
+	l.refs++
+	e.mu.Unlock()
+	release := func() {
+		e.mu.Lock()
+		l.refs--
+		if l.refs == 0 {
+			delete(e.ctxLocks, key)
+		}
+		e.mu.Unlock()
+	}
+	select {
+	case l.ch <- struct{}{}:
+		return func() { <-l.ch; release() }, nil
+	case <-ctx.Done():
+		release()
+		return nil, ctx.Err()
+	}
+}
+
+func (e *executor) status(ec *a2asrv.ExecutorContext, state a2a.TaskState, text string) *a2a.TaskStatusUpdateEvent {
+	var msg *a2a.Message
+	if text != "" {
+		msg = a2a.NewMessageForTask(a2a.MessageRoleAgent, ec, a2a.NewTextPart(text))
+	}
+	return a2a.NewStatusUpdateEvent(ec, state, msg)
+}
+
+type runEvent struct {
+	update Update
+	done   bool
+	result Result
+	err    error
+}
+
+// Execute implements a2asrv.AgentExecutor.
+func (e *executor) Execute(ctx context.Context, ec *a2asrv.ExecutorContext) iter.Seq2[a2a.Event, error] {
+	return func(yield func(a2a.Event, error) bool) {
+		principal, err := principalOf(ec)
+		if err != nil {
+			yield(nil, err)
+			return
+		}
+		prompt, err := promptOf(ec.Message)
+		if err != nil {
+			yield(nil, err)
+			return
+		}
+		if ec.StoredTask == nil && !yield(a2a.NewSubmittedTask(ec, ec.Message), nil) {
+			return
+		}
+
+		runCtx, cancelRun := context.WithCancel(e.base)
+		defer cancelRun()
+		stop := context.AfterFunc(ctx, cancelRun)
+		defer stop()
+		r := &running{cancel: cancelRun, done: make(chan struct{})}
+		e.mu.Lock()
+		e.tasks[ec.TaskID] = r
+		e.mu.Unlock()
+		e.active.Add(1)
+		defer func() {
+			e.mu.Lock()
+			if e.tasks[ec.TaskID] == r {
+				delete(e.tasks, ec.TaskID)
+			}
+			e.mu.Unlock()
+			e.active.Add(-1)
+			close(r.done)
+		}()
+
+		// Wait for a slot, then for the context's session file. The task stays submitted meanwhile.
+		select {
+		case e.sem <- struct{}{}:
+			defer func() { <-e.sem }()
+		case <-runCtx.Done():
+			e.finishStopped(ec, r, yield, runCtx)
+			return
+		}
+		unlock, err := e.lockContext(runCtx, principal.Key()+"\x00"+ec.ContextID)
+		if err != nil {
+			e.finishStopped(ec, r, yield, runCtx)
+			return
+		}
+		defer unlock()
+		if runCtx.Err() != nil {
+			e.finishStopped(ec, r, yield, runCtx)
+			return
+		}
+		if !yield(e.status(ec, a2a.TaskStateWorking, ""), nil) {
+			return
+		}
+
+		timeoutTimer := time.AfterFunc(e.timeout, func() {
+			r.reason.CompareAndSwap(int32(stopNone), int32(stopTimeout))
+			cancelRun()
+		})
+		defer timeoutTimer.Stop()
+
+		events := make(chan runEvent, 128)
+		go func() {
+			res, err := e.worker.Run(runCtx, Turn{Principal: principal, ContextID: ec.ContextID, TaskID: string(ec.TaskID), Prompt: prompt},
+				func(u Update) {
+					select {
+					case events <- runEvent{update: u}:
+					case <-runCtx.Done():
+					}
+				})
+			events <- runEvent{done: true, result: res, err: err}
+		}()
+
+		var artifactID a2a.ArtifactID
+		for ev := range events {
+			if !ev.done {
+				switch {
+				case ev.update.Text != "":
+					var out *a2a.TaskArtifactUpdateEvent
+					if artifactID == "" {
+						out = a2a.NewArtifactEvent(ec, a2a.NewTextPart(ev.update.Text))
+						artifactID = out.Artifact.ID
+					} else {
+						out = a2a.NewArtifactUpdateEvent(ec, artifactID, a2a.NewTextPart(ev.update.Text))
+					}
+					if !yield(out, nil) {
+						cancelRun()
+						drain(events)
+						return
+					}
+				case ev.update.Tool != "":
+					if !yield(e.status(ec, a2a.TaskStateWorking, "using tool "+ev.update.Tool), nil) {
+						cancelRun()
+						drain(events)
+						return
+					}
+				}
+				continue
+			}
+			switch {
+			case ev.err != nil && runCtx.Err() != nil:
+				e.finishStopped(ec, r, yield, runCtx)
+			case ev.err != nil:
+				e.logf("task %s failed: %v", ec.TaskID, ev.err)
+				yield(e.status(ec, a2a.TaskStateFailed, "PiG could not complete the task."), nil)
+			case ev.result.Failure != "":
+				yield(e.status(ec, a2a.TaskStateFailed, "PiG could not complete the task: "+ev.result.Failure), nil)
+			default:
+				yield(e.status(ec, a2a.TaskStateCompleted, ""), nil)
+			}
+			return
+		}
+	}
+}
+
+func drain(ch <-chan runEvent) {
+	go func() {
+		for range ch {
+		}
+	}()
+}
+
+// finishStopped reports a task that was stopped before or during its run.
+func (e *executor) finishStopped(ec *a2asrv.ExecutorContext, r *running, yield func(a2a.Event, error) bool, runCtx context.Context) {
+	switch stopReason(r.reason.Load()) {
+	case stopTimeout:
+		yield(e.status(ec, a2a.TaskStateFailed, fmt.Sprintf("The task exceeded its %s time limit.", e.timeout)), nil)
+	case stopCanceled:
+		// Cancel emits the canceled status itself; a second terminal event would race it.
+	default:
+		yield(e.status(ec, a2a.TaskStateCanceled, ""), nil)
+	}
+}
+
+// Cancel implements a2asrv.AgentExecutor: stop the worker, wait for it, then report canceled.
+func (e *executor) Cancel(ctx context.Context, ec *a2asrv.ExecutorContext) iter.Seq2[a2a.Event, error] {
+	return func(yield func(a2a.Event, error) bool) {
+		e.mu.Lock()
+		r := e.tasks[ec.TaskID]
+		e.mu.Unlock()
+		if r != nil {
+			r.reason.CompareAndSwap(int32(stopNone), int32(stopCanceled))
+			r.cancel()
+			select {
+			case <-r.done:
+			case <-ctx.Done():
+				yield(nil, ctx.Err())
+				return
+			case <-time.After(30 * time.Second):
+				yield(nil, errors.New("the worker did not stop"))
+				return
+			}
+		}
+		yield(e.status(ec, a2a.TaskStateCanceled, ""), nil)
+	}
+}
+
+// shutdown stops every running task and waits for them.
+func (e *executor) shutdown(ctx context.Context) error {
+	e.mu.Lock()
+	all := make([]*running, 0, len(e.tasks))
+	for _, r := range e.tasks {
+		all = append(all, r)
+	}
+	e.mu.Unlock()
+	for _, r := range all {
+		r.reason.CompareAndSwap(int32(stopNone), int32(stopShutdown))
+		r.cancel()
+	}
+	for _, r := range all {
+		select {
+		case <-r.done:
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+	return nil
+}

package/extensions/a2a/extension.go

@@ -0,0 +1,382 @@
+// Package a2aext is PiG's A2A (Agent2Agent) adapter: it serves PiG tasks to A2A
+// agents and lets PiG call remote A2A agents. It is built on the upstream Go SDK
+// github.com/a2aproject/a2a-go/v2 (Apache-2.0) and is pinned to A2A protocol 1.0.
+//
+// The listener is off unless configured (a2a.json, PIG_A2A_LISTEN or --a2a-listen).
+// See the Package README for configuration, authentication and tenant boundaries.
+package a2aext
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+// Options replaces the extension's dependencies (tests).
+type Options struct {
+	// Getenv reads the environment (default os.Getenv).
+	Getenv func(string) string
+	// Worker runs served tasks (default: a `pig --mode rpc` child process per task).
+	Worker Worker
+}
+
+// Extension returns the a2a extension.
+func Extension() *sdk.Extension { return ExtensionWith(Options{}) }
+
+type manager struct {
+	getenv func(string) string
+	worker Worker
+
+	mu      sync.Mutex
+	server  *Server
+	cfg     Config
+	cfgErr  error
+	remotes *Remotes
+}
+
+// ExtensionWith returns the extension with explicit dependencies.
+func ExtensionWith(o Options) *sdk.Extension {
+	if o.Getenv == nil {
+		o.Getenv = os.Getenv
+	}
+	m := &manager{getenv: o.Getenv, worker: o.Worker}
+	e := sdk.New("a2a")
+
+	e.Flag("a2a-listen", sdk.FlagOptions{
+		Description: "Serve PiG tasks over A2A on host:port (needs tokens in a2a.json unless the address is loopback with insecureNoAuth)",
+		Type:        sdk.FlagString,
+	})
+
+	e.OnSessionStart(func(ctx sdk.Context, data map[string]any) (any, error) {
+		m.start(ctx)
+		return nil, nil
+	})
+	e.OnSessionShutdown(func(ctx sdk.Context, data map[string]any) (any, error) {
+		reason, _ := data["reason"].(string)
+		switch reason {
+		case "new", "resume", "fork":
+			return nil, nil // a session switch inside one process keeps serving
+		}
+		m.stop()
+		return nil, nil
+	})
+
+	e.Command("a2a", "Show the A2A listener and remote agents", func(ctx sdk.Context, args string) error {
+		ctx.Notify(m.status(ctx), "info")
+		return nil
+	})
+
+	e.ToolWithGuidelines("a2a_agents", "List the remote A2A (Agent2Agent) agents configured for this PiG, with each agent's card: name, description and skills.",
+		sdk.Schema{"type": "object", "properties": map[string]any{}, "additionalProperties": false},
+		[]string{"Use a2a_agents to discover which remote agents exist before calling a2a_send."},
+		func(ctx sdk.Context, params map[string]any) (any, error) { return m.toolAgents(ctx) })
+
+	e.ToolWithGuidelines("a2a_send", "Send a task to a remote A2A agent and wait for its answer. Returns the task state, ids and the agent's reply. Reuse contextId to continue the same conversation.",
+		sdk.Schema{
+			"type": "object",
+			"properties": map[string]any{
+				"agent":     map[string]any{"type": "string", "description": "Name of a configured remote (see a2a_agents)."},
+				"message":   map[string]any{"type": "string", "description": "The task or question, as plain text."},
+				"contextId": map[string]any{"type": "string", "description": "Continue this conversation (from an earlier a2a_send)."},
+				"taskId":    map[string]any{"type": "string", "description": "Continue this task, when it is waiting for input."},
+			},
+			"required": []string{"agent", "message"}, "additionalProperties": false,
+		},
+		[]string{"The remote agent is another agent, not a tool: send it a self-contained request. Data you send leaves this machine."},
+		func(ctx sdk.Context, params map[string]any) (any, error) { return m.toolSend(ctx, params) })
+
+	e.ToolWithGuidelines("a2a_task", "Get, list or cancel tasks on a remote A2A agent.",
+		sdk.Schema{
+			"type": "object",
+			"properties": map[string]any{
+				"agent":  map[string]any{"type": "string", "description": "Name of a configured remote."},
+				"action": map[string]any{"type": "string", "enum": []string{"get", "cancel", "list"}},
+				"taskId": map[string]any{"type": "string", "description": "Required for get and cancel."},
+			},
+			"required": []string{"agent", "action"}, "additionalProperties": false,
+		},
+		nil,
+		func(ctx sdk.Context, params map[string]any) (any, error) { return m.toolTask(ctx, params) })
+	return e
+}
+
+func (m *manager) agentDir(ctx sdk.Context) string {
+	if d := m.getenv("PIG_CODING_AGENT_DIR"); d != "" {
+		return d
+	}
+	return filepath.Join(ctx.ConfigHome(), "agent")
+}
+
+// load reads the configuration and replaces the remote client set.
+func (m *manager) load(ctx sdk.Context) (Config, error) {
+	flag := ""
+	if v, err := ctx.GetFlag("a2a-listen"); err == nil {
+		flag, _ = v.(string)
+	}
+	cfg, err := LoadConfig(LoadOptions{ConfigHome: m.agentDir(ctx), Getenv: m.getenv, FlagListen: flag})
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.cfg, m.cfgErr = cfg, err
+	if err == nil {
+		m.remotes = NewRemotes(cfg.Remotes, m.getenv)
+	}
+	return cfg, err
+}
+
+// current returns the loaded configuration, loading it on first use.
+func (m *manager) current(ctx sdk.Context) (Config, *Remotes, error) {
+	m.mu.Lock()
+	loaded := m.remotes != nil || m.cfgErr != nil
+	m.mu.Unlock()
+	if !loaded {
+		if _, err := m.load(ctx); err != nil {
+			return Config{}, nil, err
+		}
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.cfg, m.remotes, m.cfgErr
+}
+
+func (m *manager) start(ctx sdk.Context) {
+	m.mu.Lock()
+	running := m.server != nil
+	m.mu.Unlock()
+	if running {
+		return
+	}
+	cfg, err := m.load(ctx)
+	if err != nil {
+		ctx.Notify(err.Error(), "error")
+		return
+	}
+	if !cfg.Enabled() {
+		return
+	}
+	worker := m.worker
+	if worker == nil {
+		worker, err = NewProcessWorker(cfg.Worker, cfg.StateDir, m.getenv)
+		if err != nil {
+			ctx.Notify(err.Error(), "error")
+			return
+		}
+	}
+	srv, err := NewServer(cfg, worker, m.getenv)
+	if err == nil {
+		err = srv.Start()
+	}
+	if err != nil {
+		ctx.Notify(err.Error(), "error")
+		return
+	}
+	m.mu.Lock()
+	m.server = srv
+	m.mu.Unlock()
+	ctx.Notify(fmt.Sprintf("a2a: listening on %s (A2A %s, %d token(s), %d concurrent task(s))", srv.Addr(), ProtocolVersion, len(cfg.Tokens), cfg.MaxConcurrentTasks), "info")
+}
+
+func (m *manager) stop() {
+	m.mu.Lock()
+	srv := m.server
+	m.server = nil
+	m.remotes, m.cfgErr = nil, nil // the next use reloads the configuration
+	m.mu.Unlock()
+	if srv == nil {
+		return
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	_ = srv.Shutdown(ctx)
+}
+
+func (m *manager) status(ctx sdk.Context) string {
+	m.mu.Lock()
+	srv := m.server
+	m.mu.Unlock()
+	cfg, remotes, err := m.current(ctx)
+	var b strings.Builder
+	switch {
+	case srv != nil:
+		fmt.Fprintf(&b, "a2a: listening on %s (A2A %s), %d active task(s)", srv.Addr(), ProtocolVersion, srv.ActiveTasks())
+		if logs := srv.RecentLogs(); len(logs) > 0 {
+			fmt.Fprintf(&b, "\nlast: %s", logs[len(logs)-1])
+		}
+	case err != nil:
+		fmt.Fprintf(&b, "a2a: listener off (%v)", err)
+	default:
+		b.WriteString("a2a: listener off (set listen in a2a.json, PIG_A2A_LISTEN or --a2a-listen to serve tasks)")
+	}
+	if remotes != nil {
+		if names := remotes.Names(); len(names) > 0 {
+			fmt.Fprintf(&b, "\nremotes: %s", strings.Join(names, ", "))
+		}
+	}
+	_ = cfg
+	return b.String()
+}
+
+// callContext adapts the tool's request context to a context.Context that is cancelled with it.
+func callContext(c sdk.Context) (context.Context, func()) {
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		select {
+		case <-c.Done():
+			cancel()
+		case <-ctx.Done():
+		}
+	}()
+	return ctx, cancel
+}
+
+func (m *manager) remotesFor(ctx sdk.Context) (*Remotes, error) {
+	_, r, err := m.current(ctx)
+	if err != nil {
+		return nil, sdk.NewToolError(err.Error())
+	}
+	if r == nil || len(r.Names()) == 0 {
+		return nil, sdk.NewToolError("a2a: no remotes are configured; add a \"remotes\" object to a2a.json")
+	}
+	return r, nil
+}
+
+func stringParam(params map[string]any, name string, required bool) (string, error) {
+	v, ok := params[name]
+	if !ok || v == nil {
+		if required {
+			return "", sdk.NewToolError(fmt.Sprintf("a2a: %s is required", name))
+		}
+		return "", nil
+	}
+	s, ok := v.(string)
+	if !ok {
+		return "", sdk.NewToolError(fmt.Sprintf("a2a: %s must be a string", name))
+	}
+	if required && strings.TrimSpace(s) == "" {
+		return "", sdk.NewToolError(fmt.Sprintf("a2a: %s must not be empty", name))
+	}
+	return s, nil
+}
+
+func formatSummary(s TaskSummary) string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "state: %s\ntaskId: %s\ncontextId: %s", s.State, s.TaskID, s.ContextID)
+	if !s.Terminal {
+		b.WriteString("\n(the task is not finished; use a2a_task to get it, or send another message with this taskId and contextId)")
+	}
+	if s.Text != "" {
+		b.WriteString("\n\n" + s.Text)
+	}
+	return b.String()
+}
+
+func (m *manager) toolAgents(ctx sdk.Context) (any, error) {
+	r, err := m.remotesFor(ctx)
+	if err != nil {
+		return nil, err
+	}
+	cctx, cancel := callContext(ctx)
+	defer cancel()
+	var b strings.Builder
+	for _, name := range r.Names() {
+		card, err := r.Card(cctx, name)
+		switch {
+		case err != nil:
+			fmt.Fprintf(&b, "- %s: %v\n", name, err)
+		default:
+			fmt.Fprintf(&b, "- %s: %s (v%s) - %s\n", name, card.Name, card.Version, card.Description)
+			for _, sk := range card.Skills {
+				fmt.Fprintf(&b, "    skill %s: %s\n", sk.Name, sk.Description)
+			}
+		}
+	}
+	return b.String(), nil
+}
+
+func (m *manager) toolSend(ctx sdk.Context, params map[string]any) (any, error) {
+	agent, err := stringParam(params, "agent", true)
+	if err != nil {
+		return nil, err
+	}
+	message, err := stringParam(params, "message", true)
+	if err != nil {
+		return nil, err
+	}
+	contextID, _ := stringParam(params, "contextId", false)
+	taskID, _ := stringParam(params, "taskId", false)
+	r, err := m.remotesFor(ctx)
+	if err != nil {
+		return nil, err
+	}
+	cctx, cancel := callContext(ctx)
+	defer cancel()
+	var soFar strings.Builder
+	last := time.Now()
+	sum, err := r.Send(cctx, SendArgs{Agent: agent, Message: message, ContextID: contextID, TaskID: taskID}, func(chunk string) {
+		soFar.WriteString(chunk)
+		if time.Since(last) > 250*time.Millisecond {
+			last = time.Now()
+			_ = ctx.OnUpdate(soFar.String())
+		}
+	})
+	if err != nil {
+		return nil, sdk.NewToolError(err.Error())
+	}
+	return formatSummary(sum), nil
+}
+
+func (m *manager) toolTask(ctx sdk.Context, params map[string]any) (any, error) {
+	agent, err := stringParam(params, "agent", true)
+	if err != nil {
+		return nil, err
+	}
+	action, err := stringParam(params, "action", true)
+	if err != nil {
+		return nil, err
+	}
+	r, err := m.remotesFor(ctx)
+	if err != nil {
+		return nil, err
+	}
+	cctx, cancel := callContext(ctx)
+	defer cancel()
+	switch action {
+	case "list":
+		list, err := r.list(cctx, agent)
+		if err != nil {
+			return nil, sdk.NewToolError(err.Error())
+		}
+		var b strings.Builder
+		for _, s := range list {
+			fmt.Fprintf(&b, "- %s (%s) context %s\n", s.TaskID, s.State, s.ContextID)
+		}
+		if b.Len() == 0 {
+			return "no tasks", nil
+		}
+		return b.String(), nil
+	case "get", "cancel":
+		taskID, err := stringParam(params, "taskId", true)
+		if err != nil {
+			return nil, err
+		}
+		var sum TaskSummary
+		if action == "get" {
+			sum, err = r.GetTask(cctx, agent, taskID)
+		} else {
+			sum, err = r.CancelTask(cctx, agent, taskID)
+		}
+		if err != nil {
+			return nil, sdk.NewToolError(err.Error())
+		}
+		return formatSummary(sum), nil
+	}
+	return nil, sdk.NewToolError(fmt.Sprintf("a2a: unknown action %q (get, cancel or list)", action))
+}
+
+var _ = errors.New