@crewai-ts/core 0.1.1 → 0.1.3

package/dist/types.d.ts

@@ -0,0 +1,72 @@
+export type InputValues = Record<string, unknown>;
+export type MaybePromise<T> = T | Promise<T>;
+export type LLMMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    files?: import("./input-files.js").InputFiles;
+    cache_breakpoint?: boolean;
+};
+export declare const LLMMessage: {
+    new (options: {
+        readonly role: "system" | "user" | "assistant" | "tool";
+        readonly content: string;
+        readonly files?: import("./input-files.js").InputFiles;
+        readonly cache_breakpoint?: boolean;
+    }): {
+        readonly role: "system" | "user" | "assistant" | "tool";
+        readonly content: string;
+        readonly files?: import("./input-files.js").InputFiles;
+        readonly cache_breakpoint?: boolean;
+    };
+};
+export type LLM = import("./llm.js").LLM;
+export type ToolContext = {
+    input: string;
+    inputs: InputValues;
+};
+export type Tool = {
+    name: string;
+    description?: string;
+    resultAsAnswer?: boolean;
+    run: (context?: ToolContext | Record<string, unknown> | string, hookContext?: {
+        agent?: unknown;
+        task?: unknown;
+        crew?: unknown;
+    }) => MaybePromise<unknown>;
+};
+export declare const Tool: ObjectConstructor;
+export declare function create_literals_from_strings<T extends readonly string[]>(values: T): T;
+export type AgentStep = {
+    type: "tool";
+    agentRole: string;
+    iteration: number;
+    toolName: string;
+    toolArgs: Record<string, unknown>;
+    output: string;
+    resultAsAnswer: false;
+} | {
+    type: "direct_tool";
+    agentRole: string;
+    iteration: number;
+    toolName: string;
+    toolArgs: Record<string, unknown>;
+    output: string;
+    resultAsAnswer: true;
+} | {
+    type: "final";
+    agentRole: string;
+    iteration: number;
+    output: string;
+};
+export type AgentStepCallback = (step: AgentStep) => MaybePromise<void>;
+export type TaskCallback = (output: import("./outputs.js").TaskOutput) => MaybePromise<void>;
+export type CrewKickoffCallback<T> = (value: T) => MaybePromise<T>;
+export declare enum Process {
+    sequential = "sequential",
+    hierarchical = "hierarchical"
+}
+export declare enum OutputFormat {
+    RAW = "raw",
+    JSON = "json",
+    PYDANTIC = "pydantic"
+}

package/dist/utilities.d.ts

