@levelcode/sdk 0.0.5 → 0.1.0

package/dist/common/src/types/skill.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod/v4';
+/**
+ * Zod schema for skill frontmatter metadata.
+ */
+export declare const SkillMetadataSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+/**
+ * Zod schema for skill frontmatter (parsed from YAML).
+ */
+export declare const SkillFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    license: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type SkillFrontmatter = z.infer<typeof SkillFrontmatterSchema>;
+/**
+ * Full skill definition including content and source path.
+ */
+export declare const SkillDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    license: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    content: z.ZodString;
+    filePath: z.ZodString;
+}, z.core.$strip>;
+export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>;
+/**
+ * Collection of skills keyed by skill name.
+ */
+export type SkillsMap = Record<string, SkillDefinition>;

package/dist/common/src/types/source.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Represents a source of data.
+ *
+ * By default, can be a value or a promise.
+ *
+ * In the case that the type is a not function itself, this can also be a function that returns the value or promise.
+ */
+export type Source<T> = T | Promise<T> | (T extends (...args: unknown[]) => unknown ? never : () => T | Promise<T>);

package/dist/common/src/types/spawn.d.ts

@@ -0,0 +1,8 @@
+import type { ChildProcess, SpawnOptions } from 'child_process';
+/**
+ * Spawn function for running shell commands.
+ *
+ * Compatible with `child_process.spawn` from Node.js.
+ * Returns ChildProcess to support full streaming capabilities (stdin, stdout, stderr).
+ */
+export type LevelCodeSpawn = (command: string, args?: readonly string[], options?: SpawnOptions) => ChildProcess;

package/dist/common/src/types/team-config.d.ts

@@ -0,0 +1,39 @@
+export type TeamRole = 'coordinator' | 'cto' | 'vp-engineering' | 'director' | 'fellow' | 'distinguished-engineer' | 'principal-engineer' | 'senior-staff-engineer' | 'staff-engineer' | 'manager' | 'sub-manager' | 'senior-engineer' | 'super-senior' | 'mid-level-engineer' | 'junior-engineer' | 'researcher' | 'scientist' | 'designer' | 'product-lead' | 'tester' | 'reviewer' | 'intern' | 'apprentice';
+export type DevPhase = 'planning' | 'pre-alpha' | 'alpha' | 'beta' | 'production' | 'mature';
+export interface TeamMember {
+    agentId: string;
+    name: string;
+    role: TeamRole;
+    agentType: string;
+    model: string;
+    joinedAt: number;
+    status: 'active' | 'idle' | 'completed' | 'failed';
+    currentTaskId?: string;
+    cwd: string;
+}
+export interface TeamConfig {
+    name: string;
+    description: string;
+    createdAt: number;
+    leadAgentId: string;
+    phase: DevPhase;
+    members: TeamMember[];
+    settings: {
+        maxMembers: number;
+        autoAssign: boolean;
+    };
+}
+export interface TeamTask {
+    id: string;
+    subject: string;
+    description: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'blocked';
+    owner?: string;
+    blockedBy: string[];
+    blocks: string[];
+    phase: DevPhase;
+    activeForm?: string;
+    createdAt: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+}

package/dist/common/src/types/team-protocol.d.ts

@@ -0,0 +1,64 @@
+export type IdleNotification = {
+    type: 'idle_notification';
+    from: string;
+    timestamp: string;
+    summary?: string;
+    completedTaskId?: string;
+};
+export type TaskCompletedMessage = {
+    type: 'task_completed';
+    from: string;
+    taskId: string;
+    taskSubject: string;
+    timestamp: string;
+};
+export type ShutdownRequest = {
+    type: 'shutdown_request';
+    requestId: string;
+    from: string;
+    reason?: string;
+    timestamp: string;
+};
+export type ShutdownApproved = {
+    type: 'shutdown_approved';
+    requestId: string;
+    from: string;
+    timestamp: string;
+};
+export type ShutdownRejected = {
+    type: 'shutdown_rejected';
+    requestId: string;
+    from: string;
+    reason: string;
+    timestamp: string;
+};
+export type PlanApprovalRequest = {
+    type: 'plan_approval_request';
+    requestId: string;
+    from: string;
+    planContent: string;
+    timestamp: string;
+};
+export type PlanApprovalResponse = {
+    type: 'plan_approval_response';
+    requestId: string;
+    approved: boolean;
+    feedback?: string;
+    timestamp: string;
+};
+export type TeamMessage = {
+    type: 'message';
+    from: string;
+    to: string;
+    text: string;
+    summary?: string;
+    timestamp: string;
+};
+export type BroadcastMessage = {
+    type: 'broadcast';
+    from: string;
+    text: string;
+    summary?: string;
+    timestamp: string;
+};
+export type TeamProtocolMessage = IdleNotification | TaskCompletedMessage | ShutdownRequest | ShutdownApproved | ShutdownRejected | PlanApprovalRequest | PlanApprovalResponse | TeamMessage | BroadcastMessage;

