@plucky-ai/node 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -0,0 +1,1107 @@
+import { createApiClient, createApiClient as createApiClient$1 } from "@plucky-ai/api-contracts/client";
+import { ValidationError, enhanceRoute, eventIterator, isContractProcedure, mergeErrorMap, mergeMeta, mergePrefix, mergeRoute, mergeTags, oc, validateORPCError } from "@orpc/contract";
+import z$1, { z } from "zod";
+import { ORPCError, mapEventIterator, toORPCError } from "@orpc/client";
+//#region ../llm-schemas/dist/index.mjs
+const TextContentBlockSchema = z.object({
+	type: z.literal("text"),
+	text: z.string()
+});
+const ToolUseContentBlockSchema = z.object({
+	type: z.literal("tool_use"),
+	id: z.string(),
+	name: z.string(),
+	input: z.unknown(),
+	defaultLoadingText: z.string().nullable().optional(),
+	defaultSuccessText: z.string().nullable().optional(),
+	partial_json: z.string().nullable().optional()
+});
+const ToolResultContentBlockSchema = z.object({
+	type: z.literal("tool_result"),
+	toolUseId: z.string(),
+	content: z.string(),
+	successText: z.string().nullish()
+});
+const ContentBlockSchema = z.union([
+	TextContentBlockSchema,
+	ToolUseContentBlockSchema,
+	ToolResultContentBlockSchema
+]);
+const ContentFieldSchema = z.union([z.string(), z.array(ContentBlockSchema)]);
+const InputMessageSchema = z.object({
+	role: z.enum(["user", "assistant"]),
+	content: ContentFieldSchema
+});
+InputMessageSchema.extend({ content: z.array(ContentBlockSchema) });
+const SavedInputMessageSchema = InputMessageSchema.extend({
+	id: z.string(),
+	content: z.array(ContentBlockSchema),
+	createdAt: z.coerce.date()
+});
+const UsageSchema = z.object({
+	inputTokens: z.number(),
+	outputTokens: z.number(),
+	cacheReadInputTokens: z.number().optional(),
+	cacheCreationInputTokens: z.number().optional()
+});
+const OutputMessageSchema = InputMessageSchema.extend({
+	id: z.string(),
+	content: z.array(ContentBlockSchema),
+	usage: UsageSchema
+});
+const SavedOutputMessageSchema = OutputMessageSchema.extend({ createdAt: z.coerce.date() });
+const SavedMessageSchema = z.union([SavedInputMessageSchema, SavedOutputMessageSchema]);
+z.union([
+	InputMessageSchema,
+	OutputMessageSchema,
+	SavedInputMessageSchema,
+	SavedOutputMessageSchema
+]);
+z.object({ messages: z.array(SavedMessageSchema) });
+const MessageStartEventSchema = z.object({
+	type: z.literal("message_start"),
+	data: z.object({
+		type: z.literal("message_start"),
+		message: z.object({
+			id: z.string(),
+			role: z.enum(["user", "assistant"]),
+			content: z.array(ContentBlockSchema)
+		})
+	})
+});
+const MessageDeltaEventSchema = z.object({
+	type: z.literal("message_delta"),
+	data: z.object({
+		type: z.literal("message_delta"),
+		delta: z.object({
+			stop_reason: z.enum(["end_turn", "tool_use"]),
+			stop_sequence: z.string().nullable()
+		}),
+		usage: UsageSchema.optional()
+	})
+});
+const MessageStopEventSchema = z.object({
+	type: z.literal("message_stop"),
+	data: z.object({ type: z.literal("message_stop") })
+});
+const ContentBlockStartEventSchema = z.object({
+	type: z.literal("content_block_start"),
+	data: z.object({
+		type: z.literal("content_block_start"),
+		index: z.number(),
+		contentBlock: ContentBlockSchema
+	})
+});
+const ContentBlockDeltaEventSchema = z.object({
+	type: z.literal("content_block_delta"),
+	data: z.object({
+		type: z.literal("content_block_delta"),
+		index: z.number(),
+		delta: z.union([z.object({
+			type: z.literal("text_delta"),
+			text: z.string()
+		}), z.object({
+			type: z.literal("input_json_delta"),
+			partial_json: z.string()
+		})])
+	})
+});
+const ContentBlockStopEventSchema = z.object({
+	type: z.literal("content_block_stop"),
+	data: z.object({
+		type: z.literal("content_block_stop"),
+		index: z.number()
+	})
+});
+const ErrorEventSchema = z.object({
+	type: z.literal("error"),
+	data: z.object({
+		type: z.literal("error"),
+		error: z.object({
+			code: z.string(),
+			message: z.string()
+		})
+	})
+});
+const PingEventSchema = z.object({
+	type: z.literal("ping"),
+	data: z.object({
+		type: z.literal("ping"),
+		timestamp: z.number()
+	})
+});
+const MessageStreamEventSchema = z.union([
+	MessageStartEventSchema,
+	MessageDeltaEventSchema,
+	MessageStopEventSchema,
+	ContentBlockStartEventSchema,
+	ContentBlockDeltaEventSchema,
+	ContentBlockStopEventSchema,
+	ErrorEventSchema,
+	PingEventSchema
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/@orpc+shared@1.13.6_@opentelemetry+api@1.9.0/node_modules/@orpc/shared/dist/index.mjs
+function resolveMaybeOptionalOptions(rest) {
+	return rest[0] ?? {};
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : value === void 0 || value === null ? [] : [value];
+}
+const ORPC_SHARED_PACKAGE_NAME = "@orpc/shared";
+const ORPC_SHARED_PACKAGE_VERSION = "1.13.6";
+function sequential(fn) {
+	let lastOperationPromise = Promise.resolve();
+	return (...args) => {
+		return lastOperationPromise = lastOperationPromise.catch(() => {}).then(() => {
+			return fn(...args);
+		});
+	};
+}
+const SPAN_ERROR_STATUS = 2;
+const GLOBAL_OTEL_CONFIG_KEY = `__${ORPC_SHARED_PACKAGE_NAME}@${ORPC_SHARED_PACKAGE_VERSION}/otel/config__`;
+function getGlobalOtelConfig() {
+	return globalThis[GLOBAL_OTEL_CONFIG_KEY];
+}
+function startSpan(name, options = {}, context) {
+	return (getGlobalOtelConfig()?.tracer)?.startSpan(name, options, context);
+}
+function setSpanError(span, error, options = {}) {
+	if (!span) return;
+	const exception = toOtelException(error);
+	span.recordException(exception);
+	if (!options.signal?.aborted || options.signal.reason !== error) span.setStatus({
+		code: SPAN_ERROR_STATUS,
+		message: exception.message
+	});
+}
+function toOtelException(error) {
+	if (error instanceof Error) {
+		const exception = {
+			message: error.message,
+			name: error.name,
+			stack: error.stack
+		};
+		if ("code" in error && (typeof error.code === "string" || typeof error.code === "number")) exception.code = error.code;
+		return exception;
+	}
+	return { message: String(error) };
+}
+async function runWithSpan({ name, context, ...options }, fn) {
+	const tracer = getGlobalOtelConfig()?.tracer;
+	if (!tracer) return fn();
+	const callback = async (span) => {
+		try {
+			return await fn(span);
+		} catch (e) {
+			setSpanError(span, e, options);
+			throw e;
+		} finally {
+			span.end();
+		}
+	};
+	if (context) return tracer.startActiveSpan(name, options, context, callback);
+	else return tracer.startActiveSpan(name, options, callback);
+}
+async function runInSpanContext(span, fn) {
+	const otelConfig = getGlobalOtelConfig();
+	if (!span || !otelConfig) return fn();
+	const ctx = otelConfig.trace.setSpan(otelConfig.context.active(), span);
+	return otelConfig.context.with(ctx, fn);
+}
+function isAsyncIteratorObject(maybe) {
+	if (!maybe || typeof maybe !== "object") return false;
+	return "next" in maybe && typeof maybe.next === "function" && Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
+}
+const fallbackAsyncDisposeSymbol = Symbol.for("asyncDispose");
+const asyncDisposeSymbol = Symbol.asyncDispose ?? fallbackAsyncDisposeSymbol;
+var AsyncIteratorClass = class {
+	#isDone = false;
+	#isExecuteComplete = false;
+	#cleanup;
+	#next;
+	constructor(next, cleanup) {
+		this.#cleanup = cleanup;
+		this.#next = sequential(async () => {
+			if (this.#isDone) return {
+				done: true,
+				value: void 0
+			};
+			try {
+				const result = await next();
+				if (result.done) this.#isDone = true;
+				return result;
+			} catch (err) {
+				this.#isDone = true;
+				throw err;
+			} finally {
+				if (this.#isDone && !this.#isExecuteComplete) {
+					this.#isExecuteComplete = true;
+					await this.#cleanup("next");
+				}
+			}
+		});
+	}
+	next() {
+		return this.#next();
+	}
+	async return(value) {
+		this.#isDone = true;
+		if (!this.#isExecuteComplete) {
+			this.#isExecuteComplete = true;
+			await this.#cleanup("return");
+		}
+		return {
+			done: true,
+			value
+		};
+	}
+	async throw(err) {
+		this.#isDone = true;
+		if (!this.#isExecuteComplete) {
+			this.#isExecuteComplete = true;
+			await this.#cleanup("throw");
+		}
+		throw err;
+	}
+	/**
+	* asyncDispose symbol only available in esnext, we should fallback to Symbol.for('asyncDispose')
+	*/
+	async [asyncDisposeSymbol]() {
+		this.#isDone = true;
+		if (!this.#isExecuteComplete) {
+			this.#isExecuteComplete = true;
+			await this.#cleanup("dispose");
+		}
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+};
+function asyncIteratorWithSpan({ name, ...options }, iterator) {
+	let span;
+	return new AsyncIteratorClass(async () => {
+		span ??= startSpan(name);
+		try {
+			const result = await runInSpanContext(span, () => iterator.next());
+			span?.addEvent(result.done ? "completed" : "yielded");
+			return result;
+		} catch (err) {
+			setSpanError(span, err, options);
+			throw err;
+		}
+	}, async (reason) => {
+		try {
+			if (reason !== "next") await runInSpanContext(span, () => iterator.return?.());
+		} catch (err) {
+			setSpanError(span, err, options);
+			throw err;
+		} finally {
+			span?.end();
+		}
+	});
+}
+function intercept(interceptors, options, main) {
+	const next = (options2, index) => {
+		const interceptor = interceptors[index];
+		if (!interceptor) return main(options2);
+		return interceptor({
+			...options2,
+			next: (newOptions = options2) => next(newOptions, index + 1)
+		});
+	};
+	return next(options, 0);
+}
+function isObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || !proto || !proto.constructor;
+}
+function value(value2, ...args) {
+	if (typeof value2 === "function") return value2(...args);
+	return value2;
+}
+function overlayProxy(target, partial) {
+	return new Proxy(typeof target === "function" ? partial : target, {
+		get(_, prop) {
+			const targetValue = prop in partial ? partial : value(target);
+			const v = Reflect.get(targetValue, prop);
+			return typeof v === "function" ? v.bind(targetValue) : v;
+		},
+		has(_, prop) {
+			return Reflect.has(partial, prop) || Reflect.has(value(target), prop);
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@orpc+standard-server@1.13.6_@opentelemetry+api@1.9.0/node_modules/@orpc/standard-server/dist/index.mjs
+var HibernationEventIterator = class extends AsyncIteratorClass {
+	/**
+	* this property is not transferred to the client, so it should be optional for type safety
+	*/
+	hibernationCallback;
+	constructor(hibernationCallback) {
+		super(async () => {
+			throw new Error("Cannot iterate over hibernating iterator directly");
+		}, async (reason) => {
+			if (reason !== "next") throw new Error("Cannot cleanup hibernating iterator directly");
+		});
+		this.hibernationCallback = hibernationCallback;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@orpc+server@1.13.6_@opentelemetry+api@1.9.0_crossws@0.3.5_ws@8.19.0/node_modules/@orpc/server/dist/shared/server.Ds4HPpvH.mjs
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazy(loader, meta = {}) {
+	return { [LAZY_SYMBOL]: {
+		loader,
+		meta
+	} };
+}
+function isLazy(item) {
+	return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+	return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+	return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+function isStartWithMiddlewares(middlewares, compare) {
+	if (compare.length > middlewares.length) return false;
+	for (let i = 0; i < middlewares.length; i++) {
+		if (compare[i] === void 0) return true;
+		if (middlewares[i] !== compare[i]) return false;
+	}
+	return true;
+}
+function mergeMiddlewares(first, second, options) {
+	if (options.dedupeLeading && isStartWithMiddlewares(second, first)) return second;
+	return [...first, ...second];
+}
+function addMiddleware(middlewares, addition) {
+	return [...middlewares, addition];
+}
+var Procedure = class {
+	/**
+	* This property holds the defined options.
+	*/
+	"~orpc";
+	constructor(def) {
+		this["~orpc"] = def;
+	}
+};
+function isProcedure(item) {
+	if (item instanceof Procedure) return true;
+	return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
+}
+function mergeCurrentContext(context, other) {
+	return {
+		...context,
+		...other
+	};
+}
+function createORPCErrorConstructorMap(errors) {
+	return new Proxy(errors, { get(target, code) {
+		if (typeof code !== "string") return Reflect.get(target, code);
+		const item = (...rest) => {
+			const options = resolveMaybeOptionalOptions(rest);
+			const config = errors[code];
+			return new ORPCError(code, {
+				defined: Boolean(config),
+				status: config?.status,
+				message: options.message ?? config?.message,
+				data: options.data,
+				cause: options.cause
+			});
+		};
+		return item;
+	} });
+}
+function middlewareOutputFn(output) {
+	return {
+		output,
+		context: {}
+	};
+}
+function createProcedureClient(lazyableProcedure, ...rest) {
+	const options = resolveMaybeOptionalOptions(rest);
+	return async (...[input, callerOptions]) => {
+		const path = toArray(options.path);
+		const { default: procedure } = await unlazy(lazyableProcedure);
+		const clientContext = callerOptions?.context ?? {};
+		const context = await value(options.context ?? {}, clientContext);
+		const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
+		const validateError = async (e) => {
+			if (e instanceof ORPCError) return await validateORPCError(procedure["~orpc"].errorMap, e);
+			return e;
+		};
+		try {
+			const output = await runWithSpan({
+				name: "call_procedure",
+				signal: callerOptions?.signal
+			}, (span) => {
+				span?.setAttribute("procedure.path", [...path]);
+				return intercept(toArray(options.interceptors), {
+					context,
+					input,
+					errors,
+					path,
+					procedure,
+					signal: callerOptions?.signal,
+					lastEventId: callerOptions?.lastEventId
+				}, (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions));
+			});
+			if (isAsyncIteratorObject(output)) {
+				if (output instanceof HibernationEventIterator) return output;
+				return overlayProxy(output, mapEventIterator(asyncIteratorWithSpan({
+					name: "consume_event_iterator_output",
+					signal: callerOptions?.signal
+				}, output), {
+					value: (v) => v,
+					error: (e) => validateError(e)
+				}));
+			}
+			return output;
+		} catch (e) {
+			throw await validateError(e);
+		}
+	};
+}
+async function validateInput(procedure, input) {
+	const schema = procedure["~orpc"].inputSchema;
+	if (!schema) return input;
+	return runWithSpan({ name: "validate_input" }, async () => {
+		const result = await schema["~standard"].validate(input);
+		if (result.issues) throw new ORPCError("BAD_REQUEST", {
+			message: "Input validation failed",
+			data: { issues: result.issues },
+			cause: new ValidationError({
+				message: "Input validation failed",
+				issues: result.issues,
+				data: input
+			})
+		});
+		return result.value;
+	});
+}
+async function validateOutput(procedure, output) {
+	const schema = procedure["~orpc"].outputSchema;
+	if (!schema) return output;
+	return runWithSpan({ name: "validate_output" }, async () => {
+		const result = await schema["~standard"].validate(output);
+		if (result.issues) throw new ORPCError("INTERNAL_SERVER_ERROR", {
+			message: "Output validation failed",
+			cause: new ValidationError({
+				message: "Output validation failed",
+				issues: result.issues,
+				data: output
+			})
+		});
+		return result.value;
+	});
+}
+async function executeProcedureInternal(procedure, options) {
+	const middlewares = procedure["~orpc"].middlewares;
+	const inputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].inputValidationIndex), middlewares.length);
+	const outputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].outputValidationIndex), middlewares.length);
+	const next = async (index, context, input) => {
+		let currentInput = input;
+		if (index === inputValidationIndex) currentInput = await validateInput(procedure, currentInput);
+		const mid = middlewares[index];
+		const output = mid ? await runWithSpan({
+			name: `middleware.${mid.name}`,
+			signal: options.signal
+		}, async (span) => {
+			span?.setAttribute("middleware.index", index);
+			span?.setAttribute("middleware.name", mid.name);
+			return (await mid({
+				...options,
+				context,
+				next: async (...[nextOptions]) => {
+					const nextContext = nextOptions?.context ?? {};
+					return {
+						output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+						context: nextContext
+					};
+				}
+			}, currentInput, middlewareOutputFn)).output;
+		}) : await runWithSpan({
+			name: "handler",
+			signal: options.signal
+		}, () => procedure["~orpc"].handler({
+			...options,
+			context,
+			input: currentInput
+		}));
+		if (index === outputValidationIndex) return await validateOutput(procedure, output);
+		return output;
+	};
+	return next(0, options.context, options.input);
+}
+function getRouter(router, path) {
+	let current = router;
+	for (let i = 0; i < path.length; i++) {
+		const segment = path[i];
+		if (!current) return;
+		if (isProcedure(current)) return;
+		if (!isLazy(current)) {
+			current = current[segment];
+			continue;
+		}
+		const lazied = current;
+		const rest = path.slice(i);
+		return lazy(async () => {
+			return unlazy(getRouter((await unlazy(lazied)).default, rest));
+		}, getLazyMeta(lazied));
+	}
+	return current;
+}
+function createAccessibleLazyRouter(lazied) {
+	return new Proxy(lazied, { get(target, key) {
+		if (typeof key !== "string") return Reflect.get(target, key);
+		return createAccessibleLazyRouter(getRouter(lazied, [key]));
+	} });
+}
+function enhanceRouter(router, options) {
+	if (isLazy(router)) {
+		const laziedMeta = getLazyMeta(router);
+		const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+		return createAccessibleLazyRouter(lazy(async () => {
+			const { default: unlaziedRouter } = await unlazy(router);
+			return unlazy(enhanceRouter(unlaziedRouter, options));
+		}, {
+			...laziedMeta,
+			prefix: enhancedPrefix
+		}));
+	}
+	if (isProcedure(router)) {
+		const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, { dedupeLeading: options.dedupeLeadingMiddlewares });
+		const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+		return new Procedure({
+			...router["~orpc"],
+			route: enhanceRoute(router["~orpc"].route, options),
+			errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+			middlewares: newMiddlewares,
+			inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+			outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
+		});
+	}
+	const enhanced = {};
+	for (const key in router) enhanced[key] = enhanceRouter(router[key], options);
+	return enhanced;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@orpc+server@1.13.6_@opentelemetry+api@1.9.0_crossws@0.3.5_ws@8.19.0/node_modules/@orpc/server/dist/index.mjs
+const DEFAULT_CONFIG = {
+	initialInputValidationIndex: 0,
+	initialOutputValidationIndex: 0,
+	dedupeLeadingMiddlewares: true
+};
+function fallbackConfig(key, value) {
+	if (value === void 0) return DEFAULT_CONFIG[key];
+	return value;
+}
+function decorateMiddleware(middleware) {
+	const decorated = ((...args) => middleware(...args));
+	decorated.mapInput = (mapInput) => {
+		return decorateMiddleware((options, input, ...rest) => middleware(options, mapInput(input), ...rest));
+	};
+	decorated.concat = (concatMiddleware, mapInput) => {
+		const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
+		return decorateMiddleware((options, input, output, ...rest) => {
+			return middleware({
+				...options,
+				next: (...[nextOptions1]) => mapped({
+					...options,
+					context: {
+						...options.context,
+						...nextOptions1?.context
+					},
+					next: (...[nextOptions2]) => options.next({ context: {
+						...nextOptions1?.context,
+						...nextOptions2?.context
+					} })
+				}, input, output, ...rest)
+			}, input, output, ...rest);
+		});
+	};
+	return decorated;
+}
+function createActionableClient(client) {
+	const action = async (input) => {
+		try {
+			return [null, await client(input)];
+		} catch (error) {
+			if (error instanceof Error && "digest" in error && typeof error.digest === "string" && error.digest.startsWith("NEXT_")) throw error;
+			if (error instanceof Response && "options" in error && isObject(error.options) || isObject(error) && error.isNotFound === true) throw error;
+			return [toORPCError(error).toJSON(), void 0];
+		}
+	};
+	return action;
+}
+var DecoratedProcedure = class DecoratedProcedure extends Procedure {
+	/**
+	* Adds type-safe custom errors.
+	* The provided errors are spared-merged with any existing errors.
+	*
+	* @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
+	*/
+	errors(errors) {
+		return new DecoratedProcedure({
+			...this["~orpc"],
+			errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+		});
+	}
+	/**
+	* Sets or updates the metadata.
+	* The provided metadata is spared-merged with any existing metadata.
+	*
+	* @see {@link https://orpc.dev/docs/metadata Metadata Docs}
+	*/
+	meta(meta) {
+		return new DecoratedProcedure({
+			...this["~orpc"],
+			meta: mergeMeta(this["~orpc"].meta, meta)
+		});
+	}
+	/**
+	* Sets or updates the route definition.
+	* The provided route is spared-merged with any existing route.
+	* This option is typically relevant when integrating with OpenAPI.
+	*
+	* @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+	* @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+	*/
+	route(route) {
+		return new DecoratedProcedure({
+			...this["~orpc"],
+			route: mergeRoute(this["~orpc"].route, route)
+		});
+	}
+	use(middleware, mapInput) {
+		const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+		return new DecoratedProcedure({
+			...this["~orpc"],
+			middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
+		});
+	}
+	/**
+	* Make this procedure callable (works like a function while still being a procedure).
+	*
+	* @see {@link https://orpc.dev/docs/client/server-side Server-side Client Docs}
+	*/
+	callable(...rest) {
+		const client = createProcedureClient(this, ...rest);
+		return new Proxy(client, {
+			get: (target, key) => {
+				return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+			},
+			has: (target, key) => {
+				return Reflect.has(this, key) || Reflect.has(target, key);
+			}
+		});
+	}
+	/**
+	* Make this procedure compatible with server action.
+	*
+	* @see {@link https://orpc.dev/docs/server-action Server Action Docs}
+	*/
+	actionable(...rest) {
+		const action = createActionableClient(createProcedureClient(this, ...rest));
+		return new Proxy(action, {
+			get: (target, key) => {
+				return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+			},
+			has: (target, key) => {
+				return Reflect.has(this, key) || Reflect.has(target, key);
+			}
+		});
+	}
+};
+new class Builder {
+	/**
+	* This property holds the defined options.
+	*/
+	"~orpc";
+	constructor(def) {
+		this["~orpc"] = def;
+	}
+	/**
+	* Sets or overrides the config.
+	*
+	* @see {@link https://orpc.dev/docs/client/server-side#middlewares-order Middlewares Order Docs}
+	* @see {@link https://orpc.dev/docs/best-practices/dedupe-middleware#configuration Dedupe Middleware Docs}
+	*/
+	$config(config) {
+		const inputValidationCount = this["~orpc"].inputValidationIndex - fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex);
+		const outputValidationCount = this["~orpc"].outputValidationIndex - fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex);
+		return new Builder({
+			...this["~orpc"],
+			config,
+			dedupeLeadingMiddlewares: fallbackConfig("dedupeLeadingMiddlewares", config.dedupeLeadingMiddlewares),
+			inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
+			outputValidationIndex: fallbackConfig("initialOutputValidationIndex", config.initialOutputValidationIndex) + outputValidationCount
+		});
+	}
+	/**
+	* Set or override the initial context.
+	*
+	* @see {@link https://orpc.dev/docs/context Context Docs}
+	*/
+	$context() {
+		return new Builder({
+			...this["~orpc"],
+			middlewares: [],
+			inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
+			outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex)
+		});
+	}
+	/**
+	* Sets or overrides the initial meta.
+	*
+	* @see {@link https://orpc.dev/docs/metadata Metadata Docs}
+	*/
+	$meta(initialMeta) {
+		return new Builder({
+			...this["~orpc"],
+			meta: initialMeta
+		});
+	}
+	/**
+	* Sets or overrides the initial route.
+	* This option is typically relevant when integrating with OpenAPI.
+	*
+	* @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+	* @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+	*/
+	$route(initialRoute) {
+		return new Builder({
+			...this["~orpc"],
+			route: initialRoute
+		});
+	}
+	/**
+	* Sets or overrides the initial input schema.
+	*
+	* @see {@link https://orpc.dev/docs/procedure#initial-configuration Initial Procedure Configuration Docs}
+	*/
+	$input(initialInputSchema) {
+		return new Builder({
+			...this["~orpc"],
+			inputSchema: initialInputSchema
+		});
+	}
+	/**
+	* Creates a middleware.
+	*
+	* @see {@link https://orpc.dev/docs/middleware Middleware Docs}
+	*/
+	middleware(middleware) {
+		return decorateMiddleware(middleware);
+	}
+	/**
+	* Adds type-safe custom errors.
+	* The provided errors are spared-merged with any existing errors.
+	*
+	* @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
+	*/
+	errors(errors) {
+		return new Builder({
+			...this["~orpc"],
+			errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+		});
+	}
+	use(middleware, mapInput) {
+		const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+		return new Builder({
+			...this["~orpc"],
+			middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
+		});
+	}
+	/**
+	* Sets or updates the metadata.
+	* The provided metadata is spared-merged with any existing metadata.
+	*
+	* @see {@link https://orpc.dev/docs/metadata Metadata Docs}
+	*/
+	meta(meta) {
+		return new Builder({
+			...this["~orpc"],
+			meta: mergeMeta(this["~orpc"].meta, meta)
+		});
+	}
+	/**
+	* Sets or updates the route definition.
+	* The provided route is spared-merged with any existing route.
+	* This option is typically relevant when integrating with OpenAPI.
+	*
+	* @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+	* @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+	*/
+	route(route) {
+		return new Builder({
+			...this["~orpc"],
+			route: mergeRoute(this["~orpc"].route, route)
+		});
+	}
+	/**
+	* Defines the input validation schema.
+	*
+	* @see {@link https://orpc.dev/docs/procedure#input-output-validation Input Validation Docs}
+	*/
+	input(schema) {
+		return new Builder({
+			...this["~orpc"],
+			inputSchema: schema,
+			inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + this["~orpc"].middlewares.length
+		});
+	}
+	/**
+	* Defines the output validation schema.
+	*
+	* @see {@link https://orpc.dev/docs/procedure#input-output-validation Output Validation Docs}
+	*/
+	output(schema) {
+		return new Builder({
+			...this["~orpc"],
+			outputSchema: schema,
+			outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
+		});
+	}
+	/**
+	* Defines the handler of the procedure.
+	*
+	* @see {@link https://orpc.dev/docs/procedure Procedure Docs}
+	*/
+	handler(handler) {
+		return new DecoratedProcedure({
+			...this["~orpc"],
+			handler
+		});
+	}
+	/**
+	* Prefixes all procedures in the router.
+	* The provided prefix is post-appended to any existing router prefix.
+	*
+	* @note This option does not affect procedures that do not define a path in their route definition.
+	*
+	* @see {@link https://orpc.dev/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
+	*/
+	prefix(prefix) {
+		return new Builder({
+			...this["~orpc"],
+			prefix: mergePrefix(this["~orpc"].prefix, prefix)
+		});
+	}
+	/**
+	* Adds tags to all procedures in the router.
+	* This helpful when you want to group procedures together in the OpenAPI specification.
+	*
+	* @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+	*/
+	tag(...tags) {
+		return new Builder({
+			...this["~orpc"],
+			tags: mergeTags(this["~orpc"].tags, tags)
+		});
+	}
+	/**
+	* Applies all of the previously defined options to the specified router.
+	*
+	* @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
+	*/
+	router(router) {
+		return enhanceRouter(router, this["~orpc"]);
+	}
+	/**
+	* Create a lazy router
+	* And applies all of the previously defined options to the specified router.
+	*
+	* @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
+	*/
+	lazy(loader) {
+		return enhanceRouter(lazy(loader), this["~orpc"]);
+	}
+}({
+	config: {},
+	route: {},
+	meta: {},
+	errorMap: {},
+	inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
+	outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
+	middlewares: [],
+	dedupeLeadingMiddlewares: true
+});
+//#endregion
+//#region ../api-contracts/dist/src-bLbxYIy4.mjs
+var apps_default = {
+	find: oc.route({
+		method: "GET",
+		path: "/apps/{id}",
+		tags: ["Apps"],
+		summary: "Get an app",
+		description: "Retrieve an app by its ID"
+	}).input(z$1.object({ id: z$1.string() })).output(z$1.object({
+		id: z$1.string(),
+		name: z$1.string(),
+		createdAt: z$1.coerce.date()
+	})),
+	list: oc.route({
+		method: "GET",
+		path: "/apps",
+		tags: ["Apps"],
+		summary: "List apps",
+		description: "Retrieve all apps"
+	}).output(z$1.object({ results: z$1.array(z$1.object({
+		id: z$1.string(),
+		name: z$1.string(),
+		createdAt: z$1.coerce.date()
+	})) }))
+};
+const ChatSchema = z$1.object({
+	id: z$1.string(),
+	title: z$1.string(),
+	userId: z$1.string(),
+	createdAt: z$1.coerce.date()
+});
+var chats_default = {
+	create: oc.route({
+		method: "POST",
+		path: "/chats",
+		tags: ["Chats"],
+		summary: "Create a chat",
+		description: "Create a new chat session"
+	}).input(z$1.object({
+		title: z$1.string(),
+		userId: z$1.string().min(1)
+	})).output(ChatSchema),
+	find: oc.route({
+		method: "GET",
+		path: "/chats/{id}",
+		tags: ["Chats"],
+		summary: "Get a chat",
+		description: "Retrieve a chat by its ID"
+	}).input(z$1.object({ id: z$1.string() })).output(ChatSchema),
+	list: oc.route({
+		method: "GET",
+		path: "/chats",
+		tags: ["Chats"],
+		summary: "List chats",
+		description: "Retrieve all chats with pagination support"
+	}).input(z$1.object({
+		userId: z$1.string().min(1).optional(),
+		limit: z$1.coerce.number().int().min(1).max(100).default(20),
+		cursor: z$1.string().optional()
+	})).output(z$1.object({
+		results: z$1.array(ChatSchema),
+		nextCursor: z$1.string().nullable(),
+		hasMore: z$1.boolean()
+	}))
+};
+const MessageSchema = z$1.object({
+	id: z$1.string(),
+	role: z$1.enum(["user", "assistant"]),
+	content: z$1.array(ContentBlockSchema),
+	createdAt: z$1.coerce.date(),
+	error: z$1.object({
+		code: z$1.string(),
+		message: z$1.string()
+	}).nullable()
+});
+var messages_default = { create: oc.route({
+	method: "POST",
+	path: "/messages",
+	tags: ["Messages"],
+	summary: "Create a message",
+	description: "Create a user message in a chat"
+}).input(z$1.object({
+	id: z$1.string().optional(),
+	chatId: z$1.string(),
+	content: ContentFieldSchema
+})).output(MessageSchema) };
+const toolSchema = z$1.object({
+	name: z$1.string(),
+	description: z$1.string(),
+	defaultLoadingText: z$1.string().nullish(),
+	defaultSuccessText: z$1.string().nullish(),
+	inputSchema: z$1.any().optional()
+});
+var responses_default = { create: oc.route({
+	method: "POST",
+	path: "/responses",
+	tags: ["Responses"],
+	summary: "Create a response",
+	description: "Send a user message to a chat and stream the assistant response. Returns a Server-Sent Events (SSE) stream of message events.",
+	successDescription: "SSE stream of message events (message_start, content_block_delta, message_delta, message_stop, etc.)."
+}).input(z$1.object({
+	id: z$1.string().optional().describe("Optional client-generated message ID."),
+	chatId: z$1.string().describe("The chat ID to send the message to."),
+	content: ContentFieldSchema.describe("The message content (text or structured blocks)."),
+	tools: z$1.array(toolSchema).default([]).describe("Tools available to the assistant for this request."),
+	tags: z$1.array(z$1.string()).optional().describe("Tags to attach to this response."),
+	model: z$1.string().optional().describe("Override the model for this request.")
+})).output(eventIterator(MessageStreamEventSchema)) };
+/**
+* Header name constants for the public API
+*/
+const API_KEY_HEADER = "x-api-key";
+/**
+* Schema for the API key header
+* API keys are prefixed with 'sk_' (secret key)
+*/
+const ApiKeyHeaderSchema = z.string().min(1, "API key is required");
+z.object({ [API_KEY_HEADER]: ApiKeyHeaderSchema });
+const contract = {
+	apps: apps_default,
+	chats: chats_default,
+	messages: messages_default,
+	responses: responses_default
+};
+//#endregion
+//#region src/index.ts
+const DEFAULT_BASE_URL = "https://api.plucky.ai";
+/**
+* Plucky API client for Node.js
+*
+* @example
+* ```ts
+* import Plucky from '@plucky-ai/node'
+*
+* const plucky = new Plucky({ apiKey: 'sk_...' })
+*
+* const chats = await plucky.chats.list()
+* ```
+*/
+var Plucky = class {
+	client;
+	/**
+	* Access to chat operations
+	*/
+	chats;
+	/**
+	* Access to app operations
+	*/
+	apps;
+	constructor(options) {
+		const { apiKey, baseUrl = DEFAULT_BASE_URL, fetch: customFetch } = options;
+		if (!apiKey) throw new Error("API key is required. Get one at https://app.plucky.ai");
+		this.client = createApiClient$1({
+			apiKey,
+			baseUrl,
+			fetch: customFetch
+		});
+		this.chats = this.client.chats;
+		this.apps = this.client.apps;
+	}
+	/**
+	* Get the underlying API client for advanced use cases
+	*/
+	get api() {
+		return this.client;
+	}
+};
+//#endregion
+export { API_KEY_HEADER, Plucky, Plucky as default, contract, createApiClient };
+
+//# sourceMappingURL=index.mjs.map