@pedrohnas/opencode-telegram 1.2.0 → 1.3.0

package/src/bot.test.ts

@@ -39,6 +39,32 @@ describe("START_MESSAGE", () => {
   })
 })
 
+// --- Phase 6.5: sequentialize middleware ---
+
+describe("sequentialize middleware", () => {
+  test("bot with sequentialize still creates successfully", () => {
+    const bot = createBot(testConfig)
+    expect(bot).toBeDefined()
+    // sequentialize is first middleware — bot should have more handlers than without it
+  })
+
+  test("sequentialize import is valid", async () => {
+    const { sequentialize } = await import("@grammyjs/runner")
+    expect(sequentialize).toBeFunction()
+    // Verify key function works
+    const resolver = (ctx: any) => String(ctx.chat?.id ?? "")
+    expect(resolver({ chat: { id: 123 } })).toBe("123")
+    expect(resolver({})).toBe("")
+  })
+
+  test("apiThrottler import is valid", async () => {
+    const { apiThrottler } = await import("@grammyjs/transformer-throttler")
+    expect(apiThrottler).toBeFunction()
+    const throttler = apiThrottler()
+    expect(throttler).toBeFunction()
+  })
+})
+
 // --- Phase 1 tests: handleMessage and handleNew ---
 
 describe("handleMessage", () => {
@@ -178,6 +204,66 @@ describe("handleNew", () => {
     expect(sm.get("456")!.sessionId).toBe("fresh-session")
     expect(result.sessionId).toBe("fresh-session")
   })
+
+  test("preserves model/agent overrides across /new", async () => {
+    const { handleNew } = await import("./bot")
+    const createMock = mock(async () => ({
+      data: { id: "new-session-2", directory: "/tmp" },
+    }))
+
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    sm.set("123", {
+      sessionId: "old-session",
+      directory: "/tmp",
+      modelOverride: { providerID: "google", modelID: "gemini-flash" },
+      agentOverride: "code",
+    })
+
+    const sdk = {
+      session: { create: createMock },
+    } as any
+
+    await handleNew({ chatId: 123, sdk, sessionManager: sm })
+
+    const entry = sm.get("123")!
+    expect(entry.sessionId).toBe("new-session-2")
+    expect(entry.modelOverride).toEqual({ providerID: "google", modelID: "gemini-flash" })
+    expect(entry.agentOverride).toBe("code")
+  })
+})
+
+describe("handleSessionCallback — override preservation", () => {
+  test("preserves model/agent overrides when switching session", async () => {
+    const { handleSessionCallback } = await import("./bot")
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    sm.set("123", {
+      sessionId: "old-session",
+      directory: "/tmp",
+      modelOverride: { providerID: "anthropic", modelID: "claude-opus" },
+      agentOverride: "build",
+    })
+
+    const sdk = {
+      session: {
+        list: mock(async () => ({
+          data: [{ id: "target-session-full", title: "Target", directory: "/proj" }],
+        })),
+      },
+    } as any
+
+    const result = await handleSessionCallback({
+      chatKey: "123",
+      sessionPrefix: "target-session",
+      sdk,
+      sessionManager: sm,
+    })
+
+    expect(result).toContain("Switched to")
+    const entry = sm.get("123")!
+    expect(entry.sessionId).toBe("target-session-full")
+    expect(entry.modelOverride).toEqual({ providerID: "anthropic", modelID: "claude-opus" })
+    expect(entry.agentOverride).toBe("build")
+  })
 })
 
 // --- Phase 4 tests: handleMessage abort, session commands ---
@@ -299,3 +385,271 @@ describe("handleSessionCallback", () => {
     expect(result).toBe("Session not found.")
   })
 })
