@crewai-ts/core 0.1.1 → 0.1.3

package/dist/rpm.d.ts

@@ -0,0 +1,27 @@
+export declare class RpmController {
+    readonly maxRpm: number;
+    private nextRequestAt;
+    private queue;
+    constructor(maxRpm: number);
+    waitForSlot(): Promise<void>;
+    reset(): void;
+}
+export declare class RPMController extends RpmController {
+    readonly max_rpm: number | null;
+    _current_rpm: number;
+    private rpmResetTimer;
+    private rpmShutdownFlag;
+    constructor(options?: number | {
+        maxRpm?: number | null;
+        max_rpm?: number | null;
+    });
+    checkOrWait(): boolean;
+    check_or_wait(): boolean;
+    _check_and_increment(): boolean;
+    resetCounter(): this;
+    reset_counter(): this;
+    stopRpmCounter(): void;
+    stop_rpm_counter(): void;
+    _wait_for_next_minute(): Promise<void>;
+    _reset_request_count(): void;
+}

package/dist/rw-lock.d.ts

@@ -0,0 +1,21 @@
+export declare class RWLock {
+    private readers;
+    private writer;
+    private readonly waiters;
+    rAcquire(): Promise<void>;
+    r_acquire(): Promise<void>;
+    rRelease(): void;
+    r_release(): void;
+    wAcquire(): Promise<void>;
+    w_acquire(): Promise<void>;
+    wRelease(): void;
+    w_release(): void;
+    withReadLock<T>(fn: () => T | Promise<T>): Promise<T>;
+    r_locked<T>(fn: () => T | Promise<T>): Promise<T>;
+    withWriteLock<T>(fn: () => T | Promise<T>): Promise<T>;
+    w_locked<T>(fn: () => T | Promise<T>): Promise<T>;
+    get activeReaders(): number;
+    get hasWriter(): boolean;
+    private hasWaitingWriter;
+    private drainWaiters;
+}

package/dist/schema-utils.d.ts

