@fickydev/pigent 0.1.6 → 0.1.8

package/src/daemon/AgentDaemon.ts

@@ -24,7 +24,7 @@ export class AgentDaemon {
   ) {
     this.adapters = createAdapters(repositories);
     this.registry = new AgentRegistry(config, repositories);
-    this.commands = new BotCommandHandler(this.registry, repositories);
+    this.commands = new BotCommandHandler(this.registry, repositories, config.modelChoices);
     this.router = new MessageRouter(repositories, this.registry);
     this.runner = new AgentRunner(this.registry, repositories);
   }
@@ -92,6 +92,7 @@ export class AgentDaemon {
         chatId: message.chatId,
         threadId: message.threadId,
         text: command.text,
+        inlineKeyboard: command.inlineKeyboard,
       });
       return;
     }
@@ -150,13 +151,28 @@ 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),
+        commands: telegramCommands(),
       }),
     );
   }
 
   return adapters;
 }
+
+function telegramCommands() {
+  return [
+    { command: "help", description: "Show Pigent commands" },
+    { command: "agents", description: "List agents available in this chat" },
+    { command: "model", description: "Choose model for this chat session" },
+    { command: "thinking", description: "Choose thinking level for this chat session" },
+    { command: "agent", description: "Send message to a specific agent" },
+  ];
+}

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 !== "");
+}