5e699ec fix: preserve bot reply anchors and status state · zut

M packages/agent/botcmd.go +2 -1


@@ -384,6 +384,7 @@ func botRun(rawTail []string, version string) error {
384	384		runner = bot.NewRunner(adapter, agent, bot.Config{
385	385		ZotHome: ZotHome(),
386	386		Provider: resolved.Provider,
	387	+	Model: resolved.Model,
387	388		AuthMethod: resolved.AuthMethod,
388	389		CWD: args.CWD,
389	390		RefreshCreds: func() error {

@@ -397,7 +398,7 @@ func botRun(rawTail []string, version string) error {
397	398		}
398	399		agent.Client = next.NewClient()
399	400		agent.Model = next.Model
400		-	runner.UpdateRuntimeConfig(next.Provider, next.AuthMethod, next.CWD)
	401	+	runner.UpdateRuntimeConfig(next.Provider, next.Model, next.AuthMethod, next.CWD)
401	402		return nil
402	403		},
403	404		})

 	runner = bot.NewRunner(adapter, agent, bot.Config{
 		ZotHome:    ZotHome(),
 		Provider:   resolved.Provider,
+		Model:      resolved.Model,
 		AuthMethod: resolved.AuthMethod,
 		CWD:        args.CWD,
 		RefreshCreds: func() error {
 			}
 			agent.Client = next.NewClient()
 			agent.Model = next.Model
-			runner.UpdateRuntimeConfig(next.Provider, next.AuthMethod, next.CWD)
+			runner.UpdateRuntimeConfig(next.Provider, next.Model, next.AuthMethod, next.CWD)
 			return nil
 		},
 	})

M packages/agent/modes/bot/adapter.go +7 -1


@@ -28,6 +28,12 @@ const (
28	28		CmdStop // cancel the active turn
29	29		)
30	30
	31	+	// SendOptions carries protocol-agnostic delivery hints for outbound messages.
	32	+	type SendOptions struct {
	33	+	// ReplyToMessageID is an optional adapter-owned message identifier to anchor replies.
	34	+	ReplyToMessageID string
	35	+	}
	36	+
31	37		// BotAdapter is the transport layer a concrete protocol must implement.
32	38		// The Runner calls these methods; it never touches protocol types directly.
33	39		type BotAdapter interface {

@@ -39,7 +45,7 @@ type BotAdapter interface {
39	45		) error
40	46
41	47		// Send delivers a reply. The adapter chunks to protocol limits.
42		-	Send(ctx context.Context, channelID, text string) error
	48	+	Send(ctx context.Context, channelID, text string, opts SendOptions) error
43	49
44	50		// IndicateWorking fires a "typing…" signal; returns a stop func.
45	51		// Return a no-op if the protocol doesn't support it.

 	CmdStop                  // cancel the active turn
 )
+// SendOptions carries protocol-agnostic delivery hints for outbound messages.
+type SendOptions struct {
+	// ReplyToMessageID is an optional adapter-owned message identifier to anchor replies.
+	ReplyToMessageID string
+}
 // BotAdapter is the transport layer a concrete protocol must implement.
 // The Runner calls these methods; it never touches protocol types directly.
 type BotAdapter interface {
 	) error
 	// Send delivers a reply.  The adapter chunks to protocol limits.
-	Send(ctx context.Context, channelID, text string) error
+	Send(ctx context.Context, channelID, text string, opts SendOptions) error
 	// IndicateWorking fires a "typing…" signal; returns a stop func.
 	// Return a no-op if the protocol doesn't support it.

M packages/agent/modes/bot/runner.go +14 -10


@@ -19,6 +19,7 @@ var stderr = func() io.Writer { return os.Stderr }
19	19		type Config struct {
20	20		ZotHome string
21	21		Provider string
	22	+	Model string
22	23		AuthMethod string
23	24		CWD string
24	25		RefreshCreds func() error

@@ -57,12 +58,13 @@ func NewRunner(adapter BotAdapter, agent core.Agent, cfg Config) Runner {
57	58		}
58	59		}
59	60
60		-	// UpdateRuntimeConfig updates provider/auth/cwd at runtime (e.g. after
	61	+	// UpdateRuntimeConfig updates provider/model/auth/cwd at runtime (e.g. after
