@crewai-ts/core 0.1.1 → 0.1.3

package/dist/plus-api.d.ts

@@ -0,0 +1,194 @@
+import { Settings } from "./settings.js";
+export type HttpMethod = "GET" | "POST" | "PATCH" | "DELETE";
+export type AvailableExport = {
+    name: string;
+};
+export type EnvVarEntry = {
+    name: string;
+    description: string;
+    required: boolean;
+    default: string | null;
+};
+export type ToolMetadata = {
+    name: string;
+    module: string;
+    humanized_name: string;
+    description: string;
+    run_params_schema: Record<string, unknown>;
+    init_params_schema: Record<string, unknown>;
+    env_vars: readonly EnvVarEntry[];
+};
+export type ToolsMetadataPayload = {
+    package: string;
+    tools: readonly ToolMetadata[] | null;
+};
+export type PublishToolPayload = {
+    handle: string;
+    public: boolean;
+    version: string;
+    file: string;
+    description: string | null;
+    available_exports: readonly AvailableExport[] | null;
+    tools_metadata: ToolsMetadataPayload | null;
+};
+export type CrewDeploymentSpec = {
+    name: string;
+    repo_clone_url: string;
+    env: Record<string, string>;
+};
+export type CreateCrewPayload = {
+    deploy: CrewDeploymentSpec;
+};
+export type TraceExecutionContext = {
+    crew_fingerprint: string | null;
+    crew_name: string | null;
+    flow_name: string | null;
+    crewai_version: string;
+    privacy_level: string;
+};
+export type TraceExecutionMetadata = {
+    expected_duration_estimate: number;
+    agent_count: number;
+    task_count: number;
+    flow_method_count: number;
+    execution_started_at: string;
+};
+export type TraceBatchInitPayload = {
+    user_identifier?: string;
+    trace_id: string;
+    execution_type: string;
+    execution_context: TraceExecutionContext;
+    execution_metadata: TraceExecutionMetadata;
+    ephemeral_trace_id?: string;
+};
+export type TraceBatchMetadata = {
+    events_count: number;
+    batch_sequence: number;
+    is_final_batch: boolean;
+};
+export type TraceEventsPayload = {
+    events: readonly Record<string, unknown>[];
+    batch_metadata: TraceBatchMetadata;
+};
+export type TraceFinalizePayload = {
+    status: "completed";
+    duration_ms: number | null;
+    final_event_count: number;
+};
+export type TraceFailedPayload = {
+    status: "failed";
+    failure_reason: string;
+};
+export type PlusApiResponse<T = unknown> = {
+    status: number;
+    ok: boolean;
+    headers: Headers;
+    json(): Promise<T>;
+    text(): Promise<string>;
+};
+export type PlusAPIOptions = {
+    apiKey?: string | null;
+    api_key?: string | null;
+    baseUrl?: string | null;
+    base_url?: string | null;
+    settings?: Settings;
+    fetch?: typeof fetch;
+    version?: string;
+};
+type MakeRequestOptions = {
+    json?: unknown;
+    params?: Record<string, string> | null;
+    timeout?: number | null;
+    verify?: boolean;
+};
+export declare class PlusAPI {
+    static readonly TOOLS_RESOURCE = "/crewai_plus/api/v1/tools";
+    static readonly SKILLS_RESOURCE = "/crewai_plus/api/v1/skills";
+    static readonly ORGANIZATIONS_RESOURCE = "/crewai_plus/api/v1/me/organizations";
+    static readonly CREWS_RESOURCE = "/crewai_plus/api/v1/crews";
+    static readonly AGENTS_RESOURCE = "/crewai_plus/api/v1/agents";
+    static readonly TRACING_RESOURCE = "/crewai_plus/api/v1/tracing";
+    static readonly EPHEMERAL_TRACING_RESOURCE = "/crewai_plus/api/v1/tracing/ephemeral";
+    static readonly INTEGRATIONS_RESOURCE = "/crewai_plus/api/v1/integrations";
+    readonly apiKey: string | null;
+    readonly api_key: string | null;
+    readonly headers: Record<string, string>;
+    readonly baseUrl: string;
+    readonly base_url: string;
+    private readonly fetchImpl;
+    constructor(options?: PlusAPIOptions | string | null);
+    makeRequest<T = unknown>(method: HttpMethod, endpoint: string, options?: MakeRequestOptions): Promise<PlusApiResponse<T>>;
+    _make_request<T = unknown>(method: HttpMethod, endpoint: string, options?: MakeRequestOptions): Promise<PlusApiResponse<T>>;
+    loginToToolRepository(userIdentifier?: string | null): Promise<PlusApiResponse<unknown>>;
+    login_to_tool_repository(userIdentifier?: string | null): Promise<PlusApiResponse<unknown>>;
+    getTool(handle: string): Promise<PlusApiResponse<unknown>>;
+    get_tool(handle: string): Promise<PlusApiResponse<unknown>>;
+    getAgent(handle: string): Promise<PlusApiResponse<unknown>>;
+    get_agent(handle: string): Promise<PlusApiResponse<unknown>>;
+    publishTool(handle: string, isPublic: boolean, version: string, description: string | null, encodedFile: string, availableExports?: readonly AvailableExport[] | null, toolsMetadata?: readonly ToolMetadata[] | null): Promise<PlusApiResponse<unknown>>;
+    publish_tool(handle: string, isPublic: boolean, version: string, description: string | null, encodedFile: string, availableExports?: readonly AvailableExport[] | null, toolsMetadata?: readonly ToolMetadata[] | null): Promise<PlusApiResponse<unknown>>;
+    getSkill(org: string, name: string, version?: string | null): Promise<PlusApiResponse<unknown>>;
+    get_skill(org: string, name: string, version?: string | null): Promise<PlusApiResponse<unknown>>;
+    publishSkill(org: string, name: string, version: string, isPublic: boolean, description: string | null, encodedFile: string): Promise<PlusApiResponse<unknown>>;
+    publish_skill(org: string, name: string, version: string, isPublic: boolean, description: string | null, encodedFile: string): Promise<PlusApiResponse<unknown>>;
+    listSkills(org?: string | null): Promise<PlusApiResponse<unknown>>;
+    list_skills(org?: string | null): Promise<PlusApiResponse<unknown>>;
+    deployByName(projectName: string): Promise<PlusApiResponse<unknown>>;
+    deploy_by_name(projectName: string): Promise<PlusApiResponse<unknown>>;
+    deployByUuid(uuid: string): Promise<PlusApiResponse<unknown>>;
+    deploy_by_uuid(uuid: string): Promise<PlusApiResponse<unknown>>;
+    crewStatusByName(projectName: string): Promise<PlusApiResponse<unknown>>;
+    crew_status_by_name(projectName: string): Promise<PlusApiResponse<unknown>>;
+    crewStatusByUuid(uuid: string): Promise<PlusApiResponse<unknown>>;
+    crew_status_by_uuid(uuid: string): Promise<PlusApiResponse<unknown>>;
+    crewByName(projectName: string, logType?: string): Promise<PlusApiResponse<unknown>>;
+    crew_by_name(projectName: string, logType?: string): Promise<PlusApiResponse<unknown>>;
+    crewByUuid(uuid: string, logType?: string): Promise<PlusApiResponse<unknown>>;
+    crew_by_uuid(uuid: string, logType?: string): Promise<PlusApiResponse<unknown>>;
+    deleteCrewByName(projectName: string): Promise<PlusApiResponse<unknown>>;
+    delete_crew_by_name(projectName: string): Promise<PlusApiResponse<unknown>>;
+    deleteCrewByUuid(uuid: string): Promise<PlusApiResponse<unknown>>;
+    delete_crew_by_uuid(uuid: string): Promise<PlusApiResponse<unknown>>;
+    listCrews(): Promise<PlusApiResponse<unknown>>;
+    list_crews(): Promise<PlusApiResponse<unknown>>;
+    createCrew(payload: CreateCrewPayload): Promise<PlusApiResponse<unknown>>;
+    create_crew(payload: CreateCrewPayload): Promise<PlusApiResponse<unknown>>;
+    getOrganizations(): Promise<PlusApiResponse<unknown>>;
+    get_organizations(): Promise<PlusApiResponse<unknown>>;
+    initializeTraceBatch(payload: TraceBatchInitPayload): Promise<PlusApiResponse<unknown>>;
+    initialize_trace_batch(payload: TraceBatchInitPayload): Promise<PlusApiResponse<unknown>>;
+    initializeEphemeralTraceBatch(payload: TraceBatchInitPayload): Promise<PlusApiResponse<unknown>>;
+    initialize_ephemeral_trace_batch(payload: TraceBatchInitPayload): Promise<PlusApiResponse<unknown>>;
+    sendTraceEvents(traceBatchId: string, payload: TraceEventsPayload): Promise<PlusApiResponse<unknown>>;
+    send_trace_events(traceBatchId: string, payload: TraceEventsPayload): Promise<PlusApiResponse<unknown>>;
+    sendEphemeralTraceEvents(traceBatchId: string, payload: TraceEventsPayload): Promise<PlusApiResponse<unknown>>;
+    send_ephemeral_trace_events(traceBatchId: string, payload: TraceEventsPayload): Promise<PlusApiResponse<unknown>>;
+    finalizeTraceBatch(traceBatchId: string, payload: TraceFinalizePayload): Promise<PlusApiResponse<unknown>>;
+    finalize_trace_batch(traceBatchId: string, payload: TraceFinalizePayload): Promise<PlusApiResponse<unknown>>;
+    finalizeEphemeralTraceBatch(traceBatchId: string, payload: TraceFinalizePayload): Promise<PlusApiResponse<unknown>>;
+    finalize_ephemeral_trace_batch(traceBatchId: string, payload: TraceFinalizePayload): Promise<PlusApiResponse<unknown>>;
+    markTraceBatchAsFailed(traceBatchId: string, errorMessage: string): Promise<PlusApiResponse<unknown>>;
+    mark_trace_batch_as_failed(traceBatchId: string, errorMessage: string): Promise<PlusApiResponse<unknown>>;
+    markEphemeralTraceBatchAsFailed(traceBatchId: string, errorMessage: string): Promise<PlusApiResponse<unknown>>;
+    mark_ephemeral_trace_batch_as_failed(traceBatchId: string, errorMessage: string): Promise<PlusApiResponse<unknown>>;
+    getMcpConfigs(slugs: readonly string[]): Promise<PlusApiResponse<unknown>>;
+    get_mcp_configs(slugs: readonly string[]): Promise<PlusApiResponse<unknown>>;
+    getTriggers(): Promise<PlusApiResponse<unknown>>;
+    get_triggers(): Promise<PlusApiResponse<unknown>>;
+    getTriggerPayload(appSlug: string, triggerSlug: string): Promise<PlusApiResponse<unknown>>;
+    get_trigger_payload(appSlug: string, triggerSlug: string): Promise<PlusApiResponse<unknown>>;
+}
+export declare function createAuthenticatedPlusApi(options?: Omit<PlusAPIOptions, "apiKey" | "api_key">): PlusAPI;
+export declare const create_authenticated_plus_api: typeof createAuthenticatedPlusApi;
+export type ToolCredentialOptions = {
+    settings?: Settings;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function buildEnvWithToolRepositoryCredentials(repositoryHandle: string, options?: ToolCredentialOptions): Record<string, string>;
+export declare const build_env_with_tool_repository_credentials: typeof buildEnvWithToolRepositoryCredentials;
+export declare function buildEnvWithAllToolCredentials(options?: ToolCredentialOptions & {
+    pyprojectPath?: string;
+    pyproject_path?: string;
+}): Record<string, string>;
+export declare const build_env_with_all_tool_credentials: typeof buildEnvWithAllToolCredentials;
+export {};

package/dist/project-compat.d.ts

@@ -0,0 +1,133 @@
+export declare const P: Readonly<{
+    kind: "ParamSpec";
+}>;
+export declare const P2: Readonly<{
+    kind: "ParamSpec";
+}>;
+export declare const R: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const R2: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const T: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const SelfT: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const TaskResultT: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const CallableT: Readonly<{
+    kind: "TypeVar";
+}>;
+export declare const AgentConfig: Readonly<{
+    kind: "AgentConfig";
+}>;
+export declare const TaskConfig: Readonly<{
+    kind: "TaskConfig";
+}>;
+export declare const CrewMetadata: Readonly<{
+    kind: "CrewMetadata";
+}>;
+export declare const CrewInstance: Readonly<{
+    kind: "CrewInstance";
+}>;
+export declare const CrewClass: Readonly<{
+    kind: "CrewClass";
+}>;
+export declare const TaskResult: Readonly<{
+    kind: "TaskResult";
+}>;
+export declare const OutputClass: Readonly<{
+    kind: "OutputClass";
+}>;
+export declare const OutputJsonClass: Readonly<{
+    kind: "OutputJsonClass";
+}>;
+export declare const OutputPydanticClass: Readonly<{
+    kind: "OutputPydanticClass";
+}>;
+type AnyFunction = (...args: readonly unknown[]) => unknown;
+export declare class DecoratedMethod {
+    readonly _meth: AnyFunction;
+    readonly __name__: string;
+    readonly __doc__: string | null;
+    constructor(method: AnyFunction);
+    call(thisArg: unknown, ...args: readonly unknown[]): unknown;
+    invoke(...args: readonly unknown[]): unknown;
+    __call__(...args: readonly unknown[]): unknown;
+    unwrap(): AnyFunction;
+}
+export declare class BeforeKickoffMethod extends DecoratedMethod {
+    readonly is_before_kickoff = true;
+}
+export declare class AfterKickoffMethod extends DecoratedMethod {
+    readonly is_after_kickoff = true;
+}
+export declare class AgentMethod extends DecoratedMethod {
+    readonly is_agent = true;
+}
+export declare class TaskMethod extends DecoratedMethod {
+    readonly is_task = true;
+    ensureTaskName<TResult>(result: TResult): TResult;
+    ensure_task_name<TResult>(result: TResult): TResult;
+    unwrap(): AnyFunction;
+    call(thisArg: unknown, ...args: readonly unknown[]): unknown;
+    invoke(...args: readonly unknown[]): unknown;
+}
+export declare class CrewMethod extends DecoratedMethod {
+    readonly is_crew = true;
+}
+export declare class ToolMethod extends DecoratedMethod {
+    readonly is_tool = true;
+}
+export declare class LLMMethod extends DecoratedMethod {
+    readonly is_llm = true;
+}
+export declare class CallbackMethod extends DecoratedMethod {
+    readonly is_callback = true;
+}
+export declare class CacheHandlerMethod extends DecoratedMethod {
+    readonly is_cache_handler = true;
+}
+export declare class OutputJsonMethod extends DecoratedMethod {
+    readonly is_output_json = true;
+}
+export declare class OutputPydanticMethod extends DecoratedMethod {
+    readonly is_output_pydantic = true;
+}
+export declare class BoundTaskMethod {
+    readonly is_task = true;
+    private readonly taskMethod;
+    private readonly instance;
+    constructor(taskMethod: TaskMethod, instance: unknown);
+    call(...args: readonly unknown[]): unknown;
+    __call__(...args: readonly unknown[]): unknown;
+}
+export declare const CrewBaseMeta: {
+    initialize(instance: object): object;
+};
+export declare function loadYaml(configPath: string): Record<string, unknown>;
+export declare const load_yaml: typeof loadYaml;
+export declare function loadConfigurations(instance: object): void;
+export declare const load_configurations: typeof loadConfigurations;
+export declare function mapAllAgentVariables(instance: object): void;
+export declare const map_all_agent_variables: typeof mapAllAgentVariables;
+export declare function mapAllTaskVariables(instance: object): void;
+export declare const map_all_task_variables: typeof mapAllTaskVariables;
+export declare function closeMcpServer<TOutput>(instance: object, output: TOutput): TOutput;
+export declare const close_mcp_server: typeof closeMcpServer;
+export declare const cache: Map<string, unknown>;
+export declare function getMcpTools(instance: object, ...toolNames: readonly string[]): unknown[];
+export declare const get_mcp_tools: typeof getMcpTools;
+export declare function memoize<TFunction extends AnyFunction>(method: TFunction): TFunction;
+export declare function _memoize_sync<TFunction extends AnyFunction>(method: TFunction): TFunction;
+export declare function _memoize_async<TFunction extends AnyFunction>(method: TFunction): TFunction;
+export declare function _make_hashable(arg: unknown): unknown;
+export declare function getAllMethods(instance: object): Record<string, unknown>;
+export declare const get_all_methods: typeof getAllMethods;
+export declare function crewMetadataFor(instance: object): Record<string, unknown>;
+export declare function loadProjectConfig(path: string): Record<string, unknown>;
+export {};

package/dist/project.d.ts

@@ -0,0 +1,221 @@
+import { Agent, type AgentGuardrail, type AgentOptions, type CodeExecutionMode } from "./agent.js";
+import { Crew } from "./crew.js";
+import type { PlanningConfig, PlanningConfigOptions } from "./agent-planning.js";
+import { Task, type TaskInputFiles, type TaskOptions, type TaskOutputConverter } from "./task.js";
+import type { AgentStepCallback, LLM, TaskCallback, Tool } from "./types.js";
+import { type CacheHandler } from "./tools.js";
+import type { EmbedderConfig } from "./rag.js";
+import type { AvailableExport, EnvVarEntry } from "./plus-api.js";
+export type ConfigRecord = Record<string, unknown>;
+export type ProjectConfig = Record<string, ConfigRecord>;
+export type ConfigSource = string | ProjectConfig | null | undefined;
+export type AgentConfig = {
+    role?: string;
+    goal?: string;
+    backstory?: string;
+    llm?: string | LLM | null;
+    function_calling_llm?: string | LLM | null;
+    functionCallingLlm?: string | LLM | null;
+    crew?: unknown;
+    tools?: readonly string[] | readonly Tool[];
+    cache?: boolean;
+    cache_handler?: string | CacheHandler;
+    cacheHandler?: string | CacheHandler;
+    tools_results?: readonly Record<string, unknown>[];
+    toolsResults?: readonly Record<string, unknown>[];
+    callbacks?: readonly string[] | readonly TaskCallback[];
+    step_callback?: string | AgentStepCallback;
+    stepCallback?: string | AgentStepCallback;
+    verbose?: boolean;
+    allow_delegation?: boolean;
+    allowDelegation?: boolean;
+    allow_code_execution?: boolean | null;
+    allowCodeExecution?: boolean | null;
+    code_execution_mode?: CodeExecutionMode;
+    codeExecutionMode?: CodeExecutionMode;
+    respect_context_window?: boolean;
+    respectContextWindow?: boolean;
+    multimodal?: boolean;
+    max_iter?: number;
+    maxIter?: number;
+    max_retry_limit?: number;
+    maxRetryLimit?: number;
+    max_execution_time?: number | null;
+    maxExecutionTime?: number | null;
+    max_rpm?: number | null;
+    maxRpm?: number | null;
+    max_tokens?: number | null;
+    maxTokens?: number | null;
+    use_system_prompt?: boolean | null;
+    useSystemPrompt?: boolean | null;
+    system_template?: string | null;
+    systemTemplate?: string | null;
+    prompt_template?: string | null;
+    promptTemplate?: string | null;
+    response_template?: string | null;
+    responseTemplate?: string | null;
+    inject_date?: boolean;
+    injectDate?: boolean;
+    date_format?: string;
+    dateFormat?: string;
+    guardrail?: AgentGuardrail | string | null;
+    guardrail_max_retries?: number;
+    guardrailMaxRetries?: number;
+    knowledge_storage?: unknown;
+    knowledgeStorage?: unknown;
+    knowledge_config?: Record<string, unknown> | null;
+    knowledgeConfig?: Record<string, unknown> | null;
+    embedder?: EmbedderConfig | null;
+    agent_knowledge_context?: string | null;
+    agentKnowledgeContext?: string | null;
+    crew_knowledge_context?: string | null;
+    crewKnowledgeContext?: string | null;
+    knowledge_search_query?: string | null;
+    knowledgeSearchQuery?: string | null;
+    apps?: readonly unknown[] | null;
+    mcps?: readonly unknown[] | null;
+    a2a?: unknown;
+    adapted_agent?: boolean;
+    adaptedAgent?: boolean;
+    from_repository?: string | null;
+    fromRepository?: string | null;
+    agent_executor?: unknown;
+    agentExecutor?: unknown;
+    executor_class?: unknown;
+    executorClass?: unknown;
+    planning?: boolean;
+    planning_config?: PlanningConfig | PlanningConfigOptions | null;
+    planningConfig?: PlanningConfig | PlanningConfigOptions | null;
+    reasoning?: boolean;
+    max_reasoning_attempts?: number | null;
+    maxReasoningAttempts?: number | null;
+    [key: string]: unknown;
+};
+export type TaskConfig = {
+    name?: string | null;
+    description?: string;
+    expected_output?: string;
+    expectedOutput?: string;
+    config?: Record<string, unknown> | null;
+    prompt_context?: string | null;
+    promptContext?: string | null;
+    agent?: string | Agent | null;
+    context?: readonly string[] | readonly Task[] | null;
+    tools?: readonly string[] | readonly Tool[];
+    callback?: string | TaskCallback | null;
+    callbacks?: readonly string[] | readonly TaskCallback[];
+    output_json?: boolean | string | TaskOutputConverter | null;
+    outputJson?: boolean | string | TaskOutputConverter | null;
+    output_pydantic?: string | TaskOutputConverter | null;
+    outputPydantic?: string | TaskOutputConverter | null;
+    output_converter?: string | TaskOutputConverter | null;
+    outputConverter?: string | TaskOutputConverter | null;
+    converter_cls?: string | TaskOutputConverter | null;
+    converterCls?: string | TaskOutputConverter | null;
+    output_file?: string | null;
+    outputFile?: string | null;
+    input_files?: TaskInputFiles;
+    inputFiles?: TaskInputFiles;
+    create_directory?: boolean;
+    createDirectory?: boolean;
+    response_model?: unknown;
+    responseModel?: unknown;
+    async_execution?: boolean;
+    asyncExecution?: boolean;
+    human_input?: boolean;
+    humanInput?: boolean;
+    markdown?: boolean;
+    allow_crewai_trigger_context?: boolean | null;
+    allowCrewaiTriggerContext?: boolean | null;
+    guardrail?: TaskOptions["guardrail"] | string | null;
+    guardrails?: TaskOptions["guardrails"] | readonly string[] | string | null;
+    guardrail_max_retries?: number;
+    guardrailMaxRetries?: number;
+    max_retries?: number;
+    retry_count?: number;
+    retryCount?: number;
+    used_tools?: number;
+    usedTools?: number;
+    tools_errors?: number;
+    toolsErrors?: number;
+    delegations?: number;
+    processed_by_agents?: Iterable<string>;
+    processedByAgents?: Iterable<string>;
+    start_time?: Date | string | null;
+    startTime?: Date | string | null;
+    end_time?: Date | string | null;
+    endTime?: Date | string | null;
+    checkpoint_original_description?: string | null;
+    checkpointOriginalDescription?: string | null;
+    checkpoint_original_expected_output?: string | null;
+    checkpointOriginalExpectedOutput?: string | null;
+    checkpoint_original_output_file?: string | null;
+    checkpointOriginalOutputFile?: string | null;
+    [key: string]: unknown;
+};
+export type CrewProjectState = {
+    baseDirectory: string;
+    agentsConfig: Record<string, AgentConfig>;
+    tasksConfig: Record<string, TaskConfig>;
+};
+export type CrewProjectLike = {
+    baseDirectory?: string;
+    agentsConfig?: ConfigSource;
+    tasksConfig?: ConfigSource;
+    agents_config?: ConfigSource;
+    tasks_config?: ConfigSource;
+    __crewProjectState__?: CrewProjectState;
+};
+export declare class CrewProject {
+    baseDirectory: string;
+    agentsConfig: ConfigSource;
+    tasksConfig: ConfigSource;
+    agentConfig(name: string): AgentConfig;
+    taskConfig(name: string): TaskConfig;
+}
+export declare function ensureCrewProject(instance: object): CrewProjectState;
+export declare function loadConfig(source: ConfigSource, baseDirectory?: string): ProjectConfig;
+export declare function mapAgentVariables(instance: object, state: CrewProjectState): void;
+export declare function mapTaskVariables(instance: object, state: CrewProjectState): void;
+export declare function agentOptionsFromConfig(config: AgentConfig): AgentOptions;
+export declare function taskOptionsFromConfig(config: TaskConfig): TaskOptions;
+export type ProjectModuleLike = object | Record<string, unknown>;
+export declare function getCrewInstance(value: unknown): Crew | null;
+export declare const get_crew_instance: typeof getCrewInstance;
+export declare function fetchCrews(moduleLike: ProjectModuleLike): Crew[];
+export declare const fetch_crews: typeof fetchCrews;
+export declare const getCrews: typeof fetchCrews;
+export declare const get_crews: typeof fetchCrews;
+export declare function getFlowInstance(value: unknown): unknown;
+export declare const get_flow_instance: typeof getFlowInstance;
+export declare function getFlows(moduleLike: ProjectModuleLike): unknown[];
+export declare const get_flows: typeof getFlows;
+export declare function isValidTool(value: unknown): value is Tool;
+export declare const is_valid_tool: typeof isValidTool;
+export declare function extractAvailableExports(moduleLike: ProjectModuleLike): AvailableExport[];
+export declare const extract_available_exports: typeof extractAvailableExports;
+export type ToolMetadata = {
+    name: string;
+    module: string;
+    humanized_name: string;
+    description: string;
+    run_params_schema: Record<string, unknown>;
+    init_params_schema: Record<string, unknown>;
+    env_vars: readonly EnvVarEntry[];
+    argsSchema?: unknown;
+    args_schema?: unknown;
+};
+export declare class SchemaGenerator {
+    handleInvalidForJsonSchema(schema: unknown, errorInfo: unknown): never;
+    handle_invalid_for_json_schema(schema: unknown, errorInfo: unknown): never;
+}
+export declare function handleInvalidForJsonSchema(schema: unknown, errorInfo: unknown): never;
+export declare const handle_invalid_for_json_schema: typeof handleInvalidForJsonSchema;
+export declare function _get_schema_generator(): typeof SchemaGenerator;
+export declare function _unwrap_schema(schema: unknown): Record<string, unknown>;
+export declare function _extract_field_default(field: unknown, fallback?: string | readonly unknown[] | number): string | readonly unknown[] | number;
+export declare function _extract_run_params_schema(argsSchemaField: unknown): Record<string, unknown>;
+export declare function _extract_init_params_schema(toolClassOrInstance: unknown): Record<string, unknown>;
+export declare function _extract_env_vars(envVarsField: unknown): EnvVarEntry[];
+export declare function extractToolsMetadata(tools: readonly unknown[] | ProjectModuleLike): ToolMetadata[];
+export declare const extract_tools_metadata: typeof extractToolsMetadata;

package/dist/prompts.d.ts

@@ -0,0 +1,66 @@
+import { type I18N } from "./i18n.js";
+export type PromptComponent = "role_playing" | "tools" | "no_tools" | "native_tools" | "task" | "native_task" | "task_no_tools";
+export interface StandardPromptResultOptions {
+    prompt?: string;
+}
+export declare class StandardPromptResult {
+    readonly prompt: string;
+    constructor(options?: StandardPromptResultOptions);
+    get(key: string, defaultValue?: unknown): unknown;
+    item(key: string): unknown;
+    __getitem__(key: string): unknown;
+    contains(key: string): boolean;
+    __contains__(key: string): boolean;
+}
+export interface SystemPromptResultOptions extends StandardPromptResultOptions {
+    system?: string;
+    user?: string;
+}
+export declare class SystemPromptResult extends StandardPromptResult {
+    readonly system: string;
+    readonly user: string;
+    constructor(options?: SystemPromptResultOptions);
+}
+export interface PromptAgentLike {
+    role: string;
+    goal: string;
+    backstory: string;
+    skills?: readonly unknown[] | null;
+}
+export interface PromptsOptions {
+    hasTools?: boolean;
+    has_tools?: boolean;
+    useNativeToolCalling?: boolean;
+    use_native_tool_calling?: boolean;
+    systemTemplate?: string | null;
+    system_template?: string | null;
+    promptTemplate?: string | null;
+    prompt_template?: string | null;
+    responseTemplate?: string | null;
+    response_template?: string | null;
+    useSystemPrompt?: boolean;
+    use_system_prompt?: boolean;
+    agent: PromptAgentLike;
+    i18n?: I18N;
+}
+export declare class Prompts {
+    readonly hasTools: boolean;
+    readonly has_tools: boolean;
+    readonly useNativeToolCalling: boolean;
+    readonly use_native_tool_calling: 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 useSystemPrompt: boolean;
+    readonly use_system_prompt: boolean;
+    readonly agent: PromptAgentLike;
+    readonly i18n: I18N;
+    constructor(options: PromptsOptions);
+    taskExecution(): SystemPromptResult | StandardPromptResult;
+    task_execution(): SystemPromptResult | StandardPromptResult;
+    private buildPrompt;
+    private buildSkillBlock;
+}