@copilotkit/runtime/dist/lib/integrations/node-http/index.cjs

<img src="https://github.com/user-attachments/assets/0a6b64d9-e193-4940-a3f6-60334ac34084" alt="banner" style="border-radius: 12px; border: 2px solid #d6d4fa;" />

require("reflect-metadata");
const require_hono_single = require('../../../v2/runtime/endpoints/hono-single.cjs');
const require_telemetry_client = require('../../telemetry-client.cjs');
const require_shared = require('../shared.cjs');
const require_request_handler = require('./request-handler.cjs');

//#region src/lib/integrations/node-http/index.ts
function copilotRuntimeNodeHttpEndpoint(options) {
	const commonConfig = require_shared.getCommonConfig(options);
	require_telemetry_client.default.setGlobalProperties({ runtime: { framework: "node-http" } });
	if (options.properties?._copilotkit) require_telemetry_client.default.setGlobalProperties({ _copilotkit: options.properties._copilotkit });
	require_telemetry_client.default.capture("oss.runtime.instance_created", require_telemetry_client.getRuntimeInstanceTelemetryInfo(options));
	const logger = commonConfig.logging;
	logger.debug("Creating Node HTTP endpoint");
	const serviceAdapter = options.serviceAdapter;
	if (serviceAdapter) options.runtime.handleServiceAdapter(serviceAdapter);
	const honoApp = require_hono_single.createCopilotEndpointSingleRoute({
		runtime: options.runtime.instance,
		basePath: options.baseUrl ?? options.endpoint,
		...options.cors && { cors: options.cors }
	});
	const handle = async function handler(req, res) {
		const url = require_request_handler.getFullUrl(req);
		const hasBody = req.method !== "GET" && req.method !== "HEAD";
		const baseHeaders = require_request_handler.toHeaders(req.headers);
		const parsedBody = req.body;
		const streamConsumed = require_request_handler.isStreamConsumed(req) || parsedBody !== void 0;
		const canStream = hasBody && !streamConsumed;
		let requestBody = void 0;
		let useDuplex = false;
		if (hasBody && canStream) {
			requestBody = require_request_handler.nodeStreamToReadableStream(req);
			useDuplex = true;
		}
		if (hasBody && streamConsumed) if (parsedBody !== void 0) {
			const synthesized = require_request_handler.synthesizeBodyFromParsedBody(parsedBody, baseHeaders);
			requestBody = synthesized.body ?? void 0;
			baseHeaders.delete("content-length");
			if (synthesized.contentType) baseHeaders.set("content-type", synthesized.contentType);
			logger.debug("Request stream already consumed; using parsed req.body to rebuild request.");
		} else {
			logger.warn("Request stream consumed with no available body; sending empty payload.");
			requestBody = void 0;
		}
		const buildRequest = (body, headers, duplex) => new Request(url, {
			method: req.method,
			headers,
			body,
			duplex: duplex ? "half" : void 0
		});
		let response;
		try {
			response = await honoApp.fetch(buildRequest(requestBody, baseHeaders, useDuplex));
		} catch (error) {
			if (require_request_handler.isDisturbedOrLockedError(error) && hasBody) {
				logger.warn("Encountered disturbed/locked request body; rebuilding request using parsed body or empty payload.");
				const fallbackHeaders = new Headers(baseHeaders);
				let fallbackBody;
				if (parsedBody !== void 0) {
					const synthesized = require_request_handler.synthesizeBodyFromParsedBody(parsedBody, fallbackHeaders);
					fallbackBody = synthesized.body ?? void 0;
					fallbackHeaders.delete("content-length");
					if (synthesized.contentType) fallbackHeaders.set("content-type", synthesized.contentType);
				} else fallbackBody = void 0;
				response = await honoApp.fetch(buildRequest(fallbackBody, fallbackHeaders, false));
			} else throw error;
		}
		res.statusCode = response.status;
		response.headers.forEach((value, key) => {
			res.setHeader(key, value);
		});
		if (response.body) require_request_handler.readableStreamToNodeStream(response.body).pipe(res);
		else res.end();
	};
	function isRequestLike(obj) {
		return obj instanceof Request || typeof obj === "object" && obj !== null && "url" in obj && "method" in obj && "headers" in obj && typeof obj.url === "string" && typeof obj.method === "string";
	}
	return function(reqOrRequest, res) {
		if (isRequestLike(reqOrRequest) && !res) return honoApp.fetch(reqOrRequest);
		if (!res) throw new TypeError("ServerResponse is required for Node HTTP requests");
		return handle(reqOrRequest, res);
	};
}

//#endregion
exports.copilotRuntimeNodeHttpEndpoint = copilotRuntimeNodeHttpEndpoint;
//# sourceMappingURL=index.cjs.map