@sekuire/sdk 0.1.4

package/dist/llm/anthropic.d.ts

@@ -0,0 +1,18 @@
+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 {
+    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;
+}

package/dist/llm/google.d.ts

@@ -0,0 +1,18 @@
+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 {
+    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;
+}

package/dist/llm/index.d.ts

@@ -0,0 +1,43 @@
+import { AnthropicProvider } from "./anthropic";
+import { GoogleProvider } from "./google";
+import { OllamaProvider } from "./ollama";
+import { OpenAIProvider } from "./openai";
+import type { LLMProvider, LLMProviderConfig } from "./types";
+export * from "./anthropic";
+export * from "./google";
+export * from "./ollama";
+export * from "./openai";
+export * from "./types";
+/**
+ * Create an LLM provider based on provider name
+ */
+export declare function createLLMProvider(provider: string, config: LLMProviderConfig): LLMProvider;
+/**
+ * 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

@@ -0,0 +1,17 @@
+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 {
+    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;
+}

package/dist/llm/openai.d.ts

@@ -0,0 +1,18 @@
+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 {
+    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;
+}

package/dist/llm/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Message format for chat conversations
+ */
+export interface Message {
+    role: "system" | "user" | "assistant" | "function" | "tool";
+    content: string | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: any[];
+}
+/**
+ * Options for chat completion
+ */
+export interface ChatOptions {
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string[];
+    stream?: boolean;
+    tools?: any[];
+}
+/**
+ * Response from chat completion
+ */
+export interface ChatResponse {
+    content: string;
+    model: string;
+    finish_reason?: string;
+    tool_calls?: any[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+/**
+ * Streaming chunk from chat completion
+ */
+export interface ChatChunk {
+    content: string;
+    finish_reason?: string;
+}
+/**
+ * Base interface for LLM providers
+ */
+export interface LLMProvider {
+    /**
+     * Send chat messages and get response
+     */
+    chat(messages: Message[], options?: ChatOptions): Promise<ChatResponse>;
+    /**
+     * Stream chat response
+     */
+    chatStream(messages: Message[], options?: ChatOptions): AsyncGenerator<ChatChunk>;
+    /**
+     * Count tokens in text (approximate)
+     */
+    countTokens(text: string): number;
+    /**
+     * Get maximum context window size
+     */
+    getMaxTokens(): number;
+    /**
+     * Get provider name
+     */
+    getProviderName(): string;
+    /**
+     * Get model name
+     */
+    getModelName(): string;
+}
+/**
+ * Configuration for creating LLM providers
+ */
+export interface LLMProviderConfig {
+    apiKey: string;
+    model: string;
+    baseUrl?: string;
+    organization?: string;
+    temperature?: number;
+    maxTokens?: number;
+}

package/dist/logger.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 🛡️ Sekuire Logger - Asynchronous Event Logging for TypeScript SDK
+ *
+ * Provides batched, fire-and-forget logging to Sekuire Registry API
+ */
+export type EventType = "tool_execution" | "model_call" | "policy_violation" | "policy_check" | "network_access" | "file_access" | "health";
+export type Severity = "debug" | "info" | "warn" | "error";
+export interface LoggerConfig {
+    sekuireId: string;
+    apiBaseUrl: string;
+    apiKey?: string;
+    sessionId?: string;
+    workspaceId?: string;
+    environment?: string;
+    enabled?: boolean;
+    batchSize?: number;
+    flushInterval?: number;
+}
+export interface EventLog {
+    sekuire_id: string;
+    session_id: string;
+    workspace_id?: string;
+    event_type: EventType;
+    severity: Severity;
+    event_timestamp: string;
+    event_data: Record<string, any>;
+    metadata: Record<string, any>;
+}
+/**
+ * Asynchronous logger for Sekuire compliance events
+ *
+ * Features:
+ * - Buffered batching (flush every N events or X seconds)
+ * - Fire-and-forget (non-blocking)
+ * - Health heartbeat tracking
+ * - Graceful shutdown
+ */
+export declare class SekuireLogger {
+    private config;
+    private buffer;
+    private flushTimer?;
+    private heartbeatTimer?;
+    private isFlushing;
+    private client;
+    private readonly sdkVersion;
+    constructor(config: LoggerConfig);
+    /**
+     * Log an event (buffered, non-blocking)
+     */
+    logEvent(eventType: EventType, severity: Severity, eventData: Record<string, any>): void;
+    /**
+     * Flush buffer to API (fire-and-forget)
+     */
+    flush(): Promise<void>;
+    /**
+     * Send health heartbeat to API
+     */
+    private sendHealthHeartbeat;
+    /**
+     * Start flush timer (every N milliseconds)
+     */
+    private startFlushTimer;
+    /**
+     * Start heartbeat timer (every 30 seconds)
+     */
+    private startHeartbeatTimer;
+    /**
+     * Stop timers
+     */
+    private stopTimers;
+    /**
+     * Shutdown logger gracefully
+     * - Stops timers
+     * - Flushes remaining events
+     * - Safe to call multiple times
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get logger status for debugging
+     */
+    getStatus(): {
+        enabled: boolean;
+        bufferedEvents: number;
+        sessionId: string;
+        environment: string;
+    };
+    /**
+     * Enable/disable logging at runtime
+     */
+    setEnabled(enabled: boolean): void;
+}
+export default SekuireLogger;

package/dist/memory/base.d.ts

@@ -0,0 +1,20 @@
+export interface MemoryMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+export interface MemoryStorage {
+    add(sessionId: string, message: MemoryMessage): Promise<void>;
+    get(sessionId: string, limit?: number): Promise<MemoryMessage[]>;
+    clear(sessionId: string): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+    exists(sessionId: string): Promise<boolean>;
+}
+export declare abstract class BaseMemoryStorage implements MemoryStorage {
+    abstract add(sessionId: string, message: MemoryMessage): Promise<void>;
+    abstract get(sessionId: string, limit?: number): Promise<MemoryMessage[]>;
+    abstract clear(sessionId: string): Promise<void>;
+    abstract delete(sessionId: string): Promise<void>;
+    abstract exists(sessionId: string): Promise<boolean>;
+}

package/dist/memory/in-memory.d.ts

@@ -0,0 +1,9 @@
+import { BaseMemoryStorage, type MemoryMessage } from "./base";
+export declare class InMemoryStorage extends BaseMemoryStorage {
+    private storage;
+    add(sessionId: string, message: MemoryMessage): Promise<void>;
+    get(sessionId: string, limit?: number): Promise<MemoryMessage[]>;
+    clear(sessionId: string): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+    exists(sessionId: string): Promise<boolean>;
+}

package/dist/memory/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./base";
+export * from "./in-memory";
+export * from "./postgres";
+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 interface MemoryFactoryConfig {
+    type: MemoryType;
+    redis?: RedisConfig;
+    postgres?: PostgresConfig;
+}
+export declare function createMemoryStorage(config: MemoryFactoryConfig): MemoryStorage;

package/dist/memory/postgres.d.ts

@@ -0,0 +1,24 @@
+import { BaseMemoryStorage, type MemoryMessage } from "./base";
+export interface PostgresConfig {
+    connectionString?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    tableName?: string;
+}
+export declare class PostgresStorage extends BaseMemoryStorage {
+    private pool;
+    private tableName;
+    private initialized;
+    constructor(config: PostgresConfig);
+    private initPool;
+    private createTableIfNotExists;
+    add(sessionId: string, message: MemoryMessage): Promise<void>;
+    get(sessionId: string, limit?: number): Promise<MemoryMessage[]>;
+    clear(sessionId: string): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+    exists(sessionId: string): Promise<boolean>;
+    disconnect(): Promise<void>;
+}

package/dist/memory/redis.d.ts

@@ -0,0 +1,23 @@
+import { BaseMemoryStorage, type MemoryMessage } from "./base";
+export interface RedisConfig {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    url?: string;
+    keyPrefix?: string;
+}
+export declare class RedisStorage extends BaseMemoryStorage {
+    private client;
+    private keyPrefix;
+    private connected;
+    constructor(config: RedisConfig);
+    private initClient;
+    private getKey;
+    add(sessionId: string, message: MemoryMessage): Promise<void>;
+    get(sessionId: string, limit?: number): Promise<MemoryMessage[]>;
+    clear(sessionId: string): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+    exists(sessionId: string): Promise<boolean>;
+    disconnect(): Promise<void>;
+}

package/dist/new-agent.d.ts

@@ -0,0 +1,134 @@
+import { type ToolDefinition } from './config/loader';
+import type { LLMProvider, Message, ChatOptions } from './llm/types';
+import { PolicyEnforcer } from './policy-enforcer';
+import { type MemoryStorage } from './memory';
+/**
+ * Options for overriding agent configuration
+ */
+export interface AgentOptions {
+    llm?: LLMProvider;
+    tools?: ToolDefinition[];
+    memory?: MemoryStorage;
+    systemPrompt?: string;
+    policyPath?: string;
+}
+/**
+ * Sekuire Agent - Config-first AI agent
+ */
+export declare class SekuireAgent {
+    readonly name: string;
+    private llm;
+    private systemPrompt;
+    private tools;
+    private sessionId;
+    private memory?;
+    private maxHistoryMessages;
+    private policyEnforcer?;
+    constructor(config: {
+        name: string;
+        llm: LLMProvider;
+        systemPrompt: string;
+        tools: ToolDefinition[];
+        memory?: MemoryStorage;
+        maxHistoryMessages?: number;
+        policyEnforcer?: PolicyEnforcer;
+    });
+    setSessionId(sessionId: string): void;
+    /**
+     * Chat with the agent
+     */
+    chat(userMessage: string, options?: ChatOptions): Promise<string>;
+    /**
+     * Execute a tool by name
+     */
+    executeTool(name: string, args: any): Promise<any>;
+    /**
+     * Stream chat response
+     */
+    chatStream(userMessage: string, options?: ChatOptions): AsyncGenerator<string>;
+    /**
+     * Clear conversation history
+     */
+    clearHistory(): Promise<void>;
+    /**
+     * Get conversation history
+     */
+    getHistory(): Promise<Message[]>;
+    /**
+     * Get LLM provider name
+     */
+    getLLMProvider(): string;
+    /**
+     * Get LLM model name
+     */
+    getModelName(): string;
+    /**
+     * Get available tools
+     */
+    getTools(): ToolDefinition[];
+    /**
+     * Get the active policy enforcer
+     */
+    getPolicyEnforcer(): PolicyEnforcer | undefined;
+}
+/**
+ * Load an agent from sekuire.yml configuration
+ *
+ * @param agentName - Name of the agent to load (for multi-agent configs)
+ * @param overrides - Optional overrides for agent configuration
+ * @param configPath - Path to sekuire.yml (defaults to './sekuire.yml')
+ * @returns Initialized agent instance
+ *
+ * @example
+ * ```typescript
+ * // Load agent from config
+ * const agent = await getAgent('my-agent-openai');
+ *
+ * // Chat with the agent
+ * const response = await agent.chat('Hello!');
+ * console.log(response);
+ * ```
+ */
+export declare function getAgent(agentName?: string, overrides?: AgentOptions, configPath?: string): Promise<SekuireAgent>;
+/**
+ * Load all agents from configuration
+ *
+ * @param configPath - Path to sekuire.yml
+ * @returns Map of agent name to agent instance
+ *
+ * @example
+ * ```typescript
+ * const agents = await getAgents();
+ * const openai = agents.get('my-agent-openai');
+ * const claude = agents.get('my-agent-claude');
+ * ```
+ */
+export declare function getAgents(configPath?: string): Promise<Map<string, SekuireAgent>>;
+/**
+ * Get system prompt for a specific agent from configuration
+ *
+ * @param agentName - Name of the agent (optional for single-agent configs)
+ * @param configPath - Path to sekuire.yml (defaults to './sekuire.yml')
+ * @returns The system prompt content
+ *
+ * @example
+ * ```typescript
+ * const prompt = await getSystemPrompt('my-agent-openai');
+ * console.log(prompt);
+ * ```
+ */
+export declare function getSystemPrompt(agentName?: string, configPath?: string): Promise<string>;
+/**
+ * Get tools for a specific agent from configuration
+ *
+ * @param agentName - Name of the agent (optional for single-agent configs)
+ * @param configPath - Path to sekuire.yml (defaults to './sekuire.yml')
+ * @returns The tools schema with tool definitions
+ *
+ * @example
+ * ```typescript
+ * const toolsSchema = await getTools('my-agent-openai');
+ * console.log(toolsSchema.tools);
+ * ```
+ */
+export declare function getTools(agentName?: string, configPath?: string): Promise<ToolDefinition[]>;

package/dist/policy-enforcer.d.ts

@@ -0,0 +1,20 @@
+import type { ActivePolicy } from "./policy";
+type ViolationHandler = (rule: string, reason: string) => void;
+export declare class PolicyEnforcer {
+    private readonly policy;
+    private readonly onViolation?;
+    private readonly override;
+    constructor(policy: ActivePolicy, override?: boolean, onViolation?: ViolationHandler | undefined);
+    enforceNetwork(domain: string, protocol: string): void;
+    enforceFilesystem(path: string, operation: string): void;
+    enforceTool(toolName: string): void;
+    private getCategoryPrefix;
+    enforceModel(model: string): void;
+    enforceApi(service: string): void;
+    enforceRateLimit(type: "request" | "token", count?: number): void;
+    private throw;
+    private warnOnly;
+    private matches;
+    private pathMatch;
+}
+export {};

package/dist/policy.d.ts

@@ -0,0 +1,20 @@
+export interface ActivePolicy {
+    policy_id: string;
+    workspace_id: string;
+    version: string;
+    status: string;
+    hash: string;
+    content: any;
+    activated_at?: string;
+    updated_at?: string;
+    signature?: string;
+    signing_key_id?: string;
+    signing_public_key?: string;
+}
+export declare class PolicyClient {
+    private readonly baseUrl;
+    private cache;
+    constructor(baseUrl: string);
+    fetchActivePolicy(workspaceId: string): Promise<ActivePolicy>;
+    verify(policy: ActivePolicy): void;
+}

package/dist/server.d.ts

@@ -0,0 +1,33 @@
+import { type HandshakeAuth, type HandshakeHello, type HandshakeWelcome, type KeyPair } from "./types";
+/**
+ * Base class for implementing Sekuire protocol servers
+ */
+export declare abstract class SekuireServer {
+    protected readonly agentId: string;
+    protected readonly keyPair: KeyPair;
+    constructor(agentId: string, keyPair: KeyPair);
+    /**
+     * Handle the HELLO handshake message
+     */
+    handleHello(hello: HandshakeHello): Promise<HandshakeWelcome>;
+    /**
+     * Handle the AUTH handshake message
+     */
+    handleAuth(auth: HandshakeAuth, clientNonce: string): Promise<void>;
+    /**
+     * Get the agent's public key
+     */
+    getPublicKey(): string;
+    /**
+     * Get the agent's ID
+     */
+    getAgentId(): string;
+}
+/**
+ * Express.js middleware for Sekuire protocol
+ */
+export declare function createSekuireExpressMiddleware(server: SekuireServer): any[];
+/**
+ * Fastify plugin for Sekuire protocol
+ */
+export declare function createSekuireFastifyPlugin(server: SekuireServer): (fastify: any, options: any) => Promise<void>;

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

@@ -0,0 +1,22 @@
+import { Tool, type ToolInput, type ToolMetadata } from './base';
+/**
+ * Agent Discovery Tool - Find other agents by capability
+ */
+export declare class AgentDiscoveryTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+/**
+ * Agent Delegation Tool - Delegate tasks to other agents
+ */
+export declare class AgentDelegationTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}
+/**
+ * Agent Status Check Tool - Check if an agent is available
+ */
+export declare class AgentStatusTool extends Tool {
+    metadata: ToolMetadata;
+    execute(input: ToolInput): Promise<string>;
+}