@crewai-ts/core 0.1.2 → 0.1.5

package/dist/agent.d.ts

@@ -0,0 +1,444 @@
+import { PlanningConfig, type PlanningConfigOptions } from "./agent-planning.js";
+import { CacheHandler, ToolsHandler } from "./tools.js";
+import { RpmController } from "./rpm.js";
+import { type UsageMetrics } from "./llm.js";
+import { Converter } from "./converter.js";
+import { Knowledge, type KnowledgeSource } from "./knowledge.js";
+import { type Fingerprint, type SecurityConfig } from "./security.js";
+import { type CheckpointConfig, type CheckpointOption } from "./state.js";
+import type { ExecutionContext } from "./context.js";
+import type { AgentStepCallback, InputValues, LLM, LLMMessage, Tool } from "./types.js";
+import { type Memory, type MemoryScope } from "./memory.js";
+import { type InputFiles } from "./input-files.js";
+import type { EmbedderConfig } from "./rag.js";
+import { type StandardPromptResult, type SystemPromptResult } from "./prompts.js";
+import { LiteAgentOutput } from "./lite-agent-output.js";
+export type AgentGuardrailResult = readonly [boolean, unknown] | {
+    success: boolean;
+    result?: unknown;
+    error?: unknown;
+};
+export type AgentGuardrail = (output: string) => AgentGuardrailResult | Promise<AgentGuardrailResult>;
+type ModelDumpOptions = {
+    mode?: string;
+    exclude?: ReadonlySet<string> | readonly string[] | Record<string, unknown>;
+};
+export type CodeExecutionMode = "safe" | "unsafe";
+export type AgentOptions = {
+    id?: string | null;
+    agent_id?: string | null;
+    role: string;
+    goal: string;
+    backstory: string;
+    config?: Record<string, unknown> | null;
+    llm?: LLM | string | null;
+    crew?: unknown;
+    functionCallingLlm?: LLM | string | null;
+    function_calling_llm?: LLM | string | null;
+    memory?: Memory | MemoryScope | null;
+    knowledge?: Knowledge | null;
+    knowledgeSources?: readonly KnowledgeSource[];
+    knowledge_sources?: readonly KnowledgeSource[];
+    knowledgeStorage?: unknown;
+    knowledge_storage?: unknown;
+    knowledgeConfig?: Record<string, unknown> | null;
+    knowledge_config?: Record<string, unknown> | null;
+    embedder?: EmbedderConfig | null;
+    agentKnowledgeContext?: string | null;
+    agent_knowledge_context?: string | null;
+    crewKnowledgeContext?: string | null;
+    crew_knowledge_context?: string | null;
+    knowledgeSearchQuery?: string | null;
+    knowledge_search_query?: string | null;
+    cache?: boolean;
+    cacheHandler?: CacheHandler | null;
+    cache_handler?: CacheHandler | null;
+    toolsHandler?: ToolsHandler | null;
+    tools_handler?: ToolsHandler | null;
+    toolsResults?: readonly Record<string, unknown>[];
+    tools_results?: readonly Record<string, unknown>[];
+    callbacks?: readonly ((...args: unknown[]) => unknown)[];
+    adaptedAgent?: boolean;
+    adapted_agent?: boolean;
+    apps?: readonly unknown[] | null;
+    mcps?: readonly unknown[] | null;
+    a2a?: unknown;
+    agentExecutor?: unknown;
+    agent_executor?: unknown;
+    executorClass?: unknown;
+    executor_class?: unknown;
+    maxTokens?: number | null;
+    max_tokens?: number | null;
+    fromRepository?: string | null;
+    from_repository?: string | null;
+    tools?: readonly Tool[];
+    verbose?: boolean;
+    allowDelegation?: boolean;
+    allow_delegation?: boolean;
+    allowCodeExecution?: boolean | null;
+    allow_code_execution?: boolean | null;
+    codeExecutionMode?: CodeExecutionMode;
+    code_execution_mode?: CodeExecutionMode;
+    respectContextWindow?: boolean;
+    respect_context_window?: boolean;
+    multimodal?: boolean;
+    maxIter?: number;
+    max_iter?: number;
+    maxRetryLimit?: number;
+    max_retry_limit?: number;
+    maxExecutionTime?: number | null;
+    max_execution_time?: number | null;
+    maxRpm?: number | null;
+    max_rpm?: number | null;
+    stepCallback?: AgentStepCallback | null;
+    step_callback?: AgentStepCallback | null;
+    useSystemPrompt?: boolean | null;
+    use_system_prompt?: boolean | null;
+    systemTemplate?: string | null;
+    system_template?: string | null;
+    promptTemplate?: string | null;
+    prompt_template?: string | null;
+    responseTemplate?: string | null;
+    response_template?: string | null;
+    injectDate?: boolean;
+    inject_date?: boolean;
+    dateFormat?: string;
+    date_format?: string;
+    guardrail?: AgentGuardrail | null;
+    guardrailMaxRetries?: number;
+    guardrail_max_retries?: number;
+    planning?: boolean;
+    planningConfig?: PlanningConfig | PlanningConfigOptions | null;
+    planning_config?: PlanningConfig | PlanningConfigOptions | null;
+    reasoning?: boolean;
+    maxReasoningAttempts?: number | null;
+    max_reasoning_attempts?: number | null;
+    skills?: readonly unknown[] | null;
+    securityConfig?: SecurityConfig | null;
+    security_config?: SecurityConfig | null;
+    checkpoint?: CheckpointOption;
+    executionContext?: ExecutionContext | null;
+    execution_context?: ExecutionContext | null;
+    checkpointKickoffEventId?: string | null;
+    checkpoint_kickoff_event_id?: string | null;
+    checkpointOriginalRole?: string | null;
+    checkpoint_original_role?: string | null;
+    checkpointOriginalGoal?: string | null;
+    checkpoint_original_goal?: string | null;
+    checkpointOriginalBackstory?: string | null;
+    checkpoint_original_backstory?: string | null;
+};
+export type AgentExecutionOptions = {
+    responseModel?: unknown;
+    responseFormat?: unknown;
+    response_format?: unknown;
+    stepCallbacks?: readonly AgentStepCallback[];
+    functionCallingLlm?: LLM | string | null;
+    memory?: Memory | MemoryScope | null;
+    knowledge?: Knowledge | null;
+    inputFiles?: InputFiles;
+    input_files?: InputFiles;
+    task?: unknown;
+};
+export type AgentKickoffInput = string | readonly LLMMessage[];
+export type AgentExecutionPromptBuild = readonly [
+    SystemPromptResult | StandardPromptResult,
+    string[],
+    (() => boolean) | null
+];
+export type AgentPreparedKickoff = readonly [
+    Record<string, unknown>,
+    Record<string, unknown>,
+    Record<string, unknown>,
+    readonly Tool[]
+];
+export declare class Agent {
+    readonly entityType = "agent";
+    readonly entity_type = "agent";
+    readonly id: string;
+    readonly agent_id: string;
+    role: string;
+    goal: string;
+    backstory: string;
+    readonly config: Record<string, unknown> | null;
+    readonly llm: LLM | string | null;
+    readonly crew: unknown;
+    readonly functionCallingLlm: LLM | string | null;
+    readonly function_calling_llm: LLM | string | null;
+    memory: Memory | MemoryScope | null;
+    knowledge: Knowledge | null;
+    readonly knowledgeSources: readonly KnowledgeSource[];
+    readonly knowledge_sources: readonly KnowledgeSource[];
+    readonly knowledgeStorage: unknown;
+    readonly knowledge_storage: unknown;
+    readonly knowledgeConfig: Record<string, unknown> | null;
+    readonly knowledge_config: Record<string, unknown> | null;
+    embedder: EmbedderConfig | null;
+    agentKnowledgeContext: string | null;
+    agent_knowledge_context: string | null;
+    crewKnowledgeContext: string | null;
+    crew_knowledge_context: string | null;
+    knowledgeSearchQuery: string | null;
+    knowledge_search_query: string | null;
+    readonly cache: boolean;
+    cacheHandler: CacheHandler | null;
+    cache_handler: CacheHandler | null;
+    toolsHandler: ToolsHandler;
+    tools_handler: ToolsHandler;
+    toolsResults: Record<string, unknown>[];
+    tools_results: Record<string, unknown>[];
+    callbacks: readonly ((...args: unknown[]) => unknown)[];
+    adaptedAgent: boolean;
+    adapted_agent: boolean;
+    apps: readonly unknown[] | null;
+    mcps: readonly unknown[] | null;
+    a2a: unknown;
+    agentExecutor: unknown;
+    agent_executor: unknown;
+    executorClass: unknown;
+    executor_class: unknown;
+    maxTokens: number | null;
+    max_tokens: number | null;
+    readonly fromRepository: string | null;
+    readonly from_repository: string | null;
+    readonly tools: readonly Tool[];
+    readonly verbose: boolean;
+    readonly allowDelegation: boolean;
+    readonly allow_delegation: boolean;
+    readonly allowCodeExecution: boolean;
+    readonly allow_code_execution: boolean;
+    readonly codeExecutionMode: CodeExecutionMode;
+    readonly code_execution_mode: CodeExecutionMode;
+    readonly respectContextWindow: boolean;
+    readonly respect_context_window: boolean;
+    readonly multimodal: boolean;
+    readonly maxIter: number;
+    readonly max_iter: number;
+    readonly maxRetryLimit: number;
+    readonly max_retry_limit: number;
+    readonly maxExecutionTime: number | null;
+    readonly max_execution_time: number | null;
+    readonly maxRpm: number | null;
+    readonly max_rpm: number | null;
+    readonly stepCallback: AgentStepCallback | null;
+    readonly step_callback: AgentStepCallback | null;
+    readonly useSystemPrompt: boolean;
+    readonly use_system_prompt: boolean;
+    readonly systemTemplate: string | null;
+    readonly system_template: string | null;
+    readonly promptTemplate: string | null;
+    readonly prompt_template: string | null;
+    readonly responseTemplate: string | null;
+    readonly response_template: string | null;
+    readonly injectDate: boolean;
+    readonly inject_date: boolean;
+    readonly dateFormat: string;
+    readonly date_format: string;
+    readonly guardrail: AgentGuardrail | null;
+    readonly guardrailMaxRetries: number;
+    readonly guardrail_max_retries: number;
+    readonly planning: boolean;
+    readonly reasoning: boolean;
+    readonly maxReasoningAttempts: number | null;
+    readonly max_reasoning_attempts: number | null;
+    readonly planningConfig: PlanningConfig | null;
+    readonly planning_config: PlanningConfig | null;
+    skills: readonly unknown[];
+    readonly securityConfig: SecurityConfig;
+    readonly security_config: SecurityConfig;
+    checkpoint: CheckpointConfig | false | null;
+    executionContext: ExecutionContext | null;
+    execution_context: ExecutionContext | null;
+    checkpointKickoffEventId: string | null;
+    checkpoint_kickoff_event_id: string | null;
+    checkpointOriginalRole: string | null;
+    checkpoint_original_role: string | null;
+    checkpointOriginalGoal: string | null;
+    checkpoint_original_goal: string | null;
+    checkpointOriginalBackstory: string | null;
+    checkpoint_original_backstory: string | null;
+    private readonly llmClient;
+    private readonly functionCallingLlmClient;
+    private rpmController;
+    private usageMetrics;
+    private lastMessagesValue;
+    constructor(options: AgentOptions);
+    get planningEnabled(): boolean;
+    get planning_enabled(): boolean;
+    get fingerprint(): Fingerprint;
+    get key(): string;
+    get lastMessages(): readonly LLMMessage[];
+    get last_messages(): readonly LLMMessage[];
+    toString(): string;
+    __repr__(): string;
+    getKnowledgeSearchQuery(taskPrompt: string, task: unknown): Promise<string | null>;
+    _get_knowledge_search_query(task_prompt: string, task: unknown): Promise<string | null>;
+    static fromCheckpoint(config: CheckpointConfig): Promise<Agent>;
+    static from_checkpoint(config: CheckpointConfig): Promise<Agent>;
+    static fork(config: CheckpointConfig, branch?: string | null): Promise<Agent>;
+    static coerceSkillStrings(skills: unknown): unknown;
+    static coerce_skill_strings(skills: unknown): unknown;
+    static processModelConfig(values: Record<string, unknown>): Record<string, unknown>;
+    static process_model_config(values: Record<string, unknown>): Record<string, unknown>;
+    static validateFromRepository(values: Record<string, unknown>): Record<string, unknown>;
+    static validate_from_repository(values: Record<string, unknown>): Record<string, unknown>;
+    setFingerprint(fingerprint: Fingerprint): void;
+    set_fingerprint(fingerprint: Fingerprint): void;
+    copy(): Agent;
+    modelDump(options?: ModelDumpOptions): Record<string, unknown>;
+    model_dump(options?: ModelDumpOptions): Record<string, unknown>;
+    setPrivateAttrs(): this;
+    postInitSetup(): this;
+    post_init_setup(): this;
+    set_private_attrs(): this;
+    validateTools(): this;
+    validate_tools(): this;
+    validateApps(): this;
+    validate_apps(): this;
+    validateMcps(): this;
+    validate_mcps(): this;
+    setupAgentExecutor(): void;
+    _setup_agent_executor(): void;
+    validateAndSetAttributes(): this;
+    validate_and_set_attributes(): this;
+    resolveMemory(): Memory | MemoryScope | null;
+    resolve_memory(): Memory | MemoryScope | null;
+    createKnowledgeFromSources(): Knowledge | null;
+    setKnowledge(knowledgeOrCrewEmbedder?: Knowledge | EmbedderConfig | null): void;
+    set_knowledge(knowledgeOrCrewEmbedder?: Knowledge | EmbedderConfig | null): void;
+    setRpmController(controller: RpmController | null): void;
+    set_rpm_controller(controller: RpmController | null): void;
+    isAnyAvailableMemory(): boolean;
+    _is_any_available_memory(): boolean;
+    supportsNativeToolCalling(tools: readonly Tool[]): boolean;
+    _supports_native_tool_calling(tools: readonly Tool[]): boolean;
+    getDelegationTools(): readonly Tool[];
+    get_delegation_tools(): readonly Tool[];
+    getPlatformTools(): readonly Tool[];
+    get_platform_tools(): readonly Tool[];
+    getMcpTools(): readonly Tool[];
+    get_mcp_tools(): readonly Tool[];
+    cleanupMcpClients(): Promise<void>;
+    _cleanup_mcp_clients(): Promise<void>;
+    executeWithoutTimeout(taskPrompt: string, task: unknown): Promise<unknown>;
+    _execute_without_timeout(task_prompt: string, task: unknown): Promise<unknown>;
+    executeWithTimeout(taskPrompt: string, task: unknown, timeout: number): Promise<unknown>;
+    _execute_with_timeout(task_prompt: string, task: unknown, timeout: number): Promise<unknown>;
+    aexecuteWithoutTimeout(taskPrompt: string, task: unknown): Promise<unknown>;
+    _aexecute_without_timeout(task_prompt: string, task: unknown): Promise<unknown>;
+    aexecuteWithTimeout(taskPrompt: string, task: unknown, timeout: number): Promise<unknown>;
+    _aexecute_with_timeout(task_prompt: string, task: unknown, timeout: number): Promise<unknown>;
+    retrieveMemoryContext(task: unknown, taskPrompt: string): string;
+    _retrieve_memory_context(task: unknown, task_prompt: string): string;
+    finalizeTaskPrompt(taskPrompt: string, _tools: readonly Tool[] | null, _task: unknown): string;
+    _finalize_task_prompt(task_prompt: string, tools: readonly Tool[] | null, task: unknown): string;
+    finalizeTaskExecution(task: unknown, result: unknown): Promise<unknown>;
+    _finalize_task_execution(task: unknown, result: unknown): Promise<unknown>;
+    checkExecutionError(error: unknown, task: unknown): void;
+    _check_execution_error(error: unknown, task: unknown): void;
+    private executorPayload;
+    getMultimodalTools(): readonly Tool[];
+    get_multimodal_tools(): readonly Tool[];
+    getCodeExecutionTools(): readonly Tool[];
+    get_code_execution_tools(): readonly Tool[];
+    _validateDockerInstallation(): void;
+    _validate_docker_installation(): void;
+    private emitCodeInterpreterDeprecationWarning;
+    static getOutputConverter(llm: unknown, text: string, model: unknown, instructions: string): Converter;
+    static get_output_converter(llm: unknown, text: string, model: unknown, instructions: string): Converter;
+    getOutputConverter(): null;
+    getOutputConverter(llm: unknown, text: string, model: unknown, instructions: string): Converter;
+    get_output_converter(): null;
+    get_output_converter(llm: unknown, text: string, model: unknown, instructions: string): Converter;
+    _training_handler(taskPrompt: string): string;
+    _use_trained_data(taskPrompt: string): string;
+    static renderTextDescription(tools: readonly Tool[]): string;
+    static _render_text_description(tools: readonly Tool[]): string;
+    _injectDateToTask(task: Record<string, unknown>): void;
+    _inject_date_to_task(task: Record<string, unknown>): void;
+    createAgentExecutor(): unknown;
+    create_agent_executor(): unknown;
+    prepareTaskExecution(task: unknown, context?: string | null): string;
+    _prepare_task_execution(task: unknown, context?: string | null): string;
+    handleExecutionError(error: unknown, task: unknown, context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    _handle_execution_error(error: unknown, task: unknown, context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    handleExecutionErrorAsync(error: unknown, task: unknown, context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    _handle_execution_error_async(error: unknown, task: unknown, context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    buildExecutionPrompt(rawTools: readonly Tool[]): AgentExecutionPromptBuild;
+    _build_execution_prompt(raw_tools: readonly Tool[]): AgentExecutionPromptBuild;
+    updateExecutorParameters(task: unknown, tools: readonly Tool[], rawTools: readonly Tool[], prompt: SystemPromptResult | StandardPromptResult, stopWords: readonly string[], rpmLimitFn: (() => boolean) | null): void;
+    _update_executor_parameters(task: unknown, tools: readonly Tool[], raw_tools: readonly Tool[], prompt: SystemPromptResult | StandardPromptResult, stop_words: readonly string[], rpm_limit_fn: (() => boolean) | null): void;
+    interpolateInputs(inputs: InputValues): void;
+    interpolate_inputs(inputs: InputValues): void;
+    executeTask(prompt: string, inputs?: InputValues, taskTools?: readonly Tool[], options?: AgentExecutionOptions): Promise<string>;
+    execute_task(promptOrOptions: string | {
+        task?: {
+            prompt?: () => string;
+            description?: string;
+        } | string;
+        context?: string | null;
+        tools?: readonly Tool[];
+    }, context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    aexecuteTask(prompt: string, inputs?: InputValues, tools?: readonly Tool[], options?: AgentExecutionOptions): Promise<string>;
+    aexecuteTask(promptOrOptions: Parameters<Agent["execute_task"]>[0], context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    aexecute_task(promptOrOptions: Parameters<Agent["execute_task"]>[0], context?: string | null, tools?: readonly Tool[]): Promise<string>;
+    private executeTaskWithRetries;
+    private executeTaskOnce;
+    kickoff(input: AgentKickoffInput, options?: AgentExecutionOptions): Promise<string | LiteAgentOutput>;
+    kickoffAsync(input: AgentKickoffInput, options?: AgentExecutionOptions): Promise<string | LiteAgentOutput>;
+    kickoff_async(input: AgentKickoffInput, options?: AgentExecutionOptions): Promise<string | LiteAgentOutput>;
+    akickoff(input: AgentKickoffInput, options?: AgentExecutionOptions): Promise<string | LiteAgentOutput>;
+    prepareKickoff(messages: AgentKickoffInput, responseFormat?: unknown, inputFiles?: InputFiles): AgentPreparedKickoff;
+    _prepare_kickoff(messages: AgentKickoffInput, response_format?: unknown, input_files?: InputFiles): AgentPreparedKickoff;
+    finalizeKickoff(output: LiteAgentOutput, executor: Record<string, unknown>, inputs: Record<string, unknown>, responseFormat: unknown, messages: AgentKickoffInput, agentInfo: Record<string, unknown>): LiteAgentOutput;
+    _finalize_kickoff(output: LiteAgentOutput, executor: Record<string, unknown>, inputs: Record<string, unknown>, response_format: unknown, messages: AgentKickoffInput, agent_info: Record<string, unknown>): LiteAgentOutput;
+    emitKickoffError(agentInfo: Record<string, unknown>, error: unknown): never;
+    _emit_kickoff_error(agent_info: Record<string, unknown>, error: unknown): never;
+    saveKickoffToMemory(messages: AgentKickoffInput, outputText: string): void;
+    _save_kickoff_to_memory(messages: AgentKickoffInput, output_text: string): void;
+    buildOutputFromResult(result: Record<string, unknown>, executor: Record<string, unknown>, responseFormat?: unknown): LiteAgentOutput;
+    _build_output_from_result(result: Record<string, unknown>, executor: Record<string, unknown>, response_format?: unknown): LiteAgentOutput;
+    executeAndBuildOutput(executor: Record<string, unknown>, inputs: Record<string, unknown>, responseFormat?: unknown): LiteAgentOutput;
+    _execute_and_build_output(executor: Record<string, unknown>, inputs: Record<string, unknown>, response_format?: unknown): LiteAgentOutput;
+    executeAndBuildOutputAsync(executor: Record<string, unknown>, inputs: Record<string, unknown>, responseFormat?: unknown): Promise<LiteAgentOutput>;
+    _execute_and_build_output_async(executor: Record<string, unknown>, inputs: Record<string, unknown>, response_format?: unknown): Promise<LiteAgentOutput>;
+    processKickoffGuardrail(output: LiteAgentOutput, executor: Record<string, unknown>, inputs: Record<string, unknown>, responseFormat?: unknown, retryCount?: number): LiteAgentOutput;
+    _process_kickoff_guardrail(output: LiteAgentOutput, executor: Record<string, unknown>, inputs: Record<string, unknown>, response_format?: unknown, retry_count?: number): LiteAgentOutput;
+    private kickoffAgentInfo;
+    getUsageMetrics(): UsageMetrics;
+    resetUsageMetrics(): void;
+    setCacheHandler(cacheHandler: CacheHandler): void;
+    set_cache_handler(cacheHandler: CacheHandler): void;
+    setSkills(resolvedCrewSkills?: readonly unknown[] | null): void;
+    set_skills(resolvedCrewSkills?: readonly unknown[] | null): void;
+    private resolveLLMClient;
+    private resolveFunctionCallingLLMClient;
+    private resolveLLMReference;
+    private resolvePlanningLLMClient;
+    private preparePromptWithPlanning;
+    private runPlanningLoop;
+    private emitReasoningStarted;
+    private emitReasoningCompleted;
+    private emitReasoningFailed;
+    private promptWithInjectedDate;
+    private promptWithMemoryContext;
+    private promptWithKnowledgeContext;
+    private saveResultToMemory;
+    private callAndTrackLLM;
+    private messagesWithInputFilesForClient;
+    private clientSupportsMultimodal;
+    private modelNameForClient;
+    private applyGuardrail;
+    private emitStep;
+    private buildMessages;
+    private renderSystemPrompt;
+    private renderUserPrompt;
+    private runToolCall;
+}
+export declare class AgentGuardrailError extends Error {
+    constructor(message: string);
+}
+export declare class AgentExecutionTimeoutError extends Error {
+    constructor(message: string);
+}
+export {};

package/dist/auth.d.ts

@@ -0,0 +1,179 @@
+export declare const ALGORITHMS: readonly ["RS256"];
+export declare class AuthError extends Error {
+    constructor(message: string);
+}
+export type TokenManagerOptions = {
+    filePath?: string;
+    file_path?: string;
+    storageDir?: string;
+    storage_dir?: string;
+};
+export declare class TokenManager {
+    readonly filePath: string;
+    readonly file_path: string;
+    readonly storageDir: string;
+    readonly storage_dir: string;
+    private readonly key;
+    constructor(filePathOrOptions?: string | TokenManagerOptions);
+    saveTokens(accessToken: string, expiresAt: number): void;
+    save_tokens(accessToken: string, expiresAt: number): void;
+    getToken(): string | null;
+    get_token(): string | null;
+    clearTokens(): void;
+    clear_tokens(): void;
+    private getOrCreateKey;
+    private atomicCreateSecureFile;
+    private atomicWriteSecureFile;
+    private readSecureFile;
+    private deleteSecureFile;
+}
+export declare function getAuthToken(tokenManager?: TokenManager): string;
+export declare const get_auth_token: typeof getAuthToken;
+export type Oauth2SettingsOptions = {
+    provider: string;
+    clientId?: string;
+    client_id?: string;
+    domain: string;
+    audience?: string | null;
+    extra?: Record<string, unknown>;
+};
+export declare class Oauth2Settings {
+    readonly provider: string;
+    readonly clientId: string;
+    readonly client_id: string;
+    readonly domain: string;
+    readonly audience: string | null;
+    readonly extra: Record<string, unknown>;
+    constructor(options: Oauth2SettingsOptions);
+    static fromSettings(settings: Oauth2SettingsOptions): Oauth2Settings;
+    static from_settings(settings: Oauth2SettingsOptions): Oauth2Settings;
+}
+export declare abstract class BaseProvider {
+    readonly settings: Oauth2Settings;
+    constructor(settings: Oauth2Settings);
+    abstract getAuthorizeUrl(): string;
+    abstract getTokenUrl(): string;
+    abstract getJwksUrl(): string;
+    abstract getIssuer(): string;
+    abstract getAudience(): string;
+    abstract getClientId(): string;
+    get_authorize_url(): string;
+    get_token_url(): string;
+    get_jwks_url(): string;
+    get_issuer(): string;
+    get_audience(): string;
+    get_client_id(): string;
+    getRequiredFields(): readonly string[];
+    get_required_fields(): readonly string[];
+    getOauthScopes(): readonly string[];
+    get_oauth_scopes(): readonly string[];
+}
+export declare class Auth0Provider extends BaseProvider {
+    getAuthorizeUrl(): string;
+    getTokenUrl(): string;
+    getJwksUrl(): string;
+    getIssuer(): string;
+    getAudience(): string;
+    getClientId(): string;
+    private domain;
+}
+export declare class WorkosProvider extends BaseProvider {
+    getAuthorizeUrl(): string;
+    getTokenUrl(): string;
+    getJwksUrl(): string;
+    getIssuer(): string;
+    getAudience(): string;
+    getClientId(): string;
+    private domain;
+}
+export declare class EntraIdProvider extends BaseProvider {
+    getAuthorizeUrl(): string;
+    getTokenUrl(): string;
+    getJwksUrl(): string;
+    getIssuer(): string;
+    getAudience(): string;
+    getClientId(): string;
+    getOauthScopes(): readonly string[];
+    getRequiredFields(): readonly string[];
+    private baseUrl;
+}
+export declare class KeycloakProvider extends BaseProvider {
+    getAuthorizeUrl(): string;
+    getTokenUrl(): string;
+    getJwksUrl(): string;
+    getIssuer(): string;
+    getAudience(): string;
+    getClientId(): string;
+    getRequiredFields(): readonly string[];
+    private baseUrl;
+}
+export declare class OktaProvider extends BaseProvider {
+    getAuthorizeUrl(): string;
+    getTokenUrl(): string;
+    getJwksUrl(): string;
+    getIssuer(): string;
+    getAudience(): string;
+    getClientId(): string;
+    getRequiredFields(): readonly string[];
+    private baseUrl;
+}
+export type ProviderConstructor = new (settings: Oauth2Settings) => BaseProvider;
+export declare const ProviderFactory: {
+    register(provider: string, providerClass: ProviderConstructor): void;
+    fromSettings(settings: Oauth2Settings): BaseProvider;
+    from_settings(settings: Oauth2Settings): BaseProvider;
+};
+export type DeviceCodeData = {
+    device_code: string;
+    user_code: string;
+    verification_uri?: string;
+    verification_uri_complete?: string;
+    interval?: number;
+};
+export type TokenResponseData = {
+    access_token?: string;
+    error?: string;
+    error_description?: string;
+    [key: string]: unknown;
+};
+export type AuthenticationCommandOptions = {
+    tokenManager?: TokenManager;
+    token_manager?: TokenManager;
+    oauth2Provider?: BaseProvider;
+    oauth2_provider?: BaseProvider;
+    fetch?: typeof fetch;
+    openBrowser?: (url: string) => unknown;
+    open_browser?: (url: string) => unknown;
+    maxAttempts?: number;
+    max_attempts?: number;
+};
+export declare class AuthenticationCommand {
+    readonly tokenManager: TokenManager;
+    readonly token_manager: TokenManager;
+    readonly oauth2Provider: BaseProvider;
+    readonly oauth2_provider: BaseProvider;
+    private readonly fetchImpl;
+    private readonly openBrowser;
+    private readonly maxAttempts;
+    constructor(options?: AuthenticationCommandOptions);
+    login(): Promise<void>;
+    private getDeviceCode;
+    private displayAuthInstructions;
+    private pollForToken;
+    private validateAndSaveToken;
+}
+export type ValidateJwtTokenOptions = {
+    jwtToken?: string;
+    jwt_token?: string;
+    jwksUrl?: string;
+    jwks_url?: string;
+    issuer: string;
+    audience: string;
+    fetch?: typeof fetch;
+    leewaySeconds?: number;
+    leeway_seconds?: number;
+};
+export declare function validateJwtToken(options: ValidateJwtTokenOptions): Promise<Record<string, unknown>>;
+export declare const validate_jwt_token: typeof validateJwtToken;
+export declare function createTemporaryTokenStorage(): string;
+export declare function constantTimeEquals(left: string, right: string): boolean;

package/dist/config-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function processConfig(values: Record<string, unknown>, modelClass: {
+    modelFields?: Record<string, unknown>;
+    model_fields?: Record<string, unknown>;
+}): Record<string, unknown>;
+export declare const process_config: typeof processConfig;

package/dist/content-processor.d.ts

@@ -0,0 +1,12 @@
+export type ContentProcessorProvider = {
+    process(content: string, context?: Record<string, unknown> | null): string;
+};
+export declare const ContentProcessorProvider: Readonly<{
+    kind: "ContentProcessorProvider";
+}>;
+export declare class NoOpContentProcessor implements ContentProcessorProvider {
+    process(content: string, _context?: Record<string, unknown> | null): string;
+}
+export declare function get_processor(): ContentProcessorProvider;
+export declare function set_processor(processor: ContentProcessorProvider): void;
+export declare function process_content(content: string, context?: Record<string, unknown> | null): string;