@@ -0,0 +1,130 @@
+export declare class ImportError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class OptionalDependencyError extends ImportError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare function normalizePathLikeString(value: unknown): string | null;
+export declare const COMPONENTS: readonly ["role_playing", "tools", "no_tools", "native_tools", "task", "native_task", "task_no_tools"];
+export declare const UNACCEPTED_ATTRIBUTES: readonly ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_DEFAULT_REGION"];
+export declare class InternalInstructor {
+    readonly content: string;
+    readonly model: unknown;
+    readonly agent: unknown;
+    readonly llm: unknown;
+    readonly _client: unknown;
+    constructor(content: string, model: unknown, agent?: unknown, llm?: unknown);
+    toJson(): string;
+    to_json(): string;
+    toPydantic(): unknown;
+    to_pydantic(): unknown;
+    _create_instructor_client(): unknown;
+    _extract_provider(): string;
+}
+export declare function _is_valid_llm(llm: unknown): boolean;
+export declare const DEFAULT_TTL = 3600;
+export declare class CrewJSONEncoder {
+    default(value: unknown): Serializable;
+    _handle_pydantic_model(value: unknown): Serializable;
+}
+export type CrewContextOptions = {
+    id?: string;
+    key?: string;
+    crew?: unknown;
+};
+export declare class CrewContext {
+    readonly id: string;
+    readonly key: string;
+    readonly crew: unknown;
+    constructor(options?: CrewContextOptions | string);
+}
+export declare function getCrewContext(): CrewContext | null;
+export declare function get_crew_context(): CrewContext | null;
+export declare function withCrewContext<T>(context: CrewContext | CrewContextOptions, fn: () => T): T;
+export declare const with_crew_context: typeof withCrewContext;
+export declare const console: Console;
+export type ResetMemoriesCommandOptions = {
+    crews?: readonly unknown[];
+    flows?: readonly unknown[];
+    getCrews?: () => readonly unknown[];
+    get_crews?: () => readonly unknown[];
+    getFlows?: () => readonly unknown[];
+    get_flows?: () => readonly unknown[];
+    console?: Pick<Console, "log" | "error">;
+};
+export declare function reset_memories_command(memory?: boolean, knowledge?: boolean, agent_knowledge?: boolean, kickoff_outputs?: boolean, all?: boolean, options?: ResetMemoriesCommandOptions): void;
+export declare function _reset_flow_memory(flow: unknown, output?: Pick<Console, "error">): void;
+export type SerializablePrimitive = string | number | boolean | null;
+export declare const SerializablePrimitive: Readonly<{
+    kind: "SerializablePrimitive";
+}>;
+export type Serializable = SerializablePrimitive | Serializable[] | {
+    [key: string]: Serializable;
+};
+export declare const Serializable: Readonly<{
+    kind: "Serializable";
+}>;
+export type ImportedDefinition = unknown;
+export declare const ImportedDefinition: Readonly<{
+    kind: "ImportedDefinition";
+}>;
+export declare const adapter: Readonly<{
+    validate_python(value: string): Promise<unknown>;
+}>;
+export type ToSerializableOptions = {
+    exclude?: ReadonlySet<string> | readonly string[] | null;
+    maxDepth?: number;
+    max_depth?: number;
+};
+export declare function toSerializable(obj: unknown, options?: ToSerializableOptions, currentDepth?: number, ancestors?: ReadonlySet<object>): Serializable;
+export declare const to_serializable: typeof toSerializable;
+export declare function toString(obj: unknown): string | null;
+export declare const to_string: typeof toString;
+export declare function crewJsonReplacer(_key: string, value: unknown): unknown;
+export declare function crewJsonStringify(value: unknown, space?: number): string;
+export declare const crew_json_stringify: typeof crewJsonStringify;
+export type SerializableCallable = (...args: readonly unknown[]) => unknown;
+export declare const SerializableCallable: FunctionConstructor;
+export declare function _trusted_deserialize(env?: NodeJS.ProcessEnv): boolean;
+export declare function _is_non_roundtrippable(value: unknown): boolean;
+export declare function registerCallable(path: string, callable: SerializableCallable): void;
+export declare const register_callable: typeof registerCallable;
+export declare function unregisterCallable(path: string): void;
+export declare const unregister_callable: typeof unregisterCallable;
+export declare function clearCallableRegistry(): void;
+export declare const clear_callable_registry: typeof clearCallableRegistry;
+export declare function callableToString(callable: SerializableCallable): string | null;
+export declare const callable_to_string: typeof callableToString;
+export declare function stringToCallable(value: unknown): Promise<SerializableCallable>;
+export declare const string_to_callable: typeof stringToCallable;
+export declare function _instance_to_dotted_path(value: unknown): string;
+export declare function _dotted_path_to_instance(value: unknown): Promise<unknown>;
+export declare function readToml(filePath?: string): Record<string, unknown>;
+export declare const read_toml: typeof readToml;
+export declare function parseToml(content: string): Record<string, unknown>;
+export declare const parse_toml: typeof parseToml;
+export declare function getProjectName(pyprojectPath?: string, require?: boolean): string | null;
+export declare const get_project_name: typeof getProjectName;
+export declare function getProjectVersion(pyprojectPath?: string, require?: boolean): string | null;
+export declare const get_project_version: typeof getProjectVersion;
+export declare function getProjectDescription(pyprojectPath?: string, require?: boolean): string | null;
+export declare const get_project_description: typeof getProjectDescription;
+export declare function getCrewaiVersion(): string;
+export declare const get_crewai_version: typeof getCrewaiVersion;
+export declare function getProjectAttribute(pyprojectPath: string, keys: readonly string[], require?: boolean): string | null;
+export declare const get_project_attribute: typeof getProjectAttribute;
+export declare function validateImportPath(path: string): Promise<unknown>;
+export declare const validate_import_path: typeof validateImportPath;
+export declare function importAndValidateDefinition(path: string): Promise<unknown>;
+export declare const import_and_validate_definition: typeof importAndValidateDefinition;
+export declare function requireModule(name: string, options: {
+    purpose: string;
+    attr?: string | null;
+}): Promise<unknown>;
+export declare const require_module: typeof requireModule;
+export declare const require: typeof requireModule;
+export declare class AttributeError extends Error {
+    constructor(message: string);
+}
+export declare function _resolve_dotted_path(path: string): Promise<unknown>;
+export declare function _to_serializable_key(key: unknown): string;

package/dist/utility-types.d.ts

@@ -0,0 +1,10 @@
+import type { InputFiles } from "./input-files.js";
+export type UtilityLLMMessage = {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string | Array<Record<string, unknown>> | null;
+    tool_call_id?: string;
+    name?: string;
+    tool_calls?: Array<Record<string, unknown>>;
+    raw_tool_call_parts?: unknown[];
+    files?: InputFiles;
+};

package/dist/version.d.ts

@@ -0,0 +1,12 @@
+export declare const __version__ = "1.14.6";
+export declare const VERSION = "1.14.6";
+export declare function get_crewai_version(): string;
+export declare function get_latest_version_from_pypi(): Promise<string | null>;
+export declare function is_newer_version_available(currentVersion: string, latestVersion: string | null): boolean;
+export declare function is_current_version_yanked(_version?: string): Promise<boolean>;
+export declare function check_version(currentVersion?: string): Promise<{
+    current_version: string;
+    latest_version: string | null;
+    update_available: boolean;
+    yanked: boolean;
+}>;