@fickydev/pigent 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -39,6 +39,10 @@
 - Added safe Pi runner failure replies with internal error persistence.
 - Added per-session locking to serialize Pi runs for the same agent/channel/chat/thread.
 - Added Telegram chat instructions to Pi prompt composition.
+- Added Telegram API retry/backoff for transient network, rate limit, and server errors.
+- Planned model selection support across profile, agent, and Telegram chat override levels.
+- Added profile and agent config-based Pi model and thinking level selection.
+- Added session-scoped model and thinking level overrides with `/model` and `/thinking` Telegram commands.
 - Kept daemon process alive after startup so CLI runs do not exit after `pigent ready`.
 
 ### Changed

package/PLAN.md

@@ -61,7 +61,8 @@ Profile defines reusable behavior shared by agents.
 
 Profile may include:
 
-- model preference
+- model preference using `provider/modelId`
+- thinking level preference (`off`, `low`, `medium`, `high`)
 - base system prompt
 - response style
 - default skills
@@ -152,6 +153,8 @@ Each Telegram group/private chat can define:
 - default agent
 - allowed agents
 - custom instructions
+- per-agent model override via Telegram command
+- per-agent thinking level override via Telegram command
 - heartbeat settings
 - enabled/disabled status
 
@@ -170,6 +173,41 @@ telegramChats:
       This is engineering group. Be concise. Prefer TypeScript.
 ```
 
+## Model Selection
+
+Pigent should support model selection at multiple levels without exposing provider secrets to channel prompts.
+
+Model identifiers use Pi SDK `provider/modelId` format, for example:
+
+```text
+anthropic/claude-opus-4-5
+openai/gpt-4.1
+ollama/qwen2.5-coder:7b
+```
+
+Selection priority:
+
+```text
+session override > agent config > profile config > Pi default
+```
+
+A session is keyed by `agentId + channel + chatId + threadId`, so the same agent can use different models in private chats, group chats, and Telegram forum topics.
+
+Config support should come first:
+
+- `profiles/*.yaml` may define `model` and `thinkingLevel`
+- `agents/*/agent.yaml` may override `model` and `thinkingLevel`
+
+Telegram command support should persist session-scoped overrides after config support exists:
+
+- `/model` shows current model for the default agent in the chat
+- `/model <provider/modelId>` sets model for the default agent session in the current chat/thread
+- `/model default` clears model override for the default agent session in the current chat/thread
+- `/thinking <level>` sets thinking level for the default agent session in the current chat/thread
+- `/thinking default` clears thinking override for the default agent session in the current chat/thread
+
+The command handler should validate agent access and model availability through a Pi model resolver. It must not reveal API keys, auth values, raw environment variables, or provider secrets.
+
 ## Prompt Composition
 
 For each request, compose context from:
@@ -195,6 +233,7 @@ Initial entities:
 - telegram chat agents
 - messages
 - heartbeats
+- session model/thinking overrides
 - tasks/events later
 
 SQLite first. Keep schema types portable so PostgreSQL migration is straightforward.
@@ -319,6 +358,8 @@ drizzle/
 ### Milestone 6: Pi Runner
 
 - create Pi SDK sessions
+- resolve profile/agent model preferences
+- resolve chat model overrides
 - send prompts
 - return responses
 - persist inbound/outbound messages
@@ -362,6 +403,8 @@ Add Hono only after daemon works. Use it for:
 
 ## Open Questions
 
+- Should `/model <agentId> ...` support non-default agent sessions in the command itself?
+- Should model availability errors block `/model` saves or save with a warning?
 - Which Pi SDK session manager should be used for persistent sessions?
 - How exactly should per-agent skills/extensions be loaded into Pi runtime?
 - Should group instructions live in YAML, DB, or both?

package/TODO.md

@@ -39,6 +39,9 @@
 
 ## Config
 
+- [x] Add profile-level `thinkingLevel` config
+- [x] Add agent-level `model` override config
+- [x] Add agent-level `thinkingLevel` override config
 - [x] Define root config format
 - [x] Define `AgentConfig`
 - [x] Define `ProfileConfig`
@@ -66,6 +69,8 @@
 - [x] Define `messages` table
 - [x] Define `heartbeats` table
 - [x] Define `runtime_kv` table for offsets and daemon state
+- [x] Add `agent_sessions.model` for session model override
+- [x] Add `agent_sessions.thinking_level` for session thinking override
 - [x] Implement repositories
   - [x] `AgentRepository`
   - [x] `SessionRepository`
@@ -83,7 +88,7 @@
   - [x] `getUpdates`
   - [x] `sendMessage`
   - [x] error handling
-  - [ ] retry/backoff
+  - [x] retry/backoff
 - [x] Implement `TelegramPollingAdapter`
   - [x] polling loop
   - [x] offset tracking
@@ -121,6 +126,12 @@
 
 ## Pi Integration
 
+- [x] Confirm SDK model selection supports `createAgentSession({ model, thinkingLevel })`
+- [x] Implement Pi model resolver for `provider/modelId`
+- [x] Apply profile-level model selection
+- [x] Apply agent-level model override
+- [x] Apply session model override
+- [x] Apply thinking level selection
 - [x] Confirm SDK APIs needed for session creation
 - [ ] Confirm persistent session manager approach
 - [ ] Confirm per-agent system prompt injection
@@ -162,6 +173,14 @@
 - [ ] `/sessions` list active sessions for chat
 - [ ] `/reset-session <agentId>` clear chat session
 - [ ] `/heartbeat status` show heartbeat state
+- [x] `/model` show current model for default chat agent session
+- [x] `/model <provider/modelId>` set model for default chat agent session
+- [x] `/model default` clear model for default chat agent session
+- [x] `/thinking` show thinking level for default chat agent session
+- [x] `/thinking <level>` set thinking level for default chat agent session
+- [x] `/thinking default` clear thinking level for default chat agent session
+- [ ] `/model <agentId> <provider/modelId>` set model for an explicit agent session
+- [ ] `/thinking <agentId> <level>` set thinking level for an explicit agent session
 - [x] `/help` show bot commands
 
 ## Tests
@@ -171,6 +190,8 @@
 - [ ] Unit test routing rules
 - [ ] Unit test session key generation
 - [ ] Unit test heartbeat `NOOP` behavior
+- [ ] Unit test model selection priority
+- [ ] Unit test Telegram `/model` command parsing
 - [ ] Repository tests against temp SQLite DB
 - [ ] Integration test fake Telegram update to fake Pi runner
 

package/agents/assistant/agent.yaml

@@ -1,6 +1,8 @@
 id: assistant
 name: Assistant
 profile: generic-assistant
+model: null
+thinkingLevel: null
 workspace: ~/.pigent/workspaces/assistant
 systemPromptFile: ./SYSTEM.md
 skills: []

package/drizzle/migrations/0001_session_model_overrides.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `agent_sessions` ADD `model` text;--> statement-breakpoint
+ALTER TABLE `agent_sessions` ADD `thinking_level` text;

package/drizzle/migrations/meta/0001_snapshot.json

@@ -0,0 +1,519 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "a63274e2-bbd7-4003-864b-df9dc906e6c1",
+  "prevId": "e22a939b-7de8-4f8f-97d8-f01f58bd0f25",
+  "tables": {
+    "agent_sessions": {
+      "name": "agent_sessions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "agent_id": {
+          "name": "agent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "channel": {
+          "name": "channel",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "chat_id": {
+          "name": "chat_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "pi_session_id": {
+          "name": "pi_session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "instructions_hash": {
+          "name": "instructions_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "thinking_level": {
+          "name": "thinking_level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "agent_sessions_key_unique": {
+          "name": "agent_sessions_key_unique",
+          "columns": [
+            "agent_id",
+            "channel",
+            "chat_id",
+            "thread_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "agents": {
+      "name": "agents",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "profile": {
+          "name": "profile",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "workspace": {
+          "name": "workspace",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "config_json": {
+          "name": "config_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "system_prompt": {
+          "name": "system_prompt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "heartbeats": {
+      "name": "heartbeats",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "agent_id": {
+          "name": "agent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prompt": {
+          "name": "prompt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "result": {
+          "name": "result",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "error": {
+          "name": "error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "messages": {
+      "name": "messages",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "agent_id": {
+          "name": "agent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "channel": {
+          "name": "channel",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "direction": {
+          "name": "direction",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sender_id": {
+          "name": "sender_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "chat_id": {
+          "name": "chat_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "raw_json": {
+          "name": "raw_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "runtime_kv": {
+      "name": "runtime_kv",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "telegram_chat_agents": {
+      "name": "telegram_chat_agents",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "chat_id": {
+          "name": "chat_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "agent_id": {
+          "name": "agent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "custom_instructions": {
+          "name": "custom_instructions",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "telegram_chat_agents_chat_agent_unique": {
+          "name": "telegram_chat_agents_chat_agent_unique",
+          "columns": [
+            "chat_id",
+            "agent_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "telegram_chats": {
+      "name": "telegram_chats",
+      "columns": {
+        "chat_id": {
+          "name": "chat_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_agent_id": {
+          "name": "default_agent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "instructions": {
+          "name": "instructions",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

package/drizzle/migrations/meta/_journal.json

@@ -8,6 +8,13 @@
       "when": 1779047084019,
       "tag": "0000_great_daredevil",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1779069686461,
+      "tag": "0001_session_model_overrides",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fickydev/pigent",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "description": "Autonomous multi-agent daemon using Pi as core execution engine.",

package/profiles/assistant.yaml

@@ -1,6 +1,7 @@
 id: generic-assistant
 name: Generic Assistant
 model: null
+thinkingLevel: null
 instructions: |
   You are a helpful general-purpose assistant.
   Prefer concise, useful answers. Ask clarifying questions only when needed.

package/src/agents/AgentRunner.ts

@@ -1,5 +1,6 @@
 import type { InboundMessage } from "../channels/types";
 import type { Repositories } from "../db/repositories";
+import type { AgentSessionRow } from "../db/schema";
 import { logger } from "../logging/logger";
 import { PiAgentRunner } from "../pi/PiAgentRunner";
 import type { AgentRegistry } from "./AgentRegistry";
@@ -53,7 +54,7 @@ export class AgentRunner {
     });
 
     const chatInstructions = await this.chatInstructions(input);
-    const response = await this.createResponse(input, chatInstructions);
+    const response = await this.createResponse(input, session, chatInstructions);
 
     if (response.error) {
       await this.repositories.messages.create({
@@ -100,7 +101,11 @@ export class AgentRunner {
     }
   }
 
-  private async createResponse(input: AgentRunInput, chatInstructions: string): Promise<AgentRunResponse> {
+  private async createResponse(
+    input: AgentRunInput,
+    session: AgentSessionRow,
+    chatInstructions: string,
+  ): Promise<AgentRunResponse> {
     if (process.env.PIGENT_FAKE_AGENT === "1") {
       return { text: this.fakeResponse(input.agentId, input.text) };
     }
@@ -112,6 +117,7 @@ export class AgentRunner {
       const text = await this.piRunner.run({
         agent,
         profile: this.registry.getProfile(agent.profile),
+        session,
         prompt: this.composePrompt(input, chatInstructions),
       });
 

package/src/agents/BotCommandHandler.ts

@@ -1,5 +1,6 @@
 import type { InboundMessage } from "../channels/types";
 import type { Repositories } from "../db/repositories";
+import { isValidModelRef } from "../pi/PiModelResolver";
 import type { AgentRegistry } from "./AgentRegistry";
 
 export type BotCommandResult =
@@ -11,6 +12,9 @@ export type BotCommandResult =
       handled: false;
     };
 
+const THINKING_LEVELS = ["off", "low", "medium", "high"] as const;
+type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
 export class BotCommandHandler {
   constructor(
     private readonly registry: AgentRegistry,
@@ -26,6 +30,10 @@ export class BotCommandHandler {
         return { handled: true, text: this.helpText() };
       case "/agents":
         return { handled: true, text: await this.agentsText(message) };
+      case "/model":
+        return { handled: true, text: await this.modelText(message) };
+      case "/thinking":
+        return { handled: true, text: await this.thinkingText(message) };
       default:
         return { handled: false };
     }
@@ -36,6 +44,12 @@ export class BotCommandHandler {
       "Pigent commands:",
       "/help - show this help",
       "/agents - list agents for this chat",
+      "/model - show model for this chat session",
+      "/model <provider/modelId> - set model for this chat session",
+      "/model default - clear model override for this chat session",
+      "/thinking - show thinking level for this chat session",
+      "/thinking <off|low|medium|high> - set thinking level for this chat session",
+      "/thinking default - clear thinking override for this chat session",
       "/agent <agentId> <message> - send message to specific agent",
       "@agentId <message> - send message to specific agent",
     ].join("\n");
@@ -62,4 +76,102 @@ export class BotCommandHandler {
       `Allowed agents: ${allowedAgentIds.length > 0 ? allowedAgentIds.join(", ") : "none"}`,
     ].join("\n");
   }
+
+  private async modelText(message: InboundMessage): Promise<string> {
+    const sessionResult = await this.getDefaultSession(message);
+    if (!sessionResult.ok) return sessionResult.message;
+
+    const [, ...args] = message.text.trim().split(/\s+/);
+    const value = args.join(" ").trim();
+
+    if (!value) {
+      return [
+        `Agent: ${sessionResult.agentId}`,
+        `Session model: ${sessionResult.session.model ?? "default"}`,
+        "Use /model <provider/modelId> to set a session model.",
+        "Use /model default to clear the session model override.",
+      ].join("\n");
+    }
+
+    if (value === "default") {
+      const session = await this.repositories.sessions.updateModel(sessionResult.session.id, null);
+      return `Session model cleared for ${session.agentId}. Current: ${session.model ?? "default"}`;
+    }
+
+    if (!isValidModelRef(value)) {
+      return "Invalid model. Use provider/modelId, for example: anthropic/claude-opus-4-5";
+    }
+
+    const session = await this.repositories.sessions.updateModel(sessionResult.session.id, value);
+    return `Session model for ${session.agentId} set to ${session.model}.`;
+  }
+
+  private async thinkingText(message: InboundMessage): Promise<string> {
+    const sessionResult = await this.getDefaultSession(message);
+    if (!sessionResult.ok) return sessionResult.message;
+
+    const [, rawValue] = message.text.trim().split(/\s+/, 2);
+    const value = rawValue?.trim();
+
+    if (!value) {
+      return [
+        `Agent: ${sessionResult.agentId}`,
+        `Session thinking level: ${sessionResult.session.thinkingLevel ?? "default"}`,
+        "Use /thinking <off|low|medium|high> to set a session thinking level.",
+        "Use /thinking default to clear the session thinking override.",
+      ].join("\n");
+    }
+
+    if (value === "default") {
+      const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, null);
+      return `Session thinking level cleared for ${session.agentId}. Current: ${session.thinkingLevel ?? "default"}`;
+    }
+
+    if (!isThinkingLevel(value)) {
+      return "Invalid thinking level. Use one of: off, low, medium, high, default";
+    }
+
+    const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, value);
+    return `Session thinking level for ${session.agentId} set to ${session.thinkingLevel}.`;
+  }
+
+  private async getDefaultSession(message: InboundMessage) {
+    if (message.channel !== "telegram") {
+      return { ok: false as const, message: "Unsupported channel." };
+    }
+
+    const chat = await this.repositories.telegram.findChat(message.chatId);
+
+    if (!chat?.enabled) {
+      return { ok: false as const, message: "No enabled chat configuration found." };
+    }
+
+    const agentId = chat.defaultAgentId;
+
+    if (!agentId) {
+      return { ok: false as const, message: "No default agent configured for this chat." };
+    }
+
+    if (!this.registry.hasAgent(agentId)) {
+      return { ok: false as const, message: `Unknown agent: ${agentId}` };
+    }
+
+    if (!(await this.repositories.telegram.isAgentAllowed(message.chatId, agentId))) {
+      return { ok: false as const, message: `Agent is not allowed in this chat: ${agentId}` };
+    }
+
+    const session = await this.repositories.sessions.getOrCreate({
+      agentId,
+      channel: message.channel,
+      chatId: message.chatId,
+      threadId: message.threadId,
+      userId: message.senderId,
+    });
+
+    return { ok: true as const, agentId, session };
+  }
+}
+
+function isThinkingLevel(value: string): value is ThinkingLevel {
+  return THINKING_LEVELS.includes(value as ThinkingLevel);
 }

package/src/channels/telegram/TelegramApi.ts

@@ -3,6 +3,8 @@ import type { TelegramGetMeResponse, TelegramGetUpdatesResponse, TelegramSendMes
 export type TelegramApiOptions = {
   token: string;
   baseUrl?: string;
+  maxAttempts?: number;
+  baseRetryDelayMs?: number;
 };
 
 export type GetUpdatesOptions = {
@@ -11,11 +13,24 @@ export type GetUpdatesOptions = {
   limit?: number;
 };
 
+type TelegramApiResponse<T> = T & {
+  ok: boolean;
+  description?: string;
+  error_code?: number;
+  parameters?: {
+    retry_after?: number;
+  };
+};
+
 export class TelegramApi {
   private readonly baseUrl: string;
+  private readonly maxAttempts: number;
+  private readonly baseRetryDelayMs: number;
 
   constructor(options: TelegramApiOptions) {
     this.baseUrl = options.baseUrl ?? `https://api.telegram.org/bot${options.token}`;
