@vorim/sdk 1.0.2 → 2.1.0

package/dist/integrations/crewai.d.cts

@@ -0,0 +1,174 @@
+import { PermissionScope, AgentRegistrationResult, VorimSDK } from '../index.cjs';
+
+interface CrewMemberConfig {
+    /** Unique role name within the crew (e.g. "researcher", "writer"). */
+    role: string;
+    /** Display name for the Vorim agent. */
+    name: string;
+    /** Description of this crew member's responsibilities. */
+    description?: string;
+    /** Tools this agent can use (e.g. ["web_search", "file_read"]). */
+    capabilities: string[];
+    /** Permission scopes to grant. */
+    scopes: PermissionScope[];
+    /** Whether this agent can delegate to other crew members. */
+    allowDelegation?: boolean;
+}
+interface CrewManifest {
+    /** Name for the overall crew. */
+    crewName: string;
+    /** Members of the crew. */
+    members: CrewMemberConfig[];
+    /** Optional metadata for the crew. */
+    metadata?: Record<string, unknown>;
+}
+interface RegisteredCrewMember {
+    role: string;
+    agentId: string;
+    registration: AgentRegistrationResult;
+    privateKey: string;
+}
+interface RegisteredCrew {
+    crewName: string;
+    members: RegisteredCrewMember[];
+    /** Lookup a member by role. */
+    getMember(role: string): RegisteredCrewMember | undefined;
+    /** Get all agent IDs in the crew. */
+    agentIds(): string[];
+}
+/**
+ * Registers an entire CrewAI crew with Vorim. Each crew member gets a
+ * unique Vorim agent identity with Ed25519 keypair and scoped permissions.
+ *
+ * @example
+ * ```ts
+ * import createVorim from "@vorim/sdk";
+ * import { registerCrew } from "@vorim/sdk/integrations/crewai";
+ *
+ * const vorim = createVorim({ apiKey: "agid_sk_live_..." });
+ *
+ * const crew = await registerCrew(vorim, {
+ *   crewName: "content-pipeline",
+ *   members: [
+ *     {
+ *       role: "researcher",
+ *       name: "crew-researcher",
+ *       capabilities: ["web_search", "summarization"],
+ *       scopes: ["agent:read", "agent:execute"],
+ *     },
+ *     {
+ *       role: "writer",
+ *       name: "crew-writer",
+ *       capabilities: ["file_write", "formatting"],
+ *       scopes: ["agent:read", "agent:write"],
+ *     },
+ *     {
+ *       role: "editor",
+ *       name: "crew-editor",
+ *       capabilities: ["review", "approval"],
+ *       scopes: ["agent:read", "agent:write"],
+ *       allowDelegation: true,
+ *     },
+ *   ],
+ * });
+ *
+ * // Access individual members
+ * const researcher = crew.getMember("researcher");
+ * console.log(researcher.agentId); // agid_acme_...
+ *
+ * // Grant delegation permission to editor
+ * // (done automatically if allowDelegation is true)
+ * ```
+ */
+declare function registerCrew(vorim: VorimSDK, manifest: CrewManifest): Promise<RegisteredCrew>;
+interface CrewTaskEvent {
+    /** The role of the crew member performing the task. */
+    role: string;
+    /** The Vorim agent_id (looked up from the crew). */
+    agentId: string;
+    /** Task description or name. */
+    task: string;
+    /** Tool used (if any). */
+    tool?: string;
+    /** Result of the action. */
+    result: 'success' | 'denied' | 'error';
+    /** Duration in milliseconds. */
+    latencyMs?: number;
+    /** Error details if result is 'error'. */
+    error?: string;
+    /** Whether this was a delegation to another crew member. */
+    delegatedTo?: string;
+    /** Additional context. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Emits a Vorim audit event for a CrewAI task execution.
+ * Call this from your orchestration layer after each CrewAI step completes.
+ *
+ * @example
+ * ```ts
+ * import { emitCrewTaskEvent } from "@vorim/sdk/integrations/crewai";
+ *
+ * // After a CrewAI task completes
+ * await emitCrewTaskEvent(vorim, {
+ *   role: "researcher",
+ *   agentId: crew.getMember("researcher").agentId,
+ *   task: "research_competitors",
+ *   tool: "web_search",
+ *   result: "success",
+ *   latencyMs: 3200,
+ * });
+ * ```
+ */
+declare function emitCrewTaskEvent(vorim: VorimSDK, event: CrewTaskEvent): Promise<void>;
+/**
+ * Emits audit events for an entire crew run (batch of task results).
+ *
+ * @example
+ * ```ts
+ * await emitCrewRunEvents(vorim, [
+ *   { role: "researcher", agentId: "...", task: "research", result: "success" },
+ *   { role: "writer", agentId: "...", task: "draft_article", result: "success" },
+ *   { role: "editor", agentId: "...", task: "review", result: "success" },
+ * ]);
+ * ```
+ */
+declare function emitCrewRunEvents(vorim: VorimSDK, events: CrewTaskEvent[]): Promise<{
+    ingested: number;
+}>;
+/**
+ * Check if a crew member has permission before executing a task.
+ * Returns the check result — does not throw.
+ *
+ * @example
+ * ```ts
+ * const { allowed } = await checkCrewPermission(vorim, crew, "writer", "agent:write");
+ * if (!allowed) {
+ *   console.log("Writer lacks write permission");
+ * }
+ * ```
+ */
+declare function checkCrewPermission(vorim: VorimSDK, crew: RegisteredCrew, role: string, scope: PermissionScope): Promise<{
+    allowed: boolean;
+    reason?: string;
+}>;
+/**
+ * Check if delegation between two crew members is permitted.
+ * The delegating agent must have the `agent:delegate` scope.
+ */
+declare function checkDelegationPermission(vorim: VorimSDK, crew: RegisteredCrew, fromRole: string, toRole: string): Promise<{
+    allowed: boolean;
+    reason?: string;
+}>;
+/**
+ * Verify trust scores for all members of a crew.
+ * Useful before starting a crew run to ensure all agents are active and trusted.
+ */
+declare function verifyCrewTrust(vorim: VorimSDK, crew: RegisteredCrew): Promise<{
+    role: string;
+    agentId: string;
+    trustScore: number;
+    status: string;
+}[]>;
+
+export { type CrewManifest, type CrewMemberConfig, type CrewTaskEvent, type RegisteredCrew, type RegisteredCrewMember, checkCrewPermission, checkDelegationPermission, emitCrewRunEvents, emitCrewTaskEvent, registerCrew, verifyCrewTrust };

package/dist/integrations/crewai.d.ts

@@ -0,0 +1,174 @@
+import { PermissionScope, AgentRegistrationResult, VorimSDK } from '../index.js';
+
+interface CrewMemberConfig {
+    /** Unique role name within the crew (e.g. "researcher", "writer"). */
+    role: string;
+    /** Display name for the Vorim agent. */
+    name: string;
+    /** Description of this crew member's responsibilities. */
+    description?: string;
+    /** Tools this agent can use (e.g. ["web_search", "file_read"]). */
+    capabilities: string[];
+    /** Permission scopes to grant. */
+    scopes: PermissionScope[];
+    /** Whether this agent can delegate to other crew members. */
+    allowDelegation?: boolean;
+}
+interface CrewManifest {
+    /** Name for the overall crew. */
+    crewName: string;
+    /** Members of the crew. */
+    members: CrewMemberConfig[];
+    /** Optional metadata for the crew. */
+    metadata?: Record<string, unknown>;
+}
+interface RegisteredCrewMember {
+    role: string;
+    agentId: string;
+    registration: AgentRegistrationResult;
+    privateKey: string;
+}
+interface RegisteredCrew {
+    crewName: string;
+    members: RegisteredCrewMember[];
+    /** Lookup a member by role. */
+    getMember(role: string): RegisteredCrewMember | undefined;
+    /** Get all agent IDs in the crew. */
+    agentIds(): string[];
+}
+/**
+ * Registers an entire CrewAI crew with Vorim. Each crew member gets a
+ * unique Vorim agent identity with Ed25519 keypair and scoped permissions.
+ *
+ * @example
+ * ```ts
+ * import createVorim from "@vorim/sdk";
+ * import { registerCrew } from "@vorim/sdk/integrations/crewai";
+ *
+ * const vorim = createVorim({ apiKey: "agid_sk_live_..." });
+ *
+ * const crew = await registerCrew(vorim, {
+ *   crewName: "content-pipeline",
+ *   members: [
+ *     {
+ *       role: "researcher",
+ *       name: "crew-researcher",
+ *       capabilities: ["web_search", "summarization"],
+ *       scopes: ["agent:read", "agent:execute"],
+ *     },
+ *     {
+ *       role: "writer",
+ *       name: "crew-writer",
+ *       capabilities: ["file_write", "formatting"],
+ *       scopes: ["agent:read", "agent:write"],
+ *     },
+ *     {
+ *       role: "editor",
+ *       name: "crew-editor",
+ *       capabilities: ["review", "approval"],
+ *       scopes: ["agent:read", "agent:write"],
+ *       allowDelegation: true,
+ *     },
+ *   ],
+ * });
+ *
+ * // Access individual members
+ * const researcher = crew.getMember("researcher");
+ * console.log(researcher.agentId); // agid_acme_...
+ *
+ * // Grant delegation permission to editor
+ * // (done automatically if allowDelegation is true)
+ * ```
+ */
+declare function registerCrew(vorim: VorimSDK, manifest: CrewManifest): Promise<RegisteredCrew>;
+interface CrewTaskEvent {
+    /** The role of the crew member performing the task. */
+    role: string;
+    /** The Vorim agent_id (looked up from the crew). */
+    agentId: string;
+    /** Task description or name. */
+    task: string;
+    /** Tool used (if any). */
+    tool?: string;
+    /** Result of the action. */
+    result: 'success' | 'denied' | 'error';
+    /** Duration in milliseconds. */
+    latencyMs?: number;
+    /** Error details if result is 'error'. */
+    error?: string;
+    /** Whether this was a delegation to another crew member. */
+    delegatedTo?: string;
+    /** Additional context. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Emits a Vorim audit event for a CrewAI task execution.
+ * Call this from your orchestration layer after each CrewAI step completes.
+ *
+ * @example
+ * ```ts
+ * import { emitCrewTaskEvent } from "@vorim/sdk/integrations/crewai";
+ *
+ * // After a CrewAI task completes
+ * await emitCrewTaskEvent(vorim, {
+ *   role: "researcher",
+ *   agentId: crew.getMember("researcher").agentId,
+ *   task: "research_competitors",
+ *   tool: "web_search",
+ *   result: "success",
+ *   latencyMs: 3200,
+ * });
+ * ```
+ */
+declare function emitCrewTaskEvent(vorim: VorimSDK, event: CrewTaskEvent): Promise<void>;
+/**
+ * Emits audit events for an entire crew run (batch of task results).
+ *
+ * @example
+ * ```ts
+ * await emitCrewRunEvents(vorim, [
+ *   { role: "researcher", agentId: "...", task: "research", result: "success" },
+ *   { role: "writer", agentId: "...", task: "draft_article", result: "success" },
+ *   { role: "editor", agentId: "...", task: "review", result: "success" },
+ * ]);
+ * ```
+ */
+declare function emitCrewRunEvents(vorim: VorimSDK, events: CrewTaskEvent[]): Promise<{
+    ingested: number;
+}>;
+/**
+ * Check if a crew member has permission before executing a task.
+ * Returns the check result — does not throw.
+ *
+ * @example
+ * ```ts
+ * const { allowed } = await checkCrewPermission(vorim, crew, "writer", "agent:write");
+ * if (!allowed) {
+ *   console.log("Writer lacks write permission");
+ * }
+ * ```
+ */
+declare function checkCrewPermission(vorim: VorimSDK, crew: RegisteredCrew, role: string, scope: PermissionScope): Promise<{
+    allowed: boolean;
+    reason?: string;
+}>;
+/**
+ * Check if delegation between two crew members is permitted.
+ * The delegating agent must have the `agent:delegate` scope.
+ */
+declare function checkDelegationPermission(vorim: VorimSDK, crew: RegisteredCrew, fromRole: string, toRole: string): Promise<{
+    allowed: boolean;
+    reason?: string;
+}>;
+/**
+ * Verify trust scores for all members of a crew.
+ * Useful before starting a crew run to ensure all agents are active and trusted.
+ */
+declare function verifyCrewTrust(vorim: VorimSDK, crew: RegisteredCrew): Promise<{
+    role: string;
+    agentId: string;
+    trustScore: number;
+    status: string;
+}[]>;
+
+export { type CrewManifest, type CrewMemberConfig, type CrewTaskEvent, type RegisteredCrew, type RegisteredCrewMember, checkCrewPermission, checkDelegationPermission, emitCrewRunEvents, emitCrewTaskEvent, registerCrew, verifyCrewTrust };

package/dist/integrations/crewai.js

@@ -0,0 +1,111 @@
+// src/integrations/crewai.ts
+async function registerCrew(vorim, manifest) {
+  const members = [];
+  for (const member of manifest.members) {
+    const scopes = [...member.scopes];
+    if (member.allowDelegation && !scopes.includes("agent:delegate")) {
+      scopes.push("agent:delegate");
+    }
+    const registration = await vorim.register({
+      name: member.name,
+      description: member.description ?? `CrewAI ${member.role} \u2014 ${manifest.crewName}`,
+      capabilities: member.capabilities,
+      scopes
+    });
+    members.push({
+      role: member.role,
+      agentId: registration.agent.agent_id,
+      registration,
+      privateKey: registration.private_key
+    });
+  }
+  return {
+    crewName: manifest.crewName,
+    members,
+    getMember(role) {
+      return members.find((m) => m.role === role);
+    },
+    agentIds() {
+      return members.map((m) => m.agentId);
+    }
+  };
+}
+async function emitCrewTaskEvent(vorim, event) {
+  const auditEvent = {
+    agent_id: event.agentId,
+    event_type: event.tool ? "tool_call" : "api_request",
+    action: event.task,
+    resource: event.tool,
+    result: event.result,
+    latency_ms: event.latencyMs,
+    error_code: event.error ? "CREW_TASK_ERROR" : void 0,
+    metadata: {
+      framework: "crewai",
+      role: event.role,
+      ...event.delegatedTo ? { delegated_to: event.delegatedTo } : {},
+      ...event.error ? { error: event.error } : {},
+      ...event.metadata
+    }
+  };
+  await vorim.emit(auditEvent);
+}
+async function emitCrewRunEvents(vorim, events) {
+  const auditEvents = events.map((event) => ({
+    agent_id: event.agentId,
+    event_type: event.tool ? "tool_call" : "api_request",
+    action: event.task,
+    resource: event.tool,
+    result: event.result,
+    latency_ms: event.latencyMs,
+    error_code: event.error ? "CREW_TASK_ERROR" : void 0,
+    metadata: {
+      framework: "crewai",
+      role: event.role,
+      ...event.delegatedTo ? { delegated_to: event.delegatedTo } : {},
+      ...event.error ? { error: event.error } : {},
+      ...event.metadata
+    }
+  }));
+  return vorim.emitBatch(auditEvents);
+}
+async function checkCrewPermission(vorim, crew, role, scope) {
+  const member = crew.getMember(role);
+  if (!member) {
+    return { allowed: false, reason: `Unknown crew member: ${role}` };
+  }
+  return vorim.check(member.agentId, scope);
+}
+async function checkDelegationPermission(vorim, crew, fromRole, toRole) {
+  const from = crew.getMember(fromRole);
+  const to = crew.getMember(toRole);
+  if (!from) return { allowed: false, reason: `Unknown crew member: ${fromRole}` };
+  if (!to) return { allowed: false, reason: `Unknown crew member: ${toRole}` };
+  const result = await vorim.check(from.agentId, "agent:delegate");
+  if (!result.allowed) {
+    return { allowed: false, reason: `${fromRole} lacks agent:delegate permission` };
+  }
+  return { allowed: true };
+}
+async function verifyCrewTrust(vorim, crew) {
+  const results = await Promise.all(
+    crew.members.map(async (member) => {
+      const trust = await vorim.verify(member.agentId);
+      return {
+        role: member.role,
+        agentId: member.agentId,
+        trustScore: trust.trust_score,
+        status: trust.status
+      };
+    })
+  );
+  return results;
+}
+export {
+  checkCrewPermission,
+  checkDelegationPermission,
+  emitCrewRunEvents,
+  emitCrewTaskEvent,
+  registerCrew,
+  verifyCrewTrust
+};
+//# sourceMappingURL=crewai.js.map

package/dist/integrations/crewai.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/integrations/crewai.ts"],"sourcesContent":["// ============================================================================\n// VORIM SDK — CrewAI Integration\n// CrewAI is Python-only, so this module provides:\n//   1. A TypeScript helper for managing CrewAI agent identities via Vorim\n//   2. Audit utilities for logging crew task execution\n//   3. A \"crew manifest\" pattern for registering entire crews at once\n//\n// Use this from a TypeScript orchestration layer that triggers CrewAI\n// runs via REST, CLI, or subprocess. For native Python integration,\n// use the Vorim REST API directly (see docs).\n//\n// No peer dependencies required — uses @vorim/sdk only.\n// ============================================================================\n\nimport type { VorimSDK } from '../index.js';\nimport type {\n  PermissionScope, AuditEventInput, AgentRegistrationResult,\n} from '../types.js';\n\n// ─── Crew Configuration ──────────────────────────────────────────────────\n\nexport interface CrewMemberConfig {\n  /** Unique role name within the crew (e.g. \"researcher\", \"writer\"). */\n  role: string;\n  /** Display name for the Vorim agent. */\n  name: string;\n  /** Description of this crew member's responsibilities. */\n  description?: string;\n  /** Tools this agent can use (e.g. [\"web_search\", \"file_read\"]). */\n  capabilities: string[];\n  /** Permission scopes to grant. */\n  scopes: PermissionScope[];\n  /** Whether this agent can delegate to other crew members. */\n  allowDelegation?: boolean;\n}\n\nexport interface CrewManifest {\n  /** Name for the overall crew. */\n  crewName: string;\n  /** Members of the crew. */\n  members: CrewMemberConfig[];\n  /** Optional metadata for the crew. */\n  metadata?: Record<string, unknown>;\n}\n\nexport interface RegisteredCrewMember {\n  role: string;\n  agentId: string;\n  registration: AgentRegistrationResult;\n  privateKey: string;\n}\n\nexport interface RegisteredCrew {\n  crewName: string;\n  members: RegisteredCrewMember[];\n  /** Lookup a member by role. */\n  getMember(role: string): RegisteredCrewMember | undefined;\n  /** Get all agent IDs in the crew. */\n  agentIds(): string[];\n}\n\n// ─── Crew Registration ──────────────────────────────────────────────────\n\n/**\n * Registers an entire CrewAI crew with Vorim. Each crew member gets a\n * unique Vorim agent identity with Ed25519 keypair and scoped permissions.\n *\n * @example\n * ```ts\n * import createVorim from \"@vorim/sdk\";\n * import { registerCrew } from \"@vorim/sdk/integrations/crewai\";\n *\n * const vorim = createVorim({ apiKey: \"agid_sk_live_...\" });\n *\n * const crew = await registerCrew(vorim, {\n *   crewName: \"content-pipeline\",\n *   members: [\n *     {\n *       role: \"researcher\",\n *       name: \"crew-researcher\",\n *       capabilities: [\"web_search\", \"summarization\"],\n *       scopes: [\"agent:read\", \"agent:execute\"],\n *     },\n *     {\n *       role: \"writer\",\n *       name: \"crew-writer\",\n *       capabilities: [\"file_write\", \"formatting\"],\n *       scopes: [\"agent:read\", \"agent:write\"],\n *     },\n *     {\n *       role: \"editor\",\n *       name: \"crew-editor\",\n *       capabilities: [\"review\", \"approval\"],\n *       scopes: [\"agent:read\", \"agent:write\"],\n *       allowDelegation: true,\n *     },\n *   ],\n * });\n *\n * // Access individual members\n * const researcher = crew.getMember(\"researcher\");\n * console.log(researcher.agentId); // agid_acme_...\n *\n * // Grant delegation permission to editor\n * // (done automatically if allowDelegation is true)\n * ```\n */\nexport async function registerCrew(\n  vorim: VorimSDK,\n  manifest: CrewManifest,\n): Promise<RegisteredCrew> {\n  const members: RegisteredCrewMember[] = [];\n\n  for (const member of manifest.members) {\n    const scopes = [...member.scopes];\n\n    // Auto-add delegate scope if delegation is allowed\n    if (member.allowDelegation && !scopes.includes('agent:delegate')) {\n      scopes.push('agent:delegate');\n    }\n\n    const registration = await vorim.register({\n      name: member.name,\n      description: member.description ?? `CrewAI ${member.role} — ${manifest.crewName}`,\n      capabilities: member.capabilities,\n      scopes,\n    });\n\n    members.push({\n      role: member.role,\n      agentId: registration.agent.agent_id,\n      registration,\n      privateKey: registration.private_key,\n    });\n  }\n\n  return {\n    crewName: manifest.crewName,\n    members,\n    getMember(role: string) {\n      return members.find(m => m.role === role);\n    },\n    agentIds() {\n      return members.map(m => m.agentId);\n    },\n  };\n}\n\n// ─── Task Audit ──────────────────────────────────────────────────────────\n\nexport interface CrewTaskEvent {\n  /** The role of the crew member performing the task. */\n  role: string;\n  /** The Vorim agent_id (looked up from the crew). */\n  agentId: string;\n  /** Task description or name. */\n  task: string;\n  /** Tool used (if any). */\n  tool?: string;\n  /** Result of the action. */\n  result: 'success' | 'denied' | 'error';\n  /** Duration in milliseconds. */\n  latencyMs?: number;\n  /** Error details if result is 'error'. */\n  error?: string;\n  /** Whether this was a delegation to another crew member. */\n  delegatedTo?: string;\n  /** Additional context. */\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Emits a Vorim audit event for a CrewAI task execution.\n * Call this from your orchestration layer after each CrewAI step completes.\n *\n * @example\n * ```ts\n * import { emitCrewTaskEvent } from \"@vorim/sdk/integrations/crewai\";\n *\n * // After a CrewAI task completes\n * await emitCrewTaskEvent(vorim, {\n *   role: \"researcher\",\n *   agentId: crew.getMember(\"researcher\").agentId,\n *   task: \"research_competitors\",\n *   tool: \"web_search\",\n *   result: \"success\",\n *   latencyMs: 3200,\n * });\n * ```\n */\nexport async function emitCrewTaskEvent(\n  vorim: VorimSDK,\n  event: CrewTaskEvent,\n): Promise<void> {\n  const auditEvent: AuditEventInput = {\n    agent_id: event.agentId,\n    event_type: event.tool ? 'tool_call' : 'api_request',\n    action: event.task,\n    resource: event.tool,\n    result: event.result,\n    latency_ms: event.latencyMs,\n    error_code: event.error ? 'CREW_TASK_ERROR' : undefined,\n    metadata: {\n      framework: 'crewai',\n      role: event.role,\n      ...(event.delegatedTo ? { delegated_to: event.delegatedTo } : {}),\n      ...(event.error ? { error: event.error } : {}),\n      ...event.metadata,\n    },\n  };\n\n  await vorim.emit(auditEvent);\n}\n\n/**\n * Emits audit events for an entire crew run (batch of task results).\n *\n * @example\n * ```ts\n * await emitCrewRunEvents(vorim, [\n *   { role: \"researcher\", agentId: \"...\", task: \"research\", result: \"success\" },\n *   { role: \"writer\", agentId: \"...\", task: \"draft_article\", result: \"success\" },\n *   { role: \"editor\", agentId: \"...\", task: \"review\", result: \"success\" },\n * ]);\n * ```\n */\nexport async function emitCrewRunEvents(\n  vorim: VorimSDK,\n  events: CrewTaskEvent[],\n): Promise<{ ingested: number }> {\n  const auditEvents: AuditEventInput[] = events.map(event => ({\n    agent_id: event.agentId,\n    event_type: event.tool ? 'tool_call' : 'api_request',\n    action: event.task,\n    resource: event.tool,\n    result: event.result,\n    latency_ms: event.latencyMs,\n    error_code: event.error ? 'CREW_TASK_ERROR' : undefined,\n    metadata: {\n      framework: 'crewai',\n      role: event.role,\n      ...(event.delegatedTo ? { delegated_to: event.delegatedTo } : {}),\n      ...(event.error ? { error: event.error } : {}),\n      ...event.metadata,\n    },\n  }));\n\n  return vorim.emitBatch(auditEvents);\n}\n\n// ─── Permission Helpers ──────────────────────────────────────────────────\n\n/**\n * Check if a crew member has permission before executing a task.\n * Returns the check result — does not throw.\n *\n * @example\n * ```ts\n * const { allowed } = await checkCrewPermission(vorim, crew, \"writer\", \"agent:write\");\n * if (!allowed) {\n *   console.log(\"Writer lacks write permission\");\n * }\n * ```\n */\nexport async function checkCrewPermission(\n  vorim: VorimSDK,\n  crew: RegisteredCrew,\n  role: string,\n  scope: PermissionScope,\n): Promise<{ allowed: boolean; reason?: string }> {\n  const member = crew.getMember(role);\n  if (!member) {\n    return { allowed: false, reason: `Unknown crew member: ${role}` };\n  }\n  return vorim.check(member.agentId, scope);\n}\n\n/**\n * Check if delegation between two crew members is permitted.\n * The delegating agent must have the `agent:delegate` scope.\n */\nexport async function checkDelegationPermission(\n  vorim: VorimSDK,\n  crew: RegisteredCrew,\n  fromRole: string,\n  toRole: string,\n): Promise<{ allowed: boolean; reason?: string }> {\n  const from = crew.getMember(fromRole);\n  const to = crew.getMember(toRole);\n  if (!from) return { allowed: false, reason: `Unknown crew member: ${fromRole}` };\n  if (!to) return { allowed: false, reason: `Unknown crew member: ${toRole}` };\n\n  const result = await vorim.check(from.agentId, 'agent:delegate');\n  if (!result.allowed) {\n    return { allowed: false, reason: `${fromRole} lacks agent:delegate permission` };\n  }\n  return { allowed: true };\n}\n\n// ─── Trust Verification ──────────────────────────────────────────────────\n\n/**\n * Verify trust scores for all members of a crew.\n * Useful before starting a crew run to ensure all agents are active and trusted.\n */\nexport async function verifyCrewTrust(\n  vorim: VorimSDK,\n  crew: RegisteredCrew,\n): Promise<{ role: string; agentId: string; trustScore: number; status: string }[]> {\n  const results = await Promise.all(\n    crew.members.map(async (member) => {\n      const trust = await vorim.verify(member.agentId);\n      return {\n        role: member.role,\n        agentId: member.agentId,\n        trustScore: trust.trust_score,\n        status: trust.status,\n      };\n    }),\n  );\n  return results;\n}\n"],"mappings":"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","names":[]}

package/dist/integrations/langchain.cjs

@@ -0,0 +1,197 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/integrations/langchain.ts
+var langchain_exports = {};
+__export(langchain_exports, {
+  VorimCallbackHandler: () => VorimCallbackHandler,
+  createVorimAgent: () => createVorimAgent,
+  wrapTool: () => wrapTool,
+  wrapTools: () => wrapTools
+});
+module.exports = __toCommonJS(langchain_exports);
+function wrapTool(tool, config) {
+  const { vorim, agentId, permissionMap = {}, defaultPermission = "agent:execute", asyncAudit = true } = config;
+  const originalCall = tool._call.bind(tool);
+  tool._call = async function vorimGuardedCall(arg, runManager, parentConfig) {
+    const scope = permissionMap[tool.name] ?? defaultPermission;
+    const { allowed, reason } = await vorim.check(agentId, scope);
+    if (!allowed) {
+      const event2 = {
+        agent_id: agentId,
+        event_type: "tool_call",
+        action: tool.name,
+        resource: truncate(JSON.stringify(arg), 500),
+        permission: scope,
+        result: "denied",
+        metadata: { reason, framework: "langchain" }
+      };
+      emitAudit(vorim, event2, asyncAudit);
+      throw new Error(`Vorim: permission denied for "${tool.name}" \u2014 scope "${scope}"${reason ? `: ${reason}` : ""}`);
+    }
+    const start = Date.now();
+    let result;
+    try {
+      result = await originalCall(arg, runManager, parentConfig);
+    } catch (err) {
+      const event2 = {
+        agent_id: agentId,
+        event_type: "tool_call",
+        action: tool.name,
+        resource: truncate(JSON.stringify(arg), 500),
+        permission: scope,
+        result: "error",
+        latency_ms: Date.now() - start,
+        error_code: err instanceof Error ? err.name : "UNKNOWN",
+        metadata: { error: err instanceof Error ? err.message : String(err), framework: "langchain" }
+      };
+      emitAudit(vorim, event2, asyncAudit);
+      throw err;
+    }
+    const event = {
+      agent_id: agentId,
+      event_type: "tool_call",
+      action: tool.name,
+      resource: truncate(JSON.stringify(arg), 500),
+      permission: scope,
+      result: "success",
+      latency_ms: Date.now() - start,
+      metadata: { framework: "langchain" }
+    };
+    emitAudit(vorim, event, asyncAudit);
+    return result;
+  };
+  return tool;
+}
+function wrapTools(tools, config) {
+  return tools.map((t) => wrapTool(t, config));
+}
+var VorimCallbackHandler = class _VorimCallbackHandler {
+  name = "VorimCallbackHandler";
+  vorim;
+  agentId;
+  runMap = /* @__PURE__ */ new Map();
+  // Flags to satisfy BaseCallbackHandler interface
+  ignoreLLM = true;
+  ignoreChain = true;
+  ignoreAgent = true;
+  ignoreRetriever = true;
+  ignoreCustomEvent = true;
+  lc_serializable = false;
+  get lc_id() {
+    return ["vorim", "callbacks", "VorimCallbackHandler"];
+  }
+  get lc_namespace() {
+    return ["vorim", "callbacks"];
+  }
+  constructor(vorim, agentId) {
+    this.vorim = vorim;
+    this.agentId = agentId;
+  }
+  async handleToolStart(tool, input, runId, _parentRunId, _tags, _metadata, runName) {
+    const toolName = runName ?? tool.id?.[tool.id.length - 1] ?? "unknown";
+    this.runMap.set(runId, { tool: toolName, input, startTime: Date.now() });
+  }
+  async handleToolEnd(_output, runId) {
+    const run = this.runMap.get(runId);
+    if (!run) return;
+    this.runMap.delete(runId);
+    await this.vorim.emit({
+      agent_id: this.agentId,
+      event_type: "tool_call",
+      action: run.tool,
+      resource: truncate(run.input, 500),
+      result: "success",
+      latency_ms: Date.now() - run.startTime,
+      metadata: { framework: "langchain" }
+    }).catch(() => {
+    });
+  }
+  async handleToolError(err, runId) {
+    const run = this.runMap.get(runId);
+    if (!run) return;
+    this.runMap.delete(runId);
+    await this.vorim.emit({
+      agent_id: this.agentId,
+      event_type: "tool_call",
+      action: run.tool,
+      resource: truncate(run.input, 500),
+      result: "error",
+      latency_ms: Date.now() - run.startTime,
+      error_code: err.name,
+      metadata: { error: err.message, framework: "langchain" }
+    }).catch(() => {
+    });
+  }
+  // Required by BaseCallbackHandler — no-op for events we don't need
+  copy() {
+    return new _VorimCallbackHandler(this.vorim, this.agentId);
+  }
+  toJSON() {
+    return { lc: 1, type: "not_implemented", id: this.lc_id };
+  }
+  toJSONNotImplemented() {
+    return this.toJSON();
+  }
+};
+async function createVorimAgent(config) {
+  const { vorim, name, capabilities, scopes, description, tools: rawTools, permissionMap, defaultPermission, asyncAudit } = config;
+  const registration = await vorim.register({
+    name,
+    description,
+    capabilities,
+    scopes
+  });
+  const agentId = registration.agent.agent_id;
+  const agentConfig = { vorim, agentId, permissionMap, defaultPermission, asyncAudit };
+  const tools = wrapTools(rawTools, agentConfig);
+  const callbackHandler = new VorimCallbackHandler(vorim, agentId);
+  return {
+    /** The Vorim agent_id. */
+    agentId,
+    /** The full agent registration result. */
+    registration,
+    /** Tools wrapped with Vorim permission checks + audit. */
+    tools,
+    /** Callback handler for audit trail observability. */
+    callbackHandler,
+    /** The private key (store securely — shown once). */
+    privateKey: registration.private_key
+  };
+}
+function truncate(str, max) {
+  return str.length > max ? str.slice(0, max) + "\u2026" : str;
+}
+function emitAudit(vorim, event, async) {
+  if (async) {
+    vorim.emit(event).catch(() => {
+    });
+  } else {
+    vorim.emit(event).catch(() => {
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VorimCallbackHandler,
+  createVorimAgent,
+  wrapTool,
+  wrapTools
+});
+//# sourceMappingURL=langchain.cjs.map