@abassey/aid 0.1.0

package/dist/types-BJReASS-.d.cts

@@ -0,0 +1,196 @@
+interface AiOptions {
+    model?: string;
+    system?: string;
+    context?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    stop?: string[];
+    timeout?: number;
+    tools?: Tool[];
+    middleware?: Middleware[];
+    stream?: boolean;
+    /** Internal: used by Conversation and tool loop to pass message history */
+    _messages?: Message[];
+}
+interface AiResponse {
+    text: string;
+    model: string;
+    tokens: TokenUsage;
+    cost: number;
+    latencyMs: number;
+    finishReason: "stop" | "length" | "tool_use" | "error";
+    toolCalls?: ToolCall[];
+    raw: unknown;
+}
+interface AiStreamChunk {
+    text: string;
+    delta: string;
+    done: boolean;
+    response?: AiResponse;
+}
+interface TokenUsage {
+    input: number;
+    output: number;
+    total: number;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+}
+type Message = {
+    role: "user";
+    content: string | ContentBlock[];
+} | {
+    role: "assistant";
+    content: string | ContentBlock[];
+} | {
+    role: "system";
+    content: string;
+} | {
+    role: "tool";
+    toolCallId: string;
+    content: string;
+};
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    source: ImageSource;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    toolUseId: string;
+    content: string;
+    isError?: boolean;
+};
+interface ImageSource {
+    type: "base64" | "url";
+    mediaType?: string;
+    data: string;
+}
+interface ProviderRequest {
+    model: string;
+    messages: Message[];
+    options: ResolvedOptions;
+    system?: string;
+    tools?: ToolDefinition[];
+}
+type AiStream = AsyncIterable<AiStreamChunk> & {
+    on(event: "text", cb: (delta: string) => void): void;
+    on(event: "done", cb: (response: AiResponse) => void): void;
+    on(event: "error", cb: (error: Error) => void): void;
+    abort(): void;
+};
+interface ResolvedOptions {
+    model: string;
+    temperature: number;
+    maxTokens: number;
+    topP: number;
+    stop: string[];
+    timeout: number;
+    tools: Tool[];
+    middleware: Middleware[];
+    [key: string]: unknown;
+}
+interface ConversationOptions {
+    system?: string;
+    model?: string;
+    maxHistory?: number;
+    [key: string]: unknown;
+}
+interface SerializedConversation {
+    system: string;
+    messages: Message[];
+    options: ConversationOptions;
+}
+interface FluentAi {
+    system(prompt: string): FluentAi;
+    temperature(value: number): FluentAi;
+    maxTokens(value: number): FluentAi;
+    run(prompt: string): Promise<AiResponse>;
+    stream(prompt: string): AiStream;
+}
+interface AiFunction {
+    (prompt: string, options?: AiOptions): Promise<AiResponse>;
+    with(options: AiOptions): AiFunction;
+    safe(prompt: string, options?: AiOptions): Promise<[AiResponse | null, Error | null]>;
+    stream(prompt: string, options?: AiOptions): AiStream;
+    model(name: string): FluentAi;
+    multi(prompt: string, models: string[]): Promise<AiResponse[]>;
+    race(prompt: string, models: string[]): Promise<AiResponse>;
+    all(promises: Promise<AiResponse>[]): Promise<AiResponse[]>;
+    batch(prompts: string[], options?: BatchOptions): Promise<AiResponse[]>;
+    extract<T>(text: string, schema: unknown, options?: AiOptions): Promise<T>;
+    classify<T extends string>(text: string, categories: readonly T[], options?: AiOptions): Promise<T>;
+    json(prompt: string, options?: AiOptions): Promise<unknown>;
+    summarize(text: string, options?: SummarizeOptions): Promise<string>;
+    translate(text: string, language: string, options?: AiOptions): Promise<string>;
+    rewrite(text: string, style: string, options?: AiOptions): Promise<string>;
+    conversation(systemOrOptions?: string | ConversationOptions): Conversation;
+}
+interface Conversation {
+    say(message: string, options?: AiOptions): Promise<AiResponse>;
+    save(): SerializedConversation;
+    fork(): Conversation;
+}
+interface Tool {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+    handler: (args: Record<string, unknown>) => string | Promise<string>;
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+}
+interface JsonSchema {
+    type: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [key: string]: unknown;
+}
+interface Middleware {
+    name: string;
+    execute(request: ProviderRequest, next: (request: ProviderRequest) => Promise<AiResponse>, context?: MiddlewareContext): Promise<AiResponse>;
+}
+interface MiddlewareContext {
+    config: ResolvedOptions;
+    attempt?: number;
+    startTime?: number;
+}
+type ErrorCode = "auth_error" | "rate_limit" | "context_length" | "invalid_request" | "provider_error" | "network" | "timeout" | "parse_error" | "cost_limit" | "tool_loop_limit" | "agent_loop_limit" | "handoff_error" | "workflow_error" | "not_found" | "serve_error" | "unknown";
+interface AidErrorOptions {
+    provider?: string;
+    model?: string;
+    retryAfter?: number;
+    statusCode?: number;
+    raw?: unknown;
+    cause?: Error;
+}
+interface BatchOptions {
+    concurrency?: number;
+    onProgress?: (completed: number, total: number) => void;
+    failFast?: boolean;
+}
+interface SummarizeOptions extends AiOptions {
+    style?: "paragraph" | "bullets" | "headline";
+    maxLength?: number;
+}
+interface RewriteOptions extends AiOptions {
+    preserveLength?: boolean;
+}
+interface RetryConfig {
+    maxAttempts?: number;
+    backoff?: "exponential" | "linear" | "fixed";
+    _baseDelay?: number;
+}
+
+export type { AiOptions as A, BatchOptions as B, ConversationOptions as C, ErrorCode as E, FluentAi as F, Middleware as M, ProviderRequest as P, ResolvedOptions as R, SummarizeOptions as S, Tool as T, AiFunction as a, AiStreamChunk as b, AiResponse as c, Message as d, RetryConfig as e, RewriteOptions as f, TokenUsage as g, ToolCall as h, MiddlewareContext as i, Conversation as j, AidErrorOptions as k };