@@ -0,0 +1,121 @@
+export type JsonSchema = Record<string, unknown>;
+export interface JsonSchemaInfo {
+    name: string;
+    strict: true;
+    schema: JsonSchema;
+}
+export interface ModelDescription {
+    type: "json_schema";
+    json_schema: JsonSchemaInfo;
+}
+export declare const JsonSchemaInfo: {
+    new (options: {
+        name: string;
+        schema: JsonSchema;
+        strict?: true;
+    }): {
+        readonly name: string;
+        readonly strict: true;
+        readonly schema: JsonSchema;
+    };
+};
+export declare const ModelDescription: {
+    new (options: {
+        json_schema: InstanceType<typeof JsonSchemaInfo> | {
+            name: string;
+            schema: JsonSchema;
+            strict?: true;
+        };
+    }): {
+        readonly type: "json_schema";
+        readonly json_schema: InstanceType<typeof JsonSchemaInfo>;
+    };
+};
+export declare const FORMAT_TYPE_MAP: {
+    readonly "date-time": "string";
+    readonly date: "string";
+    readonly time: "string";
+    readonly duration: "string";
+};
+export declare const OPENAI_SUPPORTED_FORMATS: Set<"time" | "date" | "date-time" | "duration">;
+export declare function resolveRefs(schema: JsonSchema): JsonSchema;
+export declare function addKeyInDictRecursively(schema: JsonSchema, key: string, value: unknown, criteria: (schema: JsonSchema) => boolean): JsonSchema;
+export declare function forceAdditionalPropertiesFalse<T>(schema: T): T;
+export declare function stripUnsupportedFormats<T>(schema: T): T;
+export declare function ensureTypeInSchemas<T>(schema: T): T;
+export declare function fixDiscriminatorMappings(schema: JsonSchema): JsonSchema;
+export declare function addConstToOneOfVariants(schema: JsonSchema): JsonSchema;
+export declare function convertOneOfToAnyOf(schema: JsonSchema): JsonSchema;
+export declare function ensureAllPropertiesRequired(schema: JsonSchema): JsonSchema;
+export declare function stripNullFromTypes(schema: JsonSchema): JsonSchema;
+declare function stripKeysRecursive<T>(schema: T, keys: readonly string[]): T;
+export declare const _strip_keys_recursive: typeof stripKeysRecursive;
+export declare function liftTopLevelAnyOf(schema: JsonSchema): JsonSchema;
+declare function commonStrictPipeline(params: JsonSchema): JsonSchema;
+export declare const _common_strict_pipeline: typeof commonStrictPipeline;
+export declare function sanitizeToolParamsForOpenAIStrict<T>(params: T): T;
+export declare function sanitizeToolParamsForAnthropicStrict<T>(params: T): T;
+export declare function sanitizeToolParamsForBedrockStrict<T>(params: T): T;
+export declare function buildRichFieldDescription(propSchema: JsonSchema): string;
+export declare function _inline_top_level_ref(schema: JsonSchema, rootSchema?: JsonSchema): JsonSchema;
+export declare function _process_oneof(schema: JsonSchema): JsonSchema;
+export declare function generateModelDescription(name: string, schema: JsonSchema, options?: {
+    stripNullTypes?: boolean;
+}): ModelDescription;
+export declare const resolve_refs: typeof resolveRefs;
+export declare const add_key_in_dict_recursively: typeof addKeyInDictRecursively;
+export declare const force_additional_properties_false: typeof forceAdditionalPropertiesFalse;
+export declare const strip_unsupported_formats: typeof stripUnsupportedFormats;
+export declare const ensure_type_in_schemas: typeof ensureTypeInSchemas;
+export declare const fix_discriminator_mappings: typeof fixDiscriminatorMappings;
+export declare const add_const_to_oneof_variants: typeof addConstToOneOfVariants;
+export declare const convert_oneof_to_anyof: typeof convertOneOfToAnyOf;
+export declare const ensure_all_properties_required: typeof ensureAllPropertiesRequired;
+export declare const strip_null_from_types: typeof stripNullFromTypes;
+export declare const lift_top_level_anyof: typeof liftTopLevelAnyOf;
+export declare const sanitize_tool_params_for_openai_strict: typeof sanitizeToolParamsForOpenAIStrict;
+export declare const sanitize_tool_params_for_anthropic_strict: typeof sanitizeToolParamsForAnthropicStrict;
+export declare const sanitize_tool_params_for_bedrock_strict: typeof sanitizeToolParamsForBedrockStrict;
+export declare const build_rich_field_description: typeof buildRichFieldDescription;
+export declare const generate_model_description: typeof generateModelDescription;
+export declare function serializeModelClass(model: unknown): JsonSchema;
+export declare const serialize_model_class: typeof serializeModelClass;
+export type SchemaModelField = {
+    name: string;
+    required: boolean;
+    description: string | null;
+    schema: JsonSchema;
+    annotation?: CreatedSchemaModel;
+};
+export type CreatedSchemaModel = {
+    name: string;
+    __name__: string;
+    schema: JsonSchema;
+    model_fields: Record<string, SchemaModelField>;
+    modelFields: Record<string, SchemaModelField>;
+    modelValidate(value: unknown): unknown;
+    model_validate(value: unknown): unknown;
+};
+type CreateModelOptions = {
+    rootSchema?: JsonSchema | null;
+    root_schema?: JsonSchema | null;
+    modelName?: string | null;
+    model_name?: string | null;
+    enrichDescriptions?: boolean;
+    enrich_descriptions?: boolean;
+};
+export declare function createModelFromSchema(schemaOrName: JsonSchema | string, schemaOrOptions?: JsonSchema | CreateModelOptions, maybeOptions?: CreateModelOptions): CreatedSchemaModel;
+export declare const create_model_from_schema: typeof createModelFromSchema;
+export declare function _resolve_ref(ref: string, rootSchema: JsonSchema): JsonSchema;
+export declare function _merge_all_of_schemas(schemas: readonly JsonSchema[], rootSchema?: JsonSchema): JsonSchema;
+export declare function _json_schema_to_pydantic_type(schema: JsonSchema): string;
+export declare function _json_schema_to_pydantic_field(name: string, schema: JsonSchema, required?: readonly string[]): {
+    name: string;
+    type: string;
+    required: boolean;
+    schema: JsonSchema;
+};
+export declare function _build_model_from_schema(schema: JsonSchema, _effectiveRoot?: JsonSchema, options?: {
+    model_name?: string | null;
+}): ReturnType<typeof createModelFromSchema>;
+export {};

