@pedrohnas/opencode-telegram 1.2.0 → 1.3.0

package/src/handlers/models.test.ts

@@ -0,0 +1,319 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test"
+import { SessionManager } from "../session-manager"
+import {
+  parseModelCallback,
+  filterModels,
+  formatProviderList,
+  formatModelList,
+  formatCurrentModel,
+  handleModel,
+  handleModelSelect,
+} from "./models"
+
+// --- parseModelCallback ---
+
+describe("parseModelCallback", () => {
+  test("parses provider callback", () => {
+    const result = parseModelCallback("mdl:anthropic")
+    expect(result).toEqual({ type: "provider", providerID: "anthropic" })
+  })
+
+  test("parses model callback with providerID:modelID", () => {
+    const result = parseModelCallback("mdl:anthropic:claude-sonnet-4-5-20250929")
+    expect(result).toEqual({
+      type: "model",
+      providerID: "anthropic",
+      modelID: "claude-sonnet-4-5-20250929",
+    })
+  })
+
+  test("parses back callback", () => {
+    expect(parseModelCallback("mdl:back")).toEqual({ type: "back" })
+  })
+
+  test("parses reset callback", () => {
+    expect(parseModelCallback("mdl:reset")).toEqual({ type: "reset" })
+  })
+
+  test("returns null for non-mdl prefix", () => {
+    expect(parseModelCallback("invalid")).toBeNull()
+  })
+
+  test("returns null for empty after prefix", () => {
+    expect(parseModelCallback("mdl:")).toBeNull()
+  })
+})
+
+// --- filterModels ---
+
+describe("filterModels", () => {
+  test("groups by family, returns most recent per family", () => {
+    const models = [
+      { id: "opus-4", name: "Opus 4", family: "opus", release_date: "2025-04-01" },
+      { id: "opus-4.5", name: "Opus 4.5", family: "opus", release_date: "2025-09-01" },
+      { id: "opus-4.6", name: "Opus 4.6", family: "opus", release_date: "2025-12-01" },
+      { id: "sonnet-4.5", name: "Sonnet 4.5", family: "sonnet", release_date: "2025-09-01" },
+    ]
+    const result = filterModels(models)
+    expect(result.length).toBe(2)
+    expect(result.find((m: any) => m.family === "opus").id).toBe("opus-4.6")
+    expect(result.find((m: any) => m.family === "sonnet").id).toBe("sonnet-4.5")
+  })
+
+  test("keeps models without family field (uses id as key)", () => {
+    const models = [
+      { id: "custom-model", name: "Custom" },
+      { id: "other-model", name: "Other" },
+    ]
+    const result = filterModels(models)
+    expect(result.length).toBe(2)
+  })
+
+  test("handles single model per family (no-op)", () => {
+    const models = [
+      { id: "sonnet-4.5", name: "Sonnet 4.5", family: "sonnet", release_date: "2025-09-01" },
+    ]
+    const result = filterModels(models)
+    expect(result.length).toBe(1)
+    expect(result[0].id).toBe("sonnet-4.5")
+  })
+
+  test("sorts result by release_date descending", () => {
+    const models = [
+      { id: "old", name: "Old", family: "a", release_date: "2024-01-01" },
+      { id: "new", name: "New", family: "b", release_date: "2025-12-01" },
+      { id: "mid", name: "Mid", family: "c", release_date: "2025-06-01" },
+    ]
+    const result = filterModels(models)
+    expect(result[0].id).toBe("new")
+    expect(result[1].id).toBe("mid")
+    expect(result[2].id).toBe("old")
+  })
+
+  test("handles empty array", () => {
+    expect(filterModels([])).toEqual([])
+  })
+})
+
+// --- formatProviderList ---
+
+describe("formatProviderList", () => {
+  test("formats 2 providers as inline keyboard rows with model count", () => {
+    const providers = [
+      { id: "anthropic", name: "Anthropic", models: { m1: {}, m2: {} } },
+      { id: "openai", name: "OpenAI", models: { m1: {} } },
+    ]
+    const result = formatProviderList(providers)
+    expect(result.reply_markup.inline_keyboard.length).toBe(2)
+    expect(result.reply_markup.inline_keyboard[0][0].text).toBe("Anthropic (2)")
+    expect(result.reply_markup.inline_keyboard[0][0].callback_data).toBe("mdl:anthropic")
+    expect(result.reply_markup.inline_keyboard[1][0].text).toBe("OpenAI (1)")
+  })
+
+  test("returns 'No providers' when list is empty", () => {
+    const result = formatProviderList([])
+    expect(result.text).toContain("No providers")
+    expect(result.reply_markup.inline_keyboard).toEqual([])
+  })
+
+  test("filters providers with 0 models", () => {
+    const providers = [
+      { id: "anthropic", name: "Anthropic", models: { m1: {} } },
+      { id: "empty", name: "Empty", models: {} },
+    ]
+    const result = formatProviderList(providers)
+    expect(result.reply_markup.inline_keyboard.length).toBe(1)
+    expect(result.reply_markup.inline_keyboard[0][0].text).toContain("Anthropic")
+  })
+
+  test("filters to only connected providers when connected array provided", () => {
+    const providers = [
+      { id: "anthropic", name: "Anthropic", models: { m1: {} } },
+      { id: "openai", name: "OpenAI", models: { m1: {} } },
+      { id: "google", name: "Google", models: { m1: {} } },
+    ]
+    const connected = ["anthropic", "google"]
+    const result = formatProviderList(providers, connected)
+    expect(result.reply_markup.inline_keyboard.length).toBe(2)
+    const texts = result.reply_markup.inline_keyboard.map((r: any) => r[0].callback_data)
+    expect(texts).toContain("mdl:anthropic")
+    expect(texts).toContain("mdl:google")
+    expect(texts).not.toContain("mdl:openai")
+  })
+
+  test("shows all providers when connected not provided (backward compat)", () => {
+    const providers = [
+      { id: "a", name: "A", models: { m1: {} } },
+      { id: "b", name: "B", models: { m1: {} } },
+    ]
+    const result = formatProviderList(providers)
+    expect(result.reply_markup.inline_keyboard.length).toBe(2)
+  })
+})
+
+// --- formatModelList ---
+
+describe("formatModelList", () => {
+  test("formats 3 models as rows + back button", () => {
+    const models = [
+      { id: "claude-sonnet", name: "Claude Sonnet" },
+      { id: "claude-opus", name: "Claude Opus" },
+      { id: "claude-haiku", name: "Claude Haiku" },
+    ]
+    const result = formatModelList("anthropic", "Anthropic", models)
+    // 3 model rows + 1 back row
+    expect(result.reply_markup.inline_keyboard.length).toBe(4)
+    expect(result.reply_markup.inline_keyboard[0][0].callback_data).toBe(
+      "mdl:anthropic:claude-sonnet",
+    )
+    // Last row is back button
+    const lastRow = result.reply_markup.inline_keyboard[3]
+    expect(lastRow[0].callback_data).toBe("mdl:back")
+  })
+
+  test("returns 'No models' with back button when empty", () => {
+    const result = formatModelList("anthropic", "Anthropic", [])
+    expect(result.text).toContain("No models")
+    // Still has back button
+    expect(result.reply_markup.inline_keyboard.length).toBe(1)
+    expect(result.reply_markup.inline_keyboard[0][0].callback_data).toBe("mdl:back")
+  })
+
+  test("callback_data includes providerID and modelID", () => {
+    const models = [{ id: "gpt-4o", name: "GPT-4o" }]
+    const result = formatModelList("openai", "OpenAI", models)
+    expect(result.reply_markup.inline_keyboard[0][0].callback_data).toBe("mdl:openai:gpt-4o")
+  })
+
+  test("marks active model with ✓ prefix", () => {
+    const models = [
+      { id: "claude-sonnet", name: "Claude Sonnet" },
+      { id: "claude-opus", name: "Claude Opus" },
+    ]
+    const result = formatModelList("anthropic", "Anthropic", models, "claude-opus")
+    expect(result.reply_markup.inline_keyboard[0][0].text).toBe("Claude Sonnet")
+    expect(result.reply_markup.inline_keyboard[1][0].text).toBe("✓ Claude Opus")
+  })
+
+  test("no ✓ when activeModelID not provided", () => {
+    const models = [
+      { id: "claude-sonnet", name: "Claude Sonnet" },
+      { id: "claude-opus", name: "Claude Opus" },
+    ]
+    const result = formatModelList("anthropic", "Anthropic", models)
+    expect(result.reply_markup.inline_keyboard[0][0].text).toBe("Claude Sonnet")
+    expect(result.reply_markup.inline_keyboard[1][0].text).toBe("Claude Opus")
+  })
+})
+
+// --- formatCurrentModel ---
+
+describe("formatCurrentModel", () => {
+  test("shows provider/model when override set", () => {
+    const result = formatCurrentModel({ providerID: "anthropic", modelID: "claude-opus" })
+    expect(result).toContain("anthropic")
+    expect(result).toContain("claude-opus")
+  })
+
+  test("shows default message when no override", () => {
+    const result = formatCurrentModel(undefined)
+    expect(result).toContain("default")
+  })
+})
+
+// --- handleModel ---
+
+describe("handleModel", () => {
+  let sm: SessionManager
+
+  beforeEach(() => {
+    sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+  })
+
+  test("fetches providers and returns keyboard", async () => {
+    const sdk = {
+      provider: {
+        list: mock(async () => ({
+          data: {
+            all: [
+              { id: "anthropic", name: "Anthropic", models: { m1: { id: "m1", name: "M1" } } },
+            ],
+            connected: ["anthropic"],
+          },
+        })),
+      },
+    }
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const result = await handleModel({ sdk: sdk as any, sessionManager: sm, chatKey: "123" })
+    expect(result.reply_markup.inline_keyboard.length).toBeGreaterThan(0)
+    expect(sdk.provider.list).toHaveBeenCalledTimes(1)
+  })
+
+  test("returns 'No providers' when list is empty", async () => {
+    const sdk = {
+      provider: {
+        list: mock(async () => ({ data: { all: [], connected: [] } })),
+      },
+    }
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const result = await handleModel({ sdk: sdk as any, sessionManager: sm, chatKey: "123" })
+    expect(result.text).toContain("No providers")
+  })
+
+  test("passes connected array to formatProviderList", async () => {
+    const sdk = {
+      provider: {
+        list: mock(async () => ({
+          data: {
+            all: [
+              { id: "anthropic", name: "Anthropic", models: { m1: { id: "m1", name: "M1" } } },
+              { id: "openai", name: "OpenAI", models: { m1: { id: "m1", name: "M1" } } },
+            ],
+            connected: ["anthropic"],
+          },
+        })),
+      },
+    }
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const result = await handleModel({ sdk: sdk as any, sessionManager: sm, chatKey: "123" })
+    // Only anthropic should be shown (connected)
+    expect(result.reply_markup.inline_keyboard.length).toBe(1)
+    expect(result.reply_markup.inline_keyboard[0][0].callback_data).toBe("mdl:anthropic")
+  })
+})
+
+// --- handleModelSelect ---
+
+describe("handleModelSelect", () => {
+  let sm: SessionManager
+
+  beforeEach(() => {
+    sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+  })
+
+  test("stores override in sessionManager", async () => {
+    const result = await handleModelSelect({
+      chatKey: "123",
+      providerID: "anthropic",
+      modelID: "claude-opus",
+      sessionManager: sm,
+    })
+    expect(sm.get("123")?.modelOverride).toEqual({
+      providerID: "anthropic",
+      modelID: "claude-opus",
+    })
+    expect(result).toContain("anthropic")
+    expect(result).toContain("claude-opus")
+  })
+
+  test("returns error when no active session", async () => {
+    const result = await handleModelSelect({
+      chatKey: "999",
+      providerID: "anthropic",
+      modelID: "claude-opus",
+      sessionManager: sm,
+    })
+    expect(result).toContain("No active session")
+  })
+})