package/dist/types-BJReASS-.d.ts

@@ -0,0 +1,196 @@
+interface AiOptions {
+    model?: string;
+    system?: string;
+    context?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    stop?: string[];
+    timeout?: number;
+    tools?: Tool[];
+    middleware?: Middleware[];
+    stream?: boolean;
+    /** Internal: used by Conversation and tool loop to pass message history */
+    _messages?: Message[];
+}
+interface AiResponse {
+    text: string;
+    model: string;
+    tokens: TokenUsage;
+    cost: number;
+    latencyMs: number;
+    finishReason: "stop" | "length" | "tool_use" | "error";
+    toolCalls?: ToolCall[];
+    raw: unknown;
+}
+interface AiStreamChunk {
+    text: string;
+    delta: string;
+    done: boolean;
+    response?: AiResponse;
+}
+interface TokenUsage {
+    input: number;
+    output: number;
+    total: number;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+}
+type Message = {
+    role: "user";
+    content: string | ContentBlock[];
+} | {
+    role: "assistant";
+    content: string | ContentBlock[];
+} | {
+    role: "system";
+    content: string;
+} | {
+    role: "tool";
+    toolCallId: string;
+    content: string;
+};
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    source: ImageSource;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    toolUseId: string;
+    content: string;
+    isError?: boolean;
+};
+interface ImageSource {
+    type: "base64" | "url";
+    mediaType?: string;
+    data: string;
+}
+interface ProviderRequest {
+    model: string;
+    messages: Message[];
+    options: ResolvedOptions;
+    system?: string;
+    tools?: ToolDefinition[];
+}
+type AiStream = AsyncIterable<AiStreamChunk> & {
+    on(event: "text", cb: (delta: string) => void): void;
+    on(event: "done", cb: (response: AiResponse) => void): void;
+    on(event: "error", cb: (error: Error) => void): void;
+    abort(): void;
+};
+interface ResolvedOptions {
+    model: string;
+    temperature: number;
+    maxTokens: number;
+    topP: number;
+    stop: string[];
+    timeout: number;
+    tools: Tool[];
+    middleware: Middleware[];
+    [key: string]: unknown;
+}
+interface ConversationOptions {
+    system?: string;
+    model?: string;
+    maxHistory?: number;
+    [key: string]: unknown;
+}
+interface SerializedConversation {
+    system: string;
+    messages: Message[];
+    options: ConversationOptions;
+}
+interface FluentAi {
+    system(prompt: string): FluentAi;
+    temperature(value: number): FluentAi;
+    maxTokens(value: number): FluentAi;
+    run(prompt: string): Promise<AiResponse>;
+    stream(prompt: string): AiStream;
+}
+interface AiFunction {
+    (prompt: string, options?: AiOptions): Promise<AiResponse>;
+    with(options: AiOptions): AiFunction;
+    safe(prompt: string, options?: AiOptions): Promise<[AiResponse | null, Error | null]>;
+    stream(prompt: string, options?: AiOptions): AiStream;
+    model(name: string): FluentAi;
+    multi(prompt: string, models: string[]): Promise<AiResponse[]>;
+    race(prompt: string, models: string[]): Promise<AiResponse>;
+    all(promises: Promise<AiResponse>[]): Promise<AiResponse[]>;
+    batch(prompts: string[], options?: BatchOptions): Promise<AiResponse[]>;
+    extract<T>(text: string, schema: unknown, options?: AiOptions): Promise<T>;
+    classify<T extends string>(text: string, categories: readonly T[], options?: AiOptions): Promise<T>;
+    json(prompt: string, options?: AiOptions): Promise<unknown>;
+    summarize(text: string, options?: SummarizeOptions): Promise<string>;
+    translate(text: string, language: string, options?: AiOptions): Promise<string>;
+    rewrite(text: string, style: string, options?: AiOptions): Promise<string>;
+    conversation(systemOrOptions?: string | ConversationOptions): Conversation;
+}
+interface Conversation {
+    say(message: string, options?: AiOptions): Promise<AiResponse>;
+    save(): SerializedConversation;
+    fork(): Conversation;
+}
+interface Tool {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+    handler: (args: Record<string, unknown>) => string | Promise<string>;
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+}
+interface JsonSchema {
+    type: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [key: string]: unknown;
+}
+interface Middleware {
+    name: string;
+    execute(request: ProviderRequest, next: (request: ProviderRequest) => Promise<AiResponse>, context?: MiddlewareContext): Promise<AiResponse>;
+}
+interface MiddlewareContext {
+    config: ResolvedOptions;
+    attempt?: number;
+    startTime?: number;
+}
+type ErrorCode = "auth_error" | "rate_limit" | "context_length" | "invalid_request" | "provider_error" | "network" | "timeout" | "parse_error" | "cost_limit" | "tool_loop_limit" | "agent_loop_limit" | "handoff_error" | "workflow_error" | "not_found" | "serve_error" | "unknown";
+interface AidErrorOptions {
+    provider?: string;
+    model?: string;
+    retryAfter?: number;
+    statusCode?: number;
+    raw?: unknown;
+    cause?: Error;
+}
+interface BatchOptions {
+    concurrency?: number;
+    onProgress?: (completed: number, total: number) => void;
+    failFast?: boolean;
+}
+interface SummarizeOptions extends AiOptions {
+    style?: "paragraph" | "bullets" | "headline";
+    maxLength?: number;
+}
+interface RewriteOptions extends AiOptions {
+    preserveLength?: boolean;
+}
+interface RetryConfig {
+    maxAttempts?: number;
+    backoff?: "exponential" | "linear" | "fixed";
+    _baseDelay?: number;
+}
+
+export type { AiOptions as A, BatchOptions as B, ConversationOptions as C, ErrorCode as E, FluentAi as F, Middleware as M, ProviderRequest as P, ResolvedOptions as R, SummarizeOptions as S, Tool as T, AiFunction as a, AiStreamChunk as b, AiResponse as c, Message as d, RetryConfig as e, RewriteOptions as f, TokenUsage as g, ToolCall as h, MiddlewareContext as i, Conversation as j, AidErrorOptions as k };