61	62		// credential refresh). This is thread-safe.
62		-	func (r *Runner) UpdateRuntimeConfig(provider, authMethod, cwd string) {
	63	+	func (r *Runner) UpdateRuntimeConfig(provider, model, authMethod, cwd string) {
63	64		r.mu.Lock()
64	65		defer r.mu.Unlock()
65	66		r.cfg.Provider = provider
	67	+	r.cfg.Model = model
66	68		r.cfg.AuthMethod = authMethod
67	69		r.cfg.CWD = cwd
68	70		}

@@ -105,9 +107,10 @@ func (r *Runner) handleCommand(cmd Command, msg InboundMessage) {
105	107		switch cmd {
106	108		case CmdStart, CmdHelp:
107	109		_ = r.adapter.Send(context.Background(), msg.ChannelID,
108		-	"send me any message and i'll forward it to zot. attach an image and i'll pass it to the model. commands: /status, /stop, or plain stop.")
	110	+	"send me any message and i'll forward it to zot. attach an image and i'll pass it to the model. commands: /status, /stop, or plain stop.",
	111	+	SendOptions{ReplyToMessageID: msg.MessageID})
109	112		case CmdStatus:
110		-	r.sendStatus(msg.ChannelID)
	113	+	r.sendStatus(msg.ChannelID, msg.MessageID)
111	114		case CmdStop:
112	115		r.cancelActiveTurn(msg.ChannelID, msg.MessageID)
113	116		}

@@ -199,7 +202,7 @@ func (r *Runner) runTurn(ctx context.Context, t queuedTurn) {
199	202		}
200	203
201	204		// Adapter.Send is responsible for chunking to protocol limits.
202		-	if err := r.adapter.Send(context.Background(), t.channelID, reply); err != nil {
	205	+	if err := r.adapter.Send(context.Background(), t.channelID, reply, SendOptions{}); err != nil {
203	206		fmt.Fprintln(stderr(), "bot: send reply:", err)
204	207		}
205	208		}

@@ -209,26 +212,27 @@ func (r *Runner) cancelActiveTurn(channelID, messageID string) {
209	212		r.mu.Lock()
210	213		cancel := r.activeCtx
211	214		r.mu.Unlock()
	215	+	opts := SendOptions{ReplyToMessageID: messageID}
212	216		if cancel != nil {
213	217		cancel()
214		-	_ = r.adapter.Send(context.Background(), channelID, "cancelled the current turn.")
	218	+	_ = r.adapter.Send(context.Background(), channelID, "cancelled the current turn.", opts)
215	219		} else {
216		-	_ = r.adapter.Send(context.Background(), channelID, "nothing running.")
	220	+	_ = r.adapter.Send(context.Background(), channelID, "nothing running.", opts)
217	221		}
218	222		}
219	223
220	224		// sendStatus describes agent state to the user.
221		-	func (r *Runner) sendStatus(channelID string) {
	225	+	func (r *Runner) sendStatus(channelID, messageID string) {
222	226		r.mu.Lock()
223	227		busy := r.busy
224	228		queued := len(r.queue)
225	229		ctxUsed := r.lastCtxInput
226	230		providerName := r.cfg.Provider
	231	+	model := r.cfg.Model
227	232		authMethod := r.cfg.AuthMethod
228	233		cwd := r.cfg.CWD
229	234		r.mu.Unlock()
230	235
231		-	model := r.agent.Model
232	236		ctxMax := 0
233	237		if m, err := provider.FindModel(providerName, model); err == nil {
234	238		ctxMax = m.ContextWindow

@@ -250,5 +254,5 @@ func (r *Runner) sendStatus(channelID string) {
250	254		status += "\n" + extra
251	255		}
252	256
253		-	_ = r.adapter.Send(context.Background(), channelID, status)
	257	+	_ = r.adapter.Send(context.Background(), channelID, status, SendOptions{ReplyToMessageID: messageID})
254	258		}

 type Config struct {
 	ZotHome      string
 	Provider     string
+	Model        string
 	AuthMethod   string
 	CWD          string
 	RefreshCreds func() error
 	}
 }
-// UpdateRuntimeConfig updates provider/auth/cwd at runtime (e.g. after
+// UpdateRuntimeConfig updates provider/model/auth/cwd at runtime (e.g. after
 // credential refresh).  This is thread-safe.
-func (r *Runner) UpdateRuntimeConfig(provider, authMethod, cwd string) {
+func (r *Runner) UpdateRuntimeConfig(provider, model, authMethod, cwd string) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	r.cfg.Provider = provider
+	r.cfg.Model = model
 	r.cfg.AuthMethod = authMethod
 	r.cfg.CWD = cwd
 }
 	switch cmd {
 	case CmdStart, CmdHelp:
 		_ = r.adapter.Send(context.Background(), msg.ChannelID,
-			"send me any message and i'll forward it to zot. attach an image and i'll pass it to the model. commands: /status, /stop, or plain stop.")
+			"send me any message and i'll forward it to zot. attach an image and i'll pass it to the model. commands: /status, /stop, or plain stop.",
+			SendOptions{ReplyToMessageID: msg.MessageID})
 	case CmdStatus:
-		r.sendStatus(msg.ChannelID)
+		r.sendStatus(msg.ChannelID, msg.MessageID)
 	case CmdStop:
 		r.cancelActiveTurn(msg.ChannelID, msg.MessageID)
 	}
 	}
 	// Adapter.Send is responsible for chunking to protocol limits.
-	if err := r.adapter.Send(context.Background(), t.channelID, reply); err != nil {
+	if err := r.adapter.Send(context.Background(), t.channelID, reply, SendOptions{}); err != nil {
 		fmt.Fprintln(stderr(), "bot: send reply:", err)
 	}
 }
 	r.mu.Lock()
 	cancel := r.activeCtx
 	r.mu.Unlock()