package/src/handlers/models.ts

@@ -0,0 +1,191 @@
+/**
+ * Model selection handlers — provider list → model list → store override.
+ *
+ * Exports:
+ *   - parseModelCallback(data) — parse "mdl:" callback data
+ *   - filterModels(models) — group by family, keep most recent per family
+ *   - formatProviderList(providers, connected?) — inline keyboard of providers
+ *   - formatModelList(providerID, providerName, models, activeModelID?) — inline keyboard of models
+ *   - formatCurrentModel(override?) — text showing current selection
+ *   - handleModel(params) — fetch providers, return keyboard
+ *   - handleModelSelect(params) — store model override in SessionEntry
+ */
+
+import type { OpencodeClient } from "@opencode-ai/sdk/v2"
+import type { SessionManager } from "../session-manager"
+
+// --- Pure functions ---
+
+export type ModelCallbackResult =
+  | { type: "provider"; providerID: string }
+  | { type: "model"; providerID: string; modelID: string }
+  | { type: "back" }
+  | { type: "reset" }
+
+export function parseModelCallback(data: string): ModelCallbackResult | null {
+  if (!data.startsWith("mdl:")) return null
+  const rest = data.slice(4)
+  if (!rest) return null
+
+  if (rest === "back") return { type: "back" }
+  if (rest === "reset") return { type: "reset" }
+
+  // "providerID:modelID" or just "providerID"
+  const firstColon = rest.indexOf(":")
+  if (firstColon === -1) {
+    return { type: "provider", providerID: rest }
+  }
+
+  const providerID = rest.slice(0, firstColon)
+  const modelID = rest.slice(firstColon + 1)
+  if (!providerID || !modelID) return null
+
+  return { type: "model", providerID, modelID }
+}
+
+/**
+ * Filter models: group by family, keep only the most recent per family.
+ * Models without a family field use their id as key (no grouping).
+ */
+export function filterModels(models: any[]): any[] {
+  const families = new Map<string, any[]>()
+  for (const m of models) {
+    const key = m.family || m.id
+    if (!families.has(key)) families.set(key, [])
+    families.get(key)!.push(m)
+  }
+
+  const filtered: any[] = []
+  for (const [, members] of families) {
+    if (members.length === 1) {
+      filtered.push(members[0])
+    } else {
+      members.sort((a: any, b: any) =>
+        (b.release_date ?? "").localeCompare(a.release_date ?? ""),
+      )
+      filtered.push(members[0])
+    }
+  }
+
+  // Sort final list by release_date descending (newest first)
+  filtered.sort((a: any, b: any) =>
+    (b.release_date ?? "").localeCompare(a.release_date ?? ""),
+  )
+
+  return filtered
+}
+
+export function formatProviderList(
+  providers: any[],
+  connected?: string[],
+): {
+  text: string
+  reply_markup: { inline_keyboard: any[][] }
+} {
+  // If connected list provided, filter to only those providers
+  let filtered = providers
+  if (connected) {
+    const connSet = new Set(connected)
+    filtered = providers.filter((p) => connSet.has(p.id))
+  }
+
+  const withModels = filtered.filter(
+    (p) => p.models && Object.keys(p.models).length > 0,
+  )
+
+  if (withModels.length === 0) {
+    return { text: "No providers available.", reply_markup: { inline_keyboard: [] } }
+  }
+
+  const rows = withModels.map((p) => {
+    const modelCount = Object.keys(p.models).length
+    return [
+      { text: `${p.name || p.id} (${modelCount})`, callback_data: `mdl:${p.id}` },
+    ]
+  })
+
+  return {
+    text: "Select a provider:",
+    reply_markup: { inline_keyboard: rows },
+  }
+}
+
+export function formatModelList(
+  providerID: string,
+  providerName: string,
+  models: any[],
+  activeModelID?: string,
+): {
+  text: string
+  reply_markup: { inline_keyboard: any[][] }
+} {
+  const backRow = [{ text: "⬅ Back", callback_data: "mdl:back" }]
+
+  if (models.length === 0) {
+    return {
+      text: `No models available for ${providerName}.`,
+      reply_markup: { inline_keyboard: [backRow] },
+    }
+  }
+
+  const rows = models.map((m) => {
+    const prefix = activeModelID && m.id === activeModelID ? "✓ " : ""
+    return [
+      { text: `${prefix}${m.name || m.id}`, callback_data: `mdl:${providerID}:${m.id}` },
+    ]
+  })
+
+  rows.push(backRow)
+
+  return {
+    text: `Models for ${providerName}:`,
+    reply_markup: { inline_keyboard: rows },
+  }
+}
+
+export function formatCurrentModel(
+  override?: { providerID: string; modelID: string },
+): string {
+  if (!override) return "Using default model."
+  return `Current model: ${override.providerID}/${override.modelID}`
+}
+
+// --- Async handlers ---
+
+export async function handleModel(params: {
+  sdk: OpencodeClient
+  sessionManager: SessionManager
+  chatKey: string
+}): Promise<{ text: string; reply_markup: { inline_keyboard: any[][] } }> {
+  const { sdk, sessionManager, chatKey } = params
+  const result = await sdk.provider.list()
+  const data = (result as any).data ?? {}
+  const providers = data.all ?? []
+  const connected = data.connected as string[] | undefined
+  const entry = sessionManager.get(chatKey)
+  const currentText = formatCurrentModel(entry?.modelOverride)
+  const list = formatProviderList(providers, connected)
+
+  return {
+    text: `${currentText}\n\n${list.text}`,
+    reply_markup: list.reply_markup,
+  }
+}
+
+export async function handleModelSelect(params: {
+  chatKey: string
+  providerID: string
+  modelID: string
+  sessionManager: SessionManager
+}): Promise<string> {
+  const { chatKey, providerID, modelID, sessionManager } = params
+  const entry = sessionManager.get(chatKey)
+  if (!entry) return "No active session."
+
+  sessionManager.set(chatKey, {
+    ...entry,
+    modelOverride: { providerID, modelID },
+  })
+
+  return `Model set to: ${providerID}/${modelID}`
+}