package/dist/common/src/util/agent-id-parsing.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Parse agent ID to extract publisher, agent name, and version
+ * Supports formats:
+ * - publisher/agentId[@version]
+ * - agentId[@version] (no publisher)
+ */
+export declare function parseAgentId(fullAgentId: string): {
+    publisherId?: string;
+    agentId?: string;
+    version?: string;
+    givenAgentId: string;
+};
+/**
+ * Parse published agent ID to extract publisher, agent name, and optionally version
+ *
+ * If the agent ID is not in the publisher/agent format, return null
+ */
+export declare function parsePublishedAgentId(fullAgentId: string): {
+    publisherId: string;
+    agentId: string;
+    version?: string;
+} | null;

package/dist/common/src/util/agent-name-normalization.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_ORG_PREFIX = "levelcode/";
+/**
+ * Resolves an agent ID by trying multiple strategies:
+ * 1. Direct lookup in registry
+ * 2. Try with DEFAULT_ORG_PREFIX for spawnable agents
+ * 3. Return null if not found
+ *
+ * This provides a more robust alternative to string concatenation
+ * and handles the common case where users reference spawnable agents
+ * without the org prefix.
+ */
+export declare function resolveAgentId(agentId: string, agentRegistry: Record<string, any>): string | null;

package/dist/common/src/util/array.d.ts

@@ -0,0 +1,6 @@
+export declare function filterDefined<T>(array: (T | null | undefined)[]): T[];
+type Falsey = false | undefined | null | 0 | '';
+type FalseyValueArray<T> = T | Falsey | FalseyValueArray<T>[];
+export declare function buildArray<T>(...params: FalseyValueArray<T>[]): T[];
+export declare function groupConsecutive<T, U>(xs: T[], key: (x: T) => U): any[];
+export {};

package/dist/common/src/util/credentials.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod/v4';
+export declare const userSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    authToken: z.ZodString;
+    fingerprintId: z.ZodString;
+    fingerprintHash: z.ZodString;
+}, z.core.$strip>;
+export type User = z.infer<typeof userSchema>;
+export declare const genAuthCode: (fingerprintId: string, expiresAt: string, secret: string) => string;

package/dist/common/src/util/error.d.ts

