@fickydev/pigent 0.1.5 → 0.1.7

package/src/agents/AgentRunner.ts

@@ -1,8 +1,9 @@
 import type { InboundMessage } from "../channels/types";
-import type { LoadedAgentConfig, LoadedConfig, ProfileConfig } from "../config/schemas";
 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";
 
 export type AgentRunInput = {
   agentId: string;
@@ -10,15 +11,29 @@ export type AgentRunInput = {
   message: InboundMessage;
 };
 
+type AgentRunResponse = {
+  text: string;
+  error?: string;
+};
+
+function sessionLockKey(input: AgentRunInput): string {
+  return [input.agentId, input.message.channel, input.message.chatId, input.message.threadId ?? ""].join(":");
+}
+
 export class AgentRunner {
   private readonly piRunner = new PiAgentRunner();
+  private readonly sessionLocks = new Map<string, Promise<void>>();
 
   constructor(
-    private readonly config: LoadedConfig,
+    private readonly registry: AgentRegistry,
     private readonly repositories: Repositories,
   ) {}
 
   async run(input: AgentRunInput): Promise<string> {
+    return this.withSessionLock(input, () => this.runUnlocked(input));
+  }
+
+  private async runUnlocked(input: AgentRunInput): Promise<string> {
     const session = await this.repositories.sessions.getOrCreate({
       agentId: input.agentId,
       channel: input.message.channel,
@@ -38,7 +53,20 @@ export class AgentRunner {
       rawJson: input.message.raw,
     });
 
-    const response = await this.createResponse(input);
+    const chatInstructions = await this.chatInstructions(input);
+    const response = await this.createResponse(input, session, chatInstructions);
+
+    if (response.error) {
+      await this.repositories.messages.create({
+        agentId: input.agentId,
+        sessionId: session.id,
+        channel: input.message.channel,
+        direction: "internal",
+        chatId: input.message.chatId,
+        threadId: input.message.threadId,
+        content: response.error,
+      });
+    }
 
     await this.repositories.messages.create({
       agentId: input.agentId,
@@ -47,41 +75,70 @@ export class AgentRunner {
       direction: "outbound",
       chatId: input.message.chatId,
       threadId: input.message.threadId,
-      content: response,
+      content: response.text,
     });
 
-    return response;
+    return response.text;
   }
 
-  private async createResponse(input: AgentRunInput): Promise<string> {
+  private async withSessionLock<T>(input: AgentRunInput, task: () => Promise<T>): Promise<T> {
+    const key = sessionLockKey(input);
+    const previous = this.sessionLocks.get(key) ?? Promise.resolve();
+    const run = previous.catch(() => undefined).then(task);
+    const tail = run.then(
+      () => undefined,
+      () => undefined,
+    );
+
+    this.sessionLocks.set(key, tail);
+
+    try {
+      return await run;
+    } finally {
+      if (this.sessionLocks.get(key) === tail) {
+        this.sessionLocks.delete(key);
+      }
+    }
+  }
+
+  private async createResponse(
+    input: AgentRunInput,
+    session: AgentSessionRow,
+    chatInstructions: string,
+  ): Promise<AgentRunResponse> {
     if (process.env.PIGENT_FAKE_AGENT === "1") {
-      return this.fakeResponse(input.agentId, input.text);
+      return { text: this.fakeResponse(input.agentId, input.text) };
     }
 
-    const agent = this.findAgent(input.agentId);
-    if (!agent) return `Unknown agent: ${input.agentId}`;
+    const agent = this.registry.getAgent(input.agentId);
+    if (!agent) return { text: `Unknown agent: ${input.agentId}` };
 
     try {
-      return await this.piRunner.run({
+      const text = await this.piRunner.run({
         agent,
-        profile: this.findProfile(agent.profile),
-        prompt: this.composePrompt(input),
+        profile: this.registry.getProfile(agent.profile),
+        session,
+        prompt: this.composePrompt(input, chatInstructions),
       });
+
+      return { text };
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+
       logger.error("pi runner failed", {
         agentId: input.agentId,
-        error: error instanceof Error ? error.message : String(error),
+        error: errorMessage,
       });
 
       if (process.env.PIGENT_FALLBACK_FAKE_AGENT === "1") {
-        return this.fakeResponse(input.agentId, input.text);
+        return { text: this.fakeResponse(input.agentId, input.text), error: errorMessage };
       }
 
-      return "Agent execution failed. Check daemon logs.";
+      return { text: "Agent failed to respond. Please try again later.", error: errorMessage };
     }
   }
 
-  private composePrompt(input: AgentRunInput): string {
+  private composePrompt(input: AgentRunInput, chatInstructions: string): string {
     return [
       `[Channel]\n${input.message.channel}`,
       `[Chat]\n${input.message.chatId}`,
@@ -89,24 +146,24 @@ export class AgentRunner {
       input.message.senderName || input.message.senderId
         ? `[User]\n${input.message.senderName ?? input.message.senderId}`
         : null,
+      chatInstructions ? `[Chat Instructions]\n${chatInstructions}` : null,
       `[Message]\n${input.text}`,
     ]
       .filter(Boolean)
       .join("\n\n");
   }
 
-  private fakeResponse(agentId: string, text: string): string {
-    const agent = this.findAgent(agentId);
-    const name = agent?.name ?? agentId;
+  private async chatInstructions(input: AgentRunInput): Promise<string> {
+    if (input.message.channel !== "telegram") return "";
 
-    return `[${name}] fake runner received: ${text || "(empty message)"}`;
+    const chat = await this.repositories.telegram.findChat(input.message.chatId);
+    return chat?.instructions.trim() ?? "";
   }
 
-  private findAgent(agentId: string): LoadedAgentConfig | null {
-    return this.config.agents.find((candidate) => candidate.id === agentId) ?? null;
-  }
+  private fakeResponse(agentId: string, text: string): string {
+    const agent = this.registry.getAgent(agentId);
+    const name = agent?.name ?? agentId;
 
-  private findProfile(profileId: string): ProfileConfig | null {
-    return this.config.profiles.find((candidate) => candidate.id === profileId) ?? null;
+    return `[${name}] fake runner received: ${text || "(empty message)"}`;
   }
 }

package/src/agents/BotCommandHandler.ts

@@ -1,6 +1,7 @@
 import type { InboundMessage } from "../channels/types";
-import type { LoadedConfig } from "../config/schemas";
 import type { Repositories } from "../db/repositories";
+import { isValidModelRef } from "../pi/PiModelResolver";
+import type { AgentRegistry } from "./AgentRegistry";
 
 export type BotCommandResult =
   | {
@@ -11,9 +12,12 @@ 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 config: LoadedConfig,
+    private readonly registry: AgentRegistry,
     private readonly repositories: Repositories,
   ) {}
 
@@ -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");
@@ -48,7 +62,7 @@ export class BotCommandHandler {
       return "No agents configured for this chat.";
     }
 
-    const allAgentIds = this.config.agents.map((agent) => agent.id);
+    const allAgentIds = this.registry.listAgents().map((agent) => agent.id);
     const allowedAgentIds = [];
 
     for (const agentId of allAgentIds) {
@@ -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/agents/MessageRouter.ts

@@ -1,5 +1,6 @@
 import type { InboundMessage } from "../channels/types";
 import type { Repositories } from "../db/repositories";
+import type { AgentRegistry } from "./AgentRegistry";
 
 export type RouteResult =
   | {
@@ -14,7 +15,10 @@ export type RouteResult =
     };
 
 export class MessageRouter {
-  constructor(private readonly repositories: Repositories) {}
+  constructor(
+    private readonly repositories: Repositories,
+    private readonly registry: AgentRegistry,
+  ) {}
 
   async route(message: InboundMessage): Promise<RouteResult> {
     if (message.channel !== "telegram") {
@@ -54,8 +58,7 @@ export class MessageRouter {
       };
     }
 
-    const agent = await this.repositories.agents.findById(agentId);
-    if (!agent) {
+    if (!this.registry.hasAgent(agentId)) {
       return {
         ok: false,
         reason: "unknown_agent",

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

@@ -1,3 +1,4 @@
+import { AgentRegistry } from "../agents/AgentRegistry";
 import { AgentRunner } from "../agents/AgentRunner";
 import { BotCommandHandler } from "../agents/BotCommandHandler";
 import { MessageRouter } from "../agents/MessageRouter";
@@ -13,6 +14,7 @@ export class AgentDaemon {
   private running = false;
   private readonly adapters: ChannelAdapter[];
   private readonly commands: BotCommandHandler;
+  private readonly registry: AgentRegistry;
   private readonly router: MessageRouter;
   private readonly runner: AgentRunner;
 
@@ -21,9 +23,10 @@ export class AgentDaemon {
     private readonly repositories: Repositories,
   ) {
     this.adapters = createAdapters(repositories);
-    this.commands = new BotCommandHandler(config, repositories);
-    this.router = new MessageRouter(repositories);
-    this.runner = new AgentRunner(config, repositories);
+    this.registry = new AgentRegistry(config, repositories);
+    this.commands = new BotCommandHandler(this.registry, repositories);
+    this.router = new MessageRouter(repositories, this.registry);
+    this.runner = new AgentRunner(this.registry, repositories);
   }
 
   static async create(): Promise<AgentDaemon> {
@@ -43,8 +46,8 @@ export class AgentDaemon {
     }
 
     logger.info("pigent daemon started", {
-      agents: this.config.agents.length,
-      profiles: this.config.profiles.length,
+      agents: this.registry.listAgents().length,
+      profiles: this.registry.listProfiles().length,
       telegramChats: this.config.telegramChats.length,
       adapters: this.adapters.map((adapter) => adapter.id),
     });
@@ -63,9 +66,7 @@ export class AgentDaemon {
   }
 
   private async syncConfiguredState(): Promise<void> {
-    for (const agent of this.config.agents) {
-      await this.repositories.agents.upsertLoadedAgent(agent);
-    }
+    await this.registry.syncConfiguredAgents();
 
     for (const chat of this.config.telegramChats) {
       await this.repositories.telegram.upsertConfiguredChat(chat);
@@ -125,7 +126,7 @@ export class AgentDaemon {
     if (message.channel !== "telegram") return;
     if (process.env.PIGENT_AUTO_SETUP_CHATS !== "1") return;
 
-    const defaultAgentId = process.env.PIGENT_AUTO_SETUP_DEFAULT_AGENT ?? this.config.agents[0]?.id;
+    const defaultAgentId = process.env.PIGENT_AUTO_SETUP_DEFAULT_AGENT ?? this.registry.defaultAgentId();
     if (!defaultAgentId) return;
 
     await this.repositories.telegram.autoConfigureChat(message, defaultAgentId);
@@ -149,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),