package/dist/types-CguX3F16.d.cts

@@ -0,0 +1,173 @@
+import { T as Tool, d as Message, M as Middleware, a as AiFunction, g as TokenUsage, h as ToolCall, c as AiResponse } from './types-BJReASS-.cjs';
+import { A as AidError } from './errors-zAPbTlpe.cjs';
+
+type AgentEventCallback<E extends AgentEvent> = (payload: AgentEventMap[E]) => void;
+interface AgentResult {
+    text: string;
+    completed: boolean;
+    messages: Message[];
+    steps: AgentStep[];
+    tokens: TokenUsage;
+    cost: number;
+    latencyMs: number;
+    toolCalls: ToolCall[];
+    error?: AidError;
+}
+interface AgentStep {
+    type: "llm_call" | "tool_call" | "handoff";
+    iteration: number;
+    timestamp: number;
+    data: LlmCallData | ToolCallData | HandoffData;
+    durationMs: number;
+}
+interface LlmCallData {
+    model: string;
+    tokens: TokenUsage;
+    finishReason: string;
+}
+interface ToolCallData {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    result: string;
+    isError: boolean;
+}
+interface HandoffData {
+    from: string;
+    to: string;
+    message: string;
+}
+type AgentEvent = "step:start" | "step:end" | "tool:call" | "tool:result" | "handoff" | "message" | "done" | "error";
+interface AgentEventMap {
+    "step:start": {
+        step: number;
+        iteration: number;
+    };
+    "step:end": {
+        step: number;
+        iteration: number;
+        result?: AiResponse;
+    };
+    "tool:call": {
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+    };
+    "tool:result": {
+        id: string;
+        name: string;
+        result: string;
+        durationMs: number;
+    };
+    "handoff": {
+        from: string;
+        to: string;
+        message: string;
+    };
+    "message": {
+        role: string;
+        content: string;
+    };
+    "done": {
+        result: AgentResult;
+    };
+    "error": {
+        error: AidError;
+        step?: number;
+    };
+}
+interface AgentConfig {
+    name: string;
+    role: string;
+    model?: string;
+    tools?: Tool[];
+    memory?: boolean | MemoryProvider;
+    maxIterations?: number;
+    maxChatHistory?: number;
+    middleware?: Middleware[];
+    temperature?: number;
+    maxTokens?: number;
+    ai?: AiFunction;
+}
+interface Agent {
+    readonly name: string;
+    readonly config: AgentConfig;
+    run(task: string): Promise<AgentResult>;
+    chat(message: string): Promise<AgentResult>;
+    clone(overrides?: Partial<AgentConfig>): Agent;
+    on<E extends AgentEvent>(event: E, cb: AgentEventCallback<E>): void;
+    off<E extends AgentEvent>(event: E, cb: AgentEventCallback<E>): void;
+}
+interface MemoryProvider {
+    add(messages: Message[]): Promise<void>;
+    retrieve(query: string, limit?: number): Promise<Message[]>;
+    clear(): Promise<void>;
+}
+type OrchestratorEventPayload<E extends AgentEvent> = AgentEventMap[E] & {
+    agent: string;
+};
+type OrchestratorEventCallback<E extends AgentEvent> = (payload: OrchestratorEventPayload<E>) => void;
+type CrewConfig = {
+    agents: Agent[];
+    strategy: "sequential";
+} | {
+    agents: Agent[];
+    strategy: "parallel";
+} | {
+    agents: Agent[];
+    strategy: "conditional";
+    router: (task: string) => string;
+};
+interface CrewResult {
+    text: string;
+    agentResults: Map<string, AgentResult>;
+    totalTokens: TokenUsage;
+    totalCost: number;
+    latencyMs: number;
+}
+interface Crew {
+    run(task: string): Promise<CrewResult>;
+    on<E extends AgentEvent>(event: E, cb: OrchestratorEventCallback<E>): void;
+    off<E extends AgentEvent>(event: E, cb: OrchestratorEventCallback<E>): void;
+}
+interface WorkflowStep {
+    name: string;
+    agent: Agent;
+    input?: string | string[];
+    condition?: (results: Map<string, AgentResult>) => boolean;
+}
+interface WorkflowConfig {
+    steps: WorkflowStep[];
+}
+interface WorkflowResult {
+    text: string;
+    stepResults: Map<string, AgentResult>;
+    totalTokens: TokenUsage;
+    totalCost: number;
+    latencyMs: number;
+}
+interface Workflow {
+    run(task: string): Promise<WorkflowResult>;
+    on<E extends AgentEvent>(event: E, cb: OrchestratorEventCallback<E>): void;
+    off<E extends AgentEvent>(event: E, cb: OrchestratorEventCallback<E>): void;
+}
+interface SwarmConfig {
+    agents: Agent[];
+    entry: string;
+    maxHandoffs?: number;
+}
+interface SwarmResult {
+    text: string;
+    handoffChain: string[];
+    agentResults: Map<string, AgentResult>;
+    totalTokens: TokenUsage;
+    totalCost: number;
+    latencyMs: number;
+}
+interface Swarm {
+    run(task: string): Promise<SwarmResult>;
+    on<E extends AgentEvent>(event: E, cb: OrchestratorEventCallback<E>): void;
+    off<E extends AgentEvent>(event: E, cb: OrchestratorEventCallback<E>): void;
+}
+
+export type { AgentConfig as A, CrewConfig as C, HandoffData as H, LlmCallData as L, MemoryProvider as M, OrchestratorEventCallback as O, SwarmConfig as S, ToolCallData as T, WorkflowConfig as W, Agent as a, Crew as b, Workflow as c, Swarm as d, AgentEvent as e, AgentEventCallback as f, AgentEventMap as g, AgentResult as h, AgentStep as i, CrewResult as j, OrchestratorEventPayload as k, SwarmResult as l, WorkflowResult as m, WorkflowStep as n };