+	opts := SendOptions{ReplyToMessageID: messageID}
 	if cancel != nil {
 		cancel()
-		_ = r.adapter.Send(context.Background(), channelID, "cancelled the current turn.")
+		_ = r.adapter.Send(context.Background(), channelID, "cancelled the current turn.", opts)
 	} else {
-		_ = r.adapter.Send(context.Background(), channelID, "nothing running.")
+		_ = r.adapter.Send(context.Background(), channelID, "nothing running.", opts)
 	}
 }
 // sendStatus describes agent state to the user.
-func (r *Runner) sendStatus(channelID string) {
+func (r *Runner) sendStatus(channelID, messageID string) {
 	r.mu.Lock()
 	busy := r.busy
 	queued := len(r.queue)
 	ctxUsed := r.lastCtxInput
 	providerName := r.cfg.Provider
+	model := r.cfg.Model
 	authMethod := r.cfg.AuthMethod
 	cwd := r.cfg.CWD
 	r.mu.Unlock()
-	model := r.agent.Model
 	ctxMax := 0
 	if m, err := provider.FindModel(providerName, model); err == nil {
 		ctxMax = m.ContextWindow
 		status += "\n" + extra
 	}
-	_ = r.adapter.Send(context.Background(), channelID, status)
+	_ = r.adapter.Send(context.Background(), channelID, status, SendOptions{ReplyToMessageID: messageID})
 }

M packages/agent/modes/bot/runner_test.go +3 -1


@@ -15,7 +15,9 @@ type testAdapter struct{}
15	15		func (testAdapter) Run(context.Context, func(InboundMessage), func(Command, InboundMessage)) error {
16	16		return nil
17	17		}
18		-	func (testAdapter) Send(context.Context, string, string) error { return nil }
	18	+	func (testAdapter) Send(context.Context, string, string, SendOptions) error {
	19	+	return nil
	20	+	}
19	21		func (testAdapter) IndicateWorking(context.Context, string) func() { return func() {} }
20	22		func (testAdapter) StatusText() string { return "" }
21	23

 func (testAdapter) Run(context.Context, func(InboundMessage), func(Command, InboundMessage)) error {
 	return nil
 }
-func (testAdapter) Send(context.Context, string, string) error     { return nil }
+func (testAdapter) Send(context.Context, string, string, SendOptions) error {
+	return nil
+}
 func (testAdapter) IndicateWorking(context.Context, string) func() { return func() {} }
 func (testAdapter) StatusText() string                             { return "" }

M packages/agent/modes/telegram/adapter.go +10 -2


@@ -191,15 +191,23 @@ func (a *Adapter) handleUpdate(ctx context.Context, u Update,
191	191
192	192		// Send delivers a reply to a Telegram chat. channelID is parsed back
193	193		// to int64. Messages are chunked to 4000 runes (Telegram limit 4096).
194		-	func (a *Adapter) Send(ctx context.Context, channelID, text string) error {
	194	+	func (a *Adapter) Send(ctx context.Context, channelID, text string, opts bot.SendOptions) error {
195	195		chatID, err := strconv.ParseInt(channelID, 10, 64)
196	196		if err != nil {
197	197		return fmt.Errorf("invalid channelID %q: %w", channelID, err)
198	198		}
	199	+	replyTo := 0
	200	+	if opts.ReplyToMessageID != "" {
	201	+	if n, err := strconv.Atoi(opts.ReplyToMessageID); err == nil {
	202	+	replyTo = n
	203	+	}
	204	+	}
199	205		for _, chunk := range chunkMessage(text, 4000) {
200		-	if err := a.Client.SendMessage(ctx, chatID, chunk, 0); err != nil {
	206	+	if err := a.Client.SendMessage(ctx, chatID, chunk, replyTo); err != nil {
201	207		return err
202	208		}
	209	+	// Only the first chunk should be threaded under the original message.
	210	+	replyTo = 0
203	211		}
204	212		return nil
205	213		}

 // Send delivers a reply to a Telegram chat.  channelID is parsed back
 // to int64.  Messages are chunked to 4000 runes (Telegram limit 4096).
-func (a *Adapter) Send(ctx context.Context, channelID, text string) error {
+func (a *Adapter) Send(ctx context.Context, channelID, text string, opts bot.SendOptions) error {
 	chatID, err := strconv.ParseInt(channelID, 10, 64)
 	if err != nil {
 		return fmt.Errorf("invalid channelID %q: %w", channelID, err)
 	}
+	replyTo := 0
+	if opts.ReplyToMessageID != "" {
+		if n, err := strconv.Atoi(opts.ReplyToMessageID); err == nil {
+			replyTo = n
+		}
+	}
 	for _, chunk := range chunkMessage(text, 4000) {
-		if err := a.Client.SendMessage(ctx, chatID, chunk, 0); err != nil {
+		if err := a.Client.SendMessage(ctx, chatID, chunk, replyTo); err != nil {
 			return err
 		}
+		// Only the first chunk should be threaded under the original message.
+		replyTo = 0
 	}
 	return nil
 }