@threaded/ai 1.0.30 → 1.1.0

package/dist/index.d.cts

@@ -1,352 +0,0 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index';
-
-interface Message {
-    role: "system" | "user" | "assistant" | "tool";
-    content: string;
-    tool_call_id?: string;
-}
-interface ToolCall {
-    id: string;
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-interface ToolCallResult {
-    name: string;
-    inputs: any;
-    results: any;
-}
-interface ToolDefinition {
-    type: "function";
-    function: {
-        name: string;
-        description: string;
-        parameters: {
-            type: string;
-            properties: Record<string, any>;
-            required?: string[];
-        };
-    };
-}
-interface ToolConfig {
-    name: string;
-    description: string;
-    schema: Record<string, SchemaProperty> | StandardSchema;
-    execute: (args: any) => Promise<any> | any;
-    _maxCalls?: number;
-}
-interface SchemaProperty {
-    type: "string" | "number" | "boolean" | "array" | "object";
-    description?: string;
-    enum?: string[];
-    optional?: boolean;
-    items?: SchemaProperty;
-    properties?: Record<string, SchemaProperty>;
-}
-interface ToolExecutionConfig {
-    /** require user approval before executing tools */
-    requireApproval?: boolean;
-    /**
-     * custom callback to handle tool approval, return true to approve
-     *
-     * @example
-     * // simple callback
-     * approvalCallback: (call) => call.function.name !== 'dangerousTool'
-     *
-     * @example
-     * // event-driven (SSE): server sends approval request, waits for client POST
-     * approvalCallback: (call) => new Promise((resolve) => {
-     *   pendingApprovals.set(call.id, resolve);
-     *   res.write(`data: ${JSON.stringify({ type: 'approval_needed', call })}\n\n`);
-     * })
-     * // then: app.post('/approve/:id', (req) => pendingApprovals.get(id)(req.body.approved))
-     */
-    approvalCallback?: (call: ToolCall) => boolean | Promise<boolean>;
-    /** execute tools in parallel instead of sequentially */
-    parallel?: boolean;
-    /** number of times to retry failed tool executions */
-    retryCount?: number;
-    /** identifier for approval requests, useful for managing multiple approval flows */
-    approvalId?: string;
-    /** execute tools immediately upon approval instead of waiting for all approvals (default: false, only applies when requireApproval is true) */
-    executeOnApproval?: boolean;
-}
-type StreamEvent = {
-    type: 'content';
-    content: string;
-} | {
-    type: 'tool_calls_ready';
-    calls: ToolCall[];
-} | {
-    type: 'tool_executing';
-    call: ToolCall;
-} | {
-    type: 'tool_complete';
-    call: ToolCall;
-    result: any;
-} | {
-    type: 'tool_error';
-    call: ToolCall;
-    error: string;
-} | {
-    type: 'approval_requested';
-    call: ToolCall;
-    requestId: string;
-} | {
-    type: 'usage';
-    usage: TokenUsage;
-};
-interface ConversationContext {
-    history: Message[];
-    lastRequest?: Message;
-    lastResponse?: Message & {
-        tool_calls?: ToolCall[];
-    };
-    tools?: ToolDefinition[];
-    toolExecutors?: Record<string, Function>;
-    stream?: (event: StreamEvent) => void;
-    stopReason?: string;
-    toolCallCounts?: Record<string, number>;
-    toolLimits?: Record<string, number>;
-    toolConfig?: ToolExecutionConfig;
-    abortSignal?: AbortSignal;
-    usage?: TokenUsage;
-}
-declare enum Inherit {
-    Nothing = 0,
-    Conversation = 1,
-    Tools = 2,
-    All = 3
-}
-interface ScopeConfig {
-    inherit?: number;
-    tools?: ToolConfig[];
-    toolConfig?: ToolExecutionConfig;
-    system?: string;
-    silent?: boolean;
-    until?: (ctx: ConversationContext) => boolean;
-    stream?: (event: StreamEvent) => void;
-}
-type StepFunction = (ctx: ConversationContext) => Promise<ConversationContext>;
-type ComposedFunction = (ctxOrMessage: ConversationContext | string) => Promise<ConversationContext>;
-interface JsonSchema {
-    name: string;
-    schema: Record<string, any>;
-}
-interface StandardSchema {
-    "~standard": any;
-    [key: string]: any;
-}
-interface ProviderConfig {
-    model: string;
-    instructions?: string;
-    schema?: JsonSchema;
-    apiKey?: string;
-    baseUrl?: string;
-}
-interface ParsedModel {
-    provider: string;
-    model: string;
-}
-interface ApiKeys {
-    openai?: string;
-    anthropic?: string;
-    google?: string;
-    [provider: string]: string | undefined;
-}
-interface ThreadStore {
-    get(threadId: string): Promise<Message[]>;
-    set(threadId: string, messages: Message[]): Promise<void>;
-}
-interface Thread {
-    id: string;
-    store: ThreadStore;
-    generate(step: StepFunction): Promise<ConversationContext>;
-    message(content: string, workflow?: StepFunction, options?: {
-        abortSignal?: AbortSignal;
-    }): Promise<ConversationContext>;
-}
-interface RetryOptions {
-    times?: number;
-}
-interface ImageConfig {
-    n?: number;
-    size?: string;
-    quality?: "standard" | "hd" | "low" | "medium" | "high" | "auto";
-    style?: "vivid" | "natural";
-    responseFormat?: "url" | "b64_json";
-    aspectRatio?: string;
-    outputFormat?: "png" | "jpeg" | "webp";
-    outputCompression?: number;
-    background?: "transparent" | "opaque" | "auto";
-    moderation?: "auto" | "low";
-    imageSize?: "1K" | "2K";
-}
-interface ImageResult {
-    data: string;
-    revisedPrompt?: string;
-}
-interface TokenUsage {
-    promptTokens: number;
-    completionTokens: number;
-    totalTokens: number;
-}
-
-declare const createMCPTools: (client: Client) => Promise<ToolConfig[]>;
-
-declare const toolConfigToToolDefinition: (tool: ToolConfig) => ToolDefinition;
-declare const parseModelName: (model: string) => ParsedModel;
-declare const setKeys: (keys: ApiKeys) => void;
-declare const getKey: (provider: string) => string;
-declare const maxCalls: (toolConfig: ToolConfig, maxCalls: number) => ToolConfig;
-declare const addUsage: (existing: TokenUsage | undefined, promptTokens: number, completionTokens: number, totalTokens: number) => TokenUsage;
-
-/**
- * generates embeddings for text using openai or huggingface models
- *
- * openai models use the prefix "openai/" (e.g., "openai/text-embedding-3-small")
- * all other models use huggingface transformers
- *
- * accepts a single string or an array of strings for batch embedding
- *
- * @example
- * const vector = await embed("openai/text-embedding-3-small", "hello world");
- * const vectors = await embed("openai/text-embedding-3-small", ["hello", "world"]);
- */
-declare const embed: (model: string, text: string | string[], config?: {
-    dimensions?: number;
-}) => Promise<number[] | number[][]>;
-
-declare const generateImage: (model: string, prompt: string, config?: ImageConfig) => Promise<ImageResult>;
-
-interface ConfigOption {
-    values: string[];
-    default: string;
-    description: string;
-}
-interface ModelConfig {
-    [option: string]: ConfigOption;
-}
-interface ProviderModels {
-    [model: string]: ModelConfig;
-}
-interface ImageModelSchema {
-    [provider: string]: ProviderModels;
-}
-declare const IMAGE_MODEL_SCHEMA: ImageModelSchema;
-declare const IMAGE_EDIT_MODEL_SCHEMA: ImageModelSchema;
-declare function getModelConfig(provider: string, model: string): ModelConfig | null;
-declare function getDefaultConfig(provider: string, model: string): Record<string, string>;
-
-/**
- * @example
- * // in-memory (default)
- * const thread = getOrCreateThread('user-123');
- *
- * @example
- * // sqlite
- * const thread = getOrCreateThread('user-123', {
- *   async get(id) {
- *     const row = await db.get('SELECT messages FROM threads WHERE id = ?', id);
- *     return row ? JSON.parse(row.messages) : [];
- *   },
- *   async set(id, messages) {
- *     await db.run(
- *       'INSERT OR REPLACE INTO threads (id, messages, updated_at) VALUES (?, ?, ?)',
- *       id,
- *       JSON.stringify(messages),
- *       Date.now()
- *     );
- *   }
- * });
- */
-declare const getOrCreateThread: (id: string, store?: ThreadStore) => Thread;
-
-declare const isStandardSchema: (schema: any) => schema is StandardSchema;
-declare const convertStandardSchemaToJsonSchema: (standardSchema: StandardSchema, name?: string) => JsonSchema;
-declare const convertMCPSchemaToToolSchema: (mcpSchema: any) => Record<string, SchemaProperty>;
-declare function normalizeSchema(schema: JsonSchema | StandardSchema, name?: string): JsonSchema;
-declare const convertStandardSchemaToSchemaProperties: (standardSchema: StandardSchema) => Record<string, SchemaProperty>;
-
-/**
- * scope({ until: noToolsCalled() })
- */
-declare const noToolsCalled: () => (ctx: ConversationContext) => boolean;
-declare const everyNMessages: (n: number, step: StepFunction) => StepFunction;
-declare const everyNTokens: (n: number, step: StepFunction) => StepFunction;
-declare const appendToLastRequest: (content: string) => StepFunction;
-/**
- * toolNotUsedInNTurns({ toolName: "search_web", times: 10 }, appendToLastRequest("consider using web search..."))
- */
-declare const toolNotUsedInNTurns: ({ toolName, times }: {
-    toolName: string;
-    times: number;
-}, step: StepFunction) => StepFunction;
-declare const toolWasCalled: (name: string) => (ctx: ConversationContext) => boolean;
-
-interface ApprovalRequest {
-    id: string;
-    toolCall: ToolCall;
-    approvalId?: string;
-}
-interface ApprovalResponse {
-    id: string;
-    approved: boolean;
-    reason?: string;
-}
-declare const generateApprovalToken: () => string;
-declare const requestApproval: (toolCall: ToolCall, approvalId?: string) => Promise<ApprovalResponse>;
-declare const resolveApproval: (response: ApprovalResponse) => boolean;
-declare const onApprovalRequested: (listener: (request: ApprovalRequest) => void) => void;
-declare const onApprovalResolved: (listener: (response: ApprovalResponse) => void) => void;
-declare const removeApprovalListener: (event: "approvalRequested" | "approvalResolved", listener: (...args: any[]) => void) => void;
-
-declare const tap: (fn: (ctx: ConversationContext) => Promise<void> | void) => StepFunction;
-
-declare const when: (condition: (ctx: ConversationContext) => boolean, action: StepFunction) => StepFunction;
-
-declare const model: ({ model, schema, system, apiKey, baseUrl, }?: {
-    model?: string;
-    schema?: JsonSchema | StandardSchema;
-    system?: string | ((ctx: ConversationContext) => string);
-    apiKey?: string;
-    baseUrl?: string;
-}) => ComposedFunction;
-
-/**
- * scope({}, retry({ times: 2 }, model(...)))
- */
-declare const retry: ({ times }: RetryOptions | undefined, step: StepFunction) => StepFunction;
-
-declare const scope: (config: ScopeConfig, ...steps: StepFunction[]) => StepFunction;
-
-type RateLimitConfig = {
-    rps: number;
-    burst: number;
-    concurrency: number;
-};
-/**
- * creates a rate limiter that wraps async functions with burst, rate, and concurrency controls
- *
- * @param config - rate limit configuration
- * @param config.rps - maximum requests per second
- * @param config.burst - maximum burst size (initial token bucket capacity)
- * @param config.concurrency - maximum concurrent in-flight requests
- *
- * @example
- * const limiter = rateLimited({ rps: 10, burst: 20, concurrency: 5 });
- *
- * const workflow = limiter(
- *   compose(
- *     scope({ tools: [searchTool] }, model())
- *   )
- * );
- *
- * await workflow("hello");
- */
-declare const rateLimited: (config: RateLimitConfig) => <T extends (...args: any[]) => Promise<any>>(fn: T) => T;
-
-declare const compose: (...steps: StepFunction[]) => ComposedFunction;
-
-export { type ApiKeys, type ApprovalRequest, type ApprovalResponse, type ComposedFunction, type ConfigOption, type ConversationContext, IMAGE_EDIT_MODEL_SCHEMA, IMAGE_MODEL_SCHEMA, type ImageConfig, type ImageModelSchema, type ImageResult, Inherit, type JsonSchema, type Message, type ModelConfig, type ParsedModel, type ProviderConfig, type ProviderModels, type RetryOptions, type SchemaProperty, type ScopeConfig, type StandardSchema, type StepFunction, type StreamEvent, type Thread, type ThreadStore, type TokenUsage, type ToolCall, type ToolCallResult, type ToolConfig, type ToolDefinition, type ToolExecutionConfig, addUsage, appendToLastRequest, compose, convertMCPSchemaToToolSchema, convertStandardSchemaToJsonSchema, convertStandardSchemaToSchemaProperties, createMCPTools, embed, everyNMessages, everyNTokens, generateApprovalToken, generateImage, getDefaultConfig, getKey, getModelConfig, getOrCreateThread, isStandardSchema, maxCalls, model, noToolsCalled, normalizeSchema, onApprovalRequested, onApprovalResolved, parseModelName, rateLimited, removeApprovalListener, requestApproval, resolveApproval, retry, scope, setKeys, tap, toolConfigToToolDefinition, toolNotUsedInNTurns, toolWasCalled, when };

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "lib": [
-      "ES2022"
-    ],
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "types": [
-      "node"
-    ],
-    "strict": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": [
-    "src/**/*",
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-  ]
-}