@jussmor/sdk-ai 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,251 @@
+import { T as ToolCallEntry, C as ChatMessage, L as LLMProvider, a as Conversation, b as ChatRequest, c as ChatResponse } from './conversation-kIkMQdYK.js';
+export { D as DocumentContent, I as ImageContent, M as ModelRouter, R as Role, d as TokenUsage, e as ToolChoice, f as ToolDef, g as ToolFuncParams, h as ToolParam, i as appendAssistant, j as appendUser, k as incrementTurn, l as isCold, m as messageCount, n as newConversation } from './conversation-kIkMQdYK.js';
+import { E as EnforcementResult, C as ContextBudget, I as InterruptRequest, a as Engine, P as PermissionEngine, b as InterruptGate, S as StreamEvent } from './streaming-BtD23BE0.js';
+export { A as AgentLoopConfig, c as AgentLoopResult, d as AgentResult, e as Artifact, f as ArtifactContext, g as ArtifactEmitter, h as ArtifactType, B as BaseMode, i as CompactionEvent, F as FormField, j as InterruptApprover, k as InterruptKind, l as InterruptRequester, m as InterruptResponse, M as Mode, n as ModeMeta, o as ModeProvider, p as ModelSettings, q as PermissionApprover, r as PermissionBehavior, s as PermissionDecision, t as PermissionDecisionResult, u as PermissionResult, v as PermissionRule, w as PlanModeEvent, R as ReasoningStep, x as SandboxDriver, y as SandboxExecResult, z as StaticModeProvider, D as StreamEventType, G as StreamingLLMProvider, H as SystemPromptBuilder, J as SystemPromptLayer, T as Tool, K as ToolCategory, L as ToolDispatcher, N as ToolExecuteFunc, O as ToolMatch, Q as ToolPermissionFn, U as ToolPredicate, V as ToolRegistry, W as ToolReminderFn, X as ToolResult, Y as ToolValidator, Z as ToolsMode, _ as areIndependent, $ as collectStream, a0 as defaultContextBudget, a1 as emitArtifact, a2 as enforceContextBudget, a3 as fanOutStream, a4 as hasBudget, a5 as hasLLM, a6 as hasMemory, a7 as hasModes, a8 as hasPrompt, a9 as hasSandbox, aa as hasThreads, ab as hasTools, ac as isToolAllowed, ad as newEngine, ae as newEngineWithDefaults, af as runAgentLoop, ag as runAgentLoopWithEngine, ah as toToolDef, ai as toolResultsToMessages, aj as withArtifactEmitter, ak as withBudget, al as withLLM, am as withMemory, an as withModes, ao as withPrompt, ap as withSandbox, aq as withThreads, ar as withTools } from './streaming-BtD23BE0.js';
+import { C as ConversationStore } from './conversation-store-CAyPuBjk.js';
+import { M as MemoryRoot } from './memory-uBLqrQRY.js';
+export { D as DEFAULT_MEMORY_ROOTS, a as MemoryEntry, b as MemoryProvider, c as MemorySearchResult, S as Scope } from './memory-uBLqrQRY.js';
+export { E as ErrThreadAccessDenied, M as Message, a as MultiUserThreadProvider, T as Thread, b as ThreadProvider, c as ThreadStatus } from './thread-C2b9xRMJ.js';
+import { T as Tokenizer } from './tokenizer-BhG_RGUk.js';
+export { H as HeuristicTokenizer, t as truncateToTokens } from './tokenizer-BhG_RGUk.js';
+
+declare const PROTOCOL_VERSION: "1";
+
+type SafetyDecision = "allow" | "block" | "transform";
+interface SafetyVerdict {
+    decision: SafetyDecision;
+    reason?: string;
+    newArgs?: string;
+}
+interface SafetyFilter {
+    inspect(call: ToolCallEntry, signal?: AbortSignal): SafetyVerdict;
+}
+declare class DefaultSafetyFilter implements SafetyFilter {
+    inspect(call: ToolCallEntry): SafetyVerdict;
+}
+
+interface Span {
+    traceId: string;
+    spanId: string;
+    parentId?: string;
+    name: string;
+    startedAt: Date;
+    finishedAt?: Date;
+    attrs?: Record<string, unknown>;
+    error?: string;
+}
+declare class Tracer {
+    private readonly _traceId;
+    private spans;
+    private stack;
+    constructor();
+    traceId(): string;
+    startSpan(name: string, attrs?: Record<string, unknown>): Span;
+    finishSpan(span: Span, error?: Error): void;
+    allSpans(): Span[];
+}
+interface TracedContext {
+    __tracer?: Tracer;
+}
+declare function withTracer<T extends TracedContext>(ctx: T, tracer: Tracer): T;
+declare function tracerFromContext(ctx: TracedContext): Tracer | undefined;
+
+declare function systemReminder(content: string): string;
+declare function joinSystemReminders(...reminders: string[]): string;
+
+interface CompactionResult {
+    enforcementResult: EnforcementResult;
+    summary: string;
+}
+interface Compactor {
+    summarize(messages: ChatMessage[], signal?: AbortSignal): Promise<string>;
+}
+declare class LLMCompactor implements Compactor {
+    private llm;
+    constructor(llm: LLMProvider);
+    summarize(messages: ChatMessage[], signal?: AbortSignal): Promise<string>;
+}
+declare class BulletCompactor implements Compactor {
+    summarize(messages: ChatMessage[]): Promise<string>;
+}
+declare function enforceWithCompaction(budget: ContextBudget, compactor: Compactor | undefined, conv: Conversation, memoryTokens: number, tok?: Tokenizer, signal?: AbortSignal): Promise<CompactionResult>;
+
+interface SessionContext {
+    currentTime?: Date;
+    timezone?: string;
+    userId?: string;
+    username?: string;
+    projectId?: string;
+    activeArtifactId?: string;
+    extras?: Record<string, string>;
+}
+declare function formatSessionContext(sc: SessionContext): string;
+interface SessionContextProvider {
+    get(conv: Conversation, signal?: AbortSignal): Promise<SessionContext | undefined>;
+}
+
+type TodoStatus = "pending" | "in_progress" | "completed";
+interface Todo {
+    id: string;
+    content: string;
+    activeForm?: string;
+    status: TodoStatus;
+}
+interface ExecutionContext {
+    todos(): Todo[];
+    setTodos(todos: Todo[]): void;
+    markDone(id: string): void;
+}
+declare class InMemoryExecutionContext implements ExecutionContext {
+    private _todos;
+    todos(): Todo[];
+    setTodos(todos: Todo[]): void;
+    markDone(id: string): void;
+}
+
+interface InterruptStore {
+    put(req: InterruptRequest, signal?: AbortSignal): Promise<void>;
+    get(id: string, signal?: AbortSignal): Promise<{
+        req: InterruptRequest;
+        ok: true;
+    } | {
+        ok: false;
+    }>;
+    delete(id: string, signal?: AbortSignal): Promise<void>;
+}
+declare class InMemoryInterruptStore implements InterruptStore {
+    private store;
+    put(req: InterruptRequest): Promise<void>;
+    get(id: string): Promise<{
+        req: InterruptRequest;
+        ok: true;
+    } | {
+        ok: false;
+    }>;
+    delete(id: string): Promise<void>;
+}
+
+interface Agent {
+    id: string;
+    name: string;
+    description?: string;
+    promptContent?: string;
+    sourceKind?: string;
+}
+interface AgentSource {
+    sourceName(): string;
+    list(signal?: AbortSignal): Promise<Agent[]>;
+}
+
+interface MemoryHeader {
+    path: string;
+    title?: string;
+    description?: string;
+    type?: string;
+}
+interface MemorySelector {
+    select(query: string, headers: MemoryHeader[], limit: number, signal?: AbortSignal): Promise<MemoryHeader[]>;
+}
+declare class KeywordMemorySelector implements MemorySelector {
+    select(query: string, headers: MemoryHeader[], limit: number): Promise<MemoryHeader[]>;
+}
+
+interface RuleMatcher {
+    match(ruleContent: string, input: Record<string, unknown>): boolean;
+}
+type RuleMatcherFunc = (ruleContent: string, input: Record<string, unknown>) => boolean;
+declare function ruleMatcherFromFn(fn: RuleMatcherFunc): RuleMatcher;
+declare function prefixMatcher(argKey: string): RuleMatcher;
+declare function exactMatcher(): RuleMatcher;
+
+interface Skill {
+    id: string;
+    name: string;
+    description?: string;
+    promptContent?: string;
+    sourceKind?: string;
+    allowedTools?: string[];
+}
+interface SkillSource {
+    sourceName(): string;
+    list(signal?: AbortSignal): Promise<Skill[]>;
+}
+interface SkillBashExecutor {
+    execute(command: string, allowedTools: string[], signal?: AbortSignal): Promise<string>;
+}
+
+declare function parseModelRef(ref: string): [string, string];
+declare class RoutedLLMProvider implements LLMProvider {
+    private routes;
+    private fallback?;
+    register(provider: string, llm: LLMProvider): this;
+    withFallback(llm: LLMProvider): this;
+    route(model: string): LLMProvider;
+    chat(req: ChatRequest, signal?: AbortSignal): Promise<ChatResponse>;
+}
+
+interface RuntimeResult {
+    response: string;
+    turns: number;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    stopReason: string;
+    trace: Span[];
+    traceId: string;
+    memoryRead: boolean;
+    memoryWritten: string[];
+    warnings: string[];
+    startedAt: Date;
+    completedAt?: Date;
+}
+interface PlanController {
+    onStateChanged?: (ev: {
+        state: string;
+        plan?: string;
+        reason?: string;
+    }) => void;
+}
+declare class Runtime {
+    private engine;
+    private mode;
+    private model;
+    private safety?;
+    private tokenizer;
+    private store?;
+    private sessionContext?;
+    private compactor?;
+    private maxMemoryTokens;
+    private memoryRoots;
+    private thinkingBudget;
+    private interruptGate?;
+    private permissions?;
+    private planController?;
+    private _emit?;
+    constructor(engine: Engine);
+    withMode(modeId: string): this;
+    withModel(model: string): this;
+    withSafety(s: SafetyFilter): this;
+    withPermissions(e: PermissionEngine): this;
+    withTokenizer(t: Tokenizer): this;
+    withConversationStore(s: ConversationStore): this;
+    withSessionContext(p: SessionContextProvider): this;
+    withCompactor(c: Compactor): this;
+    withMaxMemoryTokens(n: number): this;
+    withMemoryRoots(...roots: MemoryRoot[]): this;
+    withThinkingBudget(tokens: number): this;
+    withInterruptGate(gate: InterruptGate): this;
+    withPlanController(pc: PlanController): this;
+    run(conv: Conversation, userMessage: string, signal?: AbortSignal): Promise<RuntimeResult>;
+    runStream(conv: Conversation, userMessage: string, signal?: AbortSignal): AsyncGenerator<StreamEvent>;
+    private orientation;
+    private warmRefresh;
+    private buildSessionLayer;
+    private preparation;
+    private execution;
+}
+declare function newRuntime(engine: Engine): Runtime;
+
+export { type Agent, type AgentSource, BulletCompactor, ChatMessage, ChatRequest, ChatResponse, type CompactionResult, type Compactor, ContextBudget, Conversation, ConversationStore, DefaultSafetyFilter, EnforcementResult, Engine, type ExecutionContext, InMemoryExecutionContext, InMemoryInterruptStore, InterruptGate, InterruptRequest, type InterruptStore, KeywordMemorySelector, LLMCompactor, LLMProvider, type MemoryHeader, MemoryRoot, type MemorySelector, PROTOCOL_VERSION, PermissionEngine, type PlanController, RoutedLLMProvider, type RuleMatcher, type RuleMatcherFunc, Runtime, type RuntimeResult, type SafetyDecision, type SafetyFilter, type SafetyVerdict, type SessionContext, type SessionContextProvider, type Skill, type SkillBashExecutor, type SkillSource, type Span, StreamEvent, type Todo, type TodoStatus, Tokenizer, ToolCallEntry, type TracedContext, Tracer, enforceWithCompaction, exactMatcher, formatSessionContext, joinSystemReminders, newRuntime, parseModelRef, prefixMatcher, ruleMatcherFromFn, systemReminder, tracerFromContext, withTracer };