+    this.maxAttempts = options.maxAttempts ?? 3;
+    this.baseRetryDelayMs = options.baseRetryDelayMs ?? 500;
   }
 
   async getMe(): Promise<TelegramUser> {
@@ -44,24 +59,123 @@ export class TelegramApi {
   }
 
   private async request<T extends { ok: boolean; description?: string }>(method: string, body: unknown): Promise<T> {
-    const response = await fetch(`${this.baseUrl}/${method}`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-      },
-      body: JSON.stringify(body),
-    });
+    let lastError: unknown;
+
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
+      try {
+        return await this.requestOnce<T>(method, body);
+      } catch (error) {
+        lastError = error;
+
+        if (!isRetryableTelegramError(error) || attempt >= this.maxAttempts) {
+          throw error;
+        }
+
+        await sleep(retryDelayMs(error, attempt, this.baseRetryDelayMs));
+      }
+    }
+
+    throw lastError instanceof Error ? lastError : new Error(`telegram ${method} failed`);
+  }
+
+  private async requestOnce<T extends { ok: boolean; description?: string }>(method: string, body: unknown): Promise<T> {
+    let response: Response;
+
+    try {
+      response = await fetch(`${this.baseUrl}/${method}`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+      });
+    } catch (error) {
+      throw new TelegramApiError(method, `telegram ${method} failed: ${error instanceof Error ? error.message : String(error)}`, {
+        cause: error,
+        retryable: true,
+      });
+    }
+
+    const payload = await parseTelegramPayload<T>(response);
 
     if (!response.ok) {
-      throw new Error(`telegram ${method} failed with HTTP ${response.status}`);
+      throw new TelegramApiError(method, `telegram ${method} failed with HTTP ${response.status}`, {
+        status: response.status,
+        description: payload?.description,
+        retryAfterSeconds: payload?.parameters?.retry_after,
+        retryable: isRetryableStatus(response.status),
+      });
     }
 