+
+// --- Phase 5: model/agent override passing ---
+
+describe("handleMessage — model/agent overrides", () => {
+  test("passes modelOverride to sdk.session.prompt when set", async () => {
+    const { handleMessage } = await import("./bot")
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", {
+      sessionId: "s1",
+      directory: "/tmp",
+      modelOverride: { providerID: "anthropic", modelID: "claude-opus" },
+    })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: mock(async () => ({})),
+      },
+    } as any
+
+    await handleMessage({
+      chatId: 123,
+      text: "hello",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+    const call = promptMock.mock.calls[0]![0] as any
+    expect(call.model).toEqual({ providerID: "anthropic", modelID: "claude-opus" })
+  })
+
+  test("passes agentOverride to sdk.session.prompt when set", async () => {
+    const { handleMessage } = await import("./bot")
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", {
+      sessionId: "s1",
+      directory: "/tmp",
+      agentOverride: "code",
+    })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: mock(async () => ({})),
+      },
+    } as any
+
+    await handleMessage({
+      chatId: 123,
+      text: "hello",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+    const call = promptMock.mock.calls[0]![0] as any
+    expect(call.agent).toBe("code")
+  })
+
+  test("does NOT pass model/agent when overrides not set", async () => {
+    const { handleMessage } = await import("./bot")
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: mock(async () => ({})),
+      },
+    } as any
+
+    await handleMessage({
+      chatId: 123,
+      text: "hello",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+    const call = promptMock.mock.calls[0]![0] as any
+    expect(call.model).toBeUndefined()
+    expect(call.agent).toBeUndefined()
+  })
+
+  test("passes both overrides simultaneously", async () => {
+    const { handleMessage } = await import("./bot")
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", {
+      sessionId: "s1",
+      directory: "/tmp",
+      modelOverride: { providerID: "openai", modelID: "gpt-4o" },
+      agentOverride: "build",
+    })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: mock(async () => ({})),
+      },
+    } as any
+
+    await handleMessage({
+      chatId: 123,
+      text: "hello",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+    const call = promptMock.mock.calls[0]![0] as any
+    expect(call.model).toEqual({ providerID: "openai", modelID: "gpt-4o" })
+    expect(call.agent).toBe("build")
+  })
+})
+
+// --- Phase 6: media parts passthrough ---
+
+describe("handleMessage — media parts", () => {
+  test("uses explicit parts array when provided", async () => {
+    const { handleMessage } = await import("./bot")
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: mock(async () => ({})),
+      },
+    } as any
+
+    const customParts = [
+      { type: "text" as const, text: "What is this?" },
+      { type: "file" as const, mime: "image/jpeg", url: "data:image/jpeg;base64,abc", filename: "photo.jpg" },
+    ]
+
+    await handleMessage({
+      chatId: 123,
+      text: "",
+      parts: customParts,
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+    const call = promptMock.mock.calls[0]![0] as any
+    expect(call.parts).toHaveLength(2)
+    expect(call.parts[0].type).toBe("text")
+    expect(call.parts[1].type).toBe("file")
+    expect(call.parts[1].mime).toBe("image/jpeg")
+  })
+
+  test("without parts builds text part from text param (backward compat)", async () => {
+    const { handleMessage } = await import("./bot")
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: mock(async () => ({})),
+      },
+    } as any
+
+    await handleMessage({
+      chatId: 123,
+      text: "hello world",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+    const call = promptMock.mock.calls[0]![0] as any
+    expect(call.parts).toHaveLength(1)
+    expect(call.parts[0].type).toBe("text")
+    expect(call.parts[0].text).toBe("hello world")
+  })
+
+  test("with both text and parts — parts wins", async () => {
+    const { handleMessage } = await import("./bot")
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: mock(async () => ({})),
+      },
+    } as any
+
+    const customParts = [
+      { type: "file" as const, mime: "image/png", url: "data:image/png;base64,xyz", filename: "img.png" },
+    ]
+
+    await handleMessage({
+      chatId: 123,
+      text: "this should be ignored",
+      parts: customParts,
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+    const call = promptMock.mock.calls[0]![0] as any
+    expect(call.parts).toHaveLength(1)
+    expect(call.parts[0].type).toBe("file")
+  })
+
+  test("with empty parts array still works", async () => {
+    const { handleMessage } = await import("./bot")
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: mock(async () => ({})),
+      },
+    } as any
+
+    await handleMessage({
+      chatId: 123,
+      text: "fallback text",
+      parts: [],
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+    const call = promptMock.mock.calls[0]![0] as any
+    // Empty parts array → falls back to text
+    expect(call.parts).toHaveLength(1)
+    expect(call.parts[0].type).toBe("text")
+    expect(call.parts[0].text).toBe("fallback text")
+  })
+})

