@plucky-ai/node 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -1,5 +1,8 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-//#region rolldown:runtime
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -20,18 +23,947 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-
 //#endregion
-let __plucky_ai_api_contracts_client = require("@plucky-ai/api-contracts/client");
-__plucky_ai_api_contracts_client = __toESM(__plucky_ai_api_contracts_client);
-let __orpc_contract = require("@orpc/contract");
-__orpc_contract = __toESM(__orpc_contract);
+let _plucky_ai_api_contracts_client = require("@plucky-ai/api-contracts/client");
+let _orpc_contract = require("@orpc/contract");
 let zod = require("zod");
 zod = __toESM(zod);
-
-//#region ../api-contracts/dist/src-BsXbfiX4.js
+let _orpc_client = require("@orpc/client");
+//#region ../llm-schemas/dist/index.mjs
+const TextContentBlockSchema = zod.z.object({
+	type: zod.z.literal("text"),
+	text: zod.z.string()
+});
+const ToolUseContentBlockSchema = zod.z.object({
+	type: zod.z.literal("tool_use"),
+	id: zod.z.string(),
+	name: zod.z.string(),
+	input: zod.z.unknown(),
+	defaultLoadingText: zod.z.string().nullable().optional(),
+	defaultSuccessText: zod.z.string().nullable().optional(),
+	partial_json: zod.z.string().nullable().optional()
+});
+const ToolResultContentBlockSchema = zod.z.object({
+	type: zod.z.literal("tool_result"),
+	toolUseId: zod.z.string(),
+	content: zod.z.string(),
+	successText: zod.z.string().nullish()
+});
+const ContentBlockSchema = zod.z.union([
+	TextContentBlockSchema,
+	ToolUseContentBlockSchema,
+	ToolResultContentBlockSchema
+]);
+const ContentFieldSchema = zod.z.union([zod.z.string(), zod.z.array(ContentBlockSchema)]);
+const InputMessageSchema = zod.z.object({
+	role: zod.z.enum(["user", "assistant"]),
+	content: ContentFieldSchema
+});
+InputMessageSchema.extend({ content: zod.z.array(ContentBlockSchema) });
+const SavedInputMessageSchema = InputMessageSchema.extend({
+	id: zod.z.string(),
+	content: zod.z.array(ContentBlockSchema),
+	createdAt: zod.z.coerce.date()
+});
+const UsageSchema = zod.z.object({
+	inputTokens: zod.z.number(),
+	outputTokens: zod.z.number(),
+	cacheReadInputTokens: zod.z.number().optional(),
+	cacheCreationInputTokens: zod.z.number().optional()
+});
+const OutputMessageSchema = InputMessageSchema.extend({
+	id: zod.z.string(),
+	content: zod.z.array(ContentBlockSchema),
+	usage: UsageSchema
+});
+const SavedOutputMessageSchema = OutputMessageSchema.extend({ createdAt: zod.z.coerce.date() });
+const SavedMessageSchema = zod.z.union([SavedInputMessageSchema, SavedOutputMessageSchema]);
+zod.z.union([
+	InputMessageSchema,
+	OutputMessageSchema,
+	SavedInputMessageSchema,
+	SavedOutputMessageSchema
+]);
+zod.z.object({ messages: zod.z.array(SavedMessageSchema) });
+const MessageStartEventSchema = zod.z.object({
+	type: zod.z.literal("message_start"),
+	data: zod.z.object({
+		type: zod.z.literal("message_start"),
+		message: zod.z.object({
+			id: zod.z.string(),
+			role: zod.z.enum(["user", "assistant"]),
+			content: zod.z.array(ContentBlockSchema)
+		})
+	})
+});
+const MessageDeltaEventSchema = zod.z.object({
+	type: zod.z.literal("message_delta"),
+	data: zod.z.object({
+		type: zod.z.literal("message_delta"),
+		delta: zod.z.object({
+			stop_reason: zod.z.enum(["end_turn", "tool_use"]),
+			stop_sequence: zod.z.string().nullable()
+		}),
+		usage: UsageSchema.optional()
+	})
+});
+const MessageStopEventSchema = zod.z.object({
+	type: zod.z.literal("message_stop"),
+	data: zod.z.object({ type: zod.z.literal("message_stop") })
+});
+const ContentBlockStartEventSchema = zod.z.object({
+	type: zod.z.literal("content_block_start"),
+	data: zod.z.object({
+		type: zod.z.literal("content_block_start"),
+		index: zod.z.number(),
+		contentBlock: ContentBlockSchema
+	})
+});
+const ContentBlockDeltaEventSchema = zod.z.object({
+	type: zod.z.literal("content_block_delta"),
+	data: zod.z.object({
+		type: zod.z.literal("content_block_delta"),
+		index: zod.z.number(),
+		delta: zod.z.union([zod.z.object({
+			type: zod.z.literal("text_delta"),
+			text: zod.z.string()
+		}), zod.z.object({
+			type: zod.z.literal("input_json_delta"),
+			partial_json: zod.z.string()
+		})])
+	})
+});
+const ContentBlockStopEventSchema = zod.z.object({
+	type: zod.z.literal("content_block_stop"),
+	data: zod.z.object({
+		type: zod.z.literal("content_block_stop"),
+		index: zod.z.number()
+	})
+});
+const ErrorEventSchema = zod.z.object({
+	type: zod.z.literal("error"),
+	data: zod.z.object({
+		type: zod.z.literal("error"),
+		error: zod.z.object({
+			code: zod.z.string(),
+			message: zod.z.string()
+		})
+	})
+});
+const PingEventSchema = zod.z.object({
+	type: zod.z.literal("ping"),
+	data: zod.z.object({
+		type: zod.z.literal("ping"),
+		timestamp: zod.z.number()
+	})
+});
+const MessageStreamEventSchema = zod.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 (0, _orpc_contract.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 _orpc_client.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 _orpc_client.ORPCError) return await (0, _orpc_contract.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, (0, _orpc_client.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 _orpc_client.ORPCError("BAD_REQUEST", {
+			message: "Input validation failed",
+			data: { issues: result.issues },
+			cause: new _orpc_contract.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 _orpc_client.ORPCError("INTERNAL_SERVER_ERROR", {
+			message: "Output validation failed",
+			cause: new _orpc_contract.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 ? (0, _orpc_contract.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: (0, _orpc_contract.enhanceRoute)(router["~orpc"].route, options),
+			errorMap: (0, _orpc_contract.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 [(0, _orpc_client.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: (0, _orpc_contract.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: (0, _orpc_contract.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: (0, _orpc_contract.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: (0, _orpc_contract.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: (0, _orpc_contract.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: (0, _orpc_contract.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: (0, _orpc_contract.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: (0, _orpc_contract.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: __orpc_contract.oc.route({
+	find: _orpc_contract.oc.route({
 		method: "GET",
 		path: "/apps/{id}",
 		tags: ["Apps"],
@@ -42,7 +974,7 @@ var apps_default = {
 		name: zod.default.string(),
 		createdAt: zod.default.coerce.date()
 	})),
-	list: __orpc_contract.oc.route({
+	list: _orpc_contract.oc.route({
 		method: "GET",
 		path: "/apps",
 		tags: ["Apps"],
@@ -61,7 +993,7 @@ const ChatSchema = zod.default.object({
 	createdAt: zod.default.coerce.date()
 });
 var chats_default = {
-	create: __orpc_contract.oc.route({
+	create: _orpc_contract.oc.route({
 		method: "POST",
 		path: "/chats",
 		tags: ["Chats"],
@@ -71,14 +1003,14 @@ var chats_default = {
 		title: zod.default.string(),
 		userId: zod.default.string().min(1)
 	})).output(ChatSchema),
-	find: __orpc_contract.oc.route({
+	find: _orpc_contract.oc.route({
 		method: "GET",
 		path: "/chats/{id}",
 		tags: ["Chats"],
 		summary: "Get a chat",
 		description: "Retrieve a chat by its ID"
 	}).input(zod.default.object({ id: zod.default.string() })).output(ChatSchema),
-	list: __orpc_contract.oc.route({
+	list: _orpc_contract.oc.route({
 		method: "GET",
 		path: "/chats",
 		tags: ["Chats"],
@@ -94,6 +1026,49 @@ var chats_default = {
 		hasMore: zod.default.boolean()
 	}))
 };
+const MessageSchema = zod.default.object({
+	id: zod.default.string(),
+	role: zod.default.enum(["user", "assistant"]),
+	content: zod.default.array(ContentBlockSchema),
+	createdAt: zod.default.coerce.date(),
+	error: zod.default.object({
+		code: zod.default.string(),
+		message: zod.default.string()
+	}).nullable()
+});
+var messages_default = { create: _orpc_contract.oc.route({
+	method: "POST",
+	path: "/messages",
+	tags: ["Messages"],
+	summary: "Create a message",
+	description: "Create a user message in a chat"
+}).input(zod.default.object({
+	id: zod.default.string().optional(),
+	chatId: zod.default.string(),
+	content: ContentFieldSchema
+})).output(MessageSchema) };
+const toolSchema = zod.default.object({
+	name: zod.default.string(),
+	description: zod.default.string(),
+	defaultLoadingText: zod.default.string().nullish(),
+	defaultSuccessText: zod.default.string().nullish(),
+	inputSchema: zod.default.any().optional()
+});
+var responses_default = { create: _orpc_contract.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(zod.default.object({
+	id: zod.default.string().optional().describe("Optional client-generated message ID."),
+	chatId: zod.default.string().describe("The chat ID to send the message to."),
+	content: ContentFieldSchema.describe("The message content (text or structured blocks)."),
+	tools: zod.default.array(toolSchema).default([]).describe("Tools available to the assistant for this request."),
+	tags: zod.default.array(zod.default.string()).optional().describe("Tags to attach to this response."),
+	model: zod.default.string().optional().describe("Override the model for this request.")
+})).output((0, _orpc_contract.eventIterator)(MessageStreamEventSchema)) };
 /**
 * Header name constants for the public API
 */
@@ -103,15 +1078,13 @@ const API_KEY_HEADER = "x-api-key";
 * API keys are prefixed with 'sk_' (secret key)
 */
 const ApiKeyHeaderSchema = zod.z.string().min(1, "API key is required");
-/**
-* Combined headers schema for all API requests
-*/
-const ApiHeadersSchema = zod.z.object({ [API_KEY_HEADER]: ApiKeyHeaderSchema });
+zod.z.object({ [API_KEY_HEADER]: ApiKeyHeaderSchema });
 const contract = {
 	apps: apps_default,
-	chats: chats_default
+	chats: chats_default,
+	messages: messages_default,
+	responses: responses_default
 };
-
 //#endregion
 //#region src/index.ts
 const DEFAULT_BASE_URL = "https://api.plucky.ai";
@@ -140,7 +1113,7 @@ var Plucky = class {
 	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 = (0, __plucky_ai_api_contracts_client.createApiClient)({
+		this.client = (0, _plucky_ai_api_contracts_client.createApiClient)({
 			apiKey,
 			baseUrl,
 			fetch: customFetch
@@ -155,17 +1128,16 @@ var Plucky = class {
 		return this.client;
 	}
 };
-var src_default = Plucky;
-
 //#endregion
 exports.API_KEY_HEADER = API_KEY_HEADER;
 exports.Plucky = Plucky;
+exports.default = Plucky;
 exports.contract = contract;
-Object.defineProperty(exports, 'createApiClient', {
-  enumerable: true,
-  get: function () {
-    return __plucky_ai_api_contracts_client.createApiClient;
-  }
+Object.defineProperty(exports, "createApiClient", {
+	enumerable: true,
+	get: function() {
+		return _plucky_ai_api_contracts_client.createApiClient;
+	}
 });
-exports.default = src_default;
+
 //# sourceMappingURL=index.cjs.map