package/dist/security.d.ts

@@ -0,0 +1,66 @@
+export declare const CREW_AI_NAMESPACE = "f47ac10b-58cc-4372-a567-0e02b2c3d479";
+export type FingerprintMetadata = Record<string, unknown>;
+export type FingerprintOptions = {
+    metadata?: FingerprintMetadata;
+};
+export type FingerprintDict = {
+    uuid_str?: string;
+    uuidStr?: string;
+    created_at?: string;
+    createdAt?: string;
+    metadata?: FingerprintMetadata;
+};
+export declare class Fingerprint {
+    private uuidValue;
+    private createdAtValue;
+    metadata: FingerprintMetadata;
+    constructor(options?: FingerprintOptions);
+    get uuidStr(): string;
+    get uuid_str(): string;
+    get createdAt(): Date;
+    get created_at(): Date;
+    get uuid(): string;
+    static generate(seed?: string | null, metadata?: FingerprintMetadata | null): Fingerprint;
+    static generateUuid(seed: string): string;
+    static _generate_uuid(seed: string): string;
+    static fromDict(data: FingerprintDict | null | undefined): Fingerprint;
+    static from_dict(data: FingerprintDict | null | undefined): Fingerprint;
+    toDict(): Required<Pick<FingerprintDict, "metadata">> & {
+        uuid_str: string;
+        created_at: string;
+    };
+    to_dict(): Required<Pick<FingerprintDict, "metadata">> & {
+        uuid_str: string;
+        created_at: string;
+    };
+    equals(other: unknown): boolean;
+    __eq__(other: unknown): boolean;
+    __hash__(): number;
+    toString(): string;
+    __str__(): string;
+}
+export type SecurityConfigOptions = {
+    fingerprint?: Fingerprint | FingerprintDict | string | null;
+};
+export declare class SecurityConfig {
+    fingerprint: Fingerprint;
+    constructor(options?: SecurityConfigOptions);
+    static validateFingerprint(value?: Fingerprint | FingerprintDict | string | null): Fingerprint;
+    static validate_fingerprint(value?: Fingerprint | FingerprintDict | string | null): Fingerprint;
+    static fromDict(data: {
+        fingerprint?: FingerprintDict | null;
+    } | null | undefined): SecurityConfig;
+    static from_dict(data: {
+        fingerprint?: FingerprintDict | null;
+    } | null | undefined): SecurityConfig;
+    cloneWithNewFingerprint(): SecurityConfig;
+    toDict(): {
+        fingerprint: ReturnType<Fingerprint["toDict"]>;
+    };
+    to_dict(): {
+        fingerprint: ReturnType<Fingerprint["toDict"]>;
+    };
+}
+export declare function coerceSecurityConfig(value?: SecurityConfig | SecurityConfigOptions | null): SecurityConfig;
+export declare function validateMetadata(metadata: unknown): FingerprintMetadata;
+export declare const _validate_metadata: typeof validateMetadata;

package/dist/settings.d.ts

