@andreprado/agentkit 0.1.0-alpha.2 → 0.1.0-alpha.21

package/src/runtime/inspect.ts

@@ -4,6 +4,16 @@ import type { AgentChannel, AgentProvider, AgentRuntime, AccessMode } from "../i
 import type { LoadedAgentCapsule } from "./config";
 import { loadAgentCapsule } from "./config";
 import { loadCapsuleEnv } from "./env";
+import {
+  createManagedComposioTools,
+  managedComposioRequiredSecrets,
+  resolveManagedComposioIntegrations,
+} from "./integrations/composio";
+import { resolveKnowledgeConfig } from "./knowledge/config";
+import { KNOWLEDGE_SEARCH_TOOL_NAME } from "./knowledge/tool";
+import { resolveRuntimeTimeZone } from "./prompt-context";
+import { checkDefaultSkillStatus, type DefaultSkillStatus } from "./skills";
+import { resolveTranscriptionConfig } from "./transcription";
 
 export type SecretState = "set" | "missing";
 
@@ -11,9 +21,41 @@ export type AgentInspectState = {
   agent: string;
   runtime: AgentRuntime;
   provider: AgentProvider;
+  timeZone: {
+    configured: string | null;
+    effective: string;
+  };
   prompt: string;
   tools: string[];
+  integrations: AgentInspectIntegration[];
   channels: AgentInspectChannel[];
+  transcription: {
+    enabled: boolean;
+    provider: string | null;
+    model: string | null;
+    secret: string | null;
+    language: string | null;
+    prompt: string | null;
+    limits: {
+      maxDurationSeconds: number | null;
+      maxBytes: number | null;
+    };
+    rawAudioTtlSeconds: number | null;
+  };
+  knowledge: {
+    enabled: boolean;
+    sources: string[];
+    embedding: {
+      provider: string;
+      model: string | null;
+      dimensions: number | null;
+    };
+    retrieval: {
+      topK: number;
+      hybrid: boolean;
+    };
+    internalTool: string | null;
+  };
   access: {
     mode: AccessMode;
   };
@@ -36,6 +78,8 @@ export type AgentInspectState = {
   secrets: Record<string, SecretState>;
   managedSecrets: string[];
   userSecrets: string[];
+  skills: AgentInspectSkills;
+  warnings: AgentInspectWarning[];
 };
 
 export type AgentInspectDatabase = {
@@ -43,11 +87,13 @@ export type AgentInspectDatabase = {
     driver: "sqlite";
     path: string | null;
     schema: string | null;
+    migrations: string | null;
   };
   hosted: {
     driver: "none" | "turso";
     provisioning: "none" | "agentkit-managed";
     schema: string | null;
+    migrations: string | null;
   };
 };
 
@@ -56,6 +102,31 @@ export type AgentInspectChannel = {
   type: AgentChannel["type"];
   provider: AgentChannel["provider"];
   secrets: string[];
+  buffer?: AgentChannel["buffer"];
+  audio?: AgentChannel["audio"];
+};
+
+export type AgentInspectSkills = {
+  status: "current" | "missing" | "outdated" | "not_checked";
+  checked: number;
+  missing: string[];
+  outdated: string[];
+  syncCommand: string | null;
+};
+
+export type AgentInspectWarning = {
+  code: string;
+  message: string;
+  command?: string;
+};
+
+export type AgentInspectIntegration = {
+  name: string;
+  provider: "composio";
+  mode: "managed";
+  toolkits: string[];
+  tools: string[];
+  userId: string;
 };
 
 export async function inspectAgentCapsule(
@@ -63,16 +134,20 @@ export async function inspectAgentCapsule(
   env: Record<string, string | undefined> = process.env,
 ): Promise<AgentInspectState> {
   const capsule = await loadAgentCapsule(cwd);
-  return buildInspectState(capsule, await loadCapsuleEnv(capsule.root, env));
+  return buildInspectState(capsule, await loadCapsuleEnv(capsule.root, env), await checkDefaultSkillStatus(capsule.root));
 }
 
 export function buildInspectState(
   capsule: LoadedAgentCapsule,
   env: Record<string, string | undefined> = process.env,
+  skillStatus: DefaultSkillStatus | null = null,
 ): AgentInspectState {
   const declaredSecrets = new Set(capsule.config.secrets);
+  const knowledge = resolveKnowledgeConfig(capsule.config);
+  const integrationTools = createManagedComposioTools(capsule.config);
+  const transcription = resolveTranscriptionConfig(capsule.config.transcription);
 
-  for (const tool of capsule.config.tools ?? []) {
+  for (const tool of [...integrationTools, ...(capsule.config.tools ?? [])]) {
     for (const secret of tool.secrets ?? []) {
       declaredSecrets.add(secret);
     }
@@ -84,8 +159,19 @@ export function buildInspectState(
     }
   }
 
+  if (knowledge.embedding.secret) {
+    declaredSecrets.add(knowledge.embedding.secret);
+  }
+
+  if (transcription.secret) {
+    declaredSecrets.add(transcription.secret);
+  }
+
   const managedSecrets = managedCloudSecrets(capsule);
-  const userSecrets = Array.from(declaredSecrets).sort();
+  const managedSecretSet = new Set(managedSecrets);
+  const userSecrets = Array.from(declaredSecrets)
+    .filter((secret) => !managedSecretSet.has(secret))
+    .sort();
   const secrets: Record<string, SecretState> = {};
 
   for (const secret of userSecrets) {
@@ -94,18 +180,63 @@ export function buildInspectState(
 
   const database = inspectDatabase(capsule);
 
+  const skills = inspectSkills(skillStatus);
+  const warnings = inspectWarnings(capsule, transcription, skills);
+
   return {
     agent: capsule.config.name,
     runtime: capsule.config.runtime,
     provider: capsule.config.provider,
+    timeZone: {
+      configured: capsule.config.timeZone ?? null,
+      effective: resolveRuntimeTimeZone({
+        timeZone: capsule.config.timeZone,
+        env,
+      }),
+    },
     prompt: toCapsulePath(capsule.root, capsule.instructionsPath),
-    tools: (capsule.config.tools ?? []).map((tool) => tool.name),
+    tools: [...integrationTools, ...(capsule.config.tools ?? [])].map((tool) => tool.name),
+    integrations: resolveManagedComposioIntegrations(capsule.config).map((integration) => ({
+      name: integration.name,
+      provider: integration.provider,
+      mode: integration.mode,
+      toolkits: integration.toolkits,
+      tools: integration.allowedTools,
+      userId: integration.userId,
+      confirmExternalWrites: integration.confirmExternalWrites !== false,
+    })),
     channels: (capsule.config.channels ?? []).map((channel) => ({
       name: channel.name,
       type: channel.type,
       provider: channel.provider,
       secrets: [...channel.secrets],
+      ...(channel.buffer ? { buffer: channel.buffer } : {}),
+      ...(channel.audio ? { audio: channel.audio } : {}),
     })),
+    transcription: {
+      enabled: transcription.enabled,
+      provider: transcription.enabled ? transcription.provider : null,
+      model: transcription.enabled ? transcription.model : null,
+      secret: transcription.secret,
+      language: transcription.language,
+      prompt: transcription.prompt,
+      limits: {
+        maxDurationSeconds: transcription.limits.maxDurationSeconds ?? null,
+        maxBytes: transcription.limits.maxBytes ?? null,
+      },
+      rawAudioTtlSeconds: transcription.rawAudioTtlSeconds,
+    },
+    knowledge: {
+      enabled: knowledge.enabled,
+      sources: knowledge.sources.map((source) => source.value),
+      embedding: {
+        provider: knowledge.embedding.provider,
+        model: knowledge.embedding.model,
+        dimensions: knowledge.embedding.dimensions,
+      },
+      retrieval: knowledge.retrieval,
+      internalTool: knowledge.enabled ? KNOWLEDGE_SEARCH_TOOL_NAME : null,
+    },
     access: capsule.config.access,
     storage: capsule.storagePath ? toCapsulePath(capsule.root, capsule.storagePath) : null,
     database,
@@ -126,6 +257,8 @@ export function buildInspectState(
     secrets,
     managedSecrets,
     userSecrets,
+    skills,
+    warnings,
   };
 }
 
@@ -137,21 +270,74 @@ function toCapsulePath(root: string, path: string): string {
 function inspectDatabase(capsule: LoadedAgentCapsule): AgentInspectDatabase {
   const database = capsule.config.storage.database;
   const schema = database?.driver === "turso" && database.schema ? database.schema : null;
+  const migrations = database?.driver === "turso" ? database.migrations ?? "migrations" : null;
 
   return {
     local: {
       driver: "sqlite",
       path: capsule.storagePath ? toCapsulePath(capsule.root, capsule.storagePath) : null,
       schema,
+      migrations,
     },
     hosted: {
       driver: database?.driver === "turso" ? "turso" : "none",
       provisioning: database?.driver === "turso" ? "agentkit-managed" : "none",
       schema,
+      migrations,
     },
   };
 }
 
+function inspectSkills(status: DefaultSkillStatus | null): AgentInspectSkills {
+  if (!status) {
+    return {
+      status: "not_checked",
+      checked: 0,
+      missing: [],
+      outdated: [],
+      syncCommand: null,
+    };
+  }
+
+  return {
+    status: status.status,
+    checked: status.checked,
+    missing: status.missing,
+    outdated: status.outdated,
+    syncCommand: status.status === "current" ? null : "npm run agentkit -- skills sync",
+  };
+}
+
+function inspectWarnings(
+  capsule: LoadedAgentCapsule,
+  transcription: ReturnType<typeof resolveTranscriptionConfig>,
+  skills: AgentInspectSkills,
+): AgentInspectWarning[] {
+  const warnings: AgentInspectWarning[] = [];
+
+  if (skills.status === "missing" || skills.status === "outdated") {
+    warnings.push({
+      code: "local_skills_outdated",
+      message: "Local AgentKit skills are older than or missing from the installed package docs.",
+      command: "npm run agentkit -- skills sync",
+    });
+  }
+
+  if (
+    transcription.enabled &&
+    transcription.provider === "openai" &&
+    (capsule.config.channels ?? []).some((channel) => channel.type === "telegram" && channel.audio?.mode === "transcribe")
+  ) {
+    warnings.push({
+      code: "telegram_audio_openai_format",
+      message: "Telegram voice notes arrive as OGG/Opus; use Groq for the default Telegram voice-note transcription path.",
+      command: "Set transcription.provider to \"groq\" and secret to \"GROQ_API_KEY\".",
+    });
+  }
+
+  return warnings;
+}
+
 function managedCloudSecrets(capsule: LoadedAgentCapsule): string[] {
   const secrets = new Set<string>();
 
@@ -160,5 +346,9 @@ function managedCloudSecrets(capsule: LoadedAgentCapsule): string[] {
     secrets.add("TURSO_DATABASE_URL");
   }
 
+  for (const secret of managedComposioRequiredSecrets(capsule.config)) {
+    secrets.add(secret);
+  }
+
   return Array.from(secrets).sort();
 }