@@ -0,0 +1,128 @@
+export type ErrorOr<T, E extends ErrorObject = ErrorObject> = Success<T> | Failure<E>;
+export type Success<T> = {
+    success: true;
+    value: T;
+};
+export type Failure<E extends ErrorObject = ErrorObject> = {
+    success: false;
+    error: E;
+};
+/**
+ * Result type for prompt functions that can be aborted.
+ * Provides rich semantics to distinguish between successful completion and user abort.
+ *
+ * ## When to use `PromptResult<T>` vs `ErrorOr<T>`
+ *
+ * Use `PromptResult<T>` when:
+ * - The operation can be cancelled by the user (via AbortSignal)
+ * - An abort is an expected outcome, not an error
+ * - You need to distinguish between errors (which might trigger fallbacks) and
+ *   user-initiated aborts (which should propagate immediately)
+ *
+ * Use `ErrorOr<T>` when:
+ * - The operation can fail with an error that should be handled
+ * - There's no concept of user-initiated abort
+ * - You want to return error details rather than throw
+ *
+ * ## Abort handling patterns
+ *
+ * 1. **Check and return early** - For graceful handling where abort means "stop, no error":
+ *    ```ts
+ *    const result = await promptAiSdk({ ... })
+ *    if (result.aborted) return // or return null, false, etc.
+ *    doSomething(result.value)
+ *    ```
+ *
+ * 2. **Unwrap and throw** - For propagating aborts as exceptions:
+ *    ```ts
+ *    const value = unwrapPromptResult(await promptAiSdk({ ... }))
+ *    // Throws if aborted, callers should use isAbortError() in catch blocks
+ *    ```
+ *
+ * 3. **Rethrow in catch blocks** - Prevent swallowing abort errors:
+ *    ```ts
+ *    try {
+ *      await someOperation()
+ *    } catch (error) {
+ *      if (isAbortError(error)) throw error // Don't swallow aborts
+ *      // Handle other errors
+ *    }
+ *    ```
+ */
+export type PromptResult<T> = PromptSuccess<T> | PromptAborted;
+export type PromptSuccess<T> = {
+    aborted: false;
+    value: T;
+};
+export type PromptAborted = {
+    aborted: true;
+    reason?: string;
+};
+export type ErrorObject = {
+    name: string;
+    message: string;
+    stack?: string;
+    /** HTTP status code from error.status (used by some libraries) */
+    status?: number;
+    /** HTTP status code from error.statusCode (used by AI SDK and LevelCode errors) */
+    statusCode?: number;
+    /** Optional machine-friendly error code, if available */
+    code?: string;
+    /** Optional raw error object */
+    rawError?: string;
+    /** Response body from API errors (AI SDK APICallError) */
+    responseBody?: string;
+    /** URL that was called (API errors) */
+    url?: string;
+    /** Whether the error is retryable (API errors) */
+    isRetryable?: boolean;
+    /** Request body values that were sent (API errors) - stringified for safety */
+    requestBodyValues?: string;
+    /** Cause of the error, if nested */
+    cause?: ErrorObject;
+};
+export declare function success<T>(value: T): Success<T>;
+export declare function failure(error: unknown): Failure<ErrorObject>;
+/**
+ * Create a successful prompt result.
+ */
+export declare function promptSuccess<T>(value: T): PromptSuccess<T>;
+/**
+ * Create an aborted prompt result.
+ */
+export declare function promptAborted(reason?: string): PromptAborted;
+/**
+ * Standard error message for aborted requests.
+ * Use this constant when throwing abort errors to ensure consistency.
+ */
+export declare const ABORT_ERROR_MESSAGE = "Request aborted";
+/**
+ * Custom error class for abort errors.
+ * Use this class instead of generic Error for abort errors to ensure
+ * robust detection via isAbortError() (checks error.name === 'AbortError').
+ */
+export declare class AbortError extends Error {
+    constructor(reason?: string);
+}
+/**
+ * Check if an error is an abort error.
+ * Use this helper to detect abort errors in catch blocks.
+ *
+ * Detects both:
+ * - Errors with message starting with 'Request aborted' (thrown by our code via AbortError)
+ * - Native AbortError (thrown by fetch/AI SDK when AbortSignal is triggered)
+ */
+export declare function isAbortError(error: unknown): boolean;
+/**
+ * Unwrap a PromptResult, returning the value if successful or throwing if aborted.
+ *
+ * Use this helper for consistent abort handling when you want aborts to propagate
+ * as exceptions. Callers should use `isAbortError()` in catch blocks to detect
+ * and handle abort errors appropriately (e.g., rethrow instead of logging as errors).
+ *
+ * @throws {AbortError} When result.aborted is true.
+ */
+export declare function unwrapPromptResult<T>(result: PromptResult<T>): T;
+export declare function getErrorObject(error: unknown, options?: {
+    includeRawError?: boolean;
+}): ErrorObject;

