@tyvm/knowhow 0.0.128 → 0.0.130

package/src/clients/pricing/meta.ts

@@ -0,0 +1,12 @@
+/**
+ * Meta Model API pricing (USD per 1M tokens)
+ * Source: Meta Model API docs — https://api.meta.ai
+ * New accounts start with $20 in free credits.
+ */
+export const MetaTextPricing: Record<string, { input: number; output: number; cached_input?: number }> = {
+  "muse-spark-1.1": { input: 1.25, output: 4.25, cached_input: 0.15 },
+};
+
+// Web search grounding is billed per 1,000 search queries ($2.50/1,000),
+// not per-token, so it isn't represented in the per-token pricing map above.
+export const MetaWebSearchPricingPer1000Queries = 2.5;

package/src/clients/pricing/openai.ts

@@ -16,6 +16,9 @@ import {
 // ─── Model IDs ────────────────────────────────────────────────────────────────
 
 export const OpenAiModels = {
+  GPT_56_Sol: "gpt-5.6-sol",
+  GPT_56_Terra: "gpt-5.6-terra",
+  GPT_56_Luna: "gpt-5.6-luna",
   GPT_55: "gpt-5.5",
   GPT_55_Pro: "gpt-5.5-pro",
   GPT_54: "gpt-5.4",
@@ -95,6 +98,9 @@ export const OpenAiEmbeddingModels: Record<string, string> = {
 
 export const OpenAiReasoningModels: string[] = [
   OpenAiModels.GPT_5,
+  OpenAiModels.GPT_56_Sol,
+  OpenAiModels.GPT_56_Terra,
+  OpenAiModels.GPT_56_Luna,
   OpenAiModels.GPT_5_Pro,
   OpenAiModels.GPT_5_Mini,
   OpenAiModels.GPT_5_Nano,
@@ -125,6 +131,9 @@ export const OpenAiChatModels: string[] = [
   OpenAiModels.GPT_41,
   OpenAiModels.GPT_41_Mini,
   OpenAiModels.GPT_41_Nano,
+  OpenAiModels.GPT_56_Sol,
+  OpenAiModels.GPT_56_Terra,
+  OpenAiModels.GPT_56_Luna,
   OpenAiModels.GPT_54,
   OpenAiModels.GPT_54_Mini,
   OpenAiModels.GPT_55,
@@ -158,6 +167,9 @@ export const OpenAiResponsesOnlyModels: string[] = [
   OpenAiModels.GPT_55_Pro,
   OpenAiModels.GPT_55,
   OpenAiModels.GPT_5_Pro,
+  OpenAiModels.GPT_56_Sol,
+  OpenAiModels.GPT_56_Terra,
+  OpenAiModels.GPT_56_Luna,
   OpenAiModels.o1,
   OpenAiModels.o1_Pro,
 ];
@@ -218,6 +230,10 @@ export const OpenAiSearchModels: string[] = [
 // ─── Pricing (USD per 1M tokens) ──────────────────────────────────────────────
 
 export const OpenAiTextPricing: Record<string, ModelPricing> = {
+  // gpt-5.6 series — short context / long context pricing
+  [OpenAiModels.GPT_56_Sol]:   { input: 5.0, cached_input: 0.5,  cache_write: 6.25,  output: 30.0, input_gt_200k: 10.0, output_gt_200k: 45.0 },
+  [OpenAiModels.GPT_56_Terra]: { input: 2.5, cached_input: 0.25, cache_write: 3.125, output: 15.0, input_gt_200k: 5.0,  output_gt_200k: 22.5 },
+  [OpenAiModels.GPT_56_Luna]:  { input: 1.0, cached_input: 0.10, cache_write: 1.25,  output: 6.0,  input_gt_200k: 2.0,  output_gt_200k: 9.0  },
   [OpenAiModels.GPT_55]: { input: 5.0, cached_input: 0.5, output: 30.0 },
   [OpenAiModels.GPT_55_Pro]: { input: 30.0, cached_input: 0, output: 180.0, reasoningLevels: ["medium", "high", "xhigh"] },
   [OpenAiModels.GPT_54]: { input: 2.5, cached_input: 0.25, output: 15.0 },

package/src/clients/pricing/xai.ts

@@ -10,6 +10,7 @@ export const XaiModels = {
   Grok_4_20_Reasoning: "grok-4.20-0309-reasoning",
   Grok_4_20_NonReasoning: "grok-4.20-0309-non-reasoning",
   Grok_4_20_MultiAgent: "grok-4.20-multi-agent-0309",
+  Grok4_5: "grok-4.5",
   Grok4_1_Fast_Reasoning: "grok-4-1-fast-reasoning",
   Grok4_1_Fast_NonReasoning: "grok-4-1-fast-non-reasoning",
   GrokCodeFast: "grok-code-fast-1",
@@ -44,6 +45,7 @@ export const XaiTextModels: string[] = [
   XaiModels.Grok_4_20_Reasoning, XaiModels.Grok_4_20_NonReasoning,
   XaiModels.Grok_4_20_MultiAgent,
   XaiModels.Grok4_1_Fast_Reasoning, XaiModels.Grok4_1_Fast_NonReasoning,
+  XaiModels.Grok4_5,
   XaiModels.GrokCodeFast, XaiModels.Grok4,
   XaiModels.Grok3Beta, XaiModels.Grok3MiniBeta, XaiModels.Grok3FastBeta, XaiModels.Grok3MiniFastBeta,
 ];
@@ -87,6 +89,7 @@ export const XaiTextPricing: Record<string, ModelPricing> = {
   [XaiModels.Grok_4_20_MultiAgent]:      { input: 2.0, cache_hit: 0.20, output: 6.0, reasoningLevels: ["low", "medium", "high", "xhigh"], useResponsesApi: true },
   [XaiModels.Grok4_1_Fast_Reasoning]:    { input: 0.2, cache_hit: 0.05, output: 0.5, useResponsesApi: true },
   [XaiModels.Grok4_1_Fast_NonReasoning]: { input: 0.2, cache_hit: 0.05, output: 0.5, useResponsesApi: true },
+  [XaiModels.Grok4_5]:                   { input: 2.0, cache_hit: 0.50, output: 6.0 },
   [XaiModels.GrokCodeFast]:              { input: 0.2, cache_hit: 0.02, output: 1.5 },
   [XaiModels.Grok4]:                     { input: 3.0, output: 15.0 },
   [XaiModels.Grok3Beta]:                 { input: 3.0, output: 15.0 },

package/src/clients/types.ts

@@ -86,10 +86,26 @@ export interface CompletionOptions extends RetryOptions {
   tools?: Tool[];
   tool_choice?: "auto" | "none";
   max_tokens?: number;
-  /** Reasoning effort level for models that support it.
-   *  Maps to: OpenAI reasoning_effort, xAI reasoning.effort, Gemini thinkingLevel/thinkingBudget, Anthropic thinking budget.
-   *  "low" = minimal thinking, "medium" = balanced, "high" = maximum reasoning */
-  reasoning_effort?: "low" | "medium" | "high";
+  /**
+   * Reasoning effort level for models that support it.
+   * Maps to: OpenAI reasoning_effort/reasoning.effort, xAI reasoning.effort,
+   *          Gemini thinkingLevel/thinkingBudget, Anthropic thinking mode.
+   *
+   * "none"   = disable thinking entirely (Anthropic: thinking.type="disabled",
+   *            OpenAI: reasoning.effort="none").  Only supported by models that
+   *            allow disabling thinking (e.g. claude-sonnet-5).
+   * "low"    = minimal thinking
+   * "medium" = balanced (default for most models)
+   * "high"   = maximum reasoning
+   */
+  reasoning_effort?: "none" | "low" | "medium" | "high";
+  /**
+   * When true, request a summarized view of the model's thinking process.
+   * - Anthropic: thinking.display = "summarized"
+   * - OpenAI:    reasoning.summary = "auto"
+   * Defaults to false (no summary displayed).
+   */
+  reasoning_summary?: boolean;
   /**
    * When true, hints to the client that this task is long-running and it should
    * use a long-TTL cache where available.
@@ -115,6 +131,13 @@ export interface TokenUsage {
   output_tokens?: number;
   /** Convenience total (prompt + completion) */
   total_tokens?: number;
+  /** Breakdown of output tokens — thinking/reasoning tokens are billed as output
+   *  but should NOT be counted toward the visible-content heuristics. */
+  output_tokens_details?: {
+    /** Anthropic: thinking_tokens, OpenAI: reasoning_tokens */
+    thinking_tokens?: number;
+    reasoning_tokens?: number;
+  };
   /** Cache details */
   prompt_tokens_details?: {
     /** Tokens served from the prompt cache (reduces cost) */

package/src/clients/xai.ts

@@ -76,9 +76,9 @@ export class GenericXAIClient implements GenericClient {
       model: options.model,
       messages: xaiMessages,
       max_tokens: options.max_tokens,
-      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && {
+      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && options.reasoning_effort !== "none" && {
         // grok-3-mini models support reasoning_effort: "low" | "medium" | "high"
-        reasoning_effort: options.reasoning_effort,
+        reasoning_effort: options.reasoning_effort as "low" | "medium" | "high",
       }),
       ...(options.tools && {
         tools: options.tools,

package/src/commands/agent.ts

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { readPromptFile } from "../ai";
 import { AgentModule } from "../chat/modules/AgentModule";
+import { BehaviorsService, Behavior } from "../services/BehaviorsService";
 import { AskModule } from "../chat/modules/AskModule";
 import { SearchModule } from "../chat/modules/SearchModule";
 import { SessionsModule } from "../chat/modules/SessionsModule";
@@ -131,11 +132,29 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
         }
 
         await agentModule.initialize(chatService);
+
+        // Match a behavior from local disk (.knowhow/behaviors/)
+        let behaviorSystemPrompt: string | undefined;
+        let behaviorModel: string | undefined;
+        const behaviorsSvc = new BehaviorsService();
+        const matchedBehavior = behaviorsSvc.matchBehaviorLocal(input);
+        if (matchedBehavior) {
+          console.log(`🎯 Matched behavior: ${matchedBehavior.name}`);
+          if (matchedBehavior.instructions) {
+            behaviorSystemPrompt = matchedBehavior.instructions;
+          }
+          if (matchedBehavior.model) {
+            behaviorModel = matchedBehavior.model;
+          }
+        }
+
         const { taskCompleted } = await agentModule.setupAgent({
           ...options,
           input,
           maxTimeLimit: parseInt(options.maxTimeLimit, 10),
           maxSpendLimit: parseFloat(options.maxSpendLimit),
+          ...(behaviorSystemPrompt ? { systemPrompt: behaviorSystemPrompt } : {}),
+          ...(behaviorModel ? { model: behaviorModel } : {}),
           run: true,
         });
         await taskCompleted;

package/src/commands/behaviors.ts

@@ -0,0 +1,47 @@
+import { Command } from "commander";
+import { BehaviorsService } from "../services/BehaviorsService";
+
+export function addBehaviorsCommand(program: Command): void {
+  const behaviors = program
+    .command("behaviors")
+    .description("Manage org behaviors from the CLI");
+
+  behaviors
+    .command("list")
+    .description("List behaviors from backend")
+    .option("--skills-only", "Only show skill behaviors")
+    .option("--include-internal", "Include platform skills")
+    .action(async (opts) => {
+      const svc = new BehaviorsService();
+      await svc.list({
+        skillsOnly: opts.skillsOnly,
+        includeInternal: opts.includeInternal,
+      });
+    });
+
+  behaviors
+    .command("download")
+    .description("Download behaviors from backend to .knowhow/behaviors/")
+    .option("--skills-only", "Only download skill behaviors")
+    .option("--include-internal", "Include platform skills")
+    .option(
+      "--md",
+      "Save as Markdown files with YAML frontmatter instead of JSON"
+    )
+    .action(async (opts) => {
+      const svc = new BehaviorsService();
+      await svc.download({
+        skillsOnly: opts.skillsOnly,
+        includeInternal: opts.includeInternal,
+        md: opts.md,
+      });
+    });
+
+  behaviors
+    .command("upload")
+    .description("Upload behaviors from .knowhow/behaviors/ to backend")
+    .action(async () => {
+      const svc = new BehaviorsService();
+      await svc.upload();
+    });
+}

package/src/commands/services.ts

@@ -1,8 +1,9 @@
 import { includedTools } from "../agents/tools/list";
 import * as allTools from "../agents/tools";
-import { LazyToolsService, services } from "../services";
+import { LazyToolsService, services, MinimalToolsService } from "../services";
 import { agents } from "../agents";
 import { ModulesService } from "../services/modules";
+import { getConfig } from "../config";
 
 /**
  * Shared service setup used by commands that need full services (chat, agent, worker, etc.)
@@ -17,12 +18,14 @@ export async function setupServices() {
     Plugins,
     Events,
     MediaProcessor,
+    Behaviors,
   } = services();
 
-
   // cli uses LazyTools to keep context slim
   const Tools = new LazyToolsService();
+  await Behaviors.initFromConfig();
 
+  // Give LazyToolsService the same context that ToolService had
   Tools.setContext({
     ...AllTools.getContext(),
   });
@@ -70,7 +73,8 @@ export async function setupServices() {
     Clients,
     Tools,
     MediaProcessor,
-    Events
+    Behaviors,
+    Events,
   });
 
   return { Tools, Clients };

package/src/commands/skills.ts

@@ -0,0 +1,71 @@
+import { Command } from "commander";
+import { SkillsService } from "../services/SkillsService";
+
+export function addSkillsCommand(program: Command): void {
+  const skills = program
+    .command("skills")
+    .description("Manage agent skills from the skills.sh ecosystem");
+
+  skills
+    .command("add <package>")
+    .description(
+      "Add a skill. Accepts:\n" +
+        "  owner/repo@skill-name\n" +
+        "  https://github.com/owner/repo  (with --skill <name>)\n" +
+        "  https://github.com/owner/repo@skill-name"
+    )
+    .option("--skill <name>", "Skill name when using a GitHub URL as the package argument")
+    .option("--global", "Install skill globally to ~/.knowhow/skills/")
+    .option(
+      "--install-dir <dir>",
+      "Custom install directory (overrides default and --global)"
+    )
+    .action(async (pkg: string, opts: { skill?: string; global?: boolean; installDir?: string }) => {
+      const svc = new SkillsService({
+        global: opts.global,
+        installDir: opts.installDir,
+      });
+      await svc.add(pkg, opts.skill);
+    });
+
+  skills
+    .command("remove <skill>")
+    .alias("rm")
+    .description("Remove an installed skill by name")
+    .option("--global", "Remove from global ~/.knowhow/skills/")
+    .action((skillName: string, opts: { global?: boolean }) => {
+      const svc = new SkillsService({ global: opts.global });
+      svc.remove(skillName);
+    });
+
+  skills
+    .command("list")
+    .alias("ls")
+    .description("List installed skills from the lock file")
+    .option("--global", "List skills from global ~/.knowhow/skills/")
+    .action((opts: { global?: boolean }) => {
+      const svc = new SkillsService({ global: opts.global });
+      svc.list();
+    });
+
+  skills
+    .command("install")
+    .description(
+      "Install all skills from skills-lock.json (restores from lock file)"
+    )
+    .option("--global", "Install from global ~/.knowhow/skills/skills-lock.json")
+    .action(async (opts: { global?: boolean }) => {
+      const svc = new SkillsService({ global: opts.global });
+      await svc.install();
+    });
+
+  skills
+    .command("update [skills...]")
+    .alias("upgrade")
+    .description("Update installed skills to their latest versions")
+    .option("--global", "Update skills in global ~/.knowhow/skills/")
+    .action(async (skillNames: string[], opts: { global?: boolean }) => {
+      const svc = new SkillsService({ global: opts.global });
+      await svc.update(skillNames);
+    });
+}

package/src/index.ts

@@ -60,6 +60,8 @@ export { ConversionService } from "./services/conversion/ConversionService";
 // Export plugin types for external plugins
 export { PluginBase } from "./plugins/PluginBase";
 export { PluginMeta, Plugin, PluginContext } from "./plugins/types";
+export { PluginService } from "./plugins/plugins";
+export { SkillsPlugin } from "./plugins/SkillsPlugin";
 // Export embedding types
 export { MinimalEmbedding, Embeddable } from "./types";
 

package/src/plugins/PluginBase.ts

@@ -1,4 +1,3 @@
-import { MinimalEmbedding } from "../types";
 import { Plugin, PluginContext, PluginMeta } from "./types";
 
 export abstract class PluginBase implements Plugin {
@@ -66,7 +65,6 @@ export abstract class PluginBase implements Plugin {
   /** Mandatory plugin actions ---------------------------------------- */
   /* ------------------------------------------------------------------ */
   abstract call(input?: string): Promise<string>;
-  abstract embed(input: string): Promise<MinimalEmbedding[]>;
 }
 
 export { PluginMeta, Plugin } from "./types";

package/src/plugins/SkillsPlugin.ts

@@ -1,33 +1,11 @@
-import { promises as fs, Dirent } from "fs";
-import * as path from "path";
 import { PluginBase, PluginMeta } from "./PluginBase";
 import { Plugin, PluginContext } from "./types";
-import { MinimalEmbedding } from "../types";
-import { getConfig } from "../config";
-
-interface SkillMeta {
-  name: string;
-  description: string;
-  filePath: string;
-}
-
-function parseFrontmatter(content: string): Record<string, string> {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return {};
-  const result: Record<string, string> = {};
-  for (const line of match[1].split("\n")) {
-    const [key, ...rest] = line.split(":");
-    if (key && rest.length) result[key.trim()] = rest.join(":").trim();
-  }
-  return result;
-}
 
 export class SkillsPlugin extends PluginBase implements Plugin {
   static readonly meta: PluginMeta = {
     key: "skills",
     name: "Skills Plugin",
-    description:
-      "Scans configured skills directories for SKILL.md files and provides skill content to agents",
+    description: "Lists available skills",
     requires: [],
   };
 
@@ -37,114 +15,23 @@ export class SkillsPlugin extends PluginBase implements Plugin {
     super(context);
   }
 
-  async call(input?: string): Promise<string> {
-    const result = await this.embed(input || "");
-    return result.map((e) => e.text).join("\n\n");
-  }
-
-  async embed(userPrompt: string): Promise<MinimalEmbedding[]> {
-    const config = await getConfig();
-    const skillDirs: string[] = (config as any).skills || [];
-
-    if (skillDirs.length === 0) {
-      return [];
-    }
-
-    const skills = await this.scanSkills(skillDirs);
+  /**
+   * Returns a summary list of in-memory skills (name + description).
+   * This is called by the plugin system to inject context into agent prompts.
+   * Skills must be loaded into memory first via Behaviors.initFromDisk() at startup.
+   */
+  async call(_input?: string): Promise<string> {
+    const { Behaviors } = this.context;
+    const skills = Behaviors.listSkills();
 
     if (skills.length === 0) {
-      return [];
-    }
-
-    // Check if any skill name appears in the prompt
-    const matchedSkills = skills.filter((skill) =>
-      userPrompt.toLowerCase().includes(skill.name.toLowerCase())
-    );
-
-    if (matchedSkills.length > 0) {
-      // Return full skill content for matched skills
-      const results: MinimalEmbedding[] = [];
-      for (const skill of matchedSkills) {
-        try {
-          const content = await fs.readFile(skill.filePath, "utf-8");
-          results.push({
-            id: skill.filePath,
-            text: `## Skill: ${skill.name}\nFile: ${skill.filePath}\n\n${content}`,
-            metadata: { filePath: skill.filePath },
-          });
-        } catch {
-          // Skip unreadable files
-        }
-      }
-      return results;
-    }
-
-    // Return skill discovery summary
-    const summary = this.buildSkillSummary(skills);
-    return [
-      {
-        id: "skills:summary",
-        text: summary,
-        metadata: {},
-      },
-    ];
-  }
-
-  private async scanSkills(dirs: string[]): Promise<SkillMeta[]> {
-    const skills: SkillMeta[] = [];
-    for (const dir of dirs) {
-      const resolvedDir = dir.replace(/^~/, process.env.HOME || "");
-      try {
-        const found = await this.findSkillFiles(resolvedDir);
-        skills.push(...found);
-      } catch {
-        // Skip directories that don't exist or can't be read
-      }
-    }
-    return skills;
-  }
-
-  private async findSkillFiles(dir: string): Promise<SkillMeta[]> {
-    const skills: SkillMeta[] = [];
-    let entries: Dirent[];
-    try {
-      entries = await fs.readdir(dir, { withFileTypes: true });
-    } catch {
-      return skills;
-    }
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        const nested = await this.findSkillFiles(fullPath);
-        skills.push(...nested);
-      } else if (entry.isFile() && entry.name === "SKILL.md") {
-        try {
-          const content = await fs.readFile(fullPath, "utf-8");
-          const frontmatter = parseFrontmatter(content);
-          const name = frontmatter.name;
-          const description = frontmatter.description || "";
-          if (name) {
-            skills.push({ name, description, filePath: fullPath });
-          }
-        } catch {
-          // Skip unreadable files
-        }
-      }
+      return "No skills available";
     }
 
-    return skills;
-  }
-
-  private buildSkillSummary(skills: SkillMeta[]): string {
     const lines = ["Available skills:"];
     for (const skill of skills) {
-      lines.push(`- ${skill.name} (${skill.filePath}): ${skill.description}`);
+      lines.push(`- ${skill.name}: ${skill.description}`);
     }
-    lines.push("");
-    lines.push(
-      "To use a skill, reference its name in your request and I will load the full instructions."
-    );
     return lines.join("\n");
   }
 }

package/src/plugins/language.ts

@@ -6,7 +6,6 @@ import { getConfig, getLanguageConfig } from "../config";
 import { getEnabledPlugins } from "../types";
 import { PluginBase, PluginMeta } from "./PluginBase";
 import { Plugin, PluginContext } from "./types";
-import { PluginService } from "./plugins";
 
 /**
  * Language Plugin with event-driven context loading

package/src/plugins/plugins.ts

@@ -14,24 +14,12 @@ import { SkillsPlugin } from "./SkillsPlugin";
 import { EventService } from "../services/EventService";
 
 export class PluginService {
-  private pluginMap = new Map<string, Plugin>();
+  protected pluginMap = new Map<string, Plugin>();
   private events?: EventService;
 
   constructor(context: PluginContext) {
     this.events = context.Events;
     context.Plugins = this;
-
-    // Register migrated PluginBase plugins
-    this.pluginMap.set("embeddings", new EmbeddingPlugin(context));
-    this.pluginMap.set("vim", new VimPlugin(context));
-    this.pluginMap.set("linter", new LinterPlugin(context));
-    this.pluginMap.set("language", new LanguagePlugin(context));
-    this.pluginMap.set("url", new UrlPlugin(context));
-    this.pluginMap.set("git", new GitPlugin(context));
-    this.pluginMap.set("tmux", new TmuxPlugin(context));
-    this.pluginMap.set("agents-md", new AgentsMdPlugin(context));
-    this.pluginMap.set("exec", new ExecPlugin(context));
-    this.pluginMap.set("skills", new SkillsPlugin(context));
   }
 
   /* -------- lifecycle helpers ------------------------------------ */
@@ -146,3 +134,26 @@ export class PluginService {
     return newPlugin.embed ? newPlugin.embed(userInput) : [];
   }
 }
+
+/**
+ * CliPluginService extends PluginService with the full set of default plugins
+ * used by the Knowhow CLI. Use this class when setting up agents for CLI usage.
+ * Use the base PluginService when you want a clean slate to register your own plugins.
+ */
+export class CliPluginService extends PluginService {
+  constructor(context: PluginContext) {
+    super(context);
+
+    // Register CLI default plugins
+    this.pluginMap.set("embeddings", new EmbeddingPlugin(context));
+    this.pluginMap.set("vim", new VimPlugin(context));
+    this.pluginMap.set("linter", new LinterPlugin(context));
+    this.pluginMap.set("language", new LanguagePlugin(context));
+    this.pluginMap.set("url", new UrlPlugin(context));
+    this.pluginMap.set("git", new GitPlugin(context));
+    this.pluginMap.set("tmux", new TmuxPlugin(context));
+    this.pluginMap.set("agents-md", new AgentsMdPlugin(context));
+    this.pluginMap.set("exec", new ExecPlugin(context));
+    this.pluginMap.set("skills", new SkillsPlugin(context));
+  }
+}

package/src/plugins/types.ts

@@ -1,5 +1,10 @@
 import { Embeddable, MinimalEmbedding } from "../types";
-import { AgentService, EventService, ToolsService } from "../services";
+import {
+  AgentService,
+  BehaviorsService,
+  EventService,
+  ToolsService,
+} from "../services";
 import { AIClient } from "../clients";
 import { PluginService } from "./plugins";
 
@@ -13,7 +18,7 @@ export interface PluginMeta {
 export interface Plugin {
   callMany(userInput?: string): Promise<string>;
   call(userInput?: string): Promise<string>;
-  embed(userInput?: string): Promise<MinimalEmbedding[]>;
+  embed?(userInput?: string): Promise<MinimalEmbedding[]>;
   enable(): void;
   disable(): void;
   isEnabled(): boolean;
@@ -27,4 +32,5 @@ export interface PluginContext {
   Clients?: AIClient;
   Tools?: ToolsService;
   Plugins?: PluginService;
+  Behaviors?: BehaviorsService;
 }