@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-E6ORBQHP.js

@@ -0,0 +1,225 @@
+// src/lib/tool-gates.ts
+var TOOL_GATES = {
+  core: [],
+  // all agents — recall, store, ask_team, commit, search, session, consolidate, cardinality, behavior, identity, decisions
+  tasks: [],
+  // all agents — create, list, get, update, close, checkpoint, resume
+  comms: [],
+  // all agents — send_message, acknowledge
+  reminders: [],
+  // all agents — create, list, complete, reminder
+  "graph-read": [],
+  // all agents — query_relationships, get_entity_neighbors, get_hot_entities, get_graph_stats, find_similar_trajectories, code_context
+  "graph-write": ["COO", "CTO"],
+  // merge_entities, export_graph
+  wiki: ["COO", "Wiki Agent"],
+  // read/list curated wiki pages
+  crm: ["COO", "CRM Agent"],
+  // CRM read/list/get and legacy add/list/get person
+  "raw-data": ["COO", "CTO", "Gateway Agent", "CRM Agent", "Wiki Agent"],
+  // capped read-only raw landing-pad access
+  documents: ["COO", "CTO", "Wiki Agent"],
+  // ingest, list, purge, set_importance, rerank
+  gateway: ["COO", "Gateway Agent"],
+  // send_whatsapp, query_conversations, query_company_brain, company_actions
+  admin: ["COO"],
+  // deploy, backup, daemon health, auto-wake, worker gate, memory audit, consolidation, cloud sync, agent config, list employees, agent spend, sessions, session kills
+  licensing: ["COO"],
+  // get/create/list/activate license
+  orchestration: ["COO"]
+  // triggers, load_skill, starter_pack, export/import orchestration, global procedures
+};
+var TOOL_CATEGORIES = {
+  // core
+  registerMemory: "core",
+  registerRecallMyMemory: "core",
+  registerAskTeamMemory: "core",
+  registerGetSessionContext: "core",
+  registerGetMemoryById: "core",
+  registerStoreMemory: "core",
+  registerCommitMemory: "core",
+  registerSearchEverything: "core",
+  registerConsolidateMemories: "core",
+  registerGetMemoryCardinality: "core",
+  registerStoreBehavior: "core",
+  registerListBehaviors: "core",
+  registerDeactivateBehavior: "core",
+  registerBehavior: "core",
+  registerStoreDecision: "core",
+  registerGetDecision: "core",
+  registerCreateBugReport: "core",
+  registerSupportTools: "core",
+  registerCliParityTools: "admin",
+  registerGetSessionEvents: "core",
+  registerGetLastAssistantResponse: "core",
+  registerCodeContext: "graph-read",
+  // consolidated tools
+  registerDecision: "core",
+  registerSession: "core",
+  registerSupportConsolidated: "core",
+  registerDiagnostics: "admin",
+  registerListBugReports: "admin",
+  registerGetBugReport: "admin",
+  registerTriageBugReport: "admin",
+  registerIdentity: "core",
+  registerGetIdentity: "core",
+  registerUpdateIdentity: "core",
+  // tasks
+  registerTask: "tasks",
+  registerCreateTask: "tasks",
+  registerListTasks: "tasks",
+  registerUpdateTask: "tasks",
+  registerCloseTask: "tasks",
+  registerGetTask: "tasks",
+  registerCheckpointTask: "tasks",
+  registerResumeEmployee: "tasks",
+  // comms
+  registerMessage: "comms",
+  registerSendMessage: "comms",
+  registerAcknowledgeMessages: "comms",
+  // reminders
+  registerCreateReminder: "reminders",
+  registerListReminders: "reminders",
+  registerCompleteReminder: "reminders",
+  registerReminder: "reminders",
+  // graph-read
+  registerGraph: "graph-read",
+  registerQueryRelationships: "graph-read",
+  registerGetEntityNeighbors: "graph-read",
+  registerGetHotEntities: "graph-read",
+  registerGetGraphStats: "graph-read",
+  registerFindSimilarTrajectories: "graph-read",
+  // graph-write
+  registerMergeEntities: "graph-write",
+  registerExportGraph: "graph-write",
+  // wiki
+  registerWiki: "wiki",
+  registerCreateWikiPage: "wiki",
+  registerListWikiPages: "wiki",
+  registerGetWikiPage: "wiki",
+  // crm
+  registerCrm: "crm",
+  registerRawData: "raw-data",
+  registerAddPerson: "crm",
+  registerListPeople: "crm",
+  registerGetPerson: "crm",
+  // documents
+  registerDocument: "documents",
+  registerIngestDocument: "documents",
+  registerListDocuments: "documents",
+  registerPurgeDocument: "documents",
+  registerSetDocumentImportance: "documents",
+  registerRerankDocuments: "documents",
+  // gateway
+  registerGateway: "gateway",
+  registerSendWhatsapp: "gateway",
+  registerQueryConversations: "gateway",
+  registerQueryCompanyBrain: "gateway",
+  registerCompanyActions: "gateway",
+  registerWorkflowTool: "gateway",
+  registerFileCopy: "core",
+  // admin
+  registerConfig: "admin",
+  registerDeployClient: "admin",
+  registerBackupVps: "admin",
+  registerGetDaemonHealth: "admin",
+  registerMcpPing: "core",
+  registerGetAutoWakeStatus: "admin",
+  registerGetWorkerGate: "admin",
+  registerRunMemoryAudit: "admin",
+  registerRunConsolidation: "admin",
+  registerCloudSync: "admin",
+  registerOrchestrationPhase: "admin",
+  registerSetAgentConfig: "admin",
+  registerListEmployees: "admin",
+  registerGetAgentSpend: "admin",
+  registerListAgentSessions: "admin",
+  registerGetSessionKills: "admin",
+  // licensing
+  registerGetLicenseStatus: "licensing",
+  registerCreateLicense: "licensing",
+  registerListLicenses: "licensing",
+  registerActivateLicense: "licensing",
+  // orchestration
+  registerCreateTrigger: "orchestration",
+  registerListTriggers: "orchestration",
+  registerApplyStarterPack: "orchestration",
+  registerLoadSkill: "orchestration",
+  registerExportOrchestration: "orchestration",
+  registerImportOrchestration: "orchestration",
+  registerCompanyProcedure: "orchestration",
+  registerGlobalProcedure: "orchestration",
+  registerStoreGlobalProcedure: "orchestration",
+  registerListGlobalProcedures: "orchestration",
+  registerDeactivateGlobalProcedure: "orchestration"
+};
+var PLAN_TIERS = {
+  free: 0,
+  pro: 1,
+  team: 2,
+  agency: 3,
+  enterprise: 4
+};
+var PLAN_GATES = {
+  core: "free",
+  tasks: "free",
+  comms: "free",
+  reminders: "free",
+  "graph-read": "free",
+  licensing: "free",
+  // always allow checking/managing own license
+  "graph-write": "pro",
+  wiki: "pro",
+  crm: "pro",
+  "raw-data": "pro",
+  documents: "pro",
+  gateway: "pro",
+  admin: "pro",
+  orchestration: "pro"
+};
+function isToolAllowedForPlan(registerFnName, plan) {
+  const category = TOOL_CATEGORIES[registerFnName];
+  if (!category) return true;
+  const requiredPlan = PLAN_GATES[category] ?? "free";
+  return PLAN_TIERS[plan] >= PLAN_TIERS[requiredPlan];
+}
+var CHIEF_OF_STAFF_READ_TOOLS = /* @__PURE__ */ new Set([
+  "registerRecallMyMemory",
+  "registerAskTeamMemory",
+  "registerGetMemoryById",
+  "registerGetSessionContext",
+  "registerGetSessionEvents",
+  "registerGetLastAssistantResponse",
+  "registerSearchEverything",
+  "registerGetDecision",
+  "registerGetIdentity",
+  "registerMcpPing",
+  "registerListTasks",
+  "registerGetTask",
+  "registerListReminders",
+  "registerQueryConversations",
+  "registerQueryCompanyBrain"
+]);
+function isChiefOfStaffRole(role) {
+  const normalized = (role ?? "").trim().toLowerCase();
+  return normalized === "chief of staff" || normalized === "executive assistant";
+}
+function isToolAllowed(registerFnName) {
+  const role = process.env.AGENT_ROLE;
+  if (!role) return true;
+  if (isChiefOfStaffRole(role)) {
+    return CHIEF_OF_STAFF_READ_TOOLS.has(registerFnName);
+  }
+  const category = TOOL_CATEGORIES[registerFnName];
+  if (!category) return true;
+  const allowedRoles = TOOL_GATES[category];
+  if (!allowedRoles || allowedRoles.length === 0) return true;
+  return allowedRoles.includes(role);
+}
+
+export {
+  TOOL_GATES,
+  TOOL_CATEGORIES,
+  isToolAllowedForPlan,
+  isToolAllowed
+};

