@sekuire/sdk 0.1.4

package/dist/tools/agent-invocation.d.ts

@@ -0,0 +1,90 @@
+import type { Tool, ToolMetadata } from "./base";
+/**
+ * Tool for invoking other Sekuire agents
+ * Performs handshake and sends requests to verified agents
+ */
+export declare class InvokeAgentTool implements Tool {
+    private readonly privateKey?;
+    private readonly publicKey?;
+    private readonly registryUrl;
+    name: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {
+            agent_url: {
+                type: "string";
+                description: string;
+            };
+            agent_id: {
+                type: "string";
+                description: string;
+            };
+            request: {
+                type: "string";
+                description: string;
+            };
+            parameters: {
+                type: "object";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    metadata: ToolMetadata;
+    private client;
+    constructor(privateKey?: string | undefined, publicKey?: string | undefined, registryUrl?: string);
+    execute(args: Record<string, any>): Promise<string>;
+}
+/**
+ * Tool for searching the Sekuire registry for agents
+ */
+export declare class SearchAgentsTool implements Tool {
+    private readonly privateKey?;
+    private readonly publicKey?;
+    private readonly registryUrl;
+    name: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {
+            query: {
+                type: "string";
+                description: string;
+            };
+            limit: {
+                type: "number";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    metadata: ToolMetadata;
+    private client;
+    constructor(privateKey?: string | undefined, publicKey?: string | undefined, registryUrl?: string);
+    execute(args: Record<string, any>): Promise<string>;
+}
+/**
+ * Tool for getting detailed information about a specific agent
+ */
+export declare class GetAgentInfoTool implements Tool {
+    private readonly privateKey?;
+    private readonly publicKey?;
+    private readonly registryUrl;
+    name: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {
+            agent_id: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    metadata: ToolMetadata;
+    private client;
+    constructor(privateKey?: string | undefined, publicKey?: string | undefined, registryUrl?: string);
+    execute(args: Record<string, any>): Promise<string>;
+}

package/dist/tools/base.d.ts

@@ -0,0 +1,40 @@
+import type { PolicyEnforcer } from "../policy-enforcer";
+export interface ToolInput {
+    [key: string]: string | number | boolean | object;
+}
+export interface ToolParameter {
+    name: string;
+    type: "string" | "number" | "boolean" | "object";
+    description: string;
+    required: boolean;
+    default?: string | number | boolean | object;
+}
+export interface ToolMetadata {
+    name: string;
+    description: string;
+    parameters: ToolParameter[];
+    category?: string;
+    compliance_level?: "public" | "internal" | "restricted" | "system";
+    requires_approval?: boolean;
+}
+export declare abstract class Tool {
+    abstract metadata: ToolMetadata;
+    protected policyEnforcer?: PolicyEnforcer;
+    abstract execute(input: ToolInput): Promise<string | object>;
+    setPolicyEnforcer(enforcer: PolicyEnforcer): void;
+    validate(input: ToolInput): boolean;
+    toSchema(): object;
+}
+export declare class ToolRegistry {
+    private tools;
+    private categories;
+    register(tool: Tool): void;
+    get(name: string): Tool | undefined;
+    getTool(name: string): Tool | undefined;
+    list(): Tool[];
+    getAllTools(): Tool[];
+    getSchemas(): object[];
+    getToolsByCategory(category: string): string[];
+    getAllCategories(): string[];
+    hasCategory(category: string): boolean;
+}

package/dist/tools/calculator.d.ts

@@ -0,0 +1,5 @@
+import { Tool, type ToolInput, type ToolMetadata } from "./base";
+export declare class CalculatorTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}

package/dist/tools/compliance-operations.d.ts

@@ -0,0 +1,40 @@
+import { Tool, type ToolMetadata } from "./base";
+export declare class AuditLogTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        action: string;
+        actor?: string;
+        resource?: string;
+        metadata?: any;
+    }): Promise<{
+        logged: boolean;
+    }>;
+}
+export declare class PiiDetectTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        text: string;
+    }): Promise<{
+        detected: boolean;
+        types: string[];
+        matches: any[];
+    }>;
+}
+export declare class EncryptDataTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        data: string;
+        key?: string;
+    }): Promise<{
+        encrypted: string;
+        iv: string;
+    }>;
+}
+export declare class DecryptDataTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        encrypted: string;
+        iv: string;
+        key: string;
+    }): Promise<string>;
+}

package/dist/tools/data-formats.d.ts

