@khirby/plugin-ai-compose 1.1.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khirby/plugin-ai-compose",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Khirby — AI-powered reply draft suggestions (BYOK, OpenAI-compatible)",
   "main": "src/index.ts",
   "keywords": [
@@ -10,6 +10,7 @@
     "@khirby/plugin-host": "^1.0.0",
     "@khirby/plugin-sdk": "^1.0.0",
     "@nestjs/common": "*",
+    "@nestjs/core": "*",
     "@nestjs/swagger": "*",
     "drizzle-orm": "*"
   },

package/src/ai-compose-crypto.ts

@@ -1,60 +1,5 @@
-import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
-
-const ALGORITHM = 'aes-256-gcm';
-const IV_BYTES = 12;
-const TAG_BYTES = 16;
-
-function getKey(): Buffer {
-  const raw = process.env.AI_COMPOSE_SECRETS_KEY?.trim();
-  if (!raw) {
-    throw new Error('AI_COMPOSE_SECRETS_KEY is not set');
-  }
-  let buf: Buffer;
-  if (/^[0-9a-fA-F]{64}$/.test(raw)) {
-    buf = Buffer.from(raw, 'hex');
-  } else {
-    buf = Buffer.from(raw, 'base64');
-  }
-  if (buf.length !== 32) {
-    throw new Error(
-      "AI_COMPOSE_SECRETS_KEY must be 32 bytes as hex (64 chars) or base64 — generate with: node -e \"console.log(require('crypto').randomBytes(32).toString('hex'))\"",
-    );
-  }
-  return buf;
-}
-
-export function isAiComposeSecretsKeyConfigured(): boolean {
-  try {
-    getKey();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Encrypts plaintext using AES-256-GCM.
- * Returns a base64 string: iv(12) + ciphertext + tag(16)
- */
-export function encrypt(plaintext: string): string {
-  const key = getKey();
-  const iv = randomBytes(IV_BYTES);
-  const cipher = createCipheriv(ALGORITHM, key, iv);
-  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  return Buffer.concat([iv, encrypted, tag]).toString('base64');
-}
-
-/**
- * Decrypts a base64 blob produced by `encrypt`.
- */
-export function decrypt(ciphertext: string): string {
-  const key = getKey();
-  const buf = Buffer.from(ciphertext, 'base64');
-  const iv = buf.subarray(0, IV_BYTES);
-  const tag = buf.subarray(buf.length - TAG_BYTES);
-  const encrypted = buf.subarray(IV_BYTES, buf.length - TAG_BYTES);
-  const decipher = createDecipheriv(ALGORITHM, key, iv);
-  decipher.setAuthTag(tag);
-  return decipher.update(encrypted) + decipher.final('utf8');
-}
+export {
+  decrypt,
+  encrypt,
+  isInstanceSecretsKeyConfigured as isAiComposeSecretsKeyConfigured,
+} from '../../../packages/plugin-host/src/instance-secrets';

package/src/ai-compose-llm.service.ts

@@ -1,25 +1,54 @@
-import { Injectable } from '@nestjs/common';
-import type { AiComposeLlmLike } from '../../../packages/plugin-host/src';
+import { Injectable, Logger } from '@nestjs/common';
+import {
+  AppException,
+  isReasoningEffort,
+  type AiComposeLlmLike,
+} from '../../../packages/plugin-host/src';
 import { AiComposeSettingsService } from './ai-compose-settings.service';
+import { AiComposeSuggestService } from './ai-compose-suggest.service';
 
 /** Host token surface for Ask Khirby agent chat (ADR-0040). */
 @Injectable()
 export class AiComposeLlmService implements AiComposeLlmLike {
-  constructor(private readonly settings: AiComposeSettingsService) {}
+  private readonly logger = new Logger(AiComposeLlmService.name);
+
+  constructor(
+    private readonly settings: AiComposeSettingsService,
+    private readonly suggest: AiComposeSuggestService,
+  ) {}
 
   async getCompletionConfig(): Promise<{
     baseUrl: string;
     apiKey: string;
     model: string;
+    reasoningEffort?: 'none' | 'low' | 'medium' | 'high' | null;
+    reasoningSupported?: boolean | null;
   } | null> {
-    try {
-      await this.settings.assertPluginEnabled();
-      const { apiKey, baseUrl } = await this.settings.getDecryptedApiKey();
-      const model = await this.settings.getDefaultModel();
-      if (!model?.trim()) return null;
-      return { baseUrl, apiKey, model: model.trim() };
-    } catch {
-      return null;
+    await this.settings.assertPluginEnabled();
+    const { apiKey, baseUrl } = await this.settings.getDecryptedApiKey();
+    const model = await this.settings.getDefaultModel();
+    if (!model?.trim()) {
+      throw AppException.pluginNotConfigured('ai-compose', 'No default model configured');
+    }
+    const reasoningEffort = await this.settings.getReasoningEffort();
+    let reasoningSupported: boolean | null | undefined;
+    if (isReasoningEffort(reasoningEffort)) {
+      try {
+        reasoningSupported =
+          this.suggest.cachedReasoningSupport?.(baseUrl, model.trim()) ?? null;
+      } catch (err) {
+        this.logger.warn(
+          `Reasoning catalog cache unavailable: ${err instanceof Error ? err.message : 'unknown'}`,
+        );
+        reasoningSupported = null;
+      }
     }
+    return {
+      baseUrl,
+      apiKey,
+      model: model.trim(),
+      reasoningEffort,
+      reasoningSupported,
+    };
   }
 }

package/src/ai-compose-settings.controller.ts

@@ -6,7 +6,6 @@ import {
   RequirePermission,
   RequirePluginEnabled,
   PluginEnabledGuard,
-  AppException,
 } from '../../../packages/plugin-host/src';
 import { AiComposeSettingsService } from './ai-compose-settings.service';
 import { AiComposeSuggestService } from './ai-compose-suggest.service';
@@ -39,6 +38,7 @@ export class AiComposeSettingsController {
       defaultModel?: string | null;
       allowedModels?: string[];
       systemPrompt?: string | null;
+      reasoningEffort?: 'none' | 'low' | 'medium' | 'high' | null;
     },
   ) {
     return this.settings.updateSettings(dto);
@@ -47,9 +47,7 @@ export class AiComposeSettingsController {
   @Get('models')
   @ApiOperation({ summary: 'Fetch available models from the configured AI provider' })
   async getModels() {
-    const { apiKey, baseUrl } = await this.settings.getDecryptedApiKey().catch(() => {
-      throw AppException.badRequest('API key is not configured. Save your settings first.');
-    });
+    const { apiKey, baseUrl } = await this.settings.getDecryptedApiKey();
     return this.suggest.fetchModels(baseUrl, apiKey);
   }
 

package/src/ai-compose-settings.service.ts

@@ -6,6 +6,8 @@ import {
   PLUGIN_REGISTRY,
   type PluginRegistryLike,
   AppException,
+  isReasoningEffort,
+  type ReasoningEffort,
 } from '../../../packages/plugin-host/src';
 import { aiComposeSettings } from './schema';
 import { encrypt, decrypt, isAiComposeSecretsKeyConfigured } from './ai-compose-crypto';
@@ -17,6 +19,7 @@ export type AiComposeSettingsPublic = {
   defaultModel: string | null;
   allowedModels: string[];
   systemPrompt: string | null;
+  reasoningEffort: ReasoningEffort | null;
   apiKeyConfigured: boolean;
 };
 
@@ -49,6 +52,7 @@ export class AiComposeSettingsService {
       defaultModel: row?.defaultModel ?? null,
       allowedModels: row?.allowedModels ?? [],
       systemPrompt: row?.systemPrompt ?? null,
+      reasoningEffort: isReasoningEffort(row?.reasoningEffort) ? row.reasoningEffort : null,
       apiKeyConfigured: !!row?.apiKeyEnc,
     };
   }
@@ -59,6 +63,7 @@ export class AiComposeSettingsService {
     defaultModel?: string | null;
     allowedModels?: string[];
     systemPrompt?: string | null;
+    reasoningEffort?: ReasoningEffort | null;
   }): Promise<AiComposeSettingsPublic> {
     await this.assertPluginEnabled();
 
@@ -67,7 +72,7 @@ export class AiComposeSettingsService {
     let apiKeyEnc: string | undefined = undefined;
     if (dto.apiKey !== undefined && dto.apiKey.trim()) {
       if (!isAiComposeSecretsKeyConfigured()) {
-        throw AppException.badRequest('AI_COMPOSE_SECRETS_KEY is not configured');
+        throw AppException.badRequest('KHIRBY_SECRETS_KEY is not configured');
       }
       apiKeyEnc = encrypt(dto.apiKey.trim());
     }
@@ -83,6 +88,14 @@ export class AiComposeSettingsService {
       );
     }
 
+    if (
+      dto.reasoningEffort !== undefined &&
+      dto.reasoningEffort !== null &&
+      !isReasoningEffort(dto.reasoningEffort)
+    ) {
+      throw AppException.badRequest('reasoningEffort must be none, low, medium, or high');
+    }
+
     const patch: Record<string, unknown> = {
       baseUrl,
       defaultModel:
@@ -90,6 +103,12 @@ export class AiComposeSettingsService {
       allowedModels: dto.allowedModels ?? existing?.allowedModels ?? [],
       systemPrompt:
         dto.systemPrompt !== undefined ? dto.systemPrompt : (existing?.systemPrompt ?? null),
+      reasoningEffort:
+        dto.reasoningEffort !== undefined
+          ? dto.reasoningEffort
+          : isReasoningEffort(existing?.reasoningEffort)
+            ? existing.reasoningEffort
+            : null,
       updatedAt: new Date(),
     };
 
@@ -110,16 +129,26 @@ export class AiComposeSettingsService {
     return this.getSettings();
   }
 
-  /** Decrypt the stored API key for internal use; throws if missing. */
+  /** Decrypt the stored API key for internal use; throws if missing or unreadable. */
   async getDecryptedApiKey(): Promise<{ apiKey: string; baseUrl: string }> {
     const row = await this.getRow();
     if (!row?.apiKeyEnc) {
-      throw AppException.badRequest('AI Compose API key is not configured');
+      throw AppException.pluginNotConfigured('ai-compose', 'AI Compose API key is not configured');
+    }
+    try {
+      return {
+        apiKey: decrypt(row.apiKeyEnc),
+        baseUrl: row.baseUrl,
+      };
+    } catch (err) {
+      this.logger.warn(
+        `Failed to decrypt AI Compose API key: ${err instanceof Error ? err.message : 'unknown'}`,
+      );
+      throw AppException.pluginNotConfigured(
+        'ai-compose',
+        'AI Compose API key cannot be decrypted',
+      );
     }
-    return {
-      apiKey: decrypt(row.apiKeyEnc),
-      baseUrl: row.baseUrl,
-    };
   }
 
   async getAllowedModels(): Promise<string[]> {
@@ -136,4 +165,9 @@ export class AiComposeSettingsService {
     const row = await this.getRow();
     return row?.systemPrompt ?? null;
   }
+
+  async getReasoningEffort(): Promise<ReasoningEffort | null> {
+    const row = await this.getRow();
+    return isReasoningEffort(row?.reasoningEffort) ? row.reasoningEffort : null;
+  }
 }

package/src/ai-compose-suggest.service.ts

@@ -1,11 +1,16 @@
-import { Injectable, Inject, Logger, Optional } from '@nestjs/common';
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
 import {
   LEADS_SERVICE,
   MAIL_THREAD_SERVICE,
-  POKELO_CONTEXT_SERVICE,
+  KNOWLEDGE_CONTEXT,
   type MailThreadServiceLike,
-  type PokeloContextServiceLike,
+  type KnowledgeContextLike,
   AppException,
+  applyReasoningEffort,
+  isReasoningEffort,
+  parseModelReasoningSupport,
+  resolveLoadedProvider,
 } from '../../../packages/plugin-host/src';
 import { AiComposeSettingsService } from './ai-compose-settings.service';
 
@@ -33,16 +38,22 @@ export type LeadsServiceLike = {
 @Injectable()
 export class AiComposeSuggestService {
   private readonly logger = new Logger(AiComposeSuggestService.name);
+  /** Advertised (or learned from a 400) reasoning support, keyed by baseUrl + model id. */
+  private readonly reasoningByModel = new Map<string, boolean>();
+  private readonly catalogFetched = new Set<string>();
 
   constructor(
     private readonly settings: AiComposeSettingsService,
     @Inject(MAIL_THREAD_SERVICE) private readonly mailThreads: MailThreadServiceLike,
     @Inject(LEADS_SERVICE) private readonly leads: LeadsServiceLike,
-    @Optional()
-    @Inject(POKELO_CONTEXT_SERVICE)
-    private readonly pokeloContext: PokeloContextServiceLike | null = null,
+    private readonly moduleRef: ModuleRef,
   ) {}
 
+  /** Volume Pokelo may bind after this service is constructed (ADR-0048 / ADR-0050). */
+  private knowledge(): KnowledgeContextLike | null {
+    return resolveLoadedProvider<KnowledgeContextLike>(this.moduleRef, KNOWLEDGE_CONTEXT);
+  }
+
   async availability(): Promise<{ available: boolean; defaultModel: string | null }> {
     const defaultModel = await this.settings.getDefaultModel();
     try {
@@ -218,7 +229,10 @@ export class AiComposeSuggestService {
     return { draft, modelUsed };
   }
 
-  async fetchModels(baseUrl: string, apiKey: string): Promise<{ id: string; label: string }[]> {
+  async fetchModels(
+    baseUrl: string,
+    apiKey: string,
+  ): Promise<{ id: string; label: string; supportsReasoning: boolean | null }[]> {
     const response = await fetch(`${baseUrl}/models`, {
       headers: { Authorization: `Bearer ${apiKey}` },
     });
@@ -231,12 +245,40 @@ export class AiComposeSuggestService {
     }
 
     const data = (await response.json()) as {
-      data?: Array<{ id: string; object?: string }>;
+      data?: Array<Record<string, unknown> & { id?: string; object?: string }>;
     };
 
+    this.catalogFetched.add(this.originKey(baseUrl));
+
     return (data?.data ?? [])
-      .filter((m) => m.object === 'model' || !m.object)
-      .map((m) => ({ id: m.id, label: m.id }));
+      .filter((m) => typeof m.id === 'string' && (m.object === 'model' || !m.object))
+      .map((m) => {
+        const id = String(m.id);
+        const support = parseModelReasoningSupport(m);
+        if (support !== undefined) {
+          this.reasoningByModel.set(this.supportKey(baseUrl, id), support);
+        }
+        return { id, label: id, supportsReasoning: support ?? null };
+      });
+  }
+
+  async reasoningSupportFor(
+    baseUrl: string,
+    apiKey: string,
+    model: string,
+  ): Promise<boolean | undefined> {
+    const key = this.supportKey(baseUrl, model);
+    const cached = this.reasoningByModel.get(key);
+    if (cached !== undefined) return cached;
+    if (!this.catalogFetched.has(this.originKey(baseUrl))) {
+      await this.fetchModels(baseUrl, apiKey).catch(() => undefined);
+    }
+    return this.reasoningByModel.get(key);
+  }
+
+  /** In-memory only — Ask Khirby must not block SSE on GET /models. */
+  cachedReasoningSupport(baseUrl: string, model: string): boolean | undefined {
+    return this.reasoningByModel.get(this.supportKey(baseUrl, model));
   }
 
   /** Allowed models for compose UIs that are not integrations admins. */
@@ -304,35 +346,54 @@ export class AiComposeSuggestService {
   }): Promise<string> {
     const { apiKey, baseUrl } = await this.settings.getDecryptedApiKey();
 
-    let pokeloSnippets = '';
-    if (this.pokeloContext) {
-      const query = (input.ragQuery ?? input.userContent).slice(0, 800);
-      pokeloSnippets = await this.resolvePokeloSnippets({
-        query,
-        apiKey,
-        baseUrl,
-        modelUsed: input.modelUsed,
-      }).catch(() => '');
-    }
-
-    const systemContent = [input.systemContent, pokeloSnippets].filter(Boolean).join('\n\n');
+    const knowledgeQuery = (input.ragQuery ?? input.userContent).slice(0, 800);
+    const knowledge = this.knowledge();
+    const knowledgeSnippets = knowledge
+      ? await knowledge.fetchContext(knowledgeQuery).catch(() => '')
+      : '';
+
+    const systemContent = [input.systemContent, knowledgeSnippets].filter(Boolean).join('\n\n');
+    const reasoningEffort = await this.settings.getReasoningEffort();
+    const supportsReasoning = isReasoningEffort(reasoningEffort)
+      ? await this.reasoningSupportFor(baseUrl, apiKey, input.modelUsed)
+      : undefined;
+    const payload: Record<string, unknown> = {
+      model: input.modelUsed,
+      messages: [
+        { role: 'system', content: systemContent },
+        { role: 'user', content: input.userContent },
+      ],
+      temperature: 0.7,
+    };
+    const attempted = applyReasoningEffort(payload, reasoningEffort, supportsReasoning);
 
-    const response = await fetch(`${baseUrl}/chat/completions`, {
+    let response = await fetch(`${baseUrl}/chat/completions`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
         Authorization: `Bearer ${apiKey}`,
       },
-      body: JSON.stringify({
-        model: input.modelUsed,
-        messages: [
-          { role: 'system', content: systemContent },
-          { role: 'user', content: input.userContent },
-        ],
-        temperature: 0.7,
-      }),
+      body: JSON.stringify(attempted),
     });
 
+    if (
+      !response.ok &&
+      attempted.reasoning_effort &&
+      (response.status === 400 || response.status === 422)
+    ) {
+      this.reasoningByModel.set(this.supportKey(baseUrl, input.modelUsed), false);
+      response = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(payload),
+      });
+    } else if (response.ok && attempted.reasoning_effort) {
+      this.reasoningByModel.set(this.supportKey(baseUrl, input.modelUsed), true);
+    }
+
     if (!response.ok) {
       const errorText = await response.text().catch(() => 'unknown error');
       this.logger.error(`AI provider error ${response.status}: ${errorText}`);
@@ -352,162 +413,12 @@ export class AiComposeSuggestService {
     return draft;
   }
 
-  /**
-   * Multi-project Pokelo RAG (ADR-0022):
-   * - 0 bound → ''
-   * - 1–2 bound → direct search (no extra LLM round-trip)
-   * - 3+ → cheap router LLM picks primary (+ optional followUp), then search
-   */
-  private async resolvePokeloSnippets(input: {
-    query: string;
-    apiKey: string;
-    baseUrl: string;
-    modelUsed: string;
-  }): Promise<string> {
-    if (!this.pokeloContext) return '';
-
-    const bound = (await this.pokeloContext.listBoundProjects?.().catch(() => [])) ?? [];
-    if (bound.length === 0) {
-      return this.pokeloContext.fetchContext(input.query).catch(() => '');
-    }
-
-    // One or two projects: search them all — router adds latency/cost for little gain
-    // and some providers reject the router's stricter completion params (HTTP 400).
-    if (bound.length <= 2) {
-      return this.pokeloContext.fetchContext(input.query, {
-        projectIds: bound.map((p) => p.id),
-      });
-    }
-
-    const route = await this.routePokeloProjects({
-      query: input.query,
-      projects: bound,
-      apiKey: input.apiKey,
-      baseUrl: input.baseUrl,
-      modelUsed: input.modelUsed,
-    });
-
-    const primaryIds = route.primary.length > 0 ? route.primary : [bound[0].id];
-    let snippets = await this.pokeloContext.fetchContext(input.query, {
-      projectIds: primaryIds,
-    });
-
-    // Second pass: also pull from another brand/project when the router asked for it.
-    const followUp = route.followUp.filter((id) => !primaryIds.includes(id));
-    if (followUp.length > 0) {
-      const more = await this.pokeloContext.fetchContext(input.query, {
-        projectIds: followUp,
-      });
-      if (more) {
-        snippets = [snippets, more].filter(Boolean).join('\n\n');
-      }
-    }
-
-    return snippets;
+  private originKey(baseUrl: string): string {
+    return baseUrl.replace(/\/$/, '');
   }
 
-  private async routePokeloProjects(input: {
-    query: string;
-    projects: Array<{ id: string; name: string }>;
-    apiKey: string;
-    baseUrl: string;
-    modelUsed: string;
-  }): Promise<{ primary: string[]; followUp: string[] }> {
-    const catalog = input.projects.map((p) => `- ${p.name} (${p.id})`).join('\n');
-
-    const system = [
-      'You route knowledge-base lookups for a CRM AI assistant.',
-      'Given a drafting query and available Pokelo projects (brands/products),',
-      'choose which projects to search.',
-      'Return ONLY compact JSON: {"primary":["uuid",...],"followUp":["uuid",...]}',
-      'Rules:',
-      '- primary: 1–2 most relevant projects to search first',
-      '- followUp: 0–1 extra project if a second brand/product may add useful context',
-      '- use only IDs from the catalog',
-      '- if unsure, put the broadest/most central project in primary and leave followUp empty',
-    ].join(' ');
-
-    const user = [
-      'Available projects:',
-      catalog,
-      '',
-      'Drafting query:',
-      input.query.slice(0, 800),
-    ].join('\n');
-
-    try {
-      // Keep the body aligned with completeChat — many OpenAI-compatible providers
-      // reject max_tokens and/or temperature: 0 (HTTP 400) while accepting the draft call.
-      const response = await fetch(`${input.baseUrl}/chat/completions`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${input.apiKey}`,
-        },
-        body: JSON.stringify({
-          model: input.modelUsed,
-          messages: [
-            { role: 'system', content: system },
-            { role: 'user', content: user },
-          ],
-          temperature: 0.7,
-        }),
-      });
-
-      if (!response.ok) {
-        const errText = await response.text().catch(() => '');
-        this.logger.warn(
-          `Pokelo router HTTP ${response.status} — falling back to all projects: ${errText.slice(0, 300)}`,
-        );
-        return {
-          primary: input.projects.slice(0, 2).map((p) => p.id),
-          followUp: input.projects.slice(2, 3).map((p) => p.id),
-        };
-      }
-
-      const data = (await response.json()) as {
-        choices?: Array<{ message?: { content?: string } }>;
-      };
-      const raw = data?.choices?.[0]?.message?.content ?? '';
-      return parsePokeloRoute(
-        raw,
-        input.projects.map((p) => p.id),
-      );
-    } catch (err) {
-      this.logger.warn(`Pokelo router failed: ${(err as Error).message}`);
-      return {
-        primary: input.projects.slice(0, 2).map((p) => p.id),
-        followUp: input.projects.slice(2, 3).map((p) => p.id),
-      };
-    }
-  }
-}
-
-/** Exported for unit tests. */
-export function parsePokeloRoute(
-  raw: string,
-  allowedIds: string[],
-): { primary: string[]; followUp: string[] } {
-  const allowed = new Set(allowedIds);
-  const empty = { primary: [] as string[], followUp: [] as string[] };
-  const jsonMatch = raw.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) return empty;
-  try {
-    const parsed = JSON.parse(jsonMatch[0]) as {
-      primary?: unknown;
-      followUp?: unknown;
-    };
-    const pick = (v: unknown, max: number) =>
-      (Array.isArray(v) ? v : [])
-        .filter((id): id is string => typeof id === 'string' && allowed.has(id))
-        .filter((id, i, arr) => arr.indexOf(id) === i)
-        .slice(0, max);
-    return {
-      primary: pick(parsed.primary, 2),
-      followUp: pick(parsed.followUp, 1),
-    };
-  } catch {
-    return empty;
+  private supportKey(baseUrl: string, model: string): string {
+    return `${this.originKey(baseUrl)}\0${model}`;
   }
 }
 

package/src/ai-compose.spec.ts

@@ -4,7 +4,6 @@ import { AiComposeLlmService } from './ai-compose-llm.service';
 import {
   AiComposeSuggestService,
   stripCodeFences,
-  parsePokeloRoute,
 } from './ai-compose-suggest.service';
 import { AppException } from '../../../packages/plugin-host/src';
 
@@ -16,11 +15,17 @@ describe('ai-compose-crypto', () => {
   const HEX_KEY = 'a'.repeat(64);
 
   beforeEach(() => {
+    delete process.env.KHIRBY_SECRETS_KEY;
+    delete process.env.MAIL_SECRETS_KEY;
+    delete process.env.POKELO_SECRETS_KEY;
     process.env.AI_COMPOSE_SECRETS_KEY = HEX_KEY;
   });
 
   afterEach(() => {
+    delete process.env.KHIRBY_SECRETS_KEY;
+    delete process.env.MAIL_SECRETS_KEY;
     delete process.env.AI_COMPOSE_SECRETS_KEY;
+    delete process.env.POKELO_SECRETS_KEY;
   });
 
   it('encrypts and decrypts back to the same plaintext', () => {
@@ -42,7 +47,7 @@ describe('ai-compose-crypto', () => {
 
   it('throws on missing key at encrypt time', () => {
     delete process.env.AI_COMPOSE_SECRETS_KEY;
-    expect(() => encrypt('anything')).toThrow('AI_COMPOSE_SECRETS_KEY is not set');
+    expect(() => encrypt('anything')).toThrow('KHIRBY_SECRETS_KEY is not set');
   });
 });
 
@@ -118,6 +123,7 @@ describe('AiComposeSettingsService', () => {
     const settings = await service.getSettings();
     expect(settings.apiKeyConfigured).toBe(false);
     expect(settings.baseUrl).toBe('https://api.openai.com/v1');
+    expect(settings.reasoningEffort).toBe(null);
   });
 
   it('getSettings returns apiKeyConfigured: true when row has apiKeyEnc', async () => {
@@ -155,6 +161,15 @@ describe('AiComposeSettingsService', () => {
     const service = new AiComposeSettingsService(db as any, registry as any);
     await expect(service.updateSettings({ baseUrl: 'http://localhost' })).resolves.toBeDefined();
   });
+
+  it('updateSettings rejects an unknown reasoningEffort', async () => {
+    const db = makeMockDb();
+    const registry = makeMockRegistry(true);
+    const service = new AiComposeSettingsService(db as any, registry as any);
+    await expect(service.updateSettings({ reasoningEffort: 'banana' as any })).rejects.toThrow(
+      'reasoningEffort',
+    );
+  });
 });
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -168,6 +183,7 @@ function makeSettingsService(
     allowedModels: string[];
     defaultModel: string | null;
     systemPrompt: string | null;
+    reasoningEffort: 'none' | 'low' | 'medium' | 'high' | null;
   }> = {},
 ) {
   const cfg = {
@@ -176,6 +192,7 @@ function makeSettingsService(
     allowedModels: ['gpt-4o', 'gpt-3.5-turbo'],
     defaultModel: 'gpt-4o',
     systemPrompt: null,
+    reasoningEffort: null as 'none' | 'low' | 'medium' | 'high' | null,
     ...overrides,
   };
 
@@ -184,10 +201,40 @@ function makeSettingsService(
     getAllowedModels: jest.fn().mockResolvedValue(cfg.allowedModels),
     getDefaultModel: jest.fn().mockResolvedValue(cfg.defaultModel),
     getSystemPrompt: jest.fn().mockResolvedValue(cfg.systemPrompt),
+    getReasoningEffort: jest.fn().mockResolvedValue(cfg.reasoningEffort),
     assertPluginEnabled: jest.fn().mockResolvedValue(undefined),
   };
 }
 
+function mockProviderFetch(
+  opts: {
+    models?: Array<Record<string, unknown>>;
+    content?: string;
+  } = {},
+) {
+  (global.fetch as jest.Mock).mockImplementation(async (url: string) => {
+    if (String(url).includes('/models')) {
+      return {
+        ok: true,
+        json: async () => ({ data: opts.models ?? [] }),
+      };
+    }
+    return {
+      ok: true,
+      json: async () => ({
+        choices: [{ message: { content: opts.content ?? 'ok' } }],
+      }),
+    };
+  });
+}
+
+function chatBodyFromFetch(index = 0): Record<string, unknown> {
+  const calls = (global.fetch as jest.Mock).mock.calls.filter((c: [string]) =>
+    String(c[0]).includes('/chat/completions'),
+  );
+  return JSON.parse(calls[index][1].body);
+}
+
 const MOCK_THREAD = {
   id: 'thread-1',
   subject: 'Hello',
@@ -208,6 +255,13 @@ const MOCK_THREAD = {
   ],
 };
 
+
+function mockModuleRef(knowledge: unknown = null) {
+  return {
+    get: jest.fn().mockReturnValue(knowledge),
+  } as any;
+}
+
 describe('AiComposeSuggestService', () => {
   const mockMailThreads = {
     getThread: jest.fn().mockResolvedValue(MOCK_THREAD),
@@ -255,6 +309,7 @@ describe('AiComposeSuggestService', () => {
       settings as any,
       mockMailThreads as any,
       mockLeads as any,
+      mockModuleRef(),
     );
 
     const result = await service.suggest({ threadId: 'thread-1', leadId: 'l-1' });
@@ -266,12 +321,121 @@ describe('AiComposeSuggestService', () => {
     );
   });
 
+  it('sends reasoning_effort when the catalog advertises it', async () => {
+    mockProviderFetch({
+      models: [
+        {
+          id: 'reasoner',
+          object: 'model',
+          supported_parameters: ['max_tokens', 'reasoning_effort'],
+        },
+      ],
+    });
+    const settings = makeSettingsService({
+      defaultModel: 'reasoner',
+      allowedModels: ['reasoner'],
+      reasoningEffort: 'high',
+    });
+    const service = new AiComposeSuggestService(
+      settings as any,
+      mockMailThreads as any,
+      mockLeads as any,
+      mockModuleRef(),
+    );
+    await service.suggest({ threadId: 'thread-1' });
+    const body = chatBodyFromFetch();
+    expect(body.reasoning_effort).toBe('high');
+    expect(body.temperature).toBeUndefined();
+  });
+
+  it('does not send reasoning_effort when the catalog lists params without it', async () => {
+    mockProviderFetch({
+      models: [
+        {
+          id: 'gpt-4o',
+          object: 'model',
+          supported_parameters: ['temperature', 'max_tokens'],
+        },
+      ],
+    });
+    const settings = makeSettingsService({ reasoningEffort: 'high' });
+    const service = new AiComposeSuggestService(
+      settings as any,
+      mockMailThreads as any,
+      mockLeads as any,
+      mockModuleRef(),
+    );
+    await service.suggest({ threadId: 'thread-1' });
+    const body = chatBodyFromFetch();
+    expect(body.reasoning_effort).toBeUndefined();
+    expect(body.temperature).toBe(0.7);
+  });
+
+  it('tries reasoning_effort when the catalog is silent, then drops it after HTTP 400', async () => {
+    let completions = 0;
+    (global.fetch as jest.Mock).mockImplementation(async (url: string) => {
+      if (String(url).includes('/models')) {
+        return {
+          ok: true,
+          json: async () => ({ data: [{ id: 'gpt-4o', object: 'model' }] }),
+        };
+      }
+      completions += 1;
+      if (completions === 1) {
+        return { ok: false, status: 400, text: async () => 'unknown parameter' };
+      }
+      return {
+        ok: true,
+        json: async () => ({ choices: [{ message: { content: 'ok' } }] }),
+      };
+    });
+    const settings = makeSettingsService({ reasoningEffort: 'high' });
+    const service = new AiComposeSuggestService(
+      settings as any,
+      mockMailThreads as any,
+      mockLeads as any,
+      mockModuleRef(),
+    );
+    await service.suggest({ threadId: 'thread-1' });
+    expect(completions).toBe(2);
+    expect(chatBodyFromFetch(0).reasoning_effort).toBe('high');
+    expect(chatBodyFromFetch(1).reasoning_effort).toBeUndefined();
+
+    await service.suggest({ threadId: 'thread-1' });
+    expect(completions).toBe(3);
+    expect(chatBodyFromFetch(2).reasoning_effort).toBeUndefined();
+  });
+
+  it('exposes catalog reasoning flags from fetchModels', async () => {
+    mockProviderFetch({
+      models: [
+        { id: 'a', object: 'model', supported_parameters: ['reasoning'] },
+        { id: 'b', object: 'model', supported_parameters: ['temperature'] },
+        { id: 'c', object: 'model' },
+      ],
+    });
+    const service = new AiComposeSuggestService(
+      makeSettingsService() as any,
+      mockMailThreads as any,
+      mockLeads as any,
+      mockModuleRef(),
+    );
+    await expect(
+      service.fetchModels('https://api.openai.com/v1', 'sk-test'),
+    ).resolves.toEqual([
+      { id: 'a', label: 'a', supportsReasoning: true },
+      { id: 'b', label: 'b', supportsReasoning: false },
+      { id: 'c', label: 'c', supportsReasoning: null },
+    ]);
+  });
+
   it('throws 400 when model not in allowlist', async () => {
     const settings = makeSettingsService({ allowedModels: ['gpt-4o'] });
     const service = new AiComposeSuggestService(
       settings as any,
       mockMailThreads as any,
       mockLeads as any,
+      mockModuleRef(),
     );
 
     await expect(service.suggest({ threadId: 'thread-1', model: 'claude-3' })).rejects.toThrow();
@@ -288,6 +452,7 @@ describe('AiComposeSuggestService', () => {
       settings as any,
       mockMailThreads as any,
       mockLeads as any,
+      mockModuleRef(),
     );
 
     await expect(service.suggest({ threadId: 'thread-1' })).rejects.toThrow(
@@ -307,6 +472,7 @@ describe('AiComposeSuggestService', () => {
       settings as any,
       mockMailThreads as any,
       mockLeads as any,
+      mockModuleRef(),
     );
 
     await expect(service.suggest({ threadId: 'thread-1' })).rejects.toThrow();
@@ -323,6 +489,7 @@ describe('AiComposeSuggestService', () => {
       settings as any,
       mockMailThreads as any,
       mockLeads as any,
+      mockModuleRef(),
     );
 
     await service.suggest({ threadId: 'thread-1', instruction: 'Be formal' });
@@ -346,6 +513,7 @@ describe('AiComposeSuggestService', () => {
       settings as any,
       mockMailThreads as any,
       mockLeads as any,
+      mockModuleRef(),
     );
 
     const result = await service.suggest({ leadId: 'l-1' });
@@ -369,141 +537,40 @@ describe('AiComposeSuggestService', () => {
       settings as any,
       mockMailThreads as any,
       mockLeads as any,
+      mockModuleRef(),
     );
 
     await expect(service.suggest({})).rejects.toThrow('Either threadId or leadId is required');
   });
 
-  it('appends Pokelo snippets to the system message when context service is present', async () => {
+  it('appends knowledge snippets to the system message when a provider is present', async () => {
     (global.fetch as jest.Mock).mockResolvedValue({
       ok: true,
       json: async () => ({ choices: [{ message: { content: 'Draft' } }] }),
     });
 
-    const pokelo = {
-      fetchContext: jest.fn().mockResolvedValue('--- Kontekst z Pokelo ---\nPricing is X'),
-      listBoundProjects: jest.fn().mockResolvedValue([{ id: 'p1', name: 'CRM' }]),
+    const knowledge = {
+      fetchContext: jest.fn().mockResolvedValue('Pricing is X'),
     };
     const settings = makeSettingsService();
     const service = new AiComposeSuggestService(
       settings as any,
       mockMailThreads as any,
       mockLeads as any,
-      pokelo as any,
+      mockModuleRef(knowledge),
     );
 
     await service.suggest({ threadId: 'thread-1', leadId: 'l-1', instruction: 'Be brief' });
 
-    expect(pokelo.fetchContext).toHaveBeenCalledWith(expect.any(String), {
-      projectIds: ['p1'],
-    });
+    expect(knowledge.fetchContext).toHaveBeenCalledTimes(1);
+    expect(knowledge.fetchContext).toHaveBeenCalledWith(expect.any(String));
+    expect(knowledge.fetchContext.mock.calls[0][1]).toBeUndefined();
     const body = JSON.parse((global.fetch as jest.Mock).mock.calls[0][1].body);
     const systemMsg = body.messages.find((m: { role: string }) => m.role === 'system');
-    expect(systemMsg.content).toContain('Kontekst z Pokelo');
     expect(systemMsg.content).toContain('Pricing is X');
   });
 
-  it('routes across multiple Pokelo projects then fetches follow-up', async () => {
-    (global.fetch as jest.Mock).mockImplementation(async (_url: string, init: { body: string }) => {
-      const body = JSON.parse(init.body);
-      const system = body.messages?.[0]?.content ?? '';
-      if (typeof system === 'string' && system.includes('route knowledge-base')) {
-        // Router payload must match draft call (no max_tokens / no temperature:0)
-        expect(body.max_tokens).toBeUndefined();
-        expect(body.temperature).toBe(0.7);
-        return {
-          ok: true,
-          json: async () => ({
-            choices: [
-              {
-                message: {
-                  content: JSON.stringify({
-                    primary: ['crm'],
-                    followUp: ['finsly'],
-                  }),
-                },
-              },
-            ],
-          }),
-        };
-      }
-      return {
-        ok: true,
-        json: async () => ({ choices: [{ message: { content: 'Draft' } }] }),
-      };
-    });
-
-    const pokelo = {
-      listBoundProjects: jest.fn().mockResolvedValue([
-        { id: 'crm', name: 'Bearly CRM' },
-        { id: 'finsly', name: 'Finsly' },
-        { id: 'pokelo', name: 'Pokelo' },
-      ]),
-      fetchContext: jest
-        .fn()
-        .mockResolvedValueOnce('--- Kontekst z Pokelo ---\n[Bearly CRM] CRM facts')
-        .mockResolvedValueOnce('--- Kontekst z Pokelo ---\n[Finsly] Billing facts'),
-    };
-
-    const service = new AiComposeSuggestService(
-      makeSettingsService() as any,
-      mockMailThreads as any,
-      mockLeads as any,
-      pokelo as any,
-    );
-
-    await service.suggest({ threadId: 'thread-1', instruction: 'Mention Finsly pricing' });
-
-    expect(pokelo.fetchContext).toHaveBeenNthCalledWith(1, expect.any(String), {
-      projectIds: ['crm'],
-    });
-    expect(pokelo.fetchContext).toHaveBeenNthCalledWith(2, expect.any(String), {
-      projectIds: ['finsly'],
-    });
-
-    const composeCall = (global.fetch as jest.Mock).mock.calls.find((c) => {
-      const body = JSON.parse(c[1].body);
-      return !String(body.messages?.[0]?.content ?? '').includes('route knowledge-base');
-    });
-    const systemMsg = JSON.parse(composeCall[1].body).messages.find(
-      (m: { role: string }) => m.role === 'system',
-    );
-    expect(systemMsg.content).toContain('CRM facts');
-    expect(systemMsg.content).toContain('Billing facts');
-  });
-
-  it('searches both projects directly when exactly two are bound (no router)', async () => {
-    (global.fetch as jest.Mock).mockResolvedValue({
-      ok: true,
-      json: async () => ({ choices: [{ message: { content: 'Draft' } }] }),
-    });
-
-    const pokelo = {
-      listBoundProjects: jest.fn().mockResolvedValue([
-        { id: 'crm', name: 'Bearly CRM' },
-        { id: 'finsly', name: 'Finsly' },
-      ]),
-      fetchContext: jest.fn().mockResolvedValue('--- Kontekst z Pokelo ---\n[CRM] a\n[Finsly] b'),
-    };
-
-    const service = new AiComposeSuggestService(
-      makeSettingsService() as any,
-      mockMailThreads as any,
-      mockLeads as any,
-      pokelo as any,
-    );
-
-    await service.suggest({ threadId: 'thread-1', instruction: 'Hello' });
-
-    expect(pokelo.fetchContext).toHaveBeenCalledTimes(1);
-    expect(pokelo.fetchContext).toHaveBeenCalledWith(expect.any(String), {
-      projectIds: ['crm', 'finsly'],
-    });
-    // Only the compose completion — no router call
-    expect(global.fetch).toHaveBeenCalledTimes(1);
-  });
-
-  it('works without Pokelo when context service is null', async () => {
+  it('works without a knowledge provider', async () => {
     (global.fetch as jest.Mock).mockResolvedValue({
       ok: true,
       json: async () => ({ choices: [{ message: { content: 'Draft' } }] }),
@@ -514,13 +581,13 @@ describe('AiComposeSuggestService', () => {
       settings as any,
       mockMailThreads as any,
       mockLeads as any,
-      null,
+      mockModuleRef(),
     );
 
     await service.suggest({ threadId: 'thread-1' });
     const body = JSON.parse((global.fetch as jest.Mock).mock.calls[0][1].body);
     const systemMsg = body.messages.find((m: { role: string }) => m.role === 'system');
-    expect(systemMsg.content).not.toContain('Kontekst z Pokelo');
+    expect(systemMsg.content).not.toContain('Pricing is X');
   });
 });
 
@@ -538,7 +605,12 @@ describe('AiComposeSuggestService.generateNewsletter', () => {
   });
 
   function service(settings = makeSettingsService()) {
-    return new AiComposeSuggestService(settings as any, mockMailThreads as any, mockLeads as any);
+    return new AiComposeSuggestService(
+      settings as any,
+      mockMailThreads as any,
+      mockLeads as any,
+      mockModuleRef(),
+    );
   }
 
   it('asks the model for HTML and strips fences', async () => {
@@ -626,21 +698,20 @@ describe('AiComposeSuggestService.generateNewsletter', () => {
     expect(userMsg.content).toContain('## Old draft');
   });
 
-  it('appends Pokelo snippets for newsletter generate', async () => {
+  it('appends knowledge snippets for newsletter generate', async () => {
     (global.fetch as jest.Mock).mockResolvedValue({
       ok: true,
       json: async () => ({ choices: [{ message: { content: '<p>Hi</p>' } }] }),
     });
 
-    const pokelo = {
-      fetchContext: jest.fn().mockResolvedValue('--- Kontekst z Pokelo ---\nBrand voice: warm'),
-      listBoundProjects: jest.fn().mockResolvedValue([{ id: 'p1', name: 'CRM' }]),
+    const knowledge = {
+      fetchContext: jest.fn().mockResolvedValue('Brand voice: warm'),
     };
     const svc = new AiComposeSuggestService(
       makeSettingsService() as any,
       mockMailThreads as any,
       mockLeads as any,
-      pokelo as any,
+      mockModuleRef(knowledge),
     );
 
     await svc.generateNewsletter({
@@ -650,37 +721,13 @@ describe('AiComposeSuggestService.generateNewsletter', () => {
       instruction: 'Product news',
     });
 
-    expect(pokelo.fetchContext).toHaveBeenCalledWith(expect.stringContaining('Product news'), {
-      projectIds: ['p1'],
-    });
+    expect(knowledge.fetchContext).toHaveBeenCalledWith(expect.stringContaining('Product news'));
     const body = JSON.parse((global.fetch as jest.Mock).mock.calls[0][1].body);
     const systemMsg = body.messages.find((m: { role: string }) => m.role === 'system');
     expect(systemMsg.content).toContain('Brand voice: warm');
   });
 });
 
-describe('parsePokeloRoute', () => {
-  it('extracts primary and followUp IDs from JSON', () => {
-    const route = parsePokeloRoute('Here you go:\n{"primary":["a","b"],"followUp":["c"]}\n', [
-      'a',
-      'b',
-      'c',
-      'd',
-    ]);
-    expect(route).toEqual({ primary: ['a', 'b'], followUp: ['c'] });
-  });
-
-  it('drops unknown IDs and caps lengths', () => {
-    const route = parsePokeloRoute('{"primary":["a","b","x","y"],"followUp":["c","d"]}', [
-      'a',
-      'b',
-      'c',
-    ]);
-    expect(route.primary).toEqual(['a', 'b']);
-    expect(route.followUp).toEqual(['c']);
-  });
-});
-
 describe('stripCodeFences', () => {
   it('unwraps fenced blocks', () => {
     expect(stripCodeFences('```md\n# Hi\n```')).toBe('# Hi');
@@ -692,7 +739,7 @@ describe('stripCodeFences', () => {
 });
 
 describe('AiComposeLlmService', () => {
-  it('returns null when no default model is set', async () => {
+  it('throws when no default model is set', async () => {
     const settings = {
       assertPluginEnabled: jest.fn().mockResolvedValue(undefined),
       getDecryptedApiKey: jest.fn().mockResolvedValue({
@@ -700,10 +747,11 @@ describe('AiComposeLlmService', () => {
         baseUrl: 'https://api.openai.com/v1',
       }),
       getDefaultModel: jest.fn().mockResolvedValue(null),
+      getReasoningEffort: jest.fn().mockResolvedValue(null),
     } as unknown as AiComposeSettingsService;
 
-    const svc = new AiComposeLlmService(settings);
-    await expect(svc.getCompletionConfig()).resolves.toBeNull();
+    const svc = new AiComposeLlmService(settings, { reasoningSupportFor: jest.fn() } as any);
+    await expect(svc.getCompletionConfig()).rejects.toThrow(/No default model configured/);
   });
 
   it('returns BYOK config when settings are complete', async () => {
@@ -714,13 +762,25 @@ describe('AiComposeLlmService', () => {
         baseUrl: 'https://api.openai.com/v1',
       }),
       getDefaultModel: jest.fn().mockResolvedValue('gpt-4o-mini'),
+      getReasoningEffort: jest.fn().mockResolvedValue('medium'),
     } as unknown as AiComposeSettingsService;
+    const suggest = {
+      cachedReasoningSupport: jest.fn().mockReturnValue(true),
+      reasoningSupportFor: jest.fn(),
+    };
 
-    const svc = new AiComposeLlmService(settings);
+    const svc = new AiComposeLlmService(settings, suggest as any);
     await expect(svc.getCompletionConfig()).resolves.toEqual({
       apiKey: 'sk-test',
       baseUrl: 'https://api.openai.com/v1',
       model: 'gpt-4o-mini',
+      reasoningEffort: 'medium',
+      reasoningSupported: true,
     });
+    expect(suggest.cachedReasoningSupport).toHaveBeenCalledWith(
+      'https://api.openai.com/v1',
+      'gpt-4o-mini',
+    );
+    expect(suggest.reasoningSupportFor).not.toHaveBeenCalled();
   });
 });

package/src/migrations.ts

@@ -12,5 +12,7 @@ CREATE TABLE IF NOT EXISTS ai_compose_settings (
   system_prompt TEXT,
   created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
   updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-)
+);
+
+ALTER TABLE ai_compose_settings ADD COLUMN IF NOT EXISTS reasoning_effort TEXT
 `;

package/src/schema.ts

@@ -7,6 +7,7 @@ export const aiComposeSettings = pgTable('ai_compose_settings', {
   defaultModel: text('default_model'),
   allowedModels: text('allowed_models').array().notNull().default([]),
   systemPrompt: text('system_prompt'),
+  reasoningEffort: text('reasoning_effort'),
   createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
   updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
 });