@sekuire/sdk 0.1.9 → 0.1.11

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/base.d.ts

@@ -10,11 +10,18 @@ export interface MemoryStorage {
     clear(sessionId: string): Promise<void>;
     delete(sessionId: string): Promise<void>;
     exists(sessionId: string): Promise<boolean>;
+    connect?(): Promise<void>;
+    disconnect?(): Promise<void>;
+    isConnected?(): boolean;
 }
 export declare abstract class BaseMemoryStorage implements MemoryStorage {
+    protected _connected: boolean;
     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>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
 }

package/dist/memory/cloudflare-d1.d.ts

@@ -0,0 +1,24 @@
+import { BaseMemoryStorage, type MemoryMessage } from './base';
+export interface CloudflareD1Config {
+    binding?: any;
+    accountId?: string;
+    databaseId?: string;
+    apiToken?: string;
+    tableName?: string;
+}
+export declare class CloudflareD1Storage extends BaseMemoryStorage {
+    private binding;
+    private config;
+    private tableName;
+    private useRestApi;
+    private tableInitialized;
+    constructor(config: CloudflareD1Config);
+    private executeQuery;
+    private ensureTableExists;
+    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/cloudflare-kv.d.ts

@@ -0,0 +1,25 @@
+import { BaseMemoryStorage, type MemoryMessage } from './base';
+export interface CloudflareKVConfig {
+    binding?: any;
+    accountId?: string;
+    namespaceId?: string;
+    apiToken?: string;
+    keyPrefix?: string;
+}
+export declare class CloudflareKVStorage extends BaseMemoryStorage {
+    private binding;
+    private config;
+    private keyPrefix;
+    private useRestApi;
+    constructor(config: CloudflareKVConfig);
+    private getKey;
+    private kvGet;
+    private kvPut;
+    private kvDelete;
+    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/convex.d.ts

@@ -0,0 +1,21 @@
+import { BaseMemoryStorage, type MemoryMessage } from './base';
+export interface ConvexConfig {
+    url: string;
+    adminKey?: string;
+}
+export declare class ConvexStorage extends BaseMemoryStorage {
+    private client;
+    private config;
+    private connectionPromise;
+    constructor(config: ConvexConfig);
+    connect(): Promise<void>;
+    private ensureConnected;
+    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>;
+}
+export declare const CONVEX_SCHEMA_TEMPLATE = "\n// convex/schema.ts\nimport { defineSchema, defineTable } from \"convex/server\";\nimport { v } from \"convex/values\";\n\nexport default defineSchema({\n  sekuireMemory: defineTable({\n    sessionId: v.string(),\n    role: v.union(v.literal(\"user\"), v.literal(\"assistant\"), v.literal(\"system\")),\n    content: v.string(),\n    timestamp: v.number(),\n    metadata: v.optional(v.any()),\n  }).index(\"by_session\", [\"sessionId\", \"timestamp\"]),\n});\n";
+export declare const CONVEX_FUNCTIONS_TEMPLATE = "\n// convex/sekuireMemory.ts\nimport { mutation, query } from \"./_generated/server\";\nimport { v } from \"convex/values\";\n\nexport const add = mutation({\n  args: {\n    sessionId: v.string(),\n    role: v.union(v.literal(\"user\"), v.literal(\"assistant\"), v.literal(\"system\")),\n    content: v.string(),\n    timestamp: v.number(),\n    metadata: v.optional(v.any()),\n  },\n  handler: async (ctx, args) => {\n    await ctx.db.insert(\"sekuireMemory\", args);\n  },\n});\n\nexport const get = query({\n  args: {\n    sessionId: v.string(),\n    limit: v.optional(v.number()),\n  },\n  handler: async (ctx, args) => {\n    let query = ctx.db\n      .query(\"sekuireMemory\")\n      .withIndex(\"by_session\", (q) => q.eq(\"sessionId\", args.sessionId))\n      .order(\"asc\");\n\n    const messages = await query.collect();\n\n    if (args.limit) {\n      return messages.slice(-args.limit);\n    }\n    return messages;\n  },\n});\n\nexport const clear = mutation({\n  args: {\n    sessionId: v.string(),\n  },\n  handler: async (ctx, args) => {\n    const messages = await ctx.db\n      .query(\"sekuireMemory\")\n      .withIndex(\"by_session\", (q) => q.eq(\"sessionId\", args.sessionId))\n      .collect();\n\n    for (const message of messages) {\n      await ctx.db.delete(message._id);\n    }\n  },\n});\n\nexport const exists = query({\n  args: {\n    sessionId: v.string(),\n  },\n  handler: async (ctx, args) => {\n    const message = await ctx.db\n      .query(\"sekuireMemory\")\n      .withIndex(\"by_session\", (q) => q.eq(\"sessionId\", args.sessionId))\n      .first();\n    return message !== null;\n  },\n});\n";

package/dist/memory/dynamodb.d.ts

@@ -0,0 +1,28 @@
+import { BaseMemoryStorage, type MemoryMessage } from './base';
+export interface DynamoDBConfig {
+    tableName: string;
+    region?: string;
+    endpoint?: string;
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+    createTable?: boolean;
+}
+export declare class DynamoDBStorage extends BaseMemoryStorage {
+    private client;
+    private docClient;
+    private config;
+    private connectionPromise;
+    private tableReady;
+    constructor(config: DynamoDBConfig);
+    connect(): Promise<void>;
+    private ensureTableExists;
+    private ensureConnected;
+    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/in-memory.d.ts

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

package/dist/memory/index.d.ts

@@ -2,13 +2,40 @@ export * from './base';
 export * from './in-memory';
 export * from './postgres';
 export * from './redis';
+export * from './sqlite';
+export * from './upstash';
+export * from './cloudflare-kv';
+export * from './cloudflare-d1';
+export * from './dynamodb';
+export * from './turso';
+export * from './convex';
+export * from './registry';
 import type { MemoryStorage } from './base';
 import { type PostgresConfig } from './postgres';
 import { type RedisConfig } from './redis';
-export type MemoryType = 'in-memory' | 'redis' | 'postgres';
+import { type SQLiteConfig } from './sqlite';
+import { type UpstashConfig } from './upstash';
+import { type CloudflareKVConfig } from './cloudflare-kv';
+import { type CloudflareD1Config } from './cloudflare-d1';
+import { type DynamoDBConfig } from './dynamodb';
+import { type TursoConfig } from './turso';
+import { type ConvexConfig } from './convex';
+import { registerStorage, hasStorage, listStorageTypes, getStorageInfo } from './registry';
+export type BuiltInMemoryType = 'in-memory' | 'buffer' | 'redis' | 'postgres' | 'sqlite' | 'upstash' | 'cloudflare-kv' | 'cloudflare-d1' | 'dynamodb' | 'turso' | 'convex';
+export type MemoryType = BuiltInMemoryType | string;
 export interface MemoryFactoryConfig {
     type: MemoryType;
     redis?: RedisConfig;
     postgres?: PostgresConfig;
+    sqlite?: SQLiteConfig;
+    upstash?: UpstashConfig;
+    cloudflareKV?: CloudflareKVConfig;
+    cloudflareD1?: CloudflareD1Config;
+    dynamodb?: DynamoDBConfig;
+    turso?: TursoConfig;
+    convex?: ConvexConfig;
+    options?: Record<string, unknown>;
+    instance?: MemoryStorage;
 }
 export declare function createMemoryStorage(config: MemoryFactoryConfig): MemoryStorage;
+export { registerStorage, hasStorage, listStorageTypes, getStorageInfo, };

package/dist/memory/postgres.d.ts

@@ -7,13 +7,17 @@ export interface PostgresConfig {
     user?: string;
     password?: string;
     tableName?: string;
+    lazyConnect?: boolean;
 }
 export declare class PostgresStorage extends BaseMemoryStorage {
     private pool;
     private tableName;
-    private initialized;
+    private config;
+    private connectionPromise;
     constructor(config: PostgresConfig);
+    connect(): Promise<void>;
     private initPool;
+    private ensureConnected;
     private createTableIfNotExists;
     add(sessionId: string, message: MemoryMessage): Promise<void>;
     get(sessionId: string, limit?: number): Promise<MemoryMessage[]>;

package/dist/memory/redis.d.ts

@@ -6,13 +6,17 @@ export interface RedisConfig {
     db?: number;
     url?: string;
     keyPrefix?: string;
+    lazyConnect?: boolean;
 }
 export declare class RedisStorage extends BaseMemoryStorage {
     private client;
     private keyPrefix;
-    private connected;
+    private config;
+    private connectionPromise;
     constructor(config: RedisConfig);
+    connect(): Promise<void>;
     private initClient;
+    private ensureConnected;
     private getKey;
     add(sessionId: string, message: MemoryMessage): Promise<void>;
     get(sessionId: string, limit?: number): Promise<MemoryMessage[]>;

package/dist/memory/registry.d.ts

@@ -0,0 +1,12 @@
+import type { MemoryStorage } from './base';
+export type StorageFactory = (config: any) => MemoryStorage;
+export declare function registerStorage(type: string, factory: StorageFactory, description?: string): void;
+export declare function getStorageFactory(type: string): StorageFactory | undefined;
+export declare function hasStorage(type: string): boolean;
+export declare function listStorageTypes(): string[];
+export declare function getStorageInfo(): Array<{
+    type: string;
+    description?: string;
+}>;
+export declare function unregisterStorage(type: string): boolean;
+export declare function clearRegistry(): void;

package/dist/memory/sqlite.d.ts

@@ -0,0 +1,22 @@
+import { BaseMemoryStorage, type MemoryMessage } from './base';
+export interface SQLiteConfig {
+    filename: string;
+    tableName?: string;
+    readonly?: boolean;
+}
+export declare class SQLiteStorage extends BaseMemoryStorage {
+    private db;
+    private config;
+    private tableName;
+    private connectionPromise;
+    constructor(config: SQLiteConfig);
+    connect(): Promise<void>;
+    private ensureTableExists;
+    private ensureConnected;
+    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/turso.d.ts

@@ -0,0 +1,23 @@
+import { BaseMemoryStorage, type MemoryMessage } from './base';
+export interface TursoConfig {
+    url: string;
+    authToken?: string;
+    tableName?: string;
+}
+export declare class TursoStorage extends BaseMemoryStorage {
+    private client;
+    private config;
+    private tableName;
+    private connectionPromise;
+    private tableInitialized;
+    constructor(config: TursoConfig);
+    connect(): Promise<void>;
+    private ensureTableExists;
+    private ensureConnected;
+    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/upstash.d.ts

@@ -0,0 +1,22 @@
+import { BaseMemoryStorage, type MemoryMessage } from './base';
+export interface UpstashConfig {
+    url: string;
+    token: string;
+    keyPrefix?: string;
+}
+export declare class UpstashStorage extends BaseMemoryStorage {
+    private client;
+    private keyPrefix;
+    private config;
+    private connectionPromise;
+    constructor(config: UpstashConfig);
+    connect(): Promise<void>;
+    private ensureConnected;
+    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

@@ -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;