diff --git a/internal/gateway/chat_local.go b/internal/gateway/chat_local.go index 03e75edaf..884011e3f 100644 --- a/internal/gateway/chat_local.go +++ b/internal/gateway/chat_local.go @@ -230,7 +230,7 @@ func (a *LocalChatAdapter) runStreamedTurn(ctx context.Context, in Inbound, id s run := func(turnCtx context.Context) ChatEvent { reply, err := a.Router.streamTurn(turnCtx, in, stream) if err != nil { - return ChatEvent{Kind: "error", Text: err.Error(), SessionID: id} + return ChatEvent{Kind: "error", Text: turnFailureText(err), SessionID: id} } resolvedID := id if resolved, err := a.Router.ResolveSessionKey(turnCtx, in); err == nil { @@ -306,7 +306,7 @@ func (a *LocalChatAdapter) prelude(ctx context.Context, in Inbound, id string) s } ready, mine, err := a.Router.CollectTurn(ctx, in) if err != nil { - return streamPrelude{event: &ChatEvent{Kind: "error", Text: err.Error(), SessionID: id}} + return streamPrelude{event: &ChatEvent{Kind: "error", Text: turnFailureText(err), SessionID: id}} } return streamPrelude{ready: ready, proceeds: mine} } diff --git a/internal/gateway/turn.go b/internal/gateway/turn.go index 1a2cc474a..106e926c1 100644 --- a/internal/gateway/turn.go +++ b/internal/gateway/turn.go @@ -580,7 +580,7 @@ func (r *TurnRunner) failTurn(ctx context.Context, turn TurnRecord, cause error) } else { turn.Status = TurnStatusFailed } - turn.Error = cause.Error() + turn.Error = turnFailureText(cause) turn.UpdatedAt = time.Now().UTC() if r.Log != nil { level := slog.LevelError diff --git a/internal/gateway/turn_failure.go b/internal/gateway/turn_failure.go new file mode 100644 index 000000000..19964d5bb --- /dev/null +++ b/internal/gateway/turn_failure.go @@ -0,0 +1,30 @@ +package gateway + +import ( + "context" + "errors" + + "github.com/samcharles93/ai-sdk/chat" +) + +// turnFailureText is what a chat reader sees when a turn fails. The cause +// carries provider bodies, URLs and wrapping that belong in the log, which +// failTurn writes, not in front of whoever is chatting. +func turnFailureText(err error) string { + switch { + case errors.Is(err, chat.ErrRateLimited): + return "the model provider is refusing requests (rate limit or spending cap). Try again later, or switch model with /model." + case errors.Is(err, chat.ErrAuthFailed): + return "the model provider rejected Archie's credentials. Check the provider key in settings." + case errors.Is(err, chat.ErrProviderUnavailable): + return "the model provider is unavailable. Try again in a moment." + case errors.Is(err, chat.ErrContextLength): + return "this conversation is too long for the model. Start a new chat, or shorten it with /compress." + case errors.Is(err, chat.ErrUnsupportedContent): + return "the model can't read one of the attachments. Remove it, or switch model with /model." + case errors.Is(err, context.DeadlineExceeded): + return "the model took too long to answer. Try again." + default: + return "something went wrong on Archie's side. Try again; the gateway log has the cause." + } +} diff --git a/internal/gateway/turn_failure_test.go b/internal/gateway/turn_failure_test.go new file mode 100644 index 000000000..1eead81aa --- /dev/null +++ b/internal/gateway/turn_failure_test.go @@ -0,0 +1,50 @@ +package gateway + +import ( + "context" + "errors" + "fmt" + "strings" + "testing" + + "github.com/samcharles93/ai-sdk/chat" + + "github.com/samcharles93/archie-core/internal/domain/messaging" +) + +// A failed turn shows the reader what to do, never the provider's response +// body or the error's wrapping. +func TestStreamedTurnFailureHidesCause(t *testing.T) { + for _, tc := range []struct { + name string + cause error + want string + }{ + {name: "spending cap", cause: chat.ErrRateLimited, want: "rate limit or spending cap"}, + {name: "bad key", cause: chat.ErrAuthFailed, want: "credentials"}, + {name: "unknown", cause: errors.New("dial tcp 10.0.0.1:5432: refused"), want: "gateway log"}, + } { + t.Run(tc.name, func(t *testing.T) { + raw := fmt.Errorf(`llm chat stream: gemini: status 429: {"message":"https://ai.studio/spend"}: %w`, tc.cause) + router := &Router{LLMStream: func(context.Context, Inbound, TurnStream) (string, error) { return "", raw }} + adapter := &LocalChatAdapter{Router: router} + events := make(chan ChatEvent, 32) + go adapter.runStreamedTurn(context.Background(), Inbound{Message: messaging.Message{Text: "hi"}}, "s1", events) + for event := range events { + if event.Kind != "error" { + continue + } + for _, leak := range []string{"gemini", "429", "ai.studio", "10.0.0.1", "llm chat stream"} { + if strings.Contains(event.Text, leak) { + t.Fatalf("error text %q exposes %q", event.Text, leak) + } + } + if !strings.Contains(event.Text, tc.want) { + t.Fatalf("error text %q, want it to mention %q", event.Text, tc.want) + } + return + } + t.Fatal("no error event") + }) + } +} diff --git a/internal/infrastructure/controlplanestore/telegram_connection.go b/internal/infrastructure/controlplanestore/telegram_connection.go index 9274ac941..eee4468c0 100644 --- a/internal/infrastructure/controlplanestore/telegram_connection.go +++ b/internal/infrastructure/controlplanestore/telegram_connection.go @@ -100,6 +100,9 @@ func splitLegacyChannelSettings(orgID string, stored []byte) (rewritten []byte, return nil, telegramConnection{}, false, fmt.Errorf("decode telegram: %w", err) } delete(doc, "telegram") + // A document old enough to carry telegram can also carry the per-channel + // models that model aliases replaced, which the current schema rejects. + delete(doc, "models") if orgID == storecontract.DefaultOrgID { moved = telegramConnection{Token: legacy.TokenRef, Users: legacy.AllowedUserIDs} } else if len(legacy.AllowedUserIDs) > 0 { diff --git a/ui/src/chat/ChatComposer.vue b/ui/src/chat/ChatComposer.vue index d8945817e..2c0f237d7 100644 --- a/ui/src/chat/ChatComposer.vue +++ b/ui/src/chat/ChatComposer.vue @@ -15,6 +15,8 @@ import { commandSelection, commandSpecs, addTaskTag, + clearPageTag, + pageTag, composerText, editQueued, menuTrigger, @@ -219,7 +221,16 @@ function onKeydown(event: KeyboardEvent): void { -