@@ -0,0 +1,103 @@
+import { TokenManager } from "./auth.js";
+export declare const CREWAI_TRAINED_AGENTS_FILE_ENV = "CREWAI_TRAINED_AGENTS_FILE";
+export declare const TRAINING_DATA_FILE = "training_data.pkl";
+export declare const TRAINED_AGENTS_DATA_FILE = "trained_agents_data.pkl";
+export declare const KNOWLEDGE_DIRECTORY = "knowledge";
+export declare const MAX_FILE_NAME_LENGTH = 255;
+export declare const EMITTER_COLOR = "bold_blue";
+export declare const CC_ENV_VAR = "CLAUDECODE";
+export declare const CODEX_ENV_VARS: readonly ["CODEX_CI", "CODEX_MANAGED_BY_NPM", "CODEX_SANDBOX", "CODEX_SANDBOX_NETWORK_DISABLED", "CODEX_THREAD_ID"];
+export declare const CURSOR_ENV_VARS: readonly ["CURSOR_AGENT", "CURSOR_EXTENSION_HOST_ROLE", "CURSOR_SANDBOX", "CURSOR_TRACE_ID", "CURSOR_WORKSPACE_LABEL"];
+export declare class _NotSpecified {
+    toString(): string;
+    toJSON(): string;
+    static __get_pydantic_core_schema__(): {
+        type: "plain-validator";
+        validator: (value: unknown) => _NotSpecified;
+        serialization: {
+            type: "plain-serializer";
+            serializer: () => string;
+        };
+    };
+}
+export declare const NotSpecified: typeof _NotSpecified;
+export declare const NOT_SPECIFIED: _NotSpecified;
+export declare const DEFAULT_CREWAI_ENTERPRISE_URL = "https://app.crewai.com";
+export declare const CREWAI_ENTERPRISE_DEFAULT_OAUTH2_PROVIDER = "workos";
+export declare const CREWAI_ENTERPRISE_DEFAULT_OAUTH2_AUDIENCE = "client_01JNJQWBJ4SPFN3SWJM5T7BDG8";
+export declare const CREWAI_ENTERPRISE_DEFAULT_OAUTH2_CLIENT_ID = "client_01JYT06R59SP0NXYGD994NFXXX";
+export declare const CREWAI_ENTERPRISE_DEFAULT_OAUTH2_DOMAIN = "login.crewai.com";
+export declare const DEFAULT_CONFIG_PATH: string;
+export declare const USER_SETTINGS_KEYS: readonly ["tool_repository_username", "tool_repository_password", "org_name", "org_uuid"];
+export declare const CLI_SETTINGS_KEYS: readonly ["enterprise_base_url", "oauth2_provider", "oauth2_audience", "oauth2_client_id", "oauth2_domain", "oauth2_extra"];
+export declare const DEFAULT_CLI_SETTINGS: {
+    readonly enterprise_base_url: "https://app.crewai.com";
+    readonly oauth2_provider: "workos";
+    readonly oauth2_audience: "client_01JNJQWBJ4SPFN3SWJM5T7BDG8";
+    readonly oauth2_client_id: "client_01JYT06R59SP0NXYGD994NFXXX";
+    readonly oauth2_domain: "login.crewai.com";
+    readonly oauth2_extra: {};
+};
+export declare const READONLY_SETTINGS_KEYS: readonly ["org_name", "org_uuid"];
+export declare const HIDDEN_SETTINGS_KEYS: readonly ["config_path", "tool_repository_username", "tool_repository_password"];
+export type SettingsData = {
+    enterprise_base_url?: string | null;
+    tool_repository_username?: string | null;
+    tool_repository_password?: string | null;
+    org_name?: string | null;
+    org_uuid?: string | null;
+    oauth2_provider?: string;
+    oauth2_audience?: string | null;
+    oauth2_client_id?: string;
+    oauth2_domain?: string;
+    oauth2_extra?: Record<string, unknown>;
+};
+export type SettingsOptions = SettingsData & {
+    configPath?: string | null;
+    config_path?: string | null;
+    tokenManager?: TokenManager;
+    token_manager?: TokenManager;
+};
+export declare class Settings {
+    enterprise_base_url: string | null;
+    tool_repository_username: string | null;
+    tool_repository_password: string | null;
+    org_name: string | null;
+    org_uuid: string | null;
+    readonly config_path: string;
+    readonly configPath: string;
+    oauth2_provider: string;
+    oauth2_audience: string | null;
+    oauth2_client_id: string;
+    oauth2_domain: string;
+    oauth2_extra: Record<string, unknown>;
+    private readonly tokenManager;
+    constructor(options?: SettingsOptions);
+    clearUserSettings(): void;
+    clear_user_settings(): void;
+    reset(): void;
+    dump(): void;
+    toJSON(): SettingsData;
+    private resetUserSettings;
+    private resetCliSettings;
+    private clearAuthTokens;
+}
+export declare function getWritableConfigPath(): string | null;
+export declare const get_writable_config_path: typeof getWritableConfigPath;
+export declare function getProjectDirectoryName(): string;
+export declare const get_project_directory_name: typeof getProjectDirectoryName;
+export declare function dbStoragePath(): string;
+export declare const db_storage_path: typeof dbStoragePath;
+export type UserData = Record<string, unknown>;
+export declare function userDataFile(): string;
+export declare const user_data_file: typeof userDataFile;
+export declare function loadUserData(): UserData;
+export declare const load_user_data: typeof loadUserData;
+export declare function saveUserData(data: UserData): void;
+export declare const save_user_data: typeof saveUserData;
+export declare function updateUserData(updates: UserData): void;
+export declare const update_user_data: typeof updateUserData;
+export declare function hasUserDeclinedTracing(): boolean;
+export declare const has_user_declined_tracing: typeof hasUserDeclinedTracing;
+export declare function isTracingEnabled(): boolean;
+export declare const is_tracing_enabled: typeof isTracingEnabled;