package/dist/types-CrFH-_qp.d.cts

@@ -0,0 +1,68 @@
+import { g as TokenUsage, P as ProviderRequest } from './types-BJReASS-.cjs';
+
+interface Span {
+    id: string;
+    parentId?: string;
+    name: string;
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+    model: string;
+    provider: string;
+    tokens: TokenUsage;
+    cost: number;
+    status: "ok" | "error";
+    error?: {
+        message: string;
+        code?: string;
+    };
+    metadata: Record<string, unknown>;
+}
+interface SpanFilter {
+    name?: string;
+    model?: string;
+    status?: "ok" | "error";
+    from?: number;
+    to?: number;
+    parentId?: string;
+}
+interface TraceStore {
+    add(span: Span): void;
+    list(filter?: SpanFilter): Span[];
+    get(id: string): Span | undefined;
+    clear(): void;
+}
+interface ActiveSpan {
+    readonly id: string;
+    readonly name: string;
+    annotate(key: string, value: unknown): void;
+}
+type CostPeriod = "today" | "yesterday" | "this-week" | "this-month" | {
+    from: number;
+    to: number;
+};
+interface CostReport {
+    totalCost: number;
+    totalTokens: TokenUsage;
+    calls: number;
+    byModel: Record<string, ModelCostBreakdown>;
+    byProvider: Record<string, {
+        cost: number;
+        calls: number;
+    }>;
+    period: {
+        from: number;
+        to: number;
+    };
+}
+interface ModelCostBreakdown {
+    cost: number;
+    calls: number;
+    tokens: TokenUsage;
+}
+interface TracingOptions {
+    store?: TraceStore;
+    nameFrom?: (req: ProviderRequest) => string;
+}
+
+export type { ActiveSpan as A, CostPeriod as C, ModelCostBreakdown as M, Span as S, TracingOptions as T, TraceStore as a, SpanFilter as b, CostReport as c };