package/src/index.ts

@@ -15,6 +15,8 @@ import { SessionManager } from "./session-manager"
 import { TurnManager } from "./turn-manager"
 import { EventBus } from "./event-bus"
 import { PendingRequests } from "./pending-requests"
+import { apiThrottler } from "@grammyjs/transformer-throttler"
+import { createApiServer } from "./api-server"
 import { markdownToTelegramHtml } from "./send/format"
 import { chunkMessage } from "./send/chunker"
 import { formatPermissionMessage } from "./handlers/permissions"
@@ -63,6 +65,16 @@ try {
 // --- Create bot with deps ---
 const bot = createBot(config, { sdk, sessionManager, turnManager, pendingRequests })
 
+// API throttler — automatic 429 rate limit handling for Telegram API
+bot.api.config.use(apiThrottler() as any)
+
+// --- Bot Control API server ---
+const apiServer = createApiServer(
+  { sessionManager, turnManager, sdk },
+  config.apiPort,
+)
+console.log(`Bot Control API on http://127.0.0.1:${config.apiPort}`)
+
 // --- Response sender (format + chunk + send) ---
 async function sendFormattedResponse(chatId: number, markdown: string) {
   const html = markdownToTelegramHtml(markdown)
@@ -249,6 +261,7 @@ const shutdown = async () => {
   clearInterval(cleanupInterval)
   eventBus.stop()
   turnManager.abortAll()
+  apiServer.stop()
   await bot.stop()
   sdkHandle.cleanup()
   process.exit(0)
@@ -269,6 +282,8 @@ try {
     { command: "info", description: "Session info" },
     { command: "history", description: "Recent messages" },
     { command: "summarize", description: "Summarize session" },
+    { command: "model", description: "Select model" },
+    { command: "agent", description: "Select agent" },
   ])
   console.log("Command menu registered")
 } catch (err) {

package/src/send/draft-stream.test.ts

@@ -226,4 +226,80 @@ describe("DraftStream", () => {
     const ds = new DraftStream(deps, 123, ac.signal)
     expect(ds.isStopped()).toBe(true)
   })
+
+  // --- Race condition: concurrent updates before first sendMessage resolves ---
+
+  test("concurrent updates while first sendMessage is in-flight only send once", async () => {
+    // Simulate a slow sendMessage (e.g., network latency)
+    let resolveFirst: ((v: { message_id: number }) => void) | null = null
+    deps.sendMessage = mock(
+      () => new Promise<{ message_id: number }>((resolve) => { resolveFirst = resolve }),
+    )
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+
+    // Fire multiple concurrent updates — all see messageId === null
+    const p1 = ds.update("v1")
+    const p2 = ds.update("v2")
+    const p3 = ds.update("v3")
+
+    // Only ONE sendMessage call should have been made (the first)
+    expect(deps.sendMessage).toHaveBeenCalledTimes(1)
+
+    // Resolve the first sendMessage
+    resolveFirst!({ message_id: 42 })
+    await p1
+    await p2
+    await p3
+
+    // Still only one sendMessage call
+    expect(deps.sendMessage).toHaveBeenCalledTimes(1)
+    expect(ds.getMessageId()).toBe(42)
+
+    // The pending text "v3" differs from initial — a flush should be scheduled
+    await sleep(100)
+    expect(deps.editMessageText).toHaveBeenCalledTimes(1)
+    ac.abort()
+  })
+
+  test("concurrent updates during send store latest pending text", async () => {
+    let resolveFirst: ((v: { message_id: number }) => void) | null = null
+    deps.sendMessage = mock(
+      () => new Promise<{ message_id: number }>((resolve) => { resolveFirst = resolve }),
+    )
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+
+    // Start first update (goes into sending state)
+    const p1 = ds.update("first")
+    // These arrive while sending — should just update pending
+    ds.update("second")
+    ds.update("final text")
+
+    resolveFirst!({ message_id: 99 })
+    await p1
+
+    // After flush, the edit should contain "final text"
+    await sleep(100)
+    const editedText = deps.editMessageText.mock.calls[0]?.[2] as string
+    expect(editedText).toContain("final text")
+    ac.abort()
+  })
+
+  test("if sendMessage fails during race, subsequent updates retry send", async () => {
+    let callCount = 0
+    deps.sendMessage = mock(async () => {
+      callCount++
+      if (callCount === 1) throw new Error("network error")
+      return { message_id: 55 }
+    })
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+
+    // First update fails
+    await ds.update("attempt1")
+    expect(ds.getMessageId()).toBeNull()
+
+    // Second update should retry (sending flag is cleared after failure)
+    await ds.update("attempt2")
+    expect(ds.getMessageId()).toBe(55)
+    ac.abort()
+  })
 })

package/src/send/draft-stream.ts

@@ -34,6 +34,7 @@ export class DraftStream {
   private pending = ""
   private timer: ReturnType<typeof setTimeout> | null = null
   private stopped = false
+  private sending = false
   private flushing = false
   private _htmlFailed = false
   readonly throttleMs: number
@@ -57,8 +58,13 @@ export class DraftStream {
     if (this.stopped || !text.trim()) return
     this.pending = text
 
+    // Guard: if already sending the initial message, just store pending and return.
+    // This prevents concurrent sendMessage calls when multiple SSE events arrive
+    // before the first sendMessage resolves (race condition with fast models).
+    if (this.sending) return
+
     if (this.messageId === null) {
-      // First update — send initial message
+      this.sending = true
       const truncated = text.slice(0, 4096)
       try {
         const html = markdownToTelegramHtml(truncated)
@@ -71,6 +77,12 @@ export class DraftStream {
       } catch {
         // sendMessage failed — messageId stays null
       }
+      this.sending = false
+
+      // If pending changed while we were sending, schedule a flush
+      if (this.messageId !== null && this.pending.slice(0, 4096) !== this.lastText) {
+        this.scheduleFlush()
+      }
       return
     }