@sekuire/sdk 0.1.9 → 0.1.10

package/dist/llm/anthropic.d.ts

@@ -1,18 +1,10 @@
-import type { ChatChunk, ChatOptions, ChatResponse, LLMProvider, LLMProviderConfig, Message } from './types';
-/**
- * Anthropic LLM Provider
- * Supports Claude models (Claude 3, Claude 3.5, etc.)
- */
-export declare class AnthropicProvider implements LLMProvider {
+import { BaseLLMProvider } from './base-provider';
+import type { ChatChunk, ChatOptions, ChatResponse, LLMProviderConfig, Message } from './types';
+export declare class AnthropicProvider extends BaseLLMProvider {
     private client;
-    private model;
-    private maxTokens;
     constructor(config: LLMProviderConfig);
     chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse>;
     chatStream(messages: Message[], options?: ChatOptions): AsyncGenerator<ChatChunk>;
-    countTokens(text: string): number;
-    getMaxTokens(): number;
     getProviderName(): string;
-    getModelName(): string;
-    private getMaxTokensForModel;
+    protected getMaxTokensForModel(model: string): number;
 }

package/dist/llm/base-provider.d.ts

@@ -0,0 +1,13 @@
+import type { ChatChunk, ChatOptions, ChatResponse, LLMProvider, LLMProviderConfig, Message } from './types';
+export declare abstract class BaseLLMProvider implements LLMProvider {
+    protected model: string;
+    protected maxTokens: number;
+    constructor(config: LLMProviderConfig);
+    abstract chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse>;
+    abstract chatStream(messages: Message[], options?: ChatOptions): AsyncGenerator<ChatChunk>;
+    abstract getProviderName(): string;
+    protected abstract getMaxTokensForModel(model: string): number;
+    countTokens(text: string): number;
+    getMaxTokens(): number;
+    getModelName(): string;
+}

package/dist/llm/google.d.ts

@@ -1,18 +1,10 @@
-import type { ChatChunk, ChatOptions, ChatResponse, LLMProvider, LLMProviderConfig, Message } from './types';
-/**
- * Google Gemini LLM Provider
- * Supports Gemini Pro, Gemini Pro Vision, and other Google models
- */
-export declare class GoogleProvider implements LLMProvider {
+import { BaseLLMProvider } from './base-provider';
+import type { ChatChunk, ChatOptions, ChatResponse, LLMProviderConfig, Message } from './types';
+export declare class GoogleProvider extends BaseLLMProvider {
     private client;
-    private model;
-    private maxTokens;
     constructor(config: LLMProviderConfig);
     chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse>;
     chatStream(messages: Message[], options?: ChatOptions): AsyncGenerator<ChatChunk>;
-    countTokens(text: string): number;
-    getMaxTokens(): number;
     getProviderName(): string;
-    getModelName(): string;
-    private getMaxTokensForModel;
+    protected getMaxTokensForModel(model: string): number;
 }

package/dist/llm/index.d.ts

@@ -16,27 +16,15 @@ export declare function createLLMProvider(provider: string, config: LLMProviderC
  * Factory functions for easy LLM instantiation
  */
 export declare const llm: {
-    /**
-     * Create OpenAI provider (GPT-4, GPT-3.5, etc.)
-     */
     openai: (config: Omit<LLMProviderConfig, "model"> & {
         model?: string;
     }) => OpenAIProvider;
-    /**
-     * Create Anthropic provider (Claude 3, Claude 3.5, etc.)
-     */
     anthropic: (config: Omit<LLMProviderConfig, "model"> & {
         model?: string;
     }) => AnthropicProvider;
-    /**
-     * Create Google provider (Gemini Pro, Gemini 1.5, etc.)
-     */
     google: (config: Omit<LLMProviderConfig, "model"> & {
         model?: string;
     }) => GoogleProvider;
-    /**
-     * Create Ollama provider (local models: Llama 2, Mistral, etc.)
-     */
     ollama: (config: Omit<LLMProviderConfig, "model"> & {
         model?: string;
     }) => OllamaProvider;

package/dist/llm/ollama.d.ts

@@ -1,17 +1,10 @@
-import type { ChatChunk, ChatOptions, ChatResponse, LLMProvider, LLMProviderConfig, Message } from './types';
-/**
- * Ollama LLM Provider
- * Supports local models via Ollama (Llama 2, Mistral, CodeLlama, etc.)
- */
-export declare class OllamaProvider implements LLMProvider {
+import { BaseLLMProvider } from './base-provider';
+import type { ChatChunk, ChatOptions, ChatResponse, LLMProviderConfig, Message } from './types';
+export declare class OllamaProvider extends BaseLLMProvider {
     private baseUrl;
-    private model;
-    private maxTokens;
     constructor(config: LLMProviderConfig);
     chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse>;
     chatStream(messages: Message[], options?: ChatOptions): AsyncGenerator<ChatChunk>;
-    countTokens(text: string): number;
-    getMaxTokens(): number;
     getProviderName(): string;
-    getModelName(): string;
+    protected getMaxTokensForModel(_model: string): number;
 }

package/dist/llm/openai.d.ts

@@ -1,18 +1,10 @@
-import type { ChatChunk, ChatOptions, ChatResponse, LLMProvider, LLMProviderConfig, Message } from './types';
-/**
- * OpenAI LLM Provider
- * Supports GPT-3.5, GPT-4, and other OpenAI models
- */
-export declare class OpenAIProvider implements LLMProvider {
+import { BaseLLMProvider } from './base-provider';
+import type { ChatChunk, ChatOptions, ChatResponse, LLMProviderConfig, Message } from './types';
+export declare class OpenAIProvider extends BaseLLMProvider {
     private client;
-    private model;
-    private maxTokens;
     constructor(config: LLMProviderConfig);
     chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse>;
     chatStream(messages: Message[], options?: ChatOptions): AsyncGenerator<ChatChunk>;
-    countTokens(text: string): number;
-    getMaxTokens(): number;
     getProviderName(): string;
-    getModelName(): string;
-    private getMaxTokensForModel;
+    protected getMaxTokensForModel(model: string): number;
 }

package/dist/llm/types.d.ts

@@ -1,16 +1,26 @@
-/**
- * Message format for chat conversations
- */
+export interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+export interface ToolCallFunction {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
 export interface Message {
     role: 'system' | 'user' | 'assistant' | 'function' | 'tool';
     content: string | null;
     name?: string;
     tool_call_id?: string;
-    tool_calls?: any[];
+    tool_calls?: ToolCallFunction[];
 }
-/**
- * Options for chat completion
- */
 export interface ChatOptions {
     temperature?: number;
     max_tokens?: number;
@@ -19,16 +29,13 @@ export interface ChatOptions {
     presence_penalty?: number;
     stop?: string[];
     stream?: boolean;
-    tools?: any[];
+    tools?: ToolDefinition[];
 }
-/**
- * Response from chat completion
- */
 export interface ChatResponse {
     content: string;
     model: string;
     finish_reason?: string;
-    tool_calls?: any[];
+    tool_calls?: ToolCallFunction[];
     usage?: {
         prompt_tokens: number;
         completion_tokens: number;

package/dist/logger.d.ts

@@ -15,6 +15,10 @@ export interface LoggerConfig {
     enabled?: boolean;
     batchSize?: number;
     flushInterval?: number;
+    onError?: (error: Error, context: {
+        operation: string;
+        eventsLost?: number;
+    }) => void;
 }
 export interface EventLog {
     sekuire_id: string;

package/dist/memory/index.d.ts

@@ -5,7 +5,7 @@ export * from './redis';
 import type { MemoryStorage } from './base';
 import { type PostgresConfig } from './postgres';
 import { type RedisConfig } from './redis';
-export type MemoryType = 'in-memory' | 'redis' | 'postgres';
+export type MemoryType = 'in-memory' | 'redis' | 'postgres' | 'buffer';
 export interface MemoryFactoryConfig {
     type: MemoryType;
     redis?: RedisConfig;

package/dist/new-agent.d.ts

@@ -1,7 +1,7 @@
 import { type ToolDefinition } from './config/loader';
-import type { LLMProvider, Message, ChatOptions } from './llm/types';
-import { PolicyEnforcer } from './policy-enforcer';
+import type { ChatOptions, LLMProvider, Message } from './llm/types';
 import { type MemoryStorage } from './memory';
+import { PolicyEnforcer } from './policy-enforcer';
 /**
  * Options for overriding agent configuration
  */

package/dist/platform-url.d.ts

@@ -0,0 +1 @@
+export declare function detectDeploymentUrl(): string | undefined;

package/dist/registry-client.d.ts

@@ -0,0 +1,171 @@
+import { type AgentResponse, type Manifest, type ReputationResponse, type VerificationStatus } from "./types";
+export interface RegistryClientConfig {
+    apiUrl: string;
+    apiKey?: string;
+    timeout?: number;
+    retries?: number;
+}
+export interface PublishAgentOptions {
+    manifest: Manifest;
+    privateKeyHex: string;
+    systemPrompt: string;
+    tools: string;
+    publisherOrgId?: string;
+    visibility?: "public" | "private" | "internal";
+}
+export interface UpdateAgentOptions {
+    manifest?: Partial<Manifest>;
+    visibility?: "public" | "private" | "internal";
+    gitRepository?: string;
+}
+export interface SearchAgentsOptions {
+    query?: string;
+    tags?: string[];
+    verificationStatus?: VerificationStatus;
+    category?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface TaskCompletion {
+    taskId: string;
+    taskHash: string;
+    rating: number;
+    comment?: string;
+    evidence?: string;
+}
+export interface LeaderboardEntry {
+    sekuireId: string;
+    name: string;
+    reputationScore: number;
+    taskCount: number;
+    verificationStatus: VerificationStatus;
+    rank: number;
+}
+export interface PublishResponse {
+    sekuireId: string;
+    name: string;
+    version: string;
+    verificationStatus: VerificationStatus;
+    createdAt: string;
+}
+export interface DisputeResponse {
+    id: string;
+    sekuireId: string;
+    status: "pending" | "reviewing" | "resolved" | "rejected";
+    createdAt: string;
+}
+export interface VerificationRequest {
+    sekuireId: string;
+    repositoryUrl?: string;
+    commitHash?: string;
+    complianceFramework?: string;
+}
+export interface VerificationResult {
+    passed: boolean;
+    securityScore: number;
+    complianceScore: number;
+    issues: VerificationIssue[];
+    timestamp: string;
+}
+export interface VerificationIssue {
+    severity: "critical" | "high" | "medium" | "low";
+    category: string;
+    message: string;
+    file?: string;
+    line?: number;
+}
+export interface TrustHeadersRequest {
+    agentId: string;
+    action?: string;
+    context?: Record<string, unknown>;
+}
+export interface TrustHeaders {
+    "X-Sekuire-Agent-ID": string;
+    "X-Sekuire-Reputation": string;
+    "X-Sekuire-Verification": string;
+    "X-Sekuire-Badges": string;
+    "X-Sekuire-Timestamp": string;
+    "X-Sekuire-Signature": string;
+}
+export declare class SekuireRegistryClient {
+    private readonly http;
+    constructor(config: RegistryClientConfig | string, authToken?: string);
+    setAuthToken(token: string): void;
+    setApiKey(apiKey: string): void;
+    publishAgent(options: PublishAgentOptions): Promise<PublishResponse>;
+    getAgent(sekuireId: string): Promise<AgentResponse>;
+    updateAgent(sekuireId: string, options: UpdateAgentOptions): Promise<AgentResponse>;
+    deleteAgent(sekuireId: string): Promise<void>;
+    listAgents(options?: SearchAgentsOptions): Promise<AgentResponse[]>;
+    searchAgents(query: string, options?: Omit<SearchAgentsOptions, "query">): Promise<AgentResponse[]>;
+    getMyAgents(): Promise<AgentResponse[]>;
+    getReputation(sekuireId: string): Promise<ReputationResponse>;
+    recordTaskCompletion(sekuireId: string, task: TaskCompletion, privateKeyHex: string): Promise<void>;
+    getLeaderboard(limit?: number): Promise<LeaderboardEntry[]>;
+    fileDispute(sekuireId: string, reason: string, evidenceLog: string, accuserId: string): Promise<DisputeResponse>;
+    verifyAgentQuick(sekuireId: string): Promise<VerificationResult>;
+    verifyAgentComprehensive(request: VerificationRequest): Promise<VerificationResult>;
+    getVerificationHistory(sekuireId: string): Promise<VerificationResult[]>;
+    getLatestVerification(sekuireId: string): Promise<VerificationResult | null>;
+    generateTrustHeaders(request: TrustHeadersRequest): Promise<TrustHeaders>;
+    getTrustProfile(agentDid: string): Promise<Record<string, unknown>>;
+    getTransactionHistory(agentDid: string): Promise<unknown[]>;
+    createTask(task: {
+        description: string;
+        capabilities: string[];
+        priority?: number;
+        callbackUrl?: string;
+    }): Promise<{
+        taskId: string;
+        status: string;
+    }>;
+    getTask(taskId: string): Promise<{
+        taskId: string;
+        status: string;
+        result?: unknown;
+        error?: string;
+    }>;
+    completeTask(taskId: string, result: unknown, privateKeyHex: string): Promise<void>;
+    getRegistryStats(): Promise<{
+        totalAgents: number;
+        verifiedAgents: number;
+        totalTasks: number;
+        categories: string[];
+    }>;
+    getCategories(): Promise<Array<{
+        slug: string;
+        name: string;
+        agentCount: number;
+    }>>;
+    getAgentsByCategory(categorySlug: string): Promise<AgentResponse[]>;
+    getWorkspace(workspaceId: string): Promise<Record<string, unknown>>;
+    getWorkspacePolicies(workspaceId: string): Promise<unknown[]>;
+    getActivePolicy(workspaceId: string): Promise<unknown>;
+    getPolicyTemplates(): Promise<unknown[]>;
+    evaluatePolicy(workspaceId: string, action: {
+        type: string;
+        resource: string;
+        context?: Record<string, unknown>;
+    }): Promise<{
+        allowed: boolean;
+        violations: string[];
+    }>;
+    logAgentEvents(sekuireId: string, events: Array<{
+        type: string;
+        severity: string;
+        data: Record<string, unknown>;
+        timestamp?: string;
+    }>): Promise<void>;
+    logAgentHealth(sekuireId: string, health: {
+        status: "healthy" | "degraded" | "unhealthy";
+        uptime: number;
+        memoryMb?: number;
+        cpuPercent?: number;
+    }): Promise<void>;
+    getAgentLogs(sekuireId: string, options?: {
+        limit?: number;
+        offset?: number;
+        type?: string;
+    }): Promise<unknown[]>;
+}
+export declare function createRegistryClient(apiUrl: string, authToken?: string, apiKey?: string): SekuireRegistryClient;

package/dist/sdk.d.ts

@@ -0,0 +1,112 @@
+/**
+ * SekuireSDK - Main SDK entry point for TypeScript agents
+ *
+ * Combines identity, logging, and heartbeat functionality with a simple API.
+ */
+import { type BeaconStatus } from "./beacon";
+import { AgentIdentity } from "./identity";
+import { SekuireLogger, type EventType, type Severity } from "./logger";
+export declare const DEFAULT_API_URL = "https://api.sekuire.ai";
+export interface SekuireSDKConfig {
+    privateKey?: string;
+    agentId: string;
+    agentName?: string;
+    apiUrl?: string;
+    apiKey?: string;
+    workspaceId?: string;
+    environment?: string;
+    autoHeartbeat?: boolean;
+    heartbeatInterval?: number;
+    loggingEnabled?: boolean;
+}
+export declare class SekuireSDK {
+    private config;
+    private identity;
+    private logger;
+    private client;
+    private beacon;
+    private isRunning;
+    constructor(config: SekuireSDKConfig);
+    /**
+     * Create SDK instance from environment variables.
+     *
+     * Required env vars:
+     *   SEKUIRE_AGENT_ID - The agent's sekuire_id
+     *
+     * Optional env vars:
+     *   SEKUIRE_API_KEY - API key for authentication (X-API-Key header)
+     *   SEKUIRE_PRIVATE_KEY - Private key for signing (required for heartbeat)
+     *   SEKUIRE_AGENT_NAME - Human-readable agent name
+     *   SEKUIRE_API_URL - API base URL (default: https://api.sekuire.ai)
+     *   SEKUIRE_WORKSPACE_ID - Workspace ID for policy enforcement
+     *   SEKUIRE_ENVIRONMENT - Environment name (default: production)
+     */
+    static fromEnv(options?: {
+        autoHeartbeat?: boolean;
+        loggingEnabled?: boolean;
+    }): SekuireSDK;
+    /**
+     * Start the SDK.
+     *
+     * - Sends initial heartbeat
+     * - Starts auto-heartbeat loop if enabled
+     */
+    start(): Promise<void>;
+    /**
+     * Send a signed heartbeat to the registry.
+     *
+     * The heartbeat proves the agent is running and has access to the private key.
+     *
+     * @param url Optional public URL where the agent can be reached
+     * @returns True if heartbeat was acknowledged, False otherwise
+     */
+    heartbeat(url?: string): Promise<boolean>;
+    /**
+     * Log an event to Sekuire.
+     *
+     * @param eventType Type of event (tool_execution, model_call, policy_check, etc.)
+     * @param data Event-specific data
+     * @param severity Severity level (debug, info, warn, error)
+     */
+    log(eventType: EventType, data: Record<string, unknown>, severity?: Severity): void;
+    /**
+     * Check if an action is allowed by the workspace policy.
+     *
+     * @param action The action to check (e.g., "read_file", "network_access")
+     * @param context Context for the action (e.g., {path: "/etc/passwd"})
+     * @returns True if allowed, False if denied
+     */
+    checkPolicy(action: string, context: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Shutdown the SDK gracefully.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get the current beacon status (heartbeat health, connection info).
+     */
+    getBeaconStatus(): BeaconStatus;
+    /**
+     * Get the agent ID.
+     */
+    get agentId(): string;
+    /**
+     * Get the agent's public key.
+     */
+    get publicKey(): string | undefined;
+    /**
+     * Sign a message with the agent's private key.
+     */
+    sign(message: string): Promise<string>;
+    /**
+     * Verify a signature using the agent's public key.
+     */
+    verify(message: string, signature: string): boolean;
+    /**
+     * Get the underlying identity object.
+     */
+    getIdentity(): AgentIdentity;
+    /**
+     * Get the underlying logger object.
+     */
+    getLogger(): SekuireLogger;
+}

package/dist/telemetry/exporter.d.ts

@@ -0,0 +1,21 @@
+import { ExportResult } from '@opentelemetry/core';
+import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+export interface SekuireExporterConfig {
+    apiUrl: string;
+    agentId: string;
+    authToken?: string;
+    workspaceId?: string;
+}
+export declare class SekuireSpanExporter implements SpanExporter {
+    private config;
+    private pendingExport;
+    constructor(config: SekuireExporterConfig);
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    private spanToEvent;
+    private mapSpanToEventType;
+    private getDurationMs;
+    private extractAttributes;
+    private sendEvents;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}

package/dist/telemetry/index.d.ts

@@ -0,0 +1,22 @@
+import { Tracer } from '@opentelemetry/api';
+export type ExporterType = 'otlp' | 'sekuire' | 'console' | 'none';
+export interface TelemetryConfig {
+    enabled?: boolean;
+    agentId: string;
+    exporter?: ExporterType;
+    otlpEndpoint?: string;
+    sekuireApiUrl?: string;
+    authToken?: string;
+    workspaceId?: string;
+    debug?: boolean;
+    batchConfig?: {
+        maxQueueSize?: number;
+        maxExportBatchSize?: number;
+        scheduledDelayMillis?: number;
+    };
+}
+export declare function initTelemetry(config: TelemetryConfig): Tracer;
+export declare function getTracer(): Tracer;
+export declare function withSpan<T>(name: string, fn: (span: any) => T): T;
+export declare function shutdownTelemetry(): Promise<void>;
+export { SekuireSpanExporter, type SekuireExporterConfig } from './exporter';

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

@@ -1,90 +1,38 @@
-import type { Tool, ToolMetadata } from './base';
+import { Tool, ToolInput, ToolMetadata } from './base';
 /**
  * Tool for invoking other Sekuire agents
  * Performs handshake and sends requests to verified agents
  */
-export declare class InvokeAgentTool implements Tool {
+export declare class InvokeAgentTool extends Tool {
+    metadata: ToolMetadata;
+    private client;
     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>;
+    constructor(privateKey?: string, publicKey?: string, registryUrl?: string);
+    execute(input: ToolInput): Promise<string>;
 }
 /**
  * Tool for searching the Sekuire registry for agents
  */
-export declare class SearchAgentsTool implements Tool {
+export declare class SearchAgentsTool extends Tool {
+    metadata: ToolMetadata;
+    private client;
     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>;
+    constructor(privateKey?: string, publicKey?: string, registryUrl?: string);
+    execute(input: ToolInput): Promise<string>;
 }
 /**
  * Tool for getting detailed information about a specific agent
  */
-export declare class GetAgentInfoTool implements Tool {
+export declare class GetAgentInfoTool extends Tool {
+    metadata: ToolMetadata;
+    private client;
     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>;
+    constructor(privateKey?: string, publicKey?: string, registryUrl?: string);
+    execute(input: ToolInput): Promise<string>;
 }

package/dist/tools/remote.d.ts

@@ -1,5 +1,5 @@
-import type { SekuireClient } from '../client';
 import type { ToolDefinition } from '../agent';
+import type { SekuireClient } from '../client';
 /**
  * Create a tool for discovering other agents in the Sekuire network
  */