package/src/bot.ts

@@ -8,6 +8,7 @@
  */
 
 import { Bot } from "grammy"
+import { sequentialize } from "@grammyjs/runner"
 import type { Config } from "./config"
 import type { OpencodeClient } from "@opencode-ai/sdk/v2"
 import type { SessionManager } from "./session-manager"
@@ -31,6 +32,25 @@ import {
   handleSummarize,
   parseSessionCallback,
 } from "./handlers/sessions"
+import {
+  handleModel,
+  handleModelSelect,
+  parseModelCallback,
+  formatProviderList,
+  formatModelList,
+  filterModels,
+} from "./handlers/models"
+import {
+  handleAgent,
+  handleAgentSelect,
+  parseAgentCallback,
+} from "./handlers/agents"
+import {
+  extractFileRef,
+  downloadTelegramFile,
+  buildMediaParts,
+  getMimeFromFileName,
+} from "./handlers/media"
 
 export const START_MESSAGE = [
   "OpenCode Telegram Bot",
@@ -50,7 +70,10 @@ export type BotDeps = {
 export function createBot(config: Config, deps?: BotDeps) {
   const bot = new Bot(config.botToken)
 
-  // Allowlist middleware — must be first (blocks unauthorized users)
+  // Sequentialize — ensures per-chat serial processing (prevents race conditions)
+  bot.use(sequentialize((ctx) => String(ctx.chat?.id ?? "")))
+
+  // Allowlist middleware — blocks unauthorized users
   bot.use(createAllowlistMiddleware(config.allowedUsers, config.allowAllUsers))
 
   bot.command("start", async (ctx) => {
@@ -102,6 +125,18 @@ export function createBot(config: Config, deps?: BotDeps) {
       await ctx.reply(result)
     })
 
+    bot.command("model", async (ctx) => {
+      const chatKey = String(ctx.chat.id)
+      const result = await handleModel({ sdk, sessionManager, chatKey })
+      await ctx.reply(result.text, { reply_markup: result.reply_markup })
+    })
+
+    bot.command("agent", async (ctx) => {
+      const chatKey = String(ctx.chat.id)
+      const result = await handleAgent({ sdk, sessionManager, chatKey })
+      await ctx.reply(result.text, { reply_markup: result.reply_markup })
+    })
+
     bot.command("cancel", async (ctx) => {
       const chatId = ctx.chat.id
       const result = await handleCancel({
@@ -179,8 +214,147 @@ export function createBot(config: Config, deps?: BotDeps) {
         await ctx.editMessageText(result)
         return
       }
+
+      if (data.startsWith("mdl:")) {
+        const parsed = parseModelCallback(data)
+        if (!parsed) return
+        const chatKey = String(ctx.from.id)
+
+        if (parsed.type === "reset") {
+          const entry = sessionManager.get(chatKey)
+          if (entry) {
+            sessionManager.set(chatKey, { ...entry, modelOverride: undefined })
+          }
+          await ctx.editMessageText("Model reset to default.")
+          return
+        }
+
+        if (parsed.type === "back") {
+          const result = await handleModel({ sdk, sessionManager, chatKey })
+          await ctx.editMessageText(result.text, { reply_markup: result.reply_markup })
+          return
+        }
+
+        if (parsed.type === "provider") {
+          const provResult = await sdk.provider.list()
+          const data = (provResult as any).data ?? {}
+          const providers = data.all ?? []
+          const defaults = data.default ?? {}
+          const provider = providers.find((p: any) => p.id === parsed.providerID)
+          if (!provider) {
+            await ctx.editMessageText("Provider not found.")
+            return
+          }
+          const allModels = Object.values(provider.models ?? {}) as any[]
+          const filtered = filterModels(allModels)
+          const entry = sessionManager.get(chatKey)
+          const activeModelID =
+            entry?.modelOverride?.providerID === parsed.providerID
+              ? entry.modelOverride.modelID
+              : defaults[parsed.providerID]
+          const result = formatModelList(parsed.providerID, provider.name || parsed.providerID, filtered, activeModelID)
+          await ctx.editMessageText(result.text, { reply_markup: result.reply_markup })
+          return
+        }
+
+        if (parsed.type === "model") {
+          const result = await handleModelSelect({
+            chatKey,
+            providerID: parsed.providerID,
+            modelID: parsed.modelID,
+            sessionManager,
+          })
+          await ctx.editMessageText(result)
+          return
+        }
+      }
+
+      if (data.startsWith("agt:")) {
+        const parsed = parseAgentCallback(data)
+        if (!parsed) return
+        const chatKey = String(ctx.from.id)
+
+        if ("action" in parsed && parsed.action === "reset") {
+          const entry = sessionManager.get(chatKey)
+          if (entry) {
+            sessionManager.set(chatKey, { ...entry, agentOverride: undefined })
+          }
+          await ctx.editMessageText("Agent reset to default.")
+          return
+        }
+
+        if ("name" in parsed) {
+          const result = await handleAgentSelect({
+            chatKey,
+            agentName: parsed.name,
+            sessionManager,
+          })
+          await ctx.editMessageText(result)
+          return
+        }
+      }
     })
 
+    // --- Media handlers (must come BEFORE message:text) ---
+    const handleMedia = async (ctx: any) => {
+      const chatId = ctx.chat.id
+      const msg = ctx.message
+      const ref = extractFileRef(msg)
+      if (!ref) return
+
+      try {
+        const downloaded = await downloadTelegramFile({
+          fileId: ref.fileId,
+          token: config.botToken,
+          getFile: (fid: string) => ctx.api.getFile(fid),
+          filename: ref.filename,
+          mime: ref.mime,
+        })
+
+        if (!downloaded) {
+          await ctx.reply("Could not download file. It may be too large (max 20MB).")
+          return
+        }
+
+        const parts = buildMediaParts({
+          buffer: downloaded.buffer,
+          mime: downloaded.mime,
+          filename: downloaded.filename,
+          caption: msg.caption,
+        })
+
+        const { turn } = await handleMessage({
+          chatId,
+          text: msg.caption ?? "",
+          parts,
+          sdk,
+          sessionManager,
+          turnManager,
+          draftDeps: {
+            sendMessage: (id, t, o) =>
+              bot.api.sendMessage(id, t, o as any),
+            editMessageText: (id, m, t, o) =>
+              bot.api.editMessageText(id, m, t, o as any),
+          },
+        })
+
+        startTypingLoop(
+          chatId,
+          (id, action) => bot.api.sendChatAction(id, action as any),
+          turn.abortController.signal,
+        )
+      } catch (err) {
+        console.error("Media handler error:", err)
+        await ctx.reply("Error processing file.").catch(() => {})
+      }
+    }
+
+    bot.on("message:photo", handleMedia)
+    bot.on("message:document", handleMedia)
+    bot.on("message:voice", handleMedia)
+    bot.on("message:audio", handleMedia)
+    bot.on("message:video", handleMedia)
+
     bot.on("message:text", async (ctx) => {
       const chatId = ctx.chat.id
       const text = ctx.message.text.trim()
@@ -220,6 +394,7 @@ export function createBot(config: Config, deps?: BotDeps) {
 export async function handleMessage(params: {
   chatId: number
   text: string
+  parts?: Array<{ type: string; [k: string]: unknown }>
   sdk: OpencodeClient
   sessionManager: SessionManager
   turnManager: TurnManager
@@ -246,11 +421,18 @@ export async function handleMessage(params: {
     turn.draft = new DraftStream(draftDeps, chatId, turn.abortController.signal)
   }
 
+  // Use explicit parts if provided and non-empty, otherwise build from text
+  const promptParts = (params.parts && params.parts.length > 0)
+    ? params.parts
+    : [{ type: "text" as const, text }]
+
   // Fire-and-forget: don't block the Grammy handler.
   // The response comes via SSE events → DraftStream → finalizeResponse.
   sdk.session.prompt({
     sessionID: entry.sessionId,
-    parts: [{ type: "text", text }],
+    parts: promptParts as any,
+    ...(entry.modelOverride && { model: entry.modelOverride }),
+    ...(entry.agentOverride && { agent: entry.agentOverride }),
   }).catch((err: unknown) => {
     console.error("Prompt error:", err)
   })
@@ -270,9 +452,14 @@ export async function handleSessionCallback(params: {
   const match = sessions.find((s: any) => s.id.startsWith(sessionPrefix))
   if (!match) return "Session not found."
 
+  // Preserve model/agent overrides across session switches
+  const oldEntry = sessionManager.get(chatKey)
+
   sessionManager.set(chatKey, {
     sessionId: match.id,
     directory: match.directory ?? "",
+    modelOverride: oldEntry?.modelOverride,
+    agentOverride: oldEntry?.agentOverride,
   })
   return `Switched to: ${match.title || match.id}`
 }
@@ -285,10 +472,21 @@ export async function handleNew(params: {
   const { chatId, sdk, sessionManager } = params
   const chatKey = String(chatId)
 
+  // Preserve model/agent overrides across session changes
+  const oldEntry = sessionManager.get(chatKey)
+  const modelOverride = oldEntry?.modelOverride
+  const agentOverride = oldEntry?.agentOverride
+
   // Remove existing session mapping (session persists on server)
   sessionManager.remove(chatKey)
 
   // Create fresh session
   const entry = await sessionManager.getOrCreate(chatKey, sdk)
+
+  // Restore overrides
+  if (modelOverride || agentOverride) {
+    sessionManager.set(chatKey, { ...entry, modelOverride, agentOverride })
+  }
+
   return entry
 }

package/src/config.test.ts

@@ -127,4 +127,20 @@ describe("loadConfig", () => {
     const config = loadConfig()
     expect(config.allowAllUsers).toBe(false)
   })
+
+  test("apiPort defaults to 4097 when not set", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    delete process.env.TELEGRAM_API_PORT
+    const { loadConfig } = await import("./config?apiport1")
+    const config = loadConfig()
+    expect(config.apiPort).toBe(4097)
+  })
+
+  test("apiPort reads from TELEGRAM_API_PORT env var", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    process.env.TELEGRAM_API_PORT = "5555"
+    const { loadConfig } = await import("./config?apiport2")
+    const config = loadConfig()
+    expect(config.apiPort).toBe(5555)
+  })
 })

package/src/config.ts

@@ -5,6 +5,7 @@ export type Config = {
   testEnv: boolean
   allowedUsers: number[]
   allowAllUsers: boolean
+  apiPort: number
   e2e: {
     apiId: number
     apiHash: string
@@ -30,6 +31,8 @@ export function loadConfig(): Config {
         .map(Number)
         .filter((n) => !isNaN(n))
 
+  const apiPort = Number(process.env.TELEGRAM_API_PORT) || 4097
+
   return {
     botToken,
     opencodeUrl: process.env.OPENCODE_URL ?? "http://127.0.0.1:4096",
@@ -37,6 +40,7 @@ export function loadConfig(): Config {
     testEnv: process.env.TELEGRAM_TEST_ENV === "1",
     allowedUsers,
     allowAllUsers,
+    apiPort,
     e2e: {
       apiId: Number(process.env.TELEGRAM_API_ID ?? 0),
       apiHash: process.env.TELEGRAM_API_HASH ?? "",