-    const payload = (await response.json()) as T;
+    if (!payload?.ok) {
+      const status = payload?.error_code;
 
-    if (!payload.ok) {
-      throw new Error(`telegram ${method} failed: ${payload.description ?? "unknown error"}`);
+      throw new TelegramApiError(method, `telegram ${method} failed: ${payload?.description ?? "unknown error"}`, {
+        status,
+        description: payload?.description,
+        retryAfterSeconds: payload?.parameters?.retry_after,
+        retryable: status ? isRetryableStatus(status) : false,
+      });
     }
 
     return payload;
   }
 }
+
+class TelegramApiError extends Error {
+  readonly method: string;
+  readonly status?: number;
+  readonly description?: string;
+  readonly retryAfterSeconds?: number;
+  readonly retryable: boolean;
+
+  constructor(
+    method: string,
+    message: string,
+    options: {
+      status?: number;
+      description?: string;
+      retryAfterSeconds?: number;
+      retryable: boolean;
+      cause?: unknown;
+    },
+  ) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "TelegramApiError";
+    this.method = method;
+    this.status = options.status;
+    this.description = options.description;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+    this.retryable = options.retryable;
+  }
+}
+
+async function parseTelegramPayload<T extends { ok: boolean; description?: string }>(
+  response: Response,
+): Promise<TelegramApiResponse<T> | null> {
+  try {
+    return (await response.json()) as TelegramApiResponse<T>;
+  } catch {
+    return null;
+  }
+}
+
+function isRetryableTelegramError(error: unknown): boolean {
+  return error instanceof TelegramApiError && error.retryable;
+}
+
+function isRetryableStatus(status: number): boolean {
+  return status === 429 || status >= 500;
+}
+
+function retryDelayMs(error: unknown, attempt: number, baseDelayMs: number): number {
+  if (error instanceof TelegramApiError && error.retryAfterSeconds) {
+    return error.retryAfterSeconds * 1000;
+  }
+
+  return baseDelayMs * 2 ** (attempt - 1);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/config/schemas.ts

@@ -1,6 +1,8 @@
 import { z } from "zod";
 
 const relativeOrAbsolutePathSchema = z.string().min(1);
+const modelReferenceSchema = z.string().min(1).regex(/^[^/\s]+\/.+$/);
+const ThinkingLevelSchema = z.enum(["off", "low", "medium", "high"]);
 
 export const PermissionConfigSchema = z.object({
   canRunShell: z.boolean().default(false),
@@ -28,6 +30,8 @@ export const AgentConfigSchema = z.object({
   name: z.string().min(1),
   profile: z.string().min(1),
   workspace: relativeOrAbsolutePathSchema,
+  model: modelReferenceSchema.nullable().default(null),
+  thinkingLevel: ThinkingLevelSchema.nullable().default(null),
   systemPromptFile: relativeOrAbsolutePathSchema.optional(),
   skills: z.array(z.string()).default([]),
   extensions: z.array(z.string()).default([]),
@@ -48,7 +52,8 @@ export const AgentConfigSchema = z.object({
 export const ProfileConfigSchema = z.object({
   id: z.string().min(1).regex(/^[a-zA-Z0-9_-]+$/),
   name: z.string().min(1),
-  model: z.string().min(1).nullable().default(null),
+  model: modelReferenceSchema.nullable().default(null),
+  thinkingLevel: ThinkingLevelSchema.nullable().default(null),
   instructions: z.string().default(""),
   defaultSkills: z.array(z.string()).default([]),
   defaultExtensions: z.array(z.string()).default([]),

package/src/daemon/AgentDaemon.ts

@@ -150,7 +150,11 @@ function createAdapters(repositories: Repositories): ChannelAdapter[] {
   if (telegramToken) {
     adapters.push(
       new TelegramPollingAdapter({
-        api: new TelegramApi({ token: telegramToken }),
+        api: new TelegramApi({
+          token: telegramToken,
+          maxAttempts: Number(process.env.TELEGRAM_API_MAX_ATTEMPTS ?? 3),
+          baseRetryDelayMs: Number(process.env.TELEGRAM_API_BASE_RETRY_DELAY_MS ?? 500),
+        }),
         runtimeKv: repositories.runtimeKv,
         pollTimeoutSeconds: Number(process.env.TELEGRAM_POLL_TIMEOUT_SECONDS ?? 30),
         pollIntervalMs: Number(process.env.TELEGRAM_POLL_INTERVAL_MS ?? 1000),

package/src/db/repositories/SessionRepository.ts

@@ -3,6 +3,8 @@ import { nanoid } from "nanoid";
 import type { DbClient } from "../client";
 import { agentSessions, type AgentSessionRow } from "../schema";
 
+export type SessionThinkingLevel = "off" | "low" | "medium" | "high";
+
 export type SessionKey = {
   agentId: string;
   channel: string;
@@ -38,6 +40,30 @@ export class SessionRepository {
     return created;
   }
 
+  async updateModel(id: string, model: string | null): Promise<AgentSessionRow> {
+    await this.db
+      .update(agentSessions)
+      .set({
+        model,
+        updatedAt: Date.now(),
+      })
+      .where(eq(agentSessions.id, id));
+
+    return this.requireById(id);
+  }
+
+  async updateThinkingLevel(id: string, thinkingLevel: SessionThinkingLevel | null): Promise<AgentSessionRow> {
+    await this.db
+      .update(agentSessions)
+      .set({
+        thinkingLevel,
+        updatedAt: Date.now(),
+      })
+      .where(eq(agentSessions.id, id));
+
+    return this.requireById(id);
+  }
+
   async findById(id: string): Promise<AgentSessionRow | null> {
     const row = await this.db.query.agentSessions.findFirst({
       where: eq(agentSessions.id, id),
@@ -46,6 +72,13 @@ export class SessionRepository {
     return row ?? null;
   }
 
+  private async requireById(id: string): Promise<AgentSessionRow> {
+    const row = await this.findById(id);
+    if (!row) throw new Error(`session not found ${id}`);
+
+    return row;
+  }
+
   private async findByKey(key: SessionKey): Promise<AgentSessionRow | null> {
     const threadPredicate = key.threadId
       ? eq(agentSessions.threadId, key.threadId)

package/src/db/schema.ts

@@ -48,6 +48,8 @@ export const agentSessions = sqliteTable(
     userId: text("user_id"),
     piSessionId: text("pi_session_id"),
     instructionsHash: text("instructions_hash"),
+    model: text("model"),
+    thinkingLevel: text("thinking_level", { enum: ["off", "low", "medium", "high"] }),
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
   },

package/src/pi/PiAgentRunner.ts

@@ -10,10 +10,13 @@ import {
 import { mkdir } from "node:fs/promises";
 import { resolve } from "node:path";
 import type { LoadedAgentConfig, ProfileConfig } from "../config/schemas";
+import type { AgentSessionRow } from "../db/schema";
+import { resolveModelSelection } from "./PiModelResolver";
 
 export type PiAgentRunInput = {
   agent: LoadedAgentConfig;
   profile: ProfileConfig | null;
+  session: AgentSessionRow;
   prompt: string;
 };
 
@@ -37,10 +40,13 @@ export class PiAgentRunner {
 
     const authStorage = AuthStorage.create();
     const modelRegistry = ModelRegistry.create(authStorage);
+    const modelSelection = resolveModelSelection(modelRegistry, [input.session, input.agent, input.profile ?? {}]);
     const { session } = await createAgentSession({
       cwd: workspace,
       authStorage,
       modelRegistry,
+      model: modelSelection.model,
+      thinkingLevel: modelSelection.thinkingLevel,
       resourceLoader,
       sessionManager: SessionManager.create(workspace),
       settingsManager,

package/src/pi/PiModelResolver.ts

@@ -0,0 +1,76 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { logger } from "../logging/logger";
+
+export type ModelSelectionConfig = {
+  model?: string | null;
+  thinkingLevel?: ThinkingLevel | null;
+};
+
+export type ResolvedModelSelection = {
+  model?: Model<any>;
+  thinkingLevel?: ThinkingLevel;
+};
+
+export function resolveModelSelection(
+  modelRegistry: ModelRegistry,
+  configs: ModelSelectionConfig[],
+): ResolvedModelSelection {
+  const configuredModel = firstConfigured(configs.map((config) => config.model));
+  const thinkingLevel = firstConfigured(configs.map((config) => config.thinkingLevel));
+  const resolved: ResolvedModelSelection = {};
+
+  if (configuredModel) {
+    const model = resolveModel(modelRegistry, configuredModel);
+    if (model) {
+      resolved.model = model;
+    }
+  }
+
+  if (thinkingLevel) {
+    resolved.thinkingLevel = thinkingLevel;
+  }
+
+  return resolved;
+}
+
+function resolveModel(modelRegistry: ModelRegistry, modelRef: string): Model<any> | undefined {
+  const parsed = parseModelRef(modelRef);
+
+  if (!parsed) {
+    logger.warn("invalid model reference; expected provider/modelId", { model: modelRef });
+    return undefined;
+  }
+
+  const model = modelRegistry.find(parsed.provider, parsed.modelId);
+
+  if (!model) {
+    logger.warn("configured model not found; falling back to Pi default", { model: modelRef });
+    return undefined;
+  }
+
+  return model;
+}
+
+export function isValidModelRef(modelRef: string): boolean {
+  return parseModelRef(modelRef) !== null;
+}
+
+function parseModelRef(modelRef: string): { provider: string; modelId: string } | null {
+  const trimmed = modelRef.trim();
+  const separatorIndex = trimmed.indexOf("/");
+
+  if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
+    return null;
+  }
+
+  return {
+    provider: trimmed.slice(0, separatorIndex),
+    modelId: trimmed.slice(separatorIndex + 1),
+  };
+}
+
+function firstConfigured<T>(values: Array<T | null | undefined>): T | undefined {
+  return values.find((value): value is T => value !== null && value !== undefined && value !== "");
+}