chat

type ChatSink ¶ added in v0.16.0

type ChatSink interface {
	// PostComment posts a final-form message (Slack: regular comment,
	// Web: session_message type=response). Used by the chat pipeline
	// for planner messages, final responses, and warnings-as-comments.
	PostComment(ctx context.Context, text string) error

	// PostContextBlock posts an ephemeral status line (Slack: context
	// block, Web: session_message type=trace). Used for "Investigating",
	// reflection completion, etc.
	PostContextBlock(ctx context.Context, text string) error

	// PostSectionBlock posts a prominent block (Slack: section block,
	// Web: session_message type=response). Used for per-task completion
	// summaries.
	PostSectionBlock(ctx context.Context, text string) error

	// PostDivider posts a visual separator (Slack: divider block,
	// Web: session_message type=trace with a divider marker).
	PostDivider(ctx context.Context) error

	// NewUpdatableMessage returns a closure that updates a single
	// message in-place. The initial text is posted immediately.
	// Used by msg.Trace routing for the Slack updatable trace block
	// and by Web for a collapsible progress entry.
	NewUpdatableMessage(ctx context.Context, initial string) func(ctx context.Context, text string)
}

ChatSink is the narrow output surface aster/bluebell use to emit non-HITL progress to the user. Implementations route calls to the appropriate transport for the active Session.Source:

• Slack: interfaces.SlackThreadService already satisfies ChatSink via structural typing; no wrapper is needed.
• Web: persists each call as a session.Message and publishes the matching WebSocket Envelope so the Conversation UI receives it.
• CLI: routes through the legacy msg.Notify / msg.Trace handlers already installed on the context, so stdout display is preserved.

The design is deliberately transport-agnostic: Slack-specific block structures never cross this boundary. HITL rendering lives in QuestionTarget / ApprovalTarget below and their transport-specific Presenter implementations, not here.

func ResolveSink(chatCtx *chatModel.ChatContext, slackSvc *slackService.Service, repo interfaces.Repository) ChatSink

type MessageBound ¶ added in v0.16.0

type MessageBound interface {
	ProgressMessageID() string
}

MessageBound is an optional interface that ProgressHandle impls may satisfy to report the underlying SessionMessage ID backing the display row. Used by the WebSocket handler to bind a HITL prompt to an existing progress message so the UI can render approval UI in place. Slack / CLI impls return "".

type Option ¶ added in v0.15.0

type Option func(*UseCase)

Option configures a UseCase.

func WithFrontendURL(url string) Option

func WithNoAuthorization(noAuthz bool) Option

func WithPolicyClient(pc interfaces.PolicyClient) Option

func WithRepository(repo interfaces.Repository) Option

func WithSlackService(svc *slackService.Service) Option

type ProgressHandle ¶ added in v0.16.0

type ProgressHandle interface {
	// UpdateText replaces the display row with plain text.
	UpdateText(ctx context.Context, text string)

	// PresentHITL renders a HITL request on this handle.
	// taskTitle/userID are passed through for transport-specific
	// labelling (Slack includes them in block headers).
	PresentHITL(ctx context.Context, req *hitl.Request, taskTitle, userID string) error
}

ProgressHandle is a single live-updating display row attached to a task (aster/bluebell setupTaskMessageRouting). It is the unified surface for:

• Progress text updates during task execution.
• In-place HITL prompts (tool approval / question) that replace the progress display with interactive UI, then yield it back to progress once the user has responded.

Transport-specific layouts are chosen inside each implementation: Slack builds []slack.Block via BuildToolApprovalBlocks and calls UpdatableBlockMessage.UpdateBlocks; Web emits a `hitl_request_pending` envelope; CLI blocks execution (default-deny).

func NewProgressHandle(ctx context.Context, chatCtx *chatModel.ChatContext, slackSvc *slackService.Service, repo interfaces.Repository, initialText string) ProgressHandle

type RunContext ¶ added in v0.15.0

type RunContext struct {
	Session *session.Session
	Message string
	ChatCtx *chatModel.ChatContext
}

RunContext holds all the pre-initialized resources that UseCase passes to a Strategy after completing common setup.

type Strategy ¶ added in v0.15.0

type Strategy interface {
	Execute(ctx context.Context, rc *RunContext) error
}

Strategy defines the interface for chat execution strategies. Implementations receive a RunContext with a pre-initialized Warren session (session created, message routing configured, authorization verified). The strategy is responsible for its own gollem LLM session management and execution workflow (planning, task execution, replanning, etc.).

type UseCase ¶ added in v0.15.0

type UseCase struct {
	// contains filtered or unexported fields
}

UseCase implements interfaces.ChatUseCase by performing common setup (Warren session management, message routing, authorization) and delegating strategy-specific execution to a Strategy implementation.

func NewUseCase(strategy Strategy, opts ...Option) *UseCase

func (u *UseCase) Execute(ctx context.Context, message string, chatCtx chatModel.ChatContext) error