@taskyon/tyclient 0.4.5

package/dist/tyclient.d.ts

@@ -0,0 +1,1053 @@
+import z from 'zod';
+import { z } from 'zod';
+
+declare const FunctionCall: z.ZodObject<{
+	name: z.ZodString;
+	arguments: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
+		z.ZodString,
+		z.ZodNumber,
+		z.ZodBoolean,
+		z.ZodRecord<z.ZodString, z.ZodUnknown>,
+		z.ZodArray<z.ZodUnknown>,
+		z.ZodNull,
+		z.ZodUndefined
+	]>>;
+}, z.core.$strip>;
+declare const InternalTool: z.ZodObject<{
+	description: z.ZodString;
+	longDescription: z.ZodOptional<z.ZodString>;
+	name: z.ZodString;
+	renderOptions: z.ZodOptional<z.ZodObject<{
+		hideChat: z.ZodOptional<z.ZodBoolean>;
+		hideLlm: z.ZodOptional<z.ZodBoolean>;
+	}, z.core.$strip>>;
+	parameters: z.ZodReadonly<z.ZodType<import("json-schema").JSONSchema7, unknown, z.core.$ZodTypeInternals<import("json-schema").JSONSchema7, unknown>>>;
+	code: z.ZodOptional<z.ZodString>;
+	function: z.ZodOptional<z.ZodCustom<(params: any, context: toolContext) => unknown, (params: any, context: toolContext) => unknown>>;
+}, z.core.$strip>;
+declare const TaskNode: z.ZodObject<{
+	role: z.ZodEnum<{
+		function: "function";
+		system: "system";
+		user: "user";
+		assistant: "assistant";
+	}>;
+	name: z.ZodOptional<z.ZodString>;
+	content: z.ZodUnion<readonly [
+		z.ZodObject<{
+			type: z.ZodLiteral<"message">;
+			data: z.ZodString;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"toolresult">;
+			data: z.ZodUnknown;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"tooldefinition">;
+			data: z.ZodObject<{
+				description: z.ZodString;
+				longDescription: z.ZodOptional<z.ZodString>;
+				name: z.ZodString;
+				renderOptions: z.ZodOptional<z.ZodObject<{
+					hideChat: z.ZodOptional<z.ZodBoolean>;
+					hideLlm: z.ZodOptional<z.ZodBoolean>;
+				}, z.core.$strip>>;
+				parameters: z.ZodReadonly<z.ZodType<import("json-schema").JSONSchema7, unknown, z.core.$ZodTypeInternals<import("json-schema").JSONSchema7, unknown>>>;
+				code: z.ZodOptional<z.ZodString>;
+			}, z.core.$strip>;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"error">;
+			data: z.ZodUnknown;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"structured">;
+			data: z.ZodUnknown;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"functioncall">;
+			data: z.ZodObject<{
+				name: z.ZodString;
+				arguments: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
+					z.ZodString,
+					z.ZodNumber,
+					z.ZodBoolean,
+					z.ZodRecord<z.ZodString, z.ZodUnknown>,
+					z.ZodArray<z.ZodUnknown>,
+					z.ZodNull,
+					z.ZodUndefined
+				]>>;
+			}, z.core.$strip>;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"files">;
+			data: z.ZodArray<z.ZodString>;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"return">;
+			data: z.ZodString;
+		}, z.core.$strict>
+	]>;
+	label: z.ZodOptional<z.ZodArray<z.ZodString>>;
+	parentID: z.ZodOptional<z.ZodString>;
+	priorID: z.ZodOptional<z.ZodString>;
+	id: z.ZodString;
+	authorId: z.ZodOptional<z.ZodString>;
+	created_at: z.ZodOptional<z.ZodNumber>;
+	acl: z.ZodOptional<z.ZodArray<z.ZodString>>;
+	sig: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const TyProfile: z.ZodObject<{
+	version: z.ZodLiteral<19>;
+	appConfiguration: z.ZodObject<{
+		darkTheme: z.ZodUnion<readonly [
+			z.ZodLiteral<"auto">,
+			z.ZodBoolean
+		]>;
+		appConfigurationUrl: z.ZodDefault<z.ZodString>;
+		gdriveConfigurationFile: z.ZodDefault<z.ZodString>;
+		enableGdriveSync: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+		expertMode: z.ZodDefault<z.ZodBoolean>;
+		showCosts: z.ZodDefault<z.ZodBoolean>;
+		gdriveDir: z.ZodDefault<z.ZodString>;
+		showLogo: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+		welcomeMsg: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+		chatSuggestions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [
+			z.ZodObject<{
+				url: z.ZodString;
+				label: z.ZodString;
+			}, z.core.$strip>,
+			z.ZodObject<{
+				md: z.ZodString;
+				label: z.ZodString;
+			}, z.core.$strip>
+		]>>>>;
+		useEnterToSend: z.ZodDefault<z.ZodBoolean>;
+		guiMode: z.ZodDefault<z.ZodEnum<{
+			default: "default";
+			auto: "auto";
+			iframe: "iframe";
+			minChat: "minChat";
+		}>>;
+		primaryColor: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+		secondaryColor: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+	}, z.core.$strip>;
+	llmSettings: z.ZodObject<{
+		userId: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+		secretPublicKey: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+		selectedTaskId: z.ZodOptional<z.ZodString>;
+		enableOpenAiTools: z.ZodDefault<z.ZodBoolean>;
+		selectedApi: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+		llmApis: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+			name: z.ZodString;
+			baseURL: z.ZodString;
+			defaultModel: z.ZodString;
+			selectedModel: z.ZodOptional<z.ZodString>;
+			models: z.ZodOptional<z.ZodObject<{
+				instruction: z.ZodOptional<z.ZodString>;
+				chat: z.ZodOptional<z.ZodString>;
+				free: z.ZodOptional<z.ZodString>;
+			}, z.core.$strip>>;
+			streamSupport: z.ZodBoolean;
+			defaultHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+			routes: z.ZodObject<{
+				chatCompletion: z.ZodString;
+				models: z.ZodString;
+			}, z.core.$strip>;
+		}, z.core.$strip>>>;
+		siteUrl: z.ZodDefault<z.ZodString>;
+		summaryModel: z.ZodDefault<z.ZodString>;
+		vectorizationModel: z.ZodDefault<z.ZodString>;
+		maxAutonomousTasks: z.ZodDefault<z.ZodNumber>;
+		entryNode: z.ZodOptional<z.ZodObject<{
+			role: z.ZodNonOptional<z.ZodOptional<z.ZodEnum<{
+				function: "function";
+				system: "system";
+				user: "user";
+				assistant: "assistant";
+			}>>>;
+			name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+			content: z.ZodNonOptional<z.ZodOptional<z.ZodUnion<readonly [
+				z.ZodObject<{
+					type: z.ZodLiteral<"message">;
+					data: z.ZodString;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"toolresult">;
+					data: z.ZodUnknown;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"tooldefinition">;
+					data: z.ZodObject<{
+						description: z.ZodString;
+						longDescription: z.ZodOptional<z.ZodString>;
+						name: z.ZodString;
+						renderOptions: z.ZodOptional<z.ZodObject<{
+							hideChat: z.ZodOptional<z.ZodBoolean>;
+							hideLlm: z.ZodOptional<z.ZodBoolean>;
+						}, z.core.$strip>>;
+						parameters: z.ZodReadonly<z.ZodType<import("json-schema").JSONSchema7, unknown, z.core.$ZodTypeInternals<import("json-schema").JSONSchema7, unknown>>>;
+						code: z.ZodOptional<z.ZodString>;
+					}, z.core.$strip>;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"error">;
+					data: z.ZodUnknown;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"structured">;
+					data: z.ZodUnknown;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"functioncall">;
+					data: z.ZodObject<{
+						name: z.ZodString;
+						arguments: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
+							z.ZodString,
+							z.ZodNumber,
+							z.ZodBoolean,
+							z.ZodRecord<z.ZodString, z.ZodUnknown>,
+							z.ZodArray<z.ZodUnknown>,
+							z.ZodNull,
+							z.ZodUndefined
+						]>>;
+					}, z.core.$strip>;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"files">;
+					data: z.ZodArray<z.ZodString>;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"return">;
+					data: z.ZodString;
+				}, z.core.$strict>
+			]>>>;
+			label: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+			parentID: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+			priorID: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+			id: z.ZodOptional<z.ZodString>;
+			authorId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+			created_at: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+			acl: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+			sig: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+		}, z.core.$strip>>;
+		enableToolChooser: z.ZodDefault<z.ZodBoolean>;
+		useBasePrompt: z.ZodDefault<z.ZodBoolean>;
+		tryUsingVisionModels: z.ZodDefault<z.ZodBoolean>;
+		taskChatTemplates: z.ZodObject<{
+			basePrompt: z.ZodString;
+			instruction: z.ZodString;
+			toolResult: z.ZodString;
+			task: z.ZodString;
+			evaluate: z.ZodString;
+			schemaReminder: z.ZodString;
+			tools: z.ZodString;
+		}, z.core.$strip>;
+	}, z.core.$strip>;
+	toolchainConfig: z.ZodObject<{
+		tools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+	}, z.core.$strip>;
+	signatureOrKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const partialTaskDraft: z.ZodObject<{
+	role: z.ZodNonOptional<z.ZodOptional<z.ZodEnum<{
+		function: "function";
+		system: "system";
+		user: "user";
+		assistant: "assistant";
+	}>>>;
+	name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+	content: z.ZodNonOptional<z.ZodOptional<z.ZodUnion<readonly [
+		z.ZodObject<{
+			type: z.ZodLiteral<"message">;
+			data: z.ZodString;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"toolresult">;
+			data: z.ZodUnknown;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"tooldefinition">;
+			data: z.ZodObject<{
+				description: z.ZodString;
+				longDescription: z.ZodOptional<z.ZodString>;
+				name: z.ZodString;
+				renderOptions: z.ZodOptional<z.ZodObject<{
+					hideChat: z.ZodOptional<z.ZodBoolean>;
+					hideLlm: z.ZodOptional<z.ZodBoolean>;
+				}, z.core.$strip>>;
+				parameters: z.ZodReadonly<z.ZodType<import("json-schema").JSONSchema7, unknown, z.core.$ZodTypeInternals<import("json-schema").JSONSchema7, unknown>>>;
+				code: z.ZodOptional<z.ZodString>;
+			}, z.core.$strip>;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"error">;
+			data: z.ZodUnknown;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"structured">;
+			data: z.ZodUnknown;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"functioncall">;
+			data: z.ZodObject<{
+				name: z.ZodString;
+				arguments: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
+					z.ZodString,
+					z.ZodNumber,
+					z.ZodBoolean,
+					z.ZodRecord<z.ZodString, z.ZodUnknown>,
+					z.ZodArray<z.ZodUnknown>,
+					z.ZodNull,
+					z.ZodUndefined
+				]>>;
+			}, z.core.$strip>;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"files">;
+			data: z.ZodArray<z.ZodString>;
+		}, z.core.$strict>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"return">;
+			data: z.ZodString;
+		}, z.core.$strict>
+	]>>>;
+	label: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+	parentID: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+	priorID: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+	id: z.ZodOptional<z.ZodString>;
+	authorId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+	created_at: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+	acl: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+	sig: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+declare const taskResult: z.ZodObject<{
+	taskResultMarker: z.ZodDefault<z.ZodLiteral<"*TY_TASKRESULT*">>;
+	taskChainList: z.ZodArray<z.ZodArray<z.ZodObject<{
+		role: z.ZodNonOptional<z.ZodOptional<z.ZodEnum<{
+			function: "function";
+			system: "system";
+			user: "user";
+			assistant: "assistant";
+		}>>>;
+		name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+		content: z.ZodNonOptional<z.ZodOptional<z.ZodUnion<readonly [
+			z.ZodObject<{
+				type: z.ZodLiteral<"message">;
+				data: z.ZodString;
+			}, z.core.$strict>,
+			z.ZodObject<{
+				type: z.ZodLiteral<"toolresult">;
+				data: z.ZodUnknown;
+			}, z.core.$strict>,
+			z.ZodObject<{
+				type: z.ZodLiteral<"tooldefinition">;
+				data: z.ZodObject<{
+					description: z.ZodString;
+					longDescription: z.ZodOptional<z.ZodString>;
+					name: z.ZodString;
+					renderOptions: z.ZodOptional<z.ZodObject<{
+						hideChat: z.ZodOptional<z.ZodBoolean>;
+						hideLlm: z.ZodOptional<z.ZodBoolean>;
+					}, z.core.$strip>>;
+					parameters: z.ZodReadonly<z.ZodType<import("json-schema").JSONSchema7, unknown, z.core.$ZodTypeInternals<import("json-schema").JSONSchema7, unknown>>>;
+					code: z.ZodOptional<z.ZodString>;
+				}, z.core.$strip>;
+			}, z.core.$strict>,
+			z.ZodObject<{
+				type: z.ZodLiteral<"error">;
+				data: z.ZodUnknown;
+			}, z.core.$strict>,
+			z.ZodObject<{
+				type: z.ZodLiteral<"structured">;
+				data: z.ZodUnknown;
+			}, z.core.$strict>,
+			z.ZodObject<{
+				type: z.ZodLiteral<"functioncall">;
+				data: z.ZodObject<{
+					name: z.ZodString;
+					arguments: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [
+						z.ZodString,
+						z.ZodNumber,
+						z.ZodBoolean,
+						z.ZodRecord<z.ZodString, z.ZodUnknown>,
+						z.ZodArray<z.ZodUnknown>,
+						z.ZodNull,
+						z.ZodUndefined
+					]>>;
+				}, z.core.$strip>;
+			}, z.core.$strict>,
+			z.ZodObject<{
+				type: z.ZodLiteral<"files">;
+				data: z.ZodArray<z.ZodString>;
+			}, z.core.$strict>,
+			z.ZodObject<{
+				type: z.ZodLiteral<"return">;
+				data: z.ZodString;
+			}, z.core.$strict>
+		]>>>;
+		label: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+		parentID: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+		priorID: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+		id: z.ZodOptional<z.ZodString>;
+		authorId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+		created_at: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+		acl: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+		sig: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+	}, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare function createTool<T, SCHEMA extends Readonly<JSONSchema>, PARAMS = FromSchema<SCHEMA>>(tool: T & {
+	parameters: SCHEMA;
+	function?: (params: PARAMS, context: toolContext) => unknown;
+} & Omit<InternalTool$1, "function" | "parameters">): T;
+export declare function initializeTaskyon(tools: ClientTool[], configuration: partialTyConfiguration, persist?: boolean): Promise<void>;
+export declare function makeTaskResult(tasks: partialTaskDraft | partialTaskDraft[] | partialTaskDraft[][]): taskResult;
+export declare function toolCall(f: FunctionCall): partialTaskDraft & {
+	content: {
+		type: "functioncall";
+		data: FunctionCall;
+	};
+};
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+export type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny<SpecifiedOptions, Defaults, IfNever<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, {
+	[Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key];
+}> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+>>;
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+export type BuiltIns = Primitive | void | Date | RegExp;
+export type ClientTool = WithRequired<InternalTool$1, "function">;
+export type DefaultPartialDeepOptions = {
+	recurseIntoArrays: false;
+	allowUndefinedInNonTupleArrays: true;
+};
+export type FunctionCall = z.infer<typeof FunctionCall>;
+/**
+An if-else-like type that resolves depending on whether the given type is `any`.
+
+@see {@link IsAny}
+
+@example
+```
+import type {IfAny} from 'type-fest';
+
+type ShouldBeTrue = IfAny<any>;
+//=> true
+
+type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
+	return obj[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsAny<T> = 0 extends 1 & NoInfer$1<T> ? true : false;
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsNever<T> = [
+	T
+] extends [
+	never
+] ? true : false;
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+interface Foo {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+}
+
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+// => {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+@category Object
+*/
+export type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+interface Example {
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+}
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@see PickIndexSignature
+@category Object
+*/
+export type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
+};
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
+```
+
+@category Utilities
+*/
+export type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+ ? (keyof {
+	[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never;
+}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+ : never; // Should never happen
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {PartialDeep} from 'type-fest';
+
+const settings: Settings = {
+	textEditor: {
+		fontSize: 14,
+		fontColor: '#000000',
+		fontWeight: 400
+	},
+	autocomplete: false,
+	autosave: true
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
+	return {...settings, ...savedSettings};
+}
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+type Settings = {
+	languages: string[];
+}
+
+const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
+	languages: [undefined]
+};
+```
+
+@see {@link PartialDeepOptions}
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
+/**
+@see {@link PartialDeep}
+*/
+export type PartialDeepOptions = {
+	/**
+	Whether to affect the individual elements of arrays and tuples.
+
+	@default false
+	*/
+	readonly recurseIntoArrays?: boolean;
+	/**
+	Allows `undefined` values in non-tuple arrays.
+
+	- When set to `true`, elements of non-tuple arrays can be `undefined`.
+	- When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
+
+	@default true
+
+	@example
+	You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:
+
+	```
+	import type {PartialDeep} from 'type-fest';
+
+	type Settings = {
+		languages: string[];
+	};
+
+	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;
+
+	partialSettings.languages = [undefined]; // Error
+	partialSettings.languages = []; // Ok
+	```
+	*/
+	readonly allowUndefinedInNonTupleArrays?: boolean;
+};
+/**
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = (ObjectType extends (...arguments_: any) => unknown ? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType> : {}) & ({
+	[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>;
+});
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see OmitIndexSignature
+@category Object
+*/
+export type PickIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType];
+};
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+```
+
+@category Utilities
+*/
+export type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+ ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never; // Should never happen
+// Merges two objects without worrying about index signatures.
+export type SimpleMerge<Destination, Source> = {
+	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+} & Source;
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see SimplifyDeep
+@category Object
+*/
+export type Simplify<T> = {
+	[KeyType in keyof T]: T[KeyType];
+} & {};
+export type TaskNode = z.infer<typeof TaskNode>;
+export type TyProfile = z.infer<typeof TyProfile>;
+export type WithRequired<T, K extends keyof T> = Omit<T, K> & {
+	[P in K]-?: Exclude<T[P], undefined>;
+};
+export type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : IsNever<keyof T> extends true // For functions with no properties
+ ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+ ? Options["recurseIntoArrays"] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+ ? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+ ? ReadonlyArray<_PartialDeep<Options["allowUndefinedInNonTupleArrays"] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options["allowUndefinedInNonTupleArrays"] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> // Tuples behave properly
+ : T // If they don't opt into array testing, just use the original type
+ : PartialObjectDeep<T, Options> : unknown;
+export type partialTaskDraft = z.infer<typeof partialTaskDraft>;
+export type partialTyConfiguration = PartialDeep<TyProfile>;
+export type taskResult = z.infer<typeof taskResult>;
+/**
+ * Represents the context passed to tools within the Taskyon system.
+ *
+ * @property taskChain - The sequence of TaskNode objects representing the current chain of tasks.
+ * @property getSecret - Retrieves a secret value by name. If `askNew` is `true`, prompts for a new secret if it doesn't exist.
+ *   If `askNew` is a string, uses the string as a custom message or hint when prompting for the secret.
+ * @param name - The name of the secret to retrieve.
+ * @param askNew - If `true`, prompts for a new secret if not found. If a string, uses it as a hint or message when prompting.
+ * @returns A promise resolving to the secret value, or `undefined` if not found.
+ *
+ * @property setSecret - Stores a secret value by name.
+ * @param name - The name of the secret to store.
+ * @param value - The secret value to store.
+ * @returns A promise that resolves when the secret is stored.
+ * @property stopSignal - An AbortSignal that can be used to detect if the tool should stop execution.
+ * @property toolId - The unique identifier for the tool instance.
+ */
+export type toolContext = {
+	taskChain: TaskNode[];
+	getSecret: (name: string, askNew: boolean | string, saveNew?: boolean) => Promise<string | null>;
+	setSecret: (name: string, value: string) => Promise<void>;
+	stopSignal: AbortSignal;
+	toolId: string;
+	messagePort?: MessagePort;
+};
+type InternalTool$1 = z.infer<typeof InternalTool>;
+type NoInfer$1<T> = T extends infer U ? U : never;
+
+export {};