@zhin.js/agent 0.0.0 → 0.0.1

package/src/init/register-ai-trigger.ts

@@ -0,0 +1,179 @@
+/**
+ * Register AI trigger handler via MessageDispatcher or fallback middleware.
+ */
+import './types.js';
+import { getPlugin, Message, shouldTriggerAI, inferSenderPermissions, parseRichMediaContent, mergeAITriggerConfig } from '@zhin.js/core';
+import type { Tool, ToolContext } from '@zhin.js/core';
+import type { ContentPart } from '@zhin.js/core';
+import type { OutputElement } from '../output.js';
+import type { AIServiceRefs } from './shared-refs.js';
+
+function extractImageUrls(message: Message<any>): string[] {
+  const urls: string[] = [];
+  const raw = typeof message.$raw === 'string' ? message.$raw : JSON.stringify(message.$raw || '');
+
+  const xmlMatches = raw.match(/<image[^>]+url="([^"]+)"/g);
+  if (xmlMatches) {
+    for (const m of xmlMatches) {
+      const urlMatch = m.match(/url="([^"]+)"/);
+      if (urlMatch) urls.push(urlMatch[1]);
+    }
+  }
+
+  const cqMatches = raw.match(/\[CQ:image[^\]]*url=([^\],]+)/g);
+  if (cqMatches) {
+    for (const m of cqMatches) {
+      const urlMatch = m.match(/url=([^\],]+)/);
+      if (urlMatch) urls.push(urlMatch[1]);
+    }
+  }
+
+  return urls;
+}
+
+function renderOutput(elements: OutputElement[]): string {
+  const parts: string[] = [];
+  for (const el of elements) {
+    switch (el.type) {
+      case 'text':
+        if (el.content) parts.push(el.content);
+        break;
+      case 'image':
+        parts.push(`<image url="${el.url}"/>`);
+        break;
+      case 'audio':
+        parts.push(`<audio url="${el.url}"/>`);
+        break;
+      case 'video':
+        parts.push(`<video url="${el.url}"/>`);
+        break;
+      case 'card': {
+        const cp = [`📋 ${el.title}`];
+        if (el.description) cp.push(el.description);
+        if (el.fields?.length)
+          for (const f of el.fields) cp.push(`  ${f.label}: ${f.value}`);
+        if (el.imageUrl) cp.push(`<image url="${el.imageUrl}"/>`);
+        parts.push(cp.join('\n'));
+        break;
+      }
+      case 'file':
+        parts.push(`📎 ${el.name}: ${el.url}`);
+        break;
+    }
+  }
+  return parts.join('\n') || '';
+}
+
+export function registerAITrigger(refs: AIServiceRefs): void {
+  const plugin = getPlugin();
+  const { useContext, root, logger } = plugin;
+
+  useContext('ai', (ai) => {
+    const rawConfig = ai.getTriggerConfig();
+    const triggerConfig = mergeAITriggerConfig(rawConfig);
+    if (!triggerConfig.enabled) {
+      logger.info('AI Trigger is disabled');
+      return;
+    }
+
+    const handleAIMessage = async (
+      message: Message<any>,
+      content: string,
+    ) => {
+      const t0 = performance.now();
+      if (!ai.isReady()) return;
+      if (triggerConfig.thinkingMessage)
+        await message.$reply(triggerConfig.thinkingMessage);
+
+      const permissions = inferSenderPermissions(message, triggerConfig);
+      const toolContext: ToolContext = {
+        platform: message.$adapter,
+        botId: message.$bot,
+        sceneId: message.$channel?.id || message.$sender.id,
+        senderId: message.$sender.id,
+        message,
+        scope: permissions.scope,
+        senderPermissionLevel: permissions.permissionLevel,
+        isGroupAdmin: permissions.isGroupAdmin,
+        isGroupOwner: permissions.isGroupOwner,
+        isBotAdmin: permissions.isBotAdmin,
+        isOwner: permissions.isOwner,
+      };
+
+      const tCollect = performance.now();
+      const toolService = root.inject('tool');
+      let externalTools: Tool[] = [];
+      if (toolService) {
+        externalTools = toolService.collectAll(root);
+        externalTools = toolService.filterByContext(externalTools, toolContext);
+      }
+      logger.debug(`[AI Handler] 工具收集: ${externalTools.length} 个, ${(performance.now() - tCollect).toFixed(0)}ms`);
+
+      try {
+        const timeout = new Promise<never>((_, rej) =>
+          setTimeout(() => rej(new Error('AI 响应超时')), triggerConfig.timeout),
+        );
+
+        let responseText: string;
+        if (refs.zhinAgent) {
+          const imageUrls = extractImageUrls(message);
+          let elements: OutputElement[];
+          if (imageUrls.length > 0) {
+            const parts: ContentPart[] = [];
+            if (content) parts.push({ type: 'text', text: content });
+            for (const url of imageUrls) {
+              parts.push({ type: 'image_url', image_url: { url } });
+            }
+            elements = await Promise.race([
+              refs.zhinAgent.processMultimodal(parts, toolContext),
+              timeout,
+            ]);
+          } else {
+            elements = await Promise.race([
+              refs.zhinAgent.process(content, toolContext, externalTools),
+              timeout,
+            ]);
+          }
+          responseText = renderOutput(elements);
+        } else {
+          const response = await Promise.race([
+            ai.process(content, toolContext, externalTools),
+            timeout,
+          ]);
+          responseText = typeof response === 'string' ? response : '';
+        }
+
+        if (responseText) await message.$reply(parseRichMediaContent(responseText));
+        logger.info(`[AI Handler] 总耗时: ${(performance.now() - t0).toFixed(0)}ms`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.warn(`[AI Handler] 失败 (${(performance.now() - t0).toFixed(0)}ms): ${msg}`);
+        await message.$reply(triggerConfig.errorTemplate.replace('{error}', msg));
+      }
+    };
+
+    const dispatcher = root.inject('dispatcher');
+
+    if (dispatcher && typeof dispatcher.setAIHandler === 'function') {
+      dispatcher.setAITriggerMatcher((message: Message<any>) =>
+        shouldTriggerAI(message, triggerConfig),
+      );
+      dispatcher.setAIHandler(handleAIMessage);
+      logger.debug('AI Handler registered via MessageDispatcher');
+      return () => { logger.info('AI Handler unregistered'); };
+    }
+
+    const aiMw = async (
+      message: Message<any>,
+      next: () => Promise<void>,
+    ) => {
+      const { triggered, content } = shouldTriggerAI(message, triggerConfig);
+      if (!triggered) return await next();
+      await handleAIMessage(message, content);
+      await next();
+    };
+    const dispose = root.addMiddleware(aiMw);
+    logger.debug('AI Trigger middleware registered (fallback mode)');
+    return () => { dispose(); };
+  });
+}

package/src/init/register-builtin-tools.ts

@@ -0,0 +1,177 @@
+/**
+ * Register built-in system tools (file/shell/web/schedule/memory/skill)
+ * and workspace skills with hot-reload support.
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { getPlugin, type Tool, type SkillFeature } from '@zhin.js/core';
+import { createBuiltinTools, discoverWorkspaceSkills, loadAlwaysSkillsContent, buildSkillsSummaryXML } from '../builtin-tools.js';
+import { resolveSkillInstructionMaxChars, DEFAULT_CONFIG } from '../zhin-agent/config.js';
+import { loadBootstrapFiles, buildContextFiles, buildBootstrapContextSection } from '../bootstrap.js';
+import { triggerAIHook, createAIHookEvent } from '../hooks.js';
+import { createCronTools } from '../cron-engine.js';
+import type { AIServiceRefs } from './shared-refs.js';
+
+export function registerBuiltinTools(refs: AIServiceRefs): void {
+  const plugin = getPlugin();
+  const { useContext, root, logger } = plugin;
+
+  useContext('ai', 'tool', (ai, toolService) => {
+    if (!ai || !toolService) return;
+
+    const provider = ai.getProvider();
+    const agentCfg = ai.getAgentConfig();
+    const fullCfg = { ...DEFAULT_CONFIG, ...agentCfg } as Required<import('../zhin-agent/config.js').ZhinAgentConfig>;
+    const modelName = provider.models[0] || '';
+    const builtinTools = createBuiltinTools({ skillInstructionMaxChars: resolveSkillInstructionMaxChars(fullCfg, modelName) });
+    const disposers: (() => void)[] = [];
+    for (const tool of builtinTools) disposers.push(toolService.addTool(tool, root.name));
+    const cronTools = createCronTools();
+    for (const tool of cronTools) disposers.push(toolService.addTool(tool, root.name));
+    logger.info(`Registered ${builtinTools.length} built-in + ${cronTools.length} cron tools`);
+
+    let skillWatchers: fs.FSWatcher[] = [];
+    let skillReloadDebounce: ReturnType<typeof setTimeout> | null = null;
+
+    async function syncWorkspaceSkills(): Promise<number> {
+      const skillFeature = root.inject?.('skill') as SkillFeature | undefined;
+      if (!skillFeature) return 0;
+      const existing = skillFeature.getByPlugin(root.name);
+      for (const s of existing) skillFeature.remove(s);
+      const skills = await discoverWorkspaceSkills();
+      if (skills.length === 0) return 0;
+      const allRegisteredTools = toolService.getAll();
+      const toolNameIndex = new Map<string, Tool>();
+      for (const t of allRegisteredTools) {
+        toolNameIndex.set(t.name, t);
+        const parts = t.name.split('_');
+        if (parts.length === 2) toolNameIndex.set(`${parts[1]}_${parts[0]}`, t);
+      }
+      for (const s of skills) {
+        const associatedTools: Tool[] = [];
+        const toolNames = s.toolNames || [];
+        for (const toolName of toolNames) {
+          let tool = toolService.get(toolName) || toolNameIndex.get(toolName);
+          if (tool) associatedTools.push(tool);
+        }
+        skillFeature.add({
+          name: s.name,
+          description: s.description,
+          tools: associatedTools,
+          keywords: s.keywords || [],
+          tags: s.tags || [],
+          pluginName: root.name,
+        }, root.name);
+      }
+      return skills.length;
+    }
+
+    (async () => {
+      // Step 1: discover workspace skills
+      try {
+        const count = await syncWorkspaceSkills();
+        const skillFeature = root.inject?.('skill') as SkillFeature | undefined;
+        if (count > 0 && skillFeature) {
+          logger.info(`Registered ${count} workspace skills`);
+        }
+      } catch (e: any) {
+        logger.warn(`Failed to discover workspace skills: ${e.message}`);
+      }
+
+      // Step 2: load bootstrap files
+      const loadedFiles: string[] = [];
+      try {
+        const workspaceDir = process.cwd();
+        const bootstrapFiles = await loadBootstrapFiles(workspaceDir);
+        const contextFiles = buildContextFiles(bootstrapFiles);
+
+        logger.debug(`Bootstrap files loaded (cwd: ${workspaceDir}): ${bootstrapFiles.map(f => f.name + (f.missing ? ' (missing)' : '')).join(', ')}`);
+
+        const soulFile = contextFiles.find(f => f.path === 'SOUL.md');
+        if (soulFile && refs.zhinAgent) loadedFiles.push('SOUL.md');
+
+        const toolsFile = contextFiles.find(f => f.path === 'TOOLS.md');
+        if (toolsFile) loadedFiles.push('TOOLS.md');
+
+        const agentsFile = contextFiles.find(f => f.path === 'AGENTS.md');
+        if (agentsFile) loadedFiles.push('AGENTS.md');
+
+        if (loadedFiles.length > 0) {
+          logger.info(`Loaded bootstrap: ${loadedFiles.join(', ')} → agent prompt`);
+        }
+
+        if (refs.zhinAgent && contextFiles.length > 0) {
+          const contextSection = buildBootstrapContextSection(contextFiles);
+          refs.zhinAgent.setBootstrapContext(contextSection);
+        }
+      } catch (e: any) {
+        logger.debug(`Bootstrap files not loaded: ${e.message}`);
+      }
+
+      // Step 3: inject always-on skills content + XML summary
+      try {
+        const skillsForContext = await discoverWorkspaceSkills();
+        const alwaysContent = await loadAlwaysSkillsContent(skillsForContext);
+        const skillsXml = buildSkillsSummaryXML(skillsForContext);
+        if (refs.zhinAgent) {
+          refs.zhinAgent.setActiveSkillsContext(alwaysContent);
+          refs.zhinAgent.setSkillsSummaryXML(skillsXml);
+        }
+      } catch (e: unknown) {
+        logger.debug(`Skills context not set: ${e instanceof Error ? e.message : String(e)}`);
+      }
+
+      // Trigger agent:bootstrap hook
+      const skillFeature2 = root.inject('skill') as SkillFeature | undefined;
+      await triggerAIHook(createAIHookEvent('agent', 'bootstrap', undefined, {
+        workspaceDir: process.cwd(),
+        toolCount: builtinTools.length,
+        skillCount: skillFeature2?.size ?? 0,
+        bootstrapFiles: loadedFiles,
+      }));
+
+      // Hot-reload skill directories
+      const workspaceSkillDir = path.join(process.cwd(), 'skills');
+      const localSkillDir = path.join(os.homedir(), '.zhin', 'skills');
+      const onSkillDirChange = () => {
+        if (skillReloadDebounce) clearTimeout(skillReloadDebounce);
+        skillReloadDebounce = setTimeout(async () => {
+          skillReloadDebounce = null;
+          try {
+            const count = await syncWorkspaceSkills();
+            const skillsForContext = await discoverWorkspaceSkills();
+            const alwaysContent = await loadAlwaysSkillsContent(skillsForContext);
+            const skillsXml = buildSkillsSummaryXML(skillsForContext);
+            if (refs.zhinAgent) {
+              refs.zhinAgent.setActiveSkillsContext(alwaysContent);
+              refs.zhinAgent.setSkillsSummaryXML(skillsXml);
+            }
+            await triggerAIHook(createAIHookEvent('agent', 'skills-reloaded', undefined, { skillCount: count }));
+            if (count >= 0) logger.info(`[技能热重载] 已更新，当前工作区技能数: ${count}`);
+          } catch (e: any) {
+            logger.warn(`[技能热重载] 失败: ${e.message}`);
+          }
+        }, 400);
+      };
+      for (const dir of [workspaceSkillDir, localSkillDir]) {
+        if (fs.existsSync(dir)) {
+          try {
+            const w = fs.watch(dir, { recursive: true }, onSkillDirChange);
+            skillWatchers.push(w);
+            logger.debug(`[技能热重载] 监听目录: ${dir}`);
+          } catch (e: any) {
+            logger.debug(`[技能热重载] 无法监听 ${dir}: ${e.message}`);
+          }
+        }
+      }
+    })();
+
+    return () => {
+      disposers.forEach(d => d());
+      skillWatchers.forEach(w => w.close());
+      skillWatchers = [];
+      if (skillReloadDebounce) clearTimeout(skillReloadDebounce);
+    };
+  });
+}

package/src/init/register-db-models.ts

@@ -0,0 +1,31 @@
+/**
+ * Define AI-related database models (7 tables).
+ */
+import { getPlugin } from '@zhin.js/core';
+import { AI_SESSION_MODEL } from '../session.js';
+import { CHAT_MESSAGE_MODEL, CONTEXT_SUMMARY_MODEL } from '../context-manager.js';
+import { AI_MESSAGE_MODEL, AI_SUMMARY_MODEL } from '../conversation-memory.js';
+import { AI_USER_PROFILE_MODEL } from '../user-profile.js';
+import { AI_FOLLOWUP_MODEL } from '../follow-up.js';
+
+export function registerDbModels(): void {
+  const plugin = getPlugin();
+  const { logger } = plugin;
+
+  const defineModel = (plugin as unknown as Record<string, unknown>).defineModel as
+    | ((name: string, def: Record<string, unknown>) => void)
+    | undefined;
+
+  if (typeof defineModel === 'function') {
+    defineModel('chat_messages', CHAT_MESSAGE_MODEL);
+    defineModel('context_summaries', CONTEXT_SUMMARY_MODEL);
+    defineModel('ai_sessions', AI_SESSION_MODEL);
+    defineModel('ai_messages', AI_MESSAGE_MODEL);
+    defineModel('ai_summaries', AI_SUMMARY_MODEL);
+    defineModel('ai_user_profiles', AI_USER_PROFILE_MODEL);
+    defineModel('ai_followups', AI_FOLLOWUP_MODEL);
+    logger.debug('AI database models registered (7 tables)');
+  } else {
+    logger.debug('defineModel not available, AI will use in-memory storage');
+  }
+}

package/src/init/register-db-upgrade.ts

@@ -0,0 +1,77 @@
+/**
+ * Upgrade AI components from in-memory to database storage when DB becomes ready.
+ *
+ * FIX: Replaced the previous `setTimeout(100)` race condition with
+ * a proper `useContext('database', 'ai', ...)` dual-dependency wait.
+ */
+import './types.js';
+import { getPlugin } from '@zhin.js/core';
+import type { AIConfig } from '@zhin.js/core';
+import { createDatabaseSessionManager } from '../session.js';
+import { createContextManager } from '../context-manager.js';
+import type { AIServiceRefs } from './shared-refs.js';
+
+export function registerDbUpgrade(refs: AIServiceRefs): void {
+  const plugin = getPlugin();
+  const { useContext, root, logger } = plugin;
+
+  useContext('database', 'ai', async (db: any, _ai) => {
+    const aiService = refs.aiService;
+    if (!aiService) return;
+
+    const configService = root.inject('config');
+    const appConfig =
+      configService?.getPrimary<{ ai?: AIConfig }>() || {};
+    const config = appConfig.ai || {};
+
+    if (config.sessions?.useDatabase === false) return;
+
+    try {
+      const model = db.models?.get('ai_sessions');
+      if (!model) return;
+
+      const dbSession = createDatabaseSessionManager(
+        model,
+        aiService.getSessionConfig(),
+      );
+      aiService.setSessionManager(dbSession);
+      if (refs.zhinAgent) refs.zhinAgent.setSessionManager(dbSession);
+
+      const ctxCfg = aiService.getContextConfig();
+      if (ctxCfg.enabled !== false) {
+        const msgModel = db.models.get('chat_messages');
+        const sumModel = db.models.get('context_summaries');
+        if (msgModel && sumModel) {
+          const ctxMgr = createContextManager(msgModel, sumModel, ctxCfg);
+          aiService.setContextManager(ctxMgr);
+          if (refs.zhinAgent) refs.zhinAgent.setContextManager(ctxMgr);
+        }
+      }
+
+      if (refs.zhinAgent) {
+        const aiMsgModel = db.models.get('ai_messages');
+        const aiSumModel = db.models.get('ai_summaries');
+        if (aiMsgModel && aiSumModel) {
+          refs.zhinAgent.upgradeMemoryToDatabase(aiMsgModel, aiSumModel);
+        }
+
+        const profileModel = db.models.get('ai_user_profiles');
+        if (profileModel) {
+          refs.zhinAgent.upgradeProfilesToDatabase(profileModel);
+        }
+
+        const followUpModel = db.models.get('ai_followups');
+        if (followUpModel) {
+          refs.zhinAgent.upgradeFollowUpsToDatabase(followUpModel);
+          refs.zhinAgent.restoreFollowUps().catch(e => {
+            logger.warn('FollowUp restore failed:', e);
+          });
+        }
+      }
+
+      logger.debug('AI database storage activated (session, memory, profile, followup)');
+    } catch (e) {
+      logger.error('AI Session: database setup failed:', e);
+    }
+  });
+}

package/src/init/register-management-tools.ts

@@ -0,0 +1,71 @@
+/**
+ * Register AI management tools (ai.models, ai.clear, ai.health).
+ */
+import './types.js';
+import { getPlugin, Message, ZhinTool } from '@zhin.js/core';
+import { SessionManager } from '../session.js';
+
+export function registerManagementTools(): void {
+  const plugin = getPlugin();
+  const { useContext, root, logger } = plugin;
+
+  useContext('ai', 'tool', (ai, toolService) => {
+    if (!ai || !toolService) return;
+
+    const listModelsTool = new ZhinTool('ai.models')
+      .desc('列出所有可用的 AI 模型')
+      .keyword('模型', '可用模型', 'ai模型', 'model', 'models')
+      .tag('ai', 'management')
+      .execute(async () => {
+        const models = await ai.listModels();
+        return { providers: models.map(({ provider, models: ml }) => ({ name: provider, models: ml.slice(0, 10), total: ml.length })) };
+      })
+      .action(async () => {
+        const models = await ai.listModels();
+        let r = '🤖 可用模型:\n';
+        for (const { provider, models: ml } of models) {
+          r += `\n【${provider}】\n` + ml.slice(0, 5).map(m => `  • ${m}`).join('\n');
+          if (ml.length > 5) r += `\n  ... 还有 ${ml.length - 5} 个`;
+        }
+        return r;
+      });
+
+    const clearSessionTool = new ZhinTool('ai.clear')
+      .desc('清除当前对话的历史记录')
+      .keyword('清除', '清空', '重置', 'clear', 'reset')
+      .tag('ai', 'session')
+      .execute(async (_args, context) => {
+        if (!context?.message) return { success: false, error: '无消息上下文' };
+        const msg = context.message as Message;
+        const sid = SessionManager.generateId(msg.$adapter, msg.$sender.id, msg.$channel?.id);
+        await ai.sessions.reset(sid);
+        return { success: true, message: '对话历史已清除' };
+      })
+      .action(async (message: Message) => {
+        const sid = SessionManager.generateId(message.$adapter, message.$sender.id, message.$channel?.id);
+        await ai.sessions.reset(sid);
+        return '✅ 对话历史已清除';
+      });
+
+    const healthCheckTool = new ZhinTool('ai.health')
+      .desc('检查 AI 服务的健康状态')
+      .keyword('健康', '状态', '检查', 'health', 'status')
+      .tag('ai', 'management')
+      .execute(async () => {
+        const h = await ai.healthCheck();
+        return { providers: Object.entries(h).map(([n, ok]) => ({ name: n, healthy: ok })) };
+      })
+      .action(async () => {
+        const h = await ai.healthCheck();
+        return ['🏥 AI 服务健康状态:'].concat(
+          Object.entries(h).map(([p, ok]) => `  ${ok ? '✅' : '❌'} ${p}`),
+        ).join('\n');
+      });
+
+    const tools = [listModelsTool, clearSessionTool, healthCheckTool];
+    const disposers: (() => void)[] = [];
+    for (const tool of tools) disposers.push(toolService.addTool(tool, root.name));
+    logger.debug(`Registered ${tools.length} AI management tools`);
+    return () => disposers.forEach(d => d());
+  });
+}

package/src/init/register-message-recorder.ts

@@ -0,0 +1,31 @@
+/**
+ * Register middleware that records messages to the context manager.
+ */
+import { getPlugin, Message } from '@zhin.js/core';
+import type { MessageRecord } from '../context-manager.js';
+import type { AIServiceRefs } from './shared-refs.js';
+
+export function registerMessageRecorder(refs: AIServiceRefs): void {
+  const plugin = getPlugin();
+  const { root } = plugin;
+
+  root.addMiddleware(async (message: Message, next: () => Promise<void>) => {
+    await next();
+    if (refs.aiService?.contextManager) {
+      const record: MessageRecord = {
+        platform: message.$adapter,
+        scene_id: message.$channel?.id || message.$sender.id,
+        scene_type: message.$channel?.type || 'private',
+        scene_name: (message.$channel as { name?: string })?.name || '',
+        sender_id: message.$sender.id,
+        sender_name: message.$sender.name || message.$sender.id,
+        message:
+          typeof message.$raw === 'string'
+            ? message.$raw
+            : JSON.stringify(message.$raw),
+        time: message.$timestamp || Date.now(),
+      };
+      refs.aiService.contextManager.recordMessage(record).catch(() => {});
+    }
+  });
+}

package/src/init/register-tool-service.ts

@@ -0,0 +1,9 @@
+/**
+ * Register ToolFeature into the plugin system.
+ */
+import { getPlugin, ToolFeature } from '@zhin.js/core';
+
+export function registerToolService(): void {
+  const plugin = getPlugin();
+  plugin.provide(new ToolFeature());
+}

package/src/init/shared-refs.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared mutable references between init sub-modules.
+ *
+ * These refs allow the split modules to coordinate without passing
+ * the instances through function parameters everywhere.
+ */
+import type { AIService } from '../service.js';
+import type { ZhinAgent } from '../zhin-agent/index.js';
+
+export interface AIServiceRefs {
+  aiService: AIService | null;
+  zhinAgent: ZhinAgent | null;
+}
+
+export function createRefs(): AIServiceRefs {
+  return {
+    aiService: null,
+    zhinAgent: null,
+  };
+}

package/src/init/types.ts

@@ -0,0 +1,18 @@
+/**
+ * Consolidated type augmentation for the agent package.
+ * This ensures all init sub-modules can use typed inject/useContext
+ * without `as any` casts.
+ */
+
+import type { AIService } from '../service.js';
+
+// Re-export the augmentation so it is applied when this file is imported
+declare module '@zhin.js/core' {
+  namespace Plugin {
+    interface Contexts {
+      ai: AIService;
+    }
+  }
+}
+
+export {};