Skip to content
Merged
128 changes: 90 additions & 38 deletions acceleration/internal/store/channel_threads.go
Original file line number Diff line number Diff line change
Expand Up @@ -99,11 +99,48 @@ func (s *Store) ReleaseChannelThreadTurn(ctx context.Context, channelID, holder
return stack.Wrap(err)
}

// channelThreadMessage is one claimed message of a thread channel (ClaimChannelThreadMessage).
type channelThreadMessage struct {
bun.BaseModel `bun:"table:channel_thread_messages,alias:ctmsg"`

ChannelID string `bun:"channel_id,pk"`
Kind string `bun:"kind,pk"`
MessageID string `bun:"message_id,pk"`
CreatedAt time.Time `bun:"created_at,notnull"`
}

// channelThreadPerson is the one person a thread channel's chat is with
// (SetChannelThreadChatPerson).
type channelThreadPerson struct {
bun.BaseModel `bun:"table:channel_thread_people,alias:ctp"`

ChannelID string `bun:"channel_id,pk"`
ChatPerson string `bun:"chat_person,notnull"`
}

// channelThreadMember is a person a thread channel's chat reaches (AddChannelThreadMember).
type channelThreadMember struct {
bun.BaseModel `bun:"table:channel_thread_members,alias:ctm"`

ChannelID string `bun:"channel_id,pk"`
Member string `bun:"member,pk"`
}

// channelThreadStarter is the person who started a thread channel's chat
// (SetChannelThreadStarter).
type channelThreadStarter struct {
bun.BaseModel `bun:"table:channel_thread_starters,alias:cts"`

ChannelID string `bun:"channel_id,pk"`
Starter string `bun:"starter,notnull"`
}

// ReleaseChannelThreadMessage forgets a claim, so the step that took it can take it again:
// a reply whose send failed is sent on a later attempt.
func (s *Store) ReleaseChannelThreadMessage(ctx context.Context, channelID, kind, messageID string) error {
_, err := s.db.NewRaw("DELETE FROM channel_thread_messages WHERE channel_id = ? AND kind = ? AND message_id = ?",
channelID, kind, messageID).Exec(ctx)
_, err := s.db.NewDelete().Model((*channelThreadMessage)(nil)).
Where("channel_id = ? AND kind = ? AND message_id = ?", channelID, kind, messageID).
Exec(ctx)
return stack.Wrap(err)
}