@@ -0,0 +1,36 @@
+import { Tool, ToolMetadata } from './base';
+export declare class JsonStringifyTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        data: any;
+        pretty?: boolean;
+    }): Promise<string>;
+}
+export declare class CsvParseTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        csv: string;
+        delimiter?: string;
+        headers?: boolean;
+    }): Promise<any[]>;
+}
+export declare class CsvWriteTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        data: any[];
+        delimiter?: string;
+        headers?: boolean;
+    }): Promise<string>;
+}
+export declare class YamlParseTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        yaml: string;
+    }): Promise<any>;
+}
+export declare class XmlParseTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        xml: string;
+    }): Promise<any>;
+}

package/dist/tools/data-operations.d.ts

@@ -0,0 +1,17 @@
+import { Tool, type ToolInput, type ToolMetadata } from "./base";
+export declare class JsonParseTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class Base64EncodeTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class Base64DecodeTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class HashTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}

package/dist/tools/directory-operations.d.ts

@@ -0,0 +1,46 @@
+import { Tool, type ToolInput, type ToolMetadata } from "./base";
+export declare class DirectoryListTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class DirectoryMkdirTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class DirectoryRmdirTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class DirectoryRmRecursiveTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class DirectoryExistsTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class DirectoryMoveTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        source: string;
+        destination: string;
+    }): Promise<{
+        moved: boolean;
+    }>;
+}
+export declare class DirectoryCopyTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        source: string;
+        destination: string;
+    }): Promise<{
+        copied: boolean;
+    }>;
+}
+export declare class DirectoryTreeTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        path: string;
+        depth?: number;
+    }): Promise<any>;
+}

package/dist/tools/file-operations.d.ts

@@ -0,0 +1,46 @@
+import { Tool, type ToolInput, type ToolMetadata } from "./base";
+export declare class FileReadTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class FileWriteTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class FileListTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class FileAppendTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class FileDeleteTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class FileMoveTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class FileCopyTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class FileStatTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class FileExistsTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+export declare class FileChmodTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        path: string;
+        mode: string | number;
+    }): Promise<{
+        changed: boolean;
+    }>;
+}

package/dist/tools/http-request.d.ts