package/dist/chunk-ECGTESAP.js

@@ -0,0 +1,236 @@
+// src/lib/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  name;
+  defaultModel;
+  client;
+  constructor(name, config) {
+    this.name = name;
+    this.defaultModel = config.defaultModel ?? "claude-sonnet-4-20250514";
+    this.client = new Anthropic({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl || void 0
+    });
+  }
+  async createMessage(params) {
+    const response = await this.client.messages.create({
+      model: params.model || this.defaultModel,
+      max_tokens: params.maxTokens,
+      system: params.system,
+      messages: params.messages.map((m) => this.toAnthropicMessage(m)),
+      tools: params.tools?.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.inputSchema
+      }))
+    });
+    return this.normalizeResponse(response);
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      await this.client.messages.create({
+        model: this.defaultModel,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }]
+      });
+      return { available: true, latencyMs: Date.now() - start };
+    } catch {
+      return { available: false, latencyMs: Date.now() - start };
+    }
+  }
+  toAnthropicMessage(msg) {
+    if (typeof msg.content === "string") {
+      return { role: msg.role, content: msg.content };
+    }
+    const blocks = msg.content.map((block) => {
+      if (block.type === "text") {
+        return { type: "text", text: block.text };
+      }
+      if (block.type === "tool_use") {
+        return {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      }
+      if (block.type === "tool_result") {
+        return {
+          type: "tool_result",
+          tool_use_id: block.tool_use_id,
+          content: block.content,
+          is_error: block.is_error
+        };
+      }
+      return { type: "text", text: "" };
+    });
+    return { role: msg.role, content: blocks };
+  }
+  normalizeResponse(response) {
+    const content = response.content.map((block) => {
+      if (block.type === "text") {
+        return { type: "text", text: block.text };
+      }
+      if (block.type === "tool_use") {
+        return {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      }
+      return { type: "text", text: "" };
+    });
+    const stopReason = response.stop_reason === "tool_use" ? "tool_use" : response.stop_reason === "max_tokens" ? "max_tokens" : "end_turn";
+    return {
+      content,
+      stopReason,
+      usage: {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens
+      }
+    };
+  }
+};
+
+// src/lib/providers/openai-compat.ts
+import OpenAI from "openai";
+import { randomUUID } from "crypto";
+var OpenAICompatProvider = class {
+  name;
+  defaultModel;
+  client;
+  constructor(name, config) {
+    this.name = name;
+    this.defaultModel = config.defaultModel ?? "gpt-4o";
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl
+    });
+  }
+  async createMessage(params) {
+    const messages = [
+      { role: "system", content: params.system },
+      ...params.messages.flatMap((m) => this.toOpenAIMessages(m))
+    ];
+    const tools = params.tools?.map(
+      (t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema
+        }
+      })
+    );
+    const response = await this.client.chat.completions.create({
+      model: params.model || this.defaultModel,
+      max_tokens: params.maxTokens,
+      messages,
+      tools: tools?.length ? tools : void 0
+    });
+    return this.normalizeResponse(response);
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      await this.client.chat.completions.create({
+        model: this.defaultModel,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }]
+      });
+      return { available: true, latencyMs: Date.now() - start };
+    } catch {
+      return { available: false, latencyMs: Date.now() - start };
+    }
+  }
+  toOpenAIMessages(msg) {
+    if (typeof msg.content === "string") {
+      return [{ role: msg.role, content: msg.content }];
+    }
+    if (msg.role === "assistant") {
+      const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+      const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => ({
+        id: b.id,
+        type: "function",
+        function: {
+          name: b.name,
+          arguments: typeof b.input === "string" ? b.input : JSON.stringify(b.input)
+        }
+      }));
+      if (toolCalls.length > 0) {
+        return [{
+          role: "assistant",
+          content: textParts || null,
+          tool_calls: toolCalls
+        }];
+      }
+      return [{ role: "assistant", content: textParts }];
+    }
+    if (msg.role === "user") {
+      const toolResults = msg.content.filter(
+        (b) => b.type === "tool_result"
+      );
+      if (toolResults.length > 0) {
+        return toolResults.map((r) => ({
+          role: "tool",
+          tool_call_id: r.tool_use_id,
+          content: r.content
+        }));
+      }
+      const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+      return [{ role: "user", content: text }];
+    }
+    return [{ role: msg.role, content: "" }];
+  }
+  normalizeResponse(response) {
+    const choice = response.choices[0];
+    if (!choice) {
+      return {
+        content: [{ type: "text", text: "" }],
+        stopReason: "end_turn",
+        usage: { inputTokens: 0, outputTokens: 0 }
+      };
+    }
+    const content = [];
+    if (choice.message.content) {
+      content.push({ type: "text", text: choice.message.content });
+    }
+    if (choice.message.tool_calls) {
+      for (const call of choice.message.tool_calls) {
+        const fn = call.function;
+        if (!fn) continue;
+        let input;
+        try {
+          input = JSON.parse(fn.arguments);
+        } catch {
+          input = fn.arguments;
+        }
+        content.push({
+          type: "tool_use",
+          id: call.id ?? randomUUID(),
+          name: fn.name,
+          input
+        });
+      }
+    }
+    if (content.length === 0) {
+      content.push({ type: "text", text: "" });
+    }
+    const stopReason = choice.finish_reason === "tool_calls" ? "tool_use" : choice.finish_reason === "length" ? "max_tokens" : "end_turn";
+    return {
+      content,
+      stopReason,
+      usage: {
+        inputTokens: response.usage?.prompt_tokens ?? 0,
+        outputTokens: response.usage?.completion_tokens ?? 0
+      }
+    };
+  }
+};
+
+export {
+  AnthropicProvider,
+  OpenAICompatProvider
+};