package/dist/common/src/util/file.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod/v4';
+import type { LevelCodeFileSystem } from '../types/filesystem';
+import type { SkillsMap } from '../types/skill';
+export declare const FileTreeNodeSchema: z.ZodType<FileTreeNode>;
+export interface FileTreeNode {
+    name: string;
+    type: 'file' | 'directory';
+    filePath: string;
+    lastReadTime?: number;
+    children?: FileTreeNode[];
+}
+export interface DirectoryNode extends FileTreeNode {
+    type: 'directory';
+    children: FileTreeNode[];
+}
+export interface FileNode extends FileTreeNode {
+    type: 'file';
+    lastReadTime: number;
+}
+export declare const FileVersionSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type FileVersion = z.infer<typeof FileVersionSchema>;
+export declare const customToolDefinitionsSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+    inputSchema: z.ZodCustom<Record<string, unknown> | z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Record<string, unknown> | z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    endsAgentStep: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    description: z.ZodOptional<z.ZodString>;
+    exampleInputs: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+}, z.core.$strip>>>;
+export type CustomToolDefinitions = NonNullable<z.input<typeof customToolDefinitionsSchema>>;
+export declare const ProjectFileContextSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+    cwd: z.ZodString;
+    fileTree: z.ZodArray<z.ZodCustom<FileTreeNode, FileTreeNode>>;
+    fileTokenScores: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    tokenCallers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
+    knowledgeFiles: z.ZodRecord<z.ZodString, z.ZodString>;
+    userKnowledgeFiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    agentTemplates: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    customToolDefinitions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        inputSchema: z.ZodCustom<Record<string, unknown> | z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Record<string, unknown> | z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        endsAgentStep: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        description: z.ZodOptional<z.ZodString>;
+        exampleInputs: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, z.core.$strip>>>;
+    skills: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    gitChanges: z.ZodObject<{
+        status: z.ZodString;
+        diff: z.ZodString;
+        diffCached: z.ZodString;
+        lastCommitMessages: z.ZodString;
+    }, z.core.$strip>;
+    changesSinceLastChat: z.ZodRecord<z.ZodString, z.ZodString>;
+    shellConfigFiles: z.ZodRecord<z.ZodString, z.ZodString>;
+    systemInfo: z.ZodObject<{
+        platform: z.ZodString;
+        shell: z.ZodString;
+        nodeVersion: z.ZodString;
+        arch: z.ZodString;
+        homedir: z.ZodString;
+        cpus: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ProjectFileContext = {
+    projectRoot: string;
+    cwd: string;
+    fileTree: FileTreeNode[];
+    fileTokenScores: Record<string, Record<string, number>>;
+    tokenCallers?: Record<string, Record<string, string[]>>;
+    knowledgeFiles: Record<string, string>;
+    userKnowledgeFiles?: Record<string, string>;
+    agentTemplates: Record<string, any>;
+    customToolDefinitions: CustomToolDefinitions;
+    skills?: SkillsMap;
+    gitChanges: {
+        status: string;
+        diff: string;
+        diffCached: string;
+        lastCommitMessages: string;
+    };
+    changesSinceLastChat: Record<string, string>;
+    shellConfigFiles: Record<string, string>;
+    systemInfo: {
+        platform: string;
+        shell: string;
+        nodeVersion: string;
+        arch: string;
+        homedir: string;
+        cpus: number;
+    };
+};
+export declare const fileRegex: RegExp;
+export declare const fileWithNoPathRegex: RegExp;
+export declare const parseFileBlocks: (fileBlocks: string) => Record<string, string>;
+export declare const getStubProjectFileContext: () => ProjectFileContext;
+export declare const createMarkdownFileBlock: (filePath: string, content: string) => string;
+export declare const parseMarkdownCodeBlock: (content: string) => string;
+export declare const createSearchReplaceBlock: (search: string, replace: string) => string;
+export declare function printFileTree(nodes: FileTreeNode[], depth?: number): string;
+export declare function printFileTreeWithTokens(nodes: FileTreeNode[], fileTokenScores: Record<string, Record<string, number>>, path?: string[]): string;
+/**
+ * Ensures the given file contents ends with a newline character.
+ * @param contents - The file contents
+ * @returns the file contents with a newline character.
+ */
+export declare const ensureEndsWithNewline: (contents: string | null) => string | null;
+/**
+ * Node-compatible file existence check.
+ * Uses fs.stat instead of Bun-specific fs.exists.
+ */
+export declare function fileExists(params: {
+    filePath: string;
+    fs: LevelCodeFileSystem;
+}): Promise<boolean>;
+export declare const ensureDirectoryExists: (params: {
+    baseDir: string;
+    fs: LevelCodeFileSystem;
+}) => Promise<void>;
+/**
+ * Removes markdown code block syntax if present, including any language tag
+ */
+export declare const cleanMarkdownCodeBlock: (content: string) => string;
+export declare function isValidFilePath(path: string): boolean;
+export declare function isDir(params: {
+    path: string;
+    fs: LevelCodeFileSystem;
+}): Promise<boolean>;
+/**
+ * Returns true if the `toPath` is a subdirectory of `fromPath`.
+ */
+export declare function isSubdir(fromPath: string, toPath: string): boolean;
+export declare function isValidProjectRoot(dir: string): boolean;

package/dist/common/src/util/format-code-search.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Formats code search output to group matches by file.
+ *
+ * Input format: ./file.ts:line content
+ * Output format:
+ * ./file.ts:
+ * line content
+ * another line content
+ * yet another line content
+ *
+ * (double newline between distinct files)
+ *
+ * @param stdout The raw stdout from ripgrep
+ * @returns Formatted output with matches grouped by file
+ */
+export declare function formatCodeSearchOutput(stdout: string): string;

package/dist/common/src/util/lru-cache.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A simple Least Recently Used (LRU) cache implementation using a Map.
+ * It leverages the fact that Map objects maintain insertion order.
+ */
+export declare class LRUCache<K, V> {
+    private maxSize;
+    private cache;
+    constructor(maxSize: number);
+    /**
+     * Retrieves an item from the cache. If found, marks it as recently used.
+     * @param key The key of the item to retrieve.
+     * @returns The value associated with the key, or undefined if not found.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Adds or updates an item in the cache. If the cache exceeds maxSize,
+     * the least recently used item is evicted.
+     * @param key The key of the item to set.
+     * @param value The value to associate with the key.
+     */
+    set(key: K, value: V): void;
+    /**
+     * Returns the current number of items in the cache.
+     */
+    get size(): number;
+    /**
+     * Clears all items from the cache.
+     */
+    clear(): void;
+}

package/dist/common/src/util/messages.d.ts

@@ -0,0 +1,46 @@
+import type { Logger } from '../types/contracts/logger';
+import type { JSONValue } from '../types/json';
+import type { AssistantMessage, Message, SystemMessage, UserMessage } from '../types/messages/levelcode-message';
+import type { ToolResultOutput } from '../types/messages/content-part';
+import type { ProviderMetadata } from '../types/messages/provider-metadata';
+import type { ModelMessage } from 'ai';
+export declare function toContentString(msg: ModelMessage): string;
+export declare function withCacheControl<T extends {
+    providerOptions?: ProviderMetadata;
+}>(obj: T): T;
+export declare function withoutCacheControl<T extends {
+    providerOptions?: ProviderMetadata;
+}>(obj: T): T;
+export declare function convertCbToModelMessages({ messages, includeCacheControl, logger, }: {
+    messages: Message[];
+    includeCacheControl?: boolean;
+    logger?: Logger;
+}): ModelMessage[];
+export type SystemContent = string | SystemMessage['content'][number] | SystemMessage['content'];
+export declare function systemContent(content: SystemContent): SystemMessage['content'];
+export declare function systemMessage(params: SystemContent | ({
+    content: SystemContent;
+} & Omit<SystemMessage, 'role' | 'content'>)): SystemMessage;
+export type UserContent = string | UserMessage['content'][number] | UserMessage['content'];
+export declare function userContent(content: UserContent): UserMessage['content'];
+export declare function userMessage(params: UserContent | ({
+    content: UserContent;
+} & Omit<UserMessage, 'role' | 'content'>)): UserMessage;
+export type AssistantContent = string | AssistantMessage['content'][number] | AssistantMessage['content'];
+export declare function assistantContent(content: AssistantContent): AssistantMessage['content'];
+export declare function assistantMessage(params: AssistantContent | ({
+    content: AssistantContent;
+} & Omit<AssistantMessage, 'role' | 'content'>)): AssistantMessage;
+export declare function jsonToolResult<T extends JSONValue>(value: T): [
+    Extract<ToolResultOutput, {
+        type: 'json';
+    }> & {
+        value: T;
+    }
+];
+export declare function mediaToolResult(params: {
+    data: string;
+    mediaType: string;
+}): [Extract<ToolResultOutput, {
+    type: 'media';
+}>];

package/dist/common/src/util/model-utils.d.ts

@@ -0,0 +1,8 @@
+import type { Model } from '../old-constants';
+/**
+ * Check if a model is explicitly defined in the models constant object.
+ * This is used to determine if a model should allow fallbacks or support cache control.
+ * @param model - The model to check
+ * @returns boolean - True if the model is explicitly defined, false otherwise
+ */
+export declare function isExplicitlyDefinedModel(model: Model): boolean;

package/dist/common/src/util/object.d.ts

@@ -0,0 +1,22 @@
+type RemoveUndefined<T extends object> = {
+    [K in keyof T as T[K] extends undefined ? never : K]: Exclude<T[K], undefined>;
+};
+export declare const removeUndefinedProps: <T extends object>(obj: T) => RemoveUndefined<T>;
+export declare const removeNullOrUndefinedProps: <T extends object>(obj: T, exceptions?: string[]) => T;
+export declare const addObjects: <T extends {
+    [key: string]: number;
+}>(obj1: T, obj2: T) => T;
+export declare const subtractObjects: <T extends {
+    [key: string]: number;
+}>(obj1: T, obj2: T) => T;
+export declare const hasChanges: <T extends object>(obj: T, partial: Partial<T>) => boolean;
+export declare const hasSignificantDeepChanges: <T extends object>(obj: T, partial: Partial<T>, epsilonForNumbers: number) => boolean;
+export declare const filterObject: <T extends object>(obj: T, predicate: (value: any, key: keyof T) => boolean) => { [P in keyof T]: T[P]; };
+/**
+ * Asserts that a condition is true. If the condition is false, it throws an error with the provided message.
+ * @param condition The condition to check
+ * @param message The error message to display if the condition is false
+ * @throws {Error} If the condition is false
+ */
+export declare function assert(condition: boolean, message: string): asserts condition;
+export {};

package/dist/common/src/util/promise.d.ts

@@ -0,0 +1,16 @@
+export declare const INITIAL_RETRY_DELAY = 1000;
+export declare function withRetry<T>(operation: () => Promise<T>, options?: {
+    maxRetries?: number;
+    retryIf?: (error: any) => boolean;
+    onRetry?: (error: any, attempt: number) => void;
+    retryDelayMs?: number;
+}): Promise<T>;
+export declare const sleep: (ms: number) => Promise<unknown>;
+/**
+ * Wraps a promise with a timeout
+ * @param promise The promise to wrap
+ * @param timeoutMs Timeout in milliseconds
+ * @param timeoutMessage Optional message for the timeout error
+ * @returns A promise that resolves with the result of the original promise or rejects with a timeout error
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, timeoutMessage?: string): Promise<T>;

package/dist/common/src/util/random.d.ts

@@ -0,0 +1 @@
+export declare function sampleSizeWithSeed<T>(array: T[], size: number, seed: string): T[];

package/dist/common/src/util/skills.d.ts

@@ -0,0 +1,5 @@
+import type { SkillsMap } from '../types/skill';
+/**
+ * Formats available skills as XML for inclusion in tool descriptions.
+ */
+export declare function formatAvailableSkillsXml(skills: SkillsMap): string;

package/dist/common/src/util/stop-sequence.d.ts

@@ -0,0 +1,14 @@
+export declare class StopSequenceHandler {
+    private buffer;
+    private finished;
+    private stopSequences;
+    constructor(stopSequences?: string[]);
+    process(text: string): {
+        text: string;
+        endOfStream: boolean;
+    } | {
+        text: null;
+        endOfStream: true;
+    };
+    flush(): string;
+}