Expand Down Expand Up @@ -143,10 +180,12 @@ func (s *Store) SetChannelThreadChatPerson(ctx context.Context, channelID, perso
}
var err error
if person == "" {
_, err = s.db.NewRaw("DELETE FROM channel_thread_people WHERE channel_id = ?", channelID).Exec(ctx)
_, err = s.db.NewDelete().Model((*channelThreadPerson)(nil)).Where("channel_id = ?", channelID).Exec(ctx)
} else {
_, err = s.db.NewRaw("INSERT INTO channel_thread_people (channel_id, chat_person) VALUES (?, ?) "+
"ON CONFLICT (channel_id) DO UPDATE SET chat_person = EXCLUDED.chat_person", channelID, person).Exec(ctx)
_, err = s.db.NewInsert().Model(&channelThreadPerson{ChannelID: channelID, ChatPerson: person}).
On("CONFLICT (channel_id) DO UPDATE").
Set("chat_person = EXCLUDED.chat_person").
Exec(ctx)
}
if err != nil {
return stack.Wrap(fmt.Errorf("store: set channel thread chat person: %w", err))
Expand All @@ -161,8 +200,9 @@ func (s *Store) AddChannelThreadMember(ctx context.Context, channelID, member st
if channelID == "" || member == "" {
return stack.Wrap(errors.New("store: a channel id and a member are required"))
}
_, err := s.db.NewRaw("INSERT INTO channel_thread_members (channel_id, member) VALUES (?, ?) ON CONFLICT DO NOTHING",
channelID, member).Exec(ctx)
_, err := s.db.NewInsert().Model(&channelThreadMember{ChannelID: channelID, Member: member}).
On("CONFLICT DO NOTHING").
Exec(ctx)
if err != nil {
return stack.Wrap(fmt.Errorf("store: add channel thread member: %w", err))
}
Expand All @@ -177,8 +217,9 @@ func (s *Store) SetChannelThreadStarter(ctx context.Context, channelID, starter
if channelID == "" || starter == "" {
return stack.Wrap(errors.New("store: a channel id and a starter are required"))
}
_, err := s.db.NewRaw("INSERT INTO channel_thread_starters (channel_id, starter) VALUES (?, ?) ON CONFLICT DO NOTHING",
channelID, starter).Exec(ctx)
_, err := s.db.NewInsert().Model(&channelThreadStarter{ChannelID: channelID, Starter: starter}).
On("CONFLICT DO NOTHING").
Exec(ctx)
if err != nil {
return stack.Wrap(fmt.Errorf("store: set channel thread starter: %w", err))
}
Expand All @@ -189,7 +230,10 @@ func (s *Store) SetChannelThreadStarter(ctx context.Context, channelID, starter
// (SetChannelThreadStarter), or "" when none is recorded.
func (s *Store) ChannelThreadStarter(ctx context.Context, channelID string) (string, error) {
var starter string
err := s.db.NewRaw("SELECT starter FROM channel_thread_starters WHERE channel_id = ?", channelID).Scan(ctx, &starter)
err := s.db.NewSelect().Model((*channelThreadStarter)(nil)).
Column("starter").
Where("channel_id = ?", channelID).
Scan(ctx, &starter)
if errors.Is(err, sql.ErrNoRows) {
return "", nil
}
Expand Down Expand Up @@ -252,14 +296,17 @@ func (s *Store) ChannelThread(ctx context.Context, channelID string) (ChannelThr

// waitingMessage is one row of channel_thread_waiting (20261011220000_channel_thread_waiting.sql).
type waitingMessage struct {
ConnectorID string `bun:"connector_id"`
ProviderUnitID string `bun:"provider_unit_id"`
ThreadKey string `bun:"thread_key"`
ProviderMessageID string `bun:"provider_message_id"`
AuthorID string `bun:"author_id"`
Text string `bun:"text"`
Raw []byte `bun:"raw"`
CreatedAt time.Time `bun:"created_at"`
bun.BaseModel `bun:"table:channel_thread_waiting,alias:ctw"`

CustomerID string `bun:"customer_id,pk"`
ConnectorID string `bun:"connector_id,pk"`
ProviderUnitID string `bun:"provider_unit_id,pk"`
ThreadKey string `bun:"thread_key,pk"`
ProviderMessageID string `bun:"provider_message_id,pk"`
AuthorID string `bun:"author_id,notnull"`
Text string `bun:"text,notnull"`
Raw []byte `bun:"raw,notnull"`
CreatedAt time.Time `bun:"created_at,notnull"`
}

// WaitChannelThreadMessage keeps a customer's message on an external thread no thread channel
Expand All @@ -271,14 +318,15 @@ func (s *Store) WaitChannelThreadMessage(ctx context.Context, customerID string,
return false, stack.Wrap(errors.New("store: a customer, a connector, a thread key and a message id are required"))
}
now := time.Now().UTC()
if _, err := s.db.NewRaw("DELETE FROM channel_thread_waiting WHERE created_at < ?", now.Add(-channelWaitingKeep)).Exec(ctx); err != nil {
_, err := s.db.NewDelete().Model((*waitingMessage)(nil)).Where("created_at < ?", now.Add(-channelWaitingKeep)).Exec(ctx)
if err != nil {
return false, stack.Wrap(fmt.Errorf("store: wait channel thread message: %w", err))
}
result, err := s.db.NewRaw(
"INSERT INTO channel_thread_waiting (customer_id, connector_id, provider_unit_id, thread_key, provider_message_id, author_id, text, raw, created_at) "+
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT DO NOTHING",
customerID, message.ConnectorID, message.ProviderUnitID, message.ThreadKey, message.ProviderMessageID,
message.AuthorID, message.Text, message.Raw, now).Exec(ctx)
result, err := s.db.NewInsert().Model(&waitingMessage{
CustomerID: customerID, ConnectorID: message.ConnectorID, ProviderUnitID: message.ProviderUnitID,
ThreadKey: message.ThreadKey, ProviderMessageID: message.ProviderMessageID,
AuthorID: message.AuthorID, Text: message.Text, Raw: message.Raw, CreatedAt: now,
}).On("CONFLICT DO NOTHING").Exec(ctx)
if err != nil {
return false, stack.Wrap(fmt.Errorf("store: wait channel thread message: %w", err))
}
Expand All @@ -292,9 +340,11 @@ func (s *Store) WaitChannelThreadMessage(ctx context.Context, customerID string,
// UnwaitChannelThreadMessage takes one waiting message back. False is one that is not waiting:
// the message that linked its thread took it first, or it was never kept.
func (s *Store) UnwaitChannelThreadMessage(ctx context.Context, customerID string, message core.InboundMessage) (bool, error) {
result, err := s.db.NewRaw(
"DELETE FROM channel_thread_waiting WHERE customer_id = ? AND connector_id = ? AND provider_unit_id = ? AND thread_key = ? AND provider_message_id = ?",
customerID, message.ConnectorID, message.ProviderUnitID, message.ThreadKey, message.ProviderMessageID).Exec(ctx)
result, err := s.db.NewDelete().Model((*waitingMessage)(nil)).
Where("customer_id = ? AND connector_id = ? AND provider_unit_id = ? AND thread_key = ?",
customerID, message.ConnectorID, message.ProviderUnitID, message.ThreadKey).
Where("provider_message_id = ?", message.ProviderMessageID).
Exec(ctx)
if err != nil {
return false, stack.Wrap(fmt.Errorf("store: unwait channel thread message: %w", err))
}
Expand All @@ -311,10 +361,12 @@ func (s *Store) UnwaitChannelThreadMessage(ctx context.Context, customerID strin
// (UnwaitChannelThreadMessage) gets it, or this does.
func takeWaitingChannelThreadMessages(ctx context.Context, db bun.IDB, customerID, connectorID, providerUnitID, threadKey string) ([]core.InboundMessage, error) {
var rows []waitingMessage
err := db.NewRaw(
"DELETE FROM channel_thread_waiting WHERE customer_id = ? AND connector_id = ? AND provider_unit_id = ? AND thread_key = ? AND created_at >= ? "+
"RETURNING connector_id, provider_unit_id, thread_key, provider_message_id, author_id, text, raw, created_at",
customerID, connectorID, providerUnitID, threadKey, time.Now().UTC().Add(-channelWaitingKeep)).Scan(ctx, &rows)
err := db.NewDelete().Model((*waitingMessage)(nil)).
Where("customer_id = ? AND connector_id = ? AND provider_unit_id = ? AND thread_key = ?",
customerID, connectorID, providerUnitID, threadKey).
Where("created_at >= ?", time.Now().UTC().Add(-channelWaitingKeep)).
Returning("connector_id, provider_unit_id, thread_key, provider_message_id, author_id, text, raw, created_at").
Scan(ctx, &rows)
if err != nil {
return nil, stack.Wrap(fmt.Errorf("store: take waiting channel thread messages: %w", err))
}
Expand Down Expand Up @@ -355,15 +407,15 @@ func claimChannelThreadMessage(ctx context.Context, db bun.IDB, channelID, kind,
return false, stack.Wrap(errors.New("store: a channel, a kind and a message id are required"))
}
now := time.Now().UTC()
if _, err := db.NewRaw(
"DELETE FROM channel_thread_messages WHERE channel_id = ? AND created_at < ?",
channelID, now.Add(-channelMessageKeep)).Exec(ctx); err != nil {
_, err := db.NewDelete().Model((*channelThreadMessage)(nil)).
Where("channel_id = ? AND created_at < ?", channelID, now.Add(-channelMessageKeep)).
Exec(ctx)
if err != nil {
return false, stack.Wrap(fmt.Errorf("store: claim channel thread message: %w", err))
}
result, err := db.NewRaw(
"INSERT INTO channel_thread_messages (channel_id, kind, message_id, created_at) "+
"VALUES (?, ?, ?, ?) ON CONFLICT DO NOTHING",
channelID, kind, messageID, now).Exec(ctx)
result, err := db.NewInsert().Model(&channelThreadMessage{ChannelID: channelID, Kind: kind, MessageID: messageID, CreatedAt: now}).
On("CONFLICT DO NOTHING").
Exec(ctx)
if err != nil {
return false, stack.Wrap(fmt.Errorf("store: claim channel thread message: %w", err))
}
Expand Down
15 changes: 15 additions & 0 deletions acceleration/internal/store/channel_threads_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -75,6 +75,21 @@ func (s *StoreSuite) TestAnotherThreadGetsAnotherChannel() {
s.True(created)
}

func (s *StoreSuite) TestTheFirstStarterOfAThreadIsTheOneKept() {
_, err := s.store.LinkChannelThread(s.ctx, thread("thread-one", "C0000CHAN:1"))
s.Require().NoError(err)
starter, err := s.store.ChannelThreadStarter(s.ctx, "thread-one")
s.Require().NoError(err)
s.Empty(starter, "nobody started it yet")

s.Require().NoError(s.store.SetChannelThreadStarter(s.ctx, "thread-one", "+15550100"))
s.Require().NoError(s.store.SetChannelThreadStarter(s.ctx, "thread-one", "+15550199"))

starter, err = s.store.ChannelThreadStarter(s.ctx, "thread-one")
s.Require().NoError(err)
s.Equal("+15550100", starter)
}

// One Slack workspace can install two customers' apps, so the same thread is two threads.
func (s *StoreSuite) TestTheSameThreadOfAnotherCustomerIsAThreadOfItsOwn() {
_, err := s.store.LinkChannelThread(s.ctx, thread("thread-one", "C0000CHAN:1"))
Expand Down
28 changes: 20 additions & 8 deletions acceleration/internal/store/channels.go
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,8 @@ import (
"fmt"
"time"

"github.com/uptrace/bun"

"github.com/GetStream/Vision-Agents/acceleration/internal/stack"
)

Expand Down Expand Up @@ -288,13 +290,21 @@ func (s *Store) ClaimChannelLink(ctx context.Context, customerID, code string) (
// ErrUnknownChannelLink is a code nobody was given, one already spent, or one past its time.
var ErrUnknownChannelLink = errors.New("store: there is no such code")

// channelDelivery is one message a line was delivered (ClaimChannelMessage).
type channelDelivery struct {
bun.BaseModel `bun:"table:channel_deliveries,alias:cdel"`

AccountID string `bun:"account_id,pk"`
MessageID string `bun:"message_id,pk"`
ReceivedAt time.Time `bun:"received_at,notnull"`
FromAddress string `bun:"from_address,notnull"`
}

// ClaimChannelMessage records a message as delivered, and who sent it. False is one
// already taken, which a provider retrying a slow delivery sends.
func (s *Store) ClaimChannelMessage(ctx context.Context, accountID, messageID, from string) (bool, error) {
result, err := s.db.NewRaw(
"INSERT INTO channel_deliveries (account_id, message_id, received_at, from_address) "+
"VALUES (?, ?, ?, ?) ON CONFLICT DO NOTHING",
accountID, messageID, time.Now().UTC(), from).Exec(ctx)
delivery := channelDelivery{AccountID: accountID, MessageID: messageID, ReceivedAt: time.Now().UTC(), FromAddress: from}
result, err := s.db.NewInsert().Model(&delivery).On("CONFLICT DO NOTHING").Exec(ctx)
if err != nil {
return false, fmt.Errorf("store: claim channel message: %w", err)
}
Expand All @@ -309,10 +319,12 @@ func (s *Store) ClaimChannelMessage(ctx context.Context, accountID, messageID, f
// they never have. WhatsApp's window for writing first is counted from it.
func (s *Store) LastChannelMessageAt(ctx context.Context, accountID, from string) (time.Time, error) {
var received time.Time
err := s.db.NewRaw(
"SELECT received_at FROM channel_deliveries "+
"WHERE account_id = ? AND from_address = ? ORDER BY received_at DESC LIMIT 1",
accountID, from).Scan(ctx, &received)
err := s.db.NewSelect().Model((*channelDelivery)(nil)).
Column("received_at").
Where("account_id = ? AND from_address = ?", accountID, from).
OrderExpr("received_at DESC").
Limit(1).
Scan(ctx, &received)
if errors.Is(err, sql.ErrNoRows) {
return time.Time{}, nil
}
Expand Down
29 changes: 21 additions & 8 deletions acceleration/internal/store/chat_channel_turns.go
Original file line number Diff line number Diff line change
Expand Up @@ -6,9 +6,21 @@ import (
"fmt"
"time"

"github.com/uptrace/bun"

"github.com/GetStream/Vision-Agents/acceleration/internal/stack"
)

// chatChannelTurn is the lease on a channel's running turn (TakeChatChannelTurn).
type chatChannelTurn struct {
bun.BaseModel `bun:"table:chat_channel_turns,alias:cht"`

StreamAppPK int64 `bun:"stream_app_pk,pk"`
CID string `bun:"cid,pk"`
TurnHolder string `bun:"turn_holder,notnull"`
TurnUntil time.Time `bun:"turn_until,notnull"`
}

// TakeChatChannelTurn leases the one running turn of the channel cid of the Stream app app, a
// channel of a type an agent config answers in, to holder until until, when no turn holds it
// or the one that did ran out. False is a turn another holder has, as TakeChannelThreadTurn
Expand All @@ -17,12 +29,12 @@ func (s *Store) TakeChatChannelTurn(ctx context.Context, app int64, cid, holder
if cid == "" || holder == "" {
return false, stack.Wrap(errors.New("store: a channel and a holder are required"))
}
result, err := s.db.NewRaw(
"INSERT INTO chat_channel_turns (stream_app_pk, cid, turn_holder, turn_until) VALUES (?, ?, ?, ?) "+
"ON CONFLICT (stream_app_pk, cid) DO UPDATE "+
"SET turn_holder = EXCLUDED.turn_holder, turn_until = EXCLUDED.turn_until "+
"WHERE chat_channel_turns.turn_until < now() OR chat_channel_turns.turn_holder = EXCLUDED.turn_holder",
app, cid, holder, until.UTC()).Exec(ctx)
result, err := s.db.NewInsert().Model(&chatChannelTurn{StreamAppPK: app, CID: cid, TurnHolder: holder, TurnUntil: until.UTC()}).
On("CONFLICT (stream_app_pk, cid) DO UPDATE").
Set("turn_holder = EXCLUDED.turn_holder").
Set("turn_until = EXCLUDED.turn_until").
Where("cht.turn_until < now() OR cht.turn_holder = EXCLUDED.turn_holder").
Exec(ctx)
if err != nil {
return false, stack.Wrap(fmt.Errorf("store: take chat channel turn: %w", err))
}
Expand All @@ -36,7 +48,8 @@ func (s *Store) TakeChatChannelTurn(ctx context.Context, app int64, cid, holder
// ReleaseChatChannelTurn ends holder's lease on a channel's turn, so the next turn need not
// wait for it to run out. A lease another holder took since is left alone.
func (s *Store) ReleaseChatChannelTurn(ctx context.Context, app int64, cid, holder string) error {
_, err := s.db.NewRaw("DELETE FROM chat_channel_turns WHERE stream_app_pk = ? AND cid = ? AND turn_holder = ?",
app, cid, holder).Exec(ctx)
_, err := s.db.NewDelete().Model((*chatChannelTurn)(nil)).
Where("stream_app_pk = ? AND cid = ? AND turn_holder = ?", app, cid, holder).
Exec(ctx)
return stack.Wrap(err)
}
16 changes: 12 additions & 4 deletions acceleration/internal/store/connection_events.go
Original file line number Diff line number Diff line change
Expand Up @@ -204,7 +204,7 @@ func (s *Store) claimConnectionEventSubscriptions(ctx context.Context, query str
// found is false when none is ever due: there are no subscriptions, or none expires.
func (s *Store) NextConnectionEventSubscriptionAt(ctx context.Context) (next time.Time, found bool, err error) {
var at sql.NullTime
if err := s.db.NewRaw("SELECT min(next_attempt_at) FROM connection_event_subscriptions").Scan(ctx, &at); err != nil {
if err := s.db.NewSelect().Model((*ConnectionEventSubscription)(nil)).ColumnExpr("min(next_attempt_at)").Scan(ctx, &at); err != nil {
return time.Time{}, false, stack.Wrap(fmt.Errorf("store: next connection event subscription: %w", err))
}
return at.Time, at.Valid, nil
Expand Down Expand Up @@ -245,12 +245,20 @@ func (s *Store) DeleteConnectionEventSubscriptions(ctx context.Context, customer
return nil
}

// connectionEventDelivery is one event a subscription got (ClaimConnectionEvent).
type connectionEventDelivery struct {
bun.BaseModel `bun:"table:connection_event_deliveries,alias:cevd"`

SubscriptionID string `bun:"subscription_id,pk"`
EventID string `bun:"event_id,pk"`
ReceivedAt time.Time `bun:"received_at,notnull"`
}

// ClaimConnectionEvent records that a subscription's event arrived, and reports whether this
// is the first time: a retried delivery of the same event id is not.
func (s *Store) ClaimConnectionEvent(ctx context.Context, subscriptionID, eventID string) (bool, error) {
result, err := s.db.NewRaw(
"INSERT INTO connection_event_deliveries (subscription_id, event_id, received_at) VALUES (?, ?, ?) ON CONFLICT DO NOTHING",
subscriptionID, eventID, time.Now().UTC()).Exec(ctx)
delivery := connectionEventDelivery{SubscriptionID: subscriptionID, EventID: eventID, ReceivedAt: time.Now().UTC()}
result, err := s.db.NewInsert().Model(&delivery).On("CONFLICT DO NOTHING").Exec(ctx)
if err != nil {
return false, stack.Wrap(fmt.Errorf("store: claim connection event: %w", err))
}
Expand Down
Loading
Loading