@@ -0,0 +1,5 @@
+import { Tool, type ToolInput, type ToolMetadata } from "./base";
+export declare class HttpRequestTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string | object>;
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,96 @@
+export * from "./agent-delegation";
+export * from "./agent-invocation";
+export * from "./base";
+export * from "./calculator";
+export * from "./compliance-operations";
+export * from "./data-formats";
+export * from "./data-operations";
+export * from "./directory-operations";
+export * from "./file-operations";
+export * from "./http-request";
+export * from "./network-operations";
+export * from "./pattern-parser";
+export * from "./system-operations";
+export * from "./utility-operations";
+export * from "./verification-status";
+export * from "./web-search";
+import { AgentDelegationTool, AgentDiscoveryTool, AgentStatusTool } from "./agent-delegation";
+import { GetAgentInfoTool, InvokeAgentTool, SearchAgentsTool } from "./agent-invocation";
+import { ToolRegistry } from "./base";
+import { CalculatorTool } from "./calculator";
+import { AuditLogTool, DecryptDataTool, EncryptDataTool, PiiDetectTool } from "./compliance-operations";
+import { CsvParseTool, CsvWriteTool, JsonStringifyTool, XmlParseTool, YamlParseTool } from "./data-formats";
+import { Base64DecodeTool, Base64EncodeTool, HashTool, JsonParseTool } from "./data-operations";
+import { DirectoryCopyTool, DirectoryExistsTool, DirectoryListTool, DirectoryMkdirTool, DirectoryMoveTool, DirectoryRmdirTool, DirectoryRmRecursiveTool, DirectoryTreeTool } from "./directory-operations";
+import { FileAppendTool, FileChmodTool, FileCopyTool, FileDeleteTool, FileExistsTool, FileListTool, FileMoveTool, FileReadTool, FileStatTool, FileWriteTool } from "./file-operations";
+import { HttpRequestTool } from "./http-request";
+import { DnsLookupTool, DownloadFileTool, HttpDeleteTool, HttpPostTool, HttpPutTool, PingTool } from "./network-operations";
+import { EnvGetTool, EnvSetTool, GetCwdTool, GetPlatformTool } from "./system-operations";
+import { DateFormatTool, GenerateUuidTool, RandomNumberTool, RegexMatchTool, SleepTool, UrlParseTool } from "./utility-operations";
+import { VerificationStatusTool } from "./verification-status";
+import { WebSearchTool } from "./web-search";
+export interface ToolRegistryOptions {
+    privateKey?: string;
+    publicKey?: string;
+    registryUrl?: string;
+}
+export declare function createDefaultToolRegistry(options?: ToolRegistryOptions): ToolRegistry;
+export declare const builtInTools: {
+    FileReadTool: typeof FileReadTool;
+    FileWriteTool: typeof FileWriteTool;
+    FileAppendTool: typeof FileAppendTool;
+    FileDeleteTool: typeof FileDeleteTool;
+    FileMoveTool: typeof FileMoveTool;
+    FileCopyTool: typeof FileCopyTool;
+    FileStatTool: typeof FileStatTool;
+    FileExistsTool: typeof FileExistsTool;
+    FileListTool: typeof FileListTool;
+    FileChmodTool: typeof FileChmodTool;
+    DirectoryListTool: typeof DirectoryListTool;
+    DirectoryMkdirTool: typeof DirectoryMkdirTool;
+    DirectoryRmdirTool: typeof DirectoryRmdirTool;
+    DirectoryRmRecursiveTool: typeof DirectoryRmRecursiveTool;
+    DirectoryExistsTool: typeof DirectoryExistsTool;
+    DirectoryMoveTool: typeof DirectoryMoveTool;
+    DirectoryCopyTool: typeof DirectoryCopyTool;
+    DirectoryTreeTool: typeof DirectoryTreeTool;
+    WebSearchTool: typeof WebSearchTool;
+    HttpRequestTool: typeof HttpRequestTool;
+    HttpPostTool: typeof HttpPostTool;
+    HttpPutTool: typeof HttpPutTool;
+    HttpDeleteTool: typeof HttpDeleteTool;
+    DownloadFileTool: typeof DownloadFileTool;
+    DnsLookupTool: typeof DnsLookupTool;
+    PingTool: typeof PingTool;
+    JsonParseTool: typeof JsonParseTool;
+    JsonStringifyTool: typeof JsonStringifyTool;
+    CsvParseTool: typeof CsvParseTool;
+    CsvWriteTool: typeof CsvWriteTool;
+    YamlParseTool: typeof YamlParseTool;
+    XmlParseTool: typeof XmlParseTool;
+    Base64EncodeTool: typeof Base64EncodeTool;
+    Base64DecodeTool: typeof Base64DecodeTool;
+    HashTool: typeof HashTool;
+    CalculatorTool: typeof CalculatorTool;
+    DateFormatTool: typeof DateFormatTool;
+    GenerateUuidTool: typeof GenerateUuidTool;
+    RandomNumberTool: typeof RandomNumberTool;
+    SleepTool: typeof SleepTool;
+    RegexMatchTool: typeof RegexMatchTool;
+    UrlParseTool: typeof UrlParseTool;
+    GetCwdTool: typeof GetCwdTool;
+    GetPlatformTool: typeof GetPlatformTool;
+    EnvGetTool: typeof EnvGetTool;
+    EnvSetTool: typeof EnvSetTool;
+    SearchAgentsTool: typeof SearchAgentsTool;
+    GetAgentInfoTool: typeof GetAgentInfoTool;
+    InvokeAgentTool: typeof InvokeAgentTool;
+    AgentDiscoveryTool: typeof AgentDiscoveryTool;
+    AgentDelegationTool: typeof AgentDelegationTool;
+    AgentStatusTool: typeof AgentStatusTool;
+    VerificationStatusTool: typeof VerificationStatusTool;
+    AuditLogTool: typeof AuditLogTool;
+    PiiDetectTool: typeof PiiDetectTool;
+    EncryptDataTool: typeof EncryptDataTool;
+    DecryptDataTool: typeof DecryptDataTool;
+};

package/dist/tools/network-operations.d.ts

@@ -0,0 +1,52 @@
+import { Tool, ToolMetadata } from './base';
+export declare class HttpPostTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        url: string;
+        body?: any;
+        headers?: Record<string, string>;
+    }): Promise<any>;
+}
+export declare class HttpPutTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        url: string;
+        body?: any;
+        headers?: Record<string, string>;
+    }): Promise<any>;
+}
+export declare class HttpDeleteTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        url: string;
+        headers?: Record<string, string>;
+    }): Promise<any>;
+}
+export declare class DownloadFileTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        url: string;
+        destination: string;
+    }): Promise<{
+        path: string;
+        size: number;
+    }>;
+}
+export declare class DnsLookupTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        hostname: string;
+    }): Promise<{
+        addresses: string[];
+    }>;
+}
+export declare class PingTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        host: string;
+        count?: number;
+    }): Promise<{
+        alive: boolean;
+        time?: number;
+    }>;
+}