package/dist/skills.d.ts

@@ -0,0 +1,145 @@
+export declare const SKILL_FILENAME = "SKILL.md";
+export declare const MAX_SKILL_NAME_LENGTH = 64;
+export declare const MIN_SKILL_NAME_LENGTH = 1;
+export declare const MAX_DESCRIPTION_LENGTH = 1024;
+export declare const SKILL_NAME_PATTERN: RegExp;
+export declare const METADATA = 1;
+export declare const INSTRUCTIONS = 2;
+export declare const RESOURCES = 3;
+export declare const ENV_VAR = "CREWAI_EXPERIMENTAL";
+export type DisclosureLevel = typeof METADATA | typeof INSTRUCTIONS | typeof RESOURCES;
+export declare const DisclosureLevel: Readonly<{
+    METADATA: 1;
+    INSTRUCTIONS: 2;
+    RESOURCES: 3;
+}>;
+export type ResourceDirName = "scripts" | "references" | "assets";
+export declare const ResourceDirName: readonly ["scripts", "references", "assets"];
+export type SkillMetadata = {
+    org: string;
+    name: string;
+    version: string | null;
+    installed_at: string;
+};
+export declare const SkillMetadata: Readonly<{
+    kind: "SkillMetadata";
+}>;
+export type SkillFrontmatterOptions = {
+    name: string;
+    description: string;
+    license?: string | null;
+    compatibility?: string | null;
+    metadata?: Record<string, string> | null;
+    allowedTools?: readonly string[] | string | null;
+    allowed_tools?: readonly string[] | string | null;
+    "allowed-tools"?: readonly string[] | string | null;
+    version?: string | null;
+};
+export declare class SkillParseError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class SkillNotCachedError extends Error {
+    readonly ref: string;
+    constructor(ref: string);
+}
+export declare class ExperimentalFeatureDisabledError extends Error {
+    constructor();
+}
+export declare class SkillFrontmatter {
+    readonly name: string;
+    readonly description: string;
+    readonly license: string | null;
+    readonly compatibility: string | null;
+    readonly metadata: Record<string, string> | null;
+    readonly allowedTools: readonly string[] | null;
+    readonly allowed_tools: readonly string[] | null;
+    readonly version: string | null;
+    constructor(options: SkillFrontmatterOptions);
+    static parseAllowedTools<TValues extends Record<string, unknown>>(values: TValues): TValues & {
+        "allowed-tools"?: readonly string[] | null;
+    };
+    static parse_allowed_tools<TValues extends Record<string, unknown>>(values: TValues): TValues & {
+        "allowed-tools"?: readonly string[] | null;
+    };
+}
+export declare class Skill {
+    readonly frontmatter: SkillFrontmatter;
+    readonly instructions: string | null;
+    readonly path: string;
+    readonly disclosureLevel: DisclosureLevel;
+    readonly disclosure_level: DisclosureLevel;
+    readonly resourceFiles: Partial<Record<ResourceDirName, readonly string[]>> | null;
+    readonly resource_files: Partial<Record<ResourceDirName, readonly string[]>> | null;
+    constructor(options: {
+        frontmatter: SkillFrontmatter;
+        path: string;
+        instructions?: string | null;
+        disclosureLevel?: DisclosureLevel;
+        disclosure_level?: DisclosureLevel;
+        resourceFiles?: Partial<Record<ResourceDirName, readonly string[]>> | null;
+        resource_files?: Partial<Record<ResourceDirName, readonly string[]>> | null;
+    });
+    get name(): string;
+    get description(): string;
+    get scriptsDir(): string;
+    get scripts_dir(): string;
+    get referencesDir(): string;
+    get references_dir(): string;
+    get assetsDir(): string;
+    get assets_dir(): string;
+    withDisclosureLevel(level: DisclosureLevel, options?: {
+        instructions?: string | null;
+        resourceFiles?: Partial<Record<ResourceDirName, readonly string[]>> | null;
+        resource_files?: Partial<Record<ResourceDirName, readonly string[]>> | null;
+    }): Skill;
+    with_disclosure_level(level: DisclosureLevel, instructions?: string | null, resource_files?: Partial<Record<ResourceDirName, readonly string[]>> | null): Skill;
+}
+export declare class SkillCacheManager {
+    private readonly root;
+    constructor(cacheRoot?: string | null);
+    getCachedPath(org: string, name: string): string | null;
+    get_cached_path(org: string, name: string): string | null;
+    _skill_dir(org: string, name: string): string;
+    storeDirectory(org: string, name: string, version: string | null, sourceDirectory: string): string;
+    store_directory(org: string, name: string, version: string | null, source_directory: string): string;
+    store(org: string, name: string, version: string | null, archiveBytes: Uint8Array): string;
+    listCached(): SkillMetadata[];
+    list_cached(): SkillMetadata[];
+    invalidate(org: string, name: string): boolean;
+    private skillDir;
+    private writeMetadata;
+}
+export declare function parseFrontmatter(content: string): [frontmatter: Record<string, unknown>, body: string];
+export declare const parse_frontmatter: typeof parseFrontmatter;
+export declare function parseSkillMd(path: string): [frontmatter: SkillFrontmatter, body: string];
+export declare const parse_skill_md: typeof parseSkillMd;
+export declare function loadSkillMetadata(skillDir: string): Skill;
+export declare const load_skill_metadata: typeof loadSkillMetadata;
+export declare function loadSkillInstructions(skill: Skill): Skill;
+export declare const load_skill_instructions: typeof loadSkillInstructions;
+export declare function loadSkillResources(skill: Skill): Skill;
+export declare const load_skill_resources: typeof loadSkillResources;
+export declare const loadResources: typeof loadSkillResources;
+export declare const load_resources: typeof loadSkillResources;
+export declare function discoverSkills(searchPath: string, source?: unknown): Skill[];
+export declare const discover_skills: typeof discoverSkills;
+export declare function activateSkill(skill: Skill, source?: unknown): Skill;
+export declare const activate_skill: typeof activateSkill;
+export declare function formatSkillContext(skill: Skill): string;
+export declare const format_skill_context: typeof formatSkillContext;
+export declare function validateDirectoryName(skillDir: string, skillName: string): void;
+export declare const validate_directory_name: typeof validateDirectoryName;
+export declare function isRegistryRef(value: unknown): value is string;
+export declare const is_registry_ref: typeof isRegistryRef;
+export declare function is_enabled(): boolean;
+export declare function _is_noninteractive(): boolean;
+export declare function require_experimental_skills(): void;
+export declare function parseRegistryRef(ref: string): [org: string, name: string];
+export declare const parse_registry_ref: typeof parseRegistryRef;
+export declare function resolveRegistryRef(ref: string, source?: unknown, options?: {
+    cacheRoot?: string | null;
+    cwd?: string;
+}): Skill;
+export declare const resolve_registry_ref: typeof resolveRegistryRef;
+export declare function _safe_extractall(archiveBytes: Uint8Array, destination: string): void;
+export declare function _safe_extract_zip(zipArchive: Uint8Array, destination: string): void;

package/dist/state-provider-core.d.ts

@@ -1 +1 @@
-export { aq as BaseProvider } from './state-provider-core-Be9RKRAm.js';
+export { BaseProvider } from "./state.js";