package/dist/tools/pattern-parser.d.ts

@@ -0,0 +1,25 @@
+import type { ToolRegistry } from "./base";
+export declare class ToolPatternParser {
+    /**
+     * Get the tool name prefix for a category
+     * "files" -> "file"
+     * "directories" -> "dir"
+     * "network" -> "http" or "network"
+     */
+    private static getCategoryPrefix;
+    /**
+     * Parse tool patterns:
+     *   "calculator" => ["calculator"]
+     *   "files:*" => ["file_read", "file_write", "file_delete", ...]
+     *   "files:[read,write]" => ["file_read", "file_write"]
+     */
+    static parse(pattern: string, registry: ToolRegistry): string[];
+    /**
+     * Expand multiple patterns into unique tool names
+     */
+    static expandPatterns(patterns: string[], registry: ToolRegistry): string[];
+    /**
+     * Filter allowed tools by removing blocked ones
+     */
+    static filterBlocked(allowedTools: string[], blockedTools: string[]): string[];
+}

package/dist/tools/system-operations.d.ts

@@ -0,0 +1,24 @@
+import { Tool, type ToolMetadata } from "./base";
+export declare class GetCwdTool extends Tool {
+    metadata: ToolMetadata;
+    execute(): Promise<string>;
+}
+export declare class GetPlatformTool extends Tool {
+    metadata: ToolMetadata;
+    execute(): Promise<any>;
+}
+export declare class EnvGetTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        key: string;
+    }): Promise<string>;
+}
+export declare class EnvSetTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        key: string;
+        value: string;
+    }): Promise<{
+        set: boolean;
+    }>;
+}

package/dist/tools/utility-operations.d.ts

@@ -0,0 +1,44 @@
+import { Tool, type ToolMetadata } from "./base";
+export declare class DateFormatTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        date?: string | number;
+        format?: string;
+    }): Promise<string>;
+}
+export declare class GenerateUuidTool extends Tool {
+    metadata: ToolMetadata;
+    execute(): Promise<string>;
+}
+export declare class RandomNumberTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        min?: number;
+        max?: number;
+    }): Promise<string>;
+}
+export declare class SleepTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        milliseconds: number;
+    }): Promise<{
+        slept: number;
+    }>;
+}
+export declare class RegexMatchTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        text: string;
+        pattern: string;
+        flags?: string;
+    }): Promise<{
+        matches: string[];
+        groups?: any[];
+    }>;
+}
+export declare class UrlParseTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: {
+        url: string;
+    }): Promise<any>;
+}

package/dist/tools/verification-status.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ⚠️ CRITICAL SYSTEM TOOL - DO NOT EDIT OR DELETE ⚠️
+ *
+ * This tool is automatically included by Sekuire to verify agent compliance
+ * and verification status. Removing or modifying this tool will prevent your
+ * agent from being properly verified and may result in trust protocol violations.
+ *
+ * This tool queries the Sekuire registry to check:
+ * - Agent verification status (verified/unverified/pending)
+ * - Compliance framework adherence
+ * - Security score and reputation
+ * - Code review status
+ */
+import { Tool, type ToolInput, type ToolMetadata } from "./base";
+export declare class VerificationStatusTool extends Tool {
+    metadata: ToolMetadata;
+    private registryUrl;
+    constructor(registryUrl?: string);
+    execute(input: ToolInput): Promise<string>;
+    /**
+     * Get the current agent's Sekuire ID from environment or config
+     */
+    private getAgentId;
+    /**
+     * Extract compliance frameworks from manifest
+     */
+    private extractComplianceFrameworks;
+    /**
+     * Determine if agent is compliant based on verification status and checks
+     */
+    private isCompliant;
+    /**
+     * Calculate overall compliance score
+     */
+    private calculateComplianceScore;
+    /**
+     * Format the response for the agent
+     */
+    private formatResponse;
+}

package/dist/tools/web-search.d.ts

@@ -0,0 +1,5 @@
+import { Tool, type ToolInput, type ToolMetadata } from "./base";
+export declare class WebSearchTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}

package/dist/types/policy.d.ts

@@ -0,0 +1,13 @@
+export interface ActivePolicyResponse {
+    policy_id: string;
+    workspace_id: string;
+    version: string;
+    status: string;
+    hash: string;
+    content: unknown;
+    activated_at?: string;
+    updated_at?: string;
+    signature?: string;
+    signing_key_id?: string;
+    signing_public_key?: string;
+}