@inkeep/agents-run-api 0.39.2 → 0.39.4

package/dist/instrumentation.cjs

@@ -1,121 +1,12 @@
-'use strict';
-
-var autoInstrumentationsNode = require('@opentelemetry/auto-instrumentations-node');
-var baggageSpanProcessor = require('@opentelemetry/baggage-span-processor');
-var contextAsyncHooks = require('@opentelemetry/context-async-hooks');
-var core = require('@opentelemetry/core');
-var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
-var resources = require('@opentelemetry/resources');
-var sdkNode = require('@opentelemetry/sdk-node');
-var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
-var semanticConventions = require('@opentelemetry/semantic-conventions');
-var zodOpenapi = require('@hono/zod-openapi');
-var agentsCore = require('@inkeep/agents-core');
-
-// src/instrumentation.ts
-agentsCore.loadEnvironmentFiles();
-var envSchema = zodOpenapi.z.object({
-  NODE_ENV: zodOpenapi.z.enum(["development", "production", "test"]).optional(),
-  ENVIRONMENT: zodOpenapi.z.enum(["development", "production", "pentest", "test"]).optional().default("development"),
-  DATABASE_URL: zodOpenapi.z.string().optional(),
-  INKEEP_AGENTS_RUN_API_URL: zodOpenapi.z.string().optional().default("http://localhost:3003"),
-  AGENTS_MANAGE_UI_URL: zodOpenapi.z.string().optional().default("http://localhost:3000"),
-  LOG_LEVEL: zodOpenapi.z.enum(["trace", "debug", "info", "warn", "error"]).optional().default("debug"),
-  NANGO_SERVER_URL: zodOpenapi.z.string().optional().default("https://api.nango.dev"),
-  NANGO_SECRET_KEY: zodOpenapi.z.string().optional(),
-  ANTHROPIC_API_KEY: zodOpenapi.z.string(),
-  OPENAI_API_KEY: zodOpenapi.z.string().optional(),
-  GOOGLE_GENERATIVE_AI_API_KEY: zodOpenapi.z.string().optional(),
-  INKEEP_AGENTS_RUN_API_BYPASS_SECRET: zodOpenapi.z.string().optional(),
-  INKEEP_AGENTS_JWT_SIGNING_SECRET: zodOpenapi.z.string().optional(),
-  INKEEP_AGENTS_TEMP_JWT_PUBLIC_KEY: zodOpenapi.z.string().optional(),
-  OTEL_BSP_SCHEDULE_DELAY: zodOpenapi.z.coerce.number().optional().default(500),
-  OTEL_BSP_MAX_EXPORT_BATCH_SIZE: zodOpenapi.z.coerce.number().optional().default(64)
-});
-var parseEnv = () => {
-  try {
-    return envSchema.parse(process.env);
-  } catch (error) {
-    if (error instanceof zodOpenapi.z.ZodError) {
-      const missingVars = error.issues.map((issue) => issue.path.join("."));
-      throw new Error(
-        `\u274C Invalid environment variables: ${missingVars.join(", ")}
-${error.message}`
-      );
-    }
-    throw error;
-  }
-};
-var env = parseEnv();
-
-// src/instrumentation.ts
-var otlpExporter = new exporterTraceOtlpHttp.OTLPTraceExporter();
-var logger = agentsCore.getLogger("instrumentation");
-function createSafeBatchProcessor() {
-  try {
-    return new sdkTraceBase.BatchSpanProcessor(otlpExporter, {
-      scheduledDelayMillis: env.OTEL_BSP_SCHEDULE_DELAY,
-      maxExportBatchSize: env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE
-    });
-  } catch (error) {
-    logger.warn({ error }, "Failed to create batch processor");
-    return new sdkTraceBase.NoopSpanProcessor();
-  }
-}
-var defaultBatchProcessor = createSafeBatchProcessor();
-var defaultResource = resources.resourceFromAttributes({
-  [semanticConventions.ATTR_SERVICE_NAME]: "inkeep-agents-run-api"
-});
-var defaultInstrumentations = [
-  autoInstrumentationsNode.getNodeAutoInstrumentations({
-    "@opentelemetry/instrumentation-http": {
-      enabled: true,
-      requestHook: (span, request) => {
-        const url = request?.url ?? request?.path;
-        if (!url) return;
-        const u = new URL(url, "http://localhost");
-        span.updateName(`${request?.method || "UNKNOWN"} ${u.pathname}`);
-      }
-    },
-    "@opentelemetry/instrumentation-undici": {
-      requestHook: (span) => {
-        const method = span.attributes?.["http.request.method"];
-        const host = span.attributes?.["server.address"];
-        const path = span.attributes?.["url.path"];
-        if (method && path)
-          span.updateName(host ? `${method} ${host}${path}` : `${method} ${path}`);
-      }
-    }
-  })
-];
-var defaultSpanProcessors = [
-  new baggageSpanProcessor.BaggageSpanProcessor(baggageSpanProcessor.ALLOW_ALL_BAGGAGE_KEYS),
-  defaultBatchProcessor
-];
-var defaultContextManager = new contextAsyncHooks.AsyncLocalStorageContextManager();
-var defaultTextMapPropagator = new core.CompositePropagator({
-  propagators: [new core.W3CTraceContextPropagator(), new core.W3CBaggagePropagator()]
-});
-var defaultSDK = new sdkNode.NodeSDK({
-  resource: defaultResource,
-  contextManager: defaultContextManager,
-  textMapPropagator: defaultTextMapPropagator,
-  spanProcessors: defaultSpanProcessors,
-  instrumentations: defaultInstrumentations
-});
-async function flushBatchProcessor() {
-  try {
-    await defaultBatchProcessor.forceFlush();
-  } catch (error) {
-    logger.warn({ error }, "Failed to flush batch processor");
-  }
-}
-
-exports.defaultBatchProcessor = defaultBatchProcessor;
-exports.defaultContextManager = defaultContextManager;
-exports.defaultInstrumentations = defaultInstrumentations;
-exports.defaultResource = defaultResource;
-exports.defaultSDK = defaultSDK;
-exports.defaultSpanProcessors = defaultSpanProcessors;
-exports.defaultTextMapPropagator = defaultTextMapPropagator;
-exports.flushBatchProcessor = flushBatchProcessor;
+require('./env.cjs');
+require('./logger2.cjs');
+const require_instrumentation = require('./instrumentation2.cjs');
+
+exports.defaultBatchProcessor = require_instrumentation.defaultBatchProcessor;
+exports.defaultContextManager = require_instrumentation.defaultContextManager;
+exports.defaultInstrumentations = require_instrumentation.defaultInstrumentations;
+exports.defaultResource = require_instrumentation.defaultResource;
+exports.defaultSDK = require_instrumentation.defaultSDK;
+exports.defaultSpanProcessors = require_instrumentation.defaultSpanProcessors;
+exports.defaultTextMapPropagator = require_instrumentation.defaultTextMapPropagator;
+exports.flushBatchProcessor = require_instrumentation.flushBatchProcessor;

package/dist/instrumentation.d.cts

@@ -1,16 +1,18 @@
-import * as _opentelemetry_resources from '@opentelemetry/resources';
-import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
-import { CompositePropagator } from '@opentelemetry/core';
-import { NodeSDKConfiguration, NodeSDK } from '@opentelemetry/sdk-node';
-import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import * as _opentelemetry_resources0 from "@opentelemetry/resources";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { CompositePropagator } from "@opentelemetry/core";
+import { NodeSDK, NodeSDKConfiguration } from "@opentelemetry/sdk-node";
+import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
 
+//#region src/instrumentation.d.ts
 declare const defaultBatchProcessor: SpanProcessor;
-declare const defaultResource: _opentelemetry_resources.Resource;
+declare const defaultResource: _opentelemetry_resources0.Resource;
 declare const defaultInstrumentations: NonNullable<NodeSDKConfiguration['instrumentations']>;
 declare const defaultSpanProcessors: SpanProcessor[];
 declare const defaultContextManager: AsyncLocalStorageContextManager;
 declare const defaultTextMapPropagator: CompositePropagator;
 declare const defaultSDK: NodeSDK;
 declare function flushBatchProcessor(): Promise<void>;
-
+//#endregion
 export { defaultBatchProcessor, defaultContextManager, defaultInstrumentations, defaultResource, defaultSDK, defaultSpanProcessors, defaultTextMapPropagator, flushBatchProcessor };
+//# sourceMappingURL=instrumentation.d.cts.map

package/dist/instrumentation.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.cts","names":[],"sources":["../src/instrumentation.ts"],"sourcesContent":[],"mappings":";;;;;;;cAyCa,uBAAqB;cAErB,iBAEX,yBAAA,CAF0B;AAFf,cAMA,uBANqB,EAMI,WANyB,CAMb,oBANa,CAAA,kBAAA,CAAA,CAAA;AAElD,cA2BA,qBAzBX,EAyBkC,aAzBlC,EAF0B;AAIf,cA4BA,qBA5BqC,EA4BhB,+BA5Be;AAuBpC,cAOA,wBAPuB,EAOC,mBAPY;AAKpC,cAMA,UAN6D,EAMnD,OANW;AAErB,iBAYS,mBAAA,CAAA,CAZe,EAYQ,OAZR,CAAA,IAAA,CAAA"}

package/dist/instrumentation.d.ts

@@ -1,16 +1,18 @@
-import * as _opentelemetry_resources from '@opentelemetry/resources';
-import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
-import { CompositePropagator } from '@opentelemetry/core';
-import { NodeSDKConfiguration, NodeSDK } from '@opentelemetry/sdk-node';
-import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { CompositePropagator } from "@opentelemetry/core";
+import * as _opentelemetry_resources0 from "@opentelemetry/resources";
+import { NodeSDK, NodeSDKConfiguration } from "@opentelemetry/sdk-node";
+import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
 
+//#region src/instrumentation.d.ts
 declare const defaultBatchProcessor: SpanProcessor;
-declare const defaultResource: _opentelemetry_resources.Resource;
+declare const defaultResource: _opentelemetry_resources0.Resource;
 declare const defaultInstrumentations: NonNullable<NodeSDKConfiguration['instrumentations']>;
 declare const defaultSpanProcessors: SpanProcessor[];
 declare const defaultContextManager: AsyncLocalStorageContextManager;
 declare const defaultTextMapPropagator: CompositePropagator;
 declare const defaultSDK: NodeSDK;
 declare function flushBatchProcessor(): Promise<void>;
-
+//#endregion
 export { defaultBatchProcessor, defaultContextManager, defaultInstrumentations, defaultResource, defaultSDK, defaultSpanProcessors, defaultTextMapPropagator, flushBatchProcessor };
+//# sourceMappingURL=instrumentation.d.ts.map

package/dist/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","names":[],"sources":["../src/instrumentation.ts"],"sourcesContent":[],"mappings":";;;;;;;cAyCa,uBAAqB;cAErB,iBAEX,yBAAA,CAF0B;AAFf,cAMA,uBANqB,EAMI,WANyB,CAMb,oBANa,CAAA,kBAAA,CAAA,CAAA;AAElD,cA2BA,qBAzBX,EAyBkC,aAzBlC,EAF0B;AAIf,cA4BA,qBA5BqC,EA4BhB,+BA5Be;AAuBpC,cAOA,wBAPuB,EAOC,mBAPY;AAKpC,cAMA,UAN6D,EAMnD,OANW;AAErB,iBAYS,mBAAA,CAAA,CAZe,EAYQ,OAZR,CAAA,IAAA,CAAA"}

package/dist/instrumentation.js

@@ -1 +1,5 @@
-export { defaultBatchProcessor, defaultContextManager, defaultInstrumentations, defaultResource, defaultSDK, defaultSpanProcessors, defaultTextMapPropagator, flushBatchProcessor } from './chunk-UC2EPLSW.js';
+import "./env.js";
+import "./logger2.js";
+import { a as defaultSDK, c as flushBatchProcessor, i as defaultResource, n as defaultContextManager, o as defaultSpanProcessors, r as defaultInstrumentations, s as defaultTextMapPropagator, t as defaultBatchProcessor } from "./instrumentation2.js";
+
+export { defaultBatchProcessor, defaultContextManager, defaultInstrumentations, defaultResource, defaultSDK, defaultSpanProcessors, defaultTextMapPropagator, flushBatchProcessor };

package/dist/instrumentation2.cjs

@@ -0,0 +1,116 @@
+const require_chunk = require('./chunk.cjs');
+const require_env = require('./env.cjs');
+let __opentelemetry_auto_instrumentations_node = require("@opentelemetry/auto-instrumentations-node");
+let __opentelemetry_baggage_span_processor = require("@opentelemetry/baggage-span-processor");
+let __opentelemetry_context_async_hooks = require("@opentelemetry/context-async-hooks");
+let __opentelemetry_core = require("@opentelemetry/core");
+let __opentelemetry_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+let __opentelemetry_resources = require("@opentelemetry/resources");
+let __opentelemetry_sdk_node = require("@opentelemetry/sdk-node");
+let __opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+let __opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
+let __inkeep_agents_core = require("@inkeep/agents-core");
+
+//#region src/instrumentation.ts
+const otlpExporter = new __opentelemetry_exporter_trace_otlp_http.OTLPTraceExporter();
+const logger = (0, __inkeep_agents_core.getLogger)("instrumentation");
+/**
+* Creates a safe batch processor that falls back to no-op when SignOz is not configured
+*/
+function createSafeBatchProcessor() {
+	try {
+		return new __opentelemetry_sdk_trace_base.BatchSpanProcessor(otlpExporter, {
+			scheduledDelayMillis: require_env.env.OTEL_BSP_SCHEDULE_DELAY,
+			maxExportBatchSize: require_env.env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE
+		});
+	} catch (error) {
+		logger.warn({ error }, "Failed to create batch processor");
+		return new __opentelemetry_sdk_trace_base.NoopSpanProcessor();
+	}
+}
+const defaultBatchProcessor = createSafeBatchProcessor();
+const defaultResource = (0, __opentelemetry_resources.resourceFromAttributes)({ [__opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: "inkeep-agents-run-api" });
+const defaultInstrumentations = [(0, __opentelemetry_auto_instrumentations_node.getNodeAutoInstrumentations)({
+	"@opentelemetry/instrumentation-http": {
+		enabled: true,
+		requestHook: (span, request) => {
+			const url = request?.url ?? request?.path;
+			if (!url) return;
+			const u = new URL(url, "http://localhost");
+			span.updateName(`${request?.method || "UNKNOWN"} ${u.pathname}`);
+		}
+	},
+	"@opentelemetry/instrumentation-undici": { requestHook: (span) => {
+		const method = span.attributes?.["http.request.method"];
+		const host = span.attributes?.["server.address"];
+		const path = span.attributes?.["url.path"];
+		if (method && path) span.updateName(host ? `${method} ${host}${path}` : `${method} ${path}`);
+	} }
+})];
+const defaultSpanProcessors = [new __opentelemetry_baggage_span_processor.BaggageSpanProcessor(__opentelemetry_baggage_span_processor.ALLOW_ALL_BAGGAGE_KEYS), defaultBatchProcessor];
+const defaultContextManager = new __opentelemetry_context_async_hooks.AsyncLocalStorageContextManager();
+const defaultTextMapPropagator = new __opentelemetry_core.CompositePropagator({ propagators: [new __opentelemetry_core.W3CTraceContextPropagator(), new __opentelemetry_core.W3CBaggagePropagator()] });
+const defaultSDK = new __opentelemetry_sdk_node.NodeSDK({
+	resource: defaultResource,
+	contextManager: defaultContextManager,
+	textMapPropagator: defaultTextMapPropagator,
+	spanProcessors: defaultSpanProcessors,
+	instrumentations: defaultInstrumentations
+});
+async function flushBatchProcessor() {
+	try {
+		await defaultBatchProcessor.forceFlush();
+	} catch (error) {
+		logger.warn({ error }, "Failed to flush batch processor");
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'defaultBatchProcessor', {
+  enumerable: true,
+  get: function () {
+    return defaultBatchProcessor;
+  }
+});
+Object.defineProperty(exports, 'defaultContextManager', {
+  enumerable: true,
+  get: function () {
+    return defaultContextManager;
+  }
+});
+Object.defineProperty(exports, 'defaultInstrumentations', {
+  enumerable: true,
+  get: function () {
+    return defaultInstrumentations;
+  }
+});
+Object.defineProperty(exports, 'defaultResource', {
+  enumerable: true,
+  get: function () {
+    return defaultResource;
+  }
+});
+Object.defineProperty(exports, 'defaultSDK', {
+  enumerable: true,
+  get: function () {
+    return defaultSDK;
+  }
+});
+Object.defineProperty(exports, 'defaultSpanProcessors', {
+  enumerable: true,
+  get: function () {
+    return defaultSpanProcessors;
+  }
+});
+Object.defineProperty(exports, 'defaultTextMapPropagator', {
+  enumerable: true,
+  get: function () {
+    return defaultTextMapPropagator;
+  }
+});
+Object.defineProperty(exports, 'flushBatchProcessor', {
+  enumerable: true,
+  get: function () {
+    return flushBatchProcessor;
+  }
+});

package/dist/instrumentation2.js

@@ -0,0 +1,69 @@
+import { t as env } from "./env.js";
+import { t as getLogger } from "./logger2.js";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { ALLOW_ALL_BAGGAGE_KEYS, BaggageSpanProcessor } from "@opentelemetry/baggage-span-processor";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator } from "@opentelemetry/core";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { BatchSpanProcessor, NoopSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+
+//#region src/instrumentation.ts
+const otlpExporter = new OTLPTraceExporter();
+const logger = getLogger("instrumentation");
+/**
+* Creates a safe batch processor that falls back to no-op when SignOz is not configured
+*/
+function createSafeBatchProcessor() {
+	try {
+		return new BatchSpanProcessor(otlpExporter, {
+			scheduledDelayMillis: env.OTEL_BSP_SCHEDULE_DELAY,
+			maxExportBatchSize: env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE
+		});
+	} catch (error) {
+		logger.warn({ error }, "Failed to create batch processor");
+		return new NoopSpanProcessor();
+	}
+}
+const defaultBatchProcessor = createSafeBatchProcessor();
+const defaultResource = resourceFromAttributes({ [ATTR_SERVICE_NAME]: "inkeep-agents-run-api" });
+const defaultInstrumentations = [getNodeAutoInstrumentations({
+	"@opentelemetry/instrumentation-http": {
+		enabled: true,
+		requestHook: (span, request) => {
+			const url = request?.url ?? request?.path;
+			if (!url) return;
+			const u = new URL(url, "http://localhost");
+			span.updateName(`${request?.method || "UNKNOWN"} ${u.pathname}`);
+		}
+	},
+	"@opentelemetry/instrumentation-undici": { requestHook: (span) => {
+		const method = span.attributes?.["http.request.method"];
+		const host = span.attributes?.["server.address"];
+		const path = span.attributes?.["url.path"];
+		if (method && path) span.updateName(host ? `${method} ${host}${path}` : `${method} ${path}`);
+	} }
+})];
+const defaultSpanProcessors = [new BaggageSpanProcessor(ALLOW_ALL_BAGGAGE_KEYS), defaultBatchProcessor];
+const defaultContextManager = new AsyncLocalStorageContextManager();
+const defaultTextMapPropagator = new CompositePropagator({ propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()] });
+const defaultSDK = new NodeSDK({
+	resource: defaultResource,
+	contextManager: defaultContextManager,
+	textMapPropagator: defaultTextMapPropagator,
+	spanProcessors: defaultSpanProcessors,
+	instrumentations: defaultInstrumentations
+});
+async function flushBatchProcessor() {
+	try {
+		await defaultBatchProcessor.forceFlush();
+	} catch (error) {
+		logger.warn({ error }, "Failed to flush batch processor");
+	}
+}
+
+//#endregion
+export { defaultSDK as a, flushBatchProcessor as c, defaultResource as i, defaultContextManager as n, defaultSpanProcessors as o, defaultInstrumentations as r, defaultTextMapPropagator as s, defaultBatchProcessor as t };
+//# sourceMappingURL=instrumentation2.js.map

package/dist/instrumentation2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation2.js","names":["defaultInstrumentations: NonNullable<NodeSDKConfiguration['instrumentations']>","url: string | undefined","defaultSpanProcessors: SpanProcessor[]"],"sources":["../src/instrumentation.ts"],"sourcesContent":["import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';\nimport {\n  ALLOW_ALL_BAGGAGE_KEYS,\n  BaggageSpanProcessor,\n} from '@opentelemetry/baggage-span-processor';\nimport { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';\nimport {\n  CompositePropagator,\n  W3CBaggagePropagator,\n  W3CTraceContextPropagator,\n} from '@opentelemetry/core';\nimport { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';\nimport { resourceFromAttributes } from '@opentelemetry/resources';\nimport type { NodeSDKConfiguration } from '@opentelemetry/sdk-node';\nimport { NodeSDK } from '@opentelemetry/sdk-node';\nimport {\n  BatchSpanProcessor,\n  NoopSpanProcessor,\n  type SpanProcessor,\n} from '@opentelemetry/sdk-trace-base';\nimport { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';\nimport { env } from './env';\nimport { getLogger } from './logger';\n\nconst otlpExporter = new OTLPTraceExporter();\nconst logger = getLogger('instrumentation');\n/**\n * Creates a safe batch processor that falls back to no-op when SignOz is not configured\n */\nfunction createSafeBatchProcessor(): SpanProcessor {\n  try {\n    return new BatchSpanProcessor(otlpExporter, {\n      scheduledDelayMillis: env.OTEL_BSP_SCHEDULE_DELAY,\n      maxExportBatchSize: env.OTEL_BSP_MAX_EXPORT_BATCH_SIZE,\n    });\n  } catch (error) {\n    logger.warn({ error }, 'Failed to create batch processor');\n    return new NoopSpanProcessor();\n  }\n}\n\nexport const defaultBatchProcessor = createSafeBatchProcessor();\n\nexport const defaultResource = resourceFromAttributes({\n  [ATTR_SERVICE_NAME]: 'inkeep-agents-run-api',\n});\n\nexport const defaultInstrumentations: NonNullable<NodeSDKConfiguration['instrumentations']> = [\n  getNodeAutoInstrumentations({\n    '@opentelemetry/instrumentation-http': {\n      enabled: true,\n      requestHook: (span, request: any) => {\n        const url: string | undefined = request?.url ?? request?.path;\n        if (!url) return;\n        const u = new URL(url, 'http://localhost');\n        span.updateName(`${request?.method || 'UNKNOWN'} ${u.pathname}`);\n      },\n    },\n    '@opentelemetry/instrumentation-undici': {\n      requestHook: (span: any) => {\n        const method = span.attributes?.['http.request.method'];\n        const host = span.attributes?.['server.address'];\n        const path = span.attributes?.['url.path'];\n        if (method && path)\n          span.updateName(host ? `${method} ${host}${path}` : `${method} ${path}`);\n      },\n    },\n  }),\n];\n\nexport const defaultSpanProcessors: SpanProcessor[] = [\n  new BaggageSpanProcessor(ALLOW_ALL_BAGGAGE_KEYS),\n  defaultBatchProcessor,\n];\n\nexport const defaultContextManager = new AsyncLocalStorageContextManager();\n\nexport const defaultTextMapPropagator = new CompositePropagator({\n  propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()],\n});\n\nexport const defaultSDK = new NodeSDK({\n  resource: defaultResource,\n  contextManager: defaultContextManager,\n  textMapPropagator: defaultTextMapPropagator,\n  spanProcessors: defaultSpanProcessors,\n  instrumentations: defaultInstrumentations,\n});\n\nexport async function flushBatchProcessor(): Promise<void> {\n  try {\n    await defaultBatchProcessor.forceFlush();\n  } catch (error) {\n    logger.warn({ error }, 'Failed to flush batch processor');\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAwBA,MAAM,eAAe,IAAI,mBAAmB;AAC5C,MAAM,SAAS,UAAU,kBAAkB;;;;AAI3C,SAAS,2BAA0C;AACjD,KAAI;AACF,SAAO,IAAI,mBAAmB,cAAc;GAC1C,sBAAsB,IAAI;GAC1B,oBAAoB,IAAI;GACzB,CAAC;UACK,OAAO;AACd,SAAO,KAAK,EAAE,OAAO,EAAE,mCAAmC;AAC1D,SAAO,IAAI,mBAAmB;;;AAIlC,MAAa,wBAAwB,0BAA0B;AAE/D,MAAa,kBAAkB,uBAAuB,GACnD,oBAAoB,yBACtB,CAAC;AAEF,MAAaA,0BAAiF,CAC5F,4BAA4B;CAC1B,uCAAuC;EACrC,SAAS;EACT,cAAc,MAAM,YAAiB;GACnC,MAAMC,MAA0B,SAAS,OAAO,SAAS;AACzD,OAAI,CAAC,IAAK;GACV,MAAM,IAAI,IAAI,IAAI,KAAK,mBAAmB;AAC1C,QAAK,WAAW,GAAG,SAAS,UAAU,UAAU,GAAG,EAAE,WAAW;;EAEnE;CACD,yCAAyC,EACvC,cAAc,SAAc;EAC1B,MAAM,SAAS,KAAK,aAAa;EACjC,MAAM,OAAO,KAAK,aAAa;EAC/B,MAAM,OAAO,KAAK,aAAa;AAC/B,MAAI,UAAU,KACZ,MAAK,WAAW,OAAO,GAAG,OAAO,GAAG,OAAO,SAAS,GAAG,OAAO,GAAG,OAAO;IAE7E;CACF,CAAC,CACH;AAED,MAAaC,wBAAyC,CACpD,IAAI,qBAAqB,uBAAuB,EAChD,sBACD;AAED,MAAa,wBAAwB,IAAI,iCAAiC;AAE1E,MAAa,2BAA2B,IAAI,oBAAoB,EAC9D,aAAa,CAAC,IAAI,2BAA2B,EAAE,IAAI,sBAAsB,CAAC,EAC3E,CAAC;AAEF,MAAa,aAAa,IAAI,QAAQ;CACpC,UAAU;CACV,gBAAgB;CAChB,mBAAmB;CACnB,gBAAgB;CAChB,kBAAkB;CACnB,CAAC;AAEF,eAAsB,sBAAqC;AACzD,KAAI;AACF,QAAM,sBAAsB,YAAY;UACjC,OAAO;AACd,SAAO,KAAK,EAAE,OAAO,EAAE,kCAAkC"}

package/dist/json-postprocessor.cjs

@@ -0,0 +1,20 @@
+
+//#region src/utils/json-postprocessor.ts
+/**
+* Simple post-processor to clean up common LLM JSON formatting issues
+*/
+function stripJsonCodeBlocks(text) {
+	return text.trim().replace(/^```json\s*/is, "").replace(/^```\s*/s, "").replace(/\s*```$/s, "").replace(/^```json\s*([\s\S]*?)\s*```$/i, "$1").replace(/^```\s*([\s\S]*?)\s*```$/i, "$1").trim();
+}
+/**
+* Configuration helper to add JSON post-processing to generateObject calls
+*/
+function withJsonPostProcessing(config) {
+	return {
+		...config,
+		experimental_transform: (text) => stripJsonCodeBlocks(text)
+	};
+}
+
+//#endregion
+exports.withJsonPostProcessing = withJsonPostProcessing;

package/dist/json-postprocessor.js

@@ -0,0 +1,20 @@
+//#region src/utils/json-postprocessor.ts
+/**
+* Simple post-processor to clean up common LLM JSON formatting issues
+*/
+function stripJsonCodeBlocks(text) {
+	return text.trim().replace(/^```json\s*/is, "").replace(/^```\s*/s, "").replace(/\s*```$/s, "").replace(/^```json\s*([\s\S]*?)\s*```$/i, "$1").replace(/^```\s*([\s\S]*?)\s*```$/i, "$1").trim();
+}
+/**
+* Configuration helper to add JSON post-processing to generateObject calls
+*/
+function withJsonPostProcessing(config) {
+	return {
+		...config,
+		experimental_transform: (text) => stripJsonCodeBlocks(text)
+	};
+}
+
+//#endregion
+export { withJsonPostProcessing };
+//# sourceMappingURL=json-postprocessor.js.map

package/dist/json-postprocessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-postprocessor.js","names":[],"sources":["../src/utils/json-postprocessor.ts"],"sourcesContent":["/**\n * Simple post-processor to clean up common LLM JSON formatting issues\n */\nexport function stripJsonCodeBlocks(text: string): string {\n  return (\n    text\n      .trim()\n      // Remove ```json and ``` blocks - handle multiline with dotall flag\n      .replace(/^```json\\s*/is, '')\n      .replace(/^```\\s*/s, '')\n      .replace(/\\s*```$/s, '')\n      // Also handle cases where the entire response is wrapped\n      .replace(/^```json\\s*([\\s\\S]*?)\\s*```$/i, '$1')\n      .replace(/^```\\s*([\\s\\S]*?)\\s*```$/i, '$1')\n      .trim()\n  );\n}\n\n/**\n * Configuration helper to add JSON post-processing to generateObject calls\n */\nexport function withJsonPostProcessing<T extends Record<string, any>>(\n  config: T\n): T & {\n  experimental_transform?: (text: string) => string;\n} {\n  return {\n    ...config,\n    experimental_transform: (text: string) => stripJsonCodeBlocks(text),\n  };\n}\n"],"mappings":";;;;AAGA,SAAgB,oBAAoB,MAAsB;AACxD,QACE,KACG,MAAM,CAEN,QAAQ,iBAAiB,GAAG,CAC5B,QAAQ,YAAY,GAAG,CACvB,QAAQ,YAAY,GAAG,CAEvB,QAAQ,iCAAiC,KAAK,CAC9C,QAAQ,6BAA6B,KAAK,CAC1C,MAAM;;;;;AAOb,SAAgB,uBACd,QAGA;AACA,QAAO;EACL,GAAG;EACH,yBAAyB,SAAiB,oBAAoB,KAAK;EACpE"}

package/dist/logger.cjs

@@ -0,0 +1,5 @@
+const require_chunk = require('./chunk.cjs');
+require('./logger2.cjs');
+let __inkeep_agents_core = require("@inkeep/agents-core");
+
+exports.getLogger = __inkeep_agents_core.getLogger;

package/dist/logger.js

@@ -0,0 +1,3 @@
+import { t as getLogger } from "./logger2.js";
+
+export { getLogger };

package/dist/logger2.cjs

@@ -0,0 +1 @@
+let __inkeep_agents_core = require("@inkeep/agents-core");

package/dist/logger2.js

@@ -0,0 +1,3 @@
+import { getLogger } from "@inkeep/agents-core";
+
+export { getLogger as t };

package/dist/nodefs.cjs

@@ -0,0 +1,29 @@
+const require_chunk = require('./chunk.cjs');
+const require_chunk_VBDAOXYI = require('./chunk-VBDAOXYI.cjs');
+let fs = require("fs");
+fs = require_chunk.__toESM(fs);
+let path = require("path");
+path = require_chunk.__toESM(path);
+
+//#region ../node_modules/.pnpm/@electric-sql+pglite@0.3.14/node_modules/@electric-sql/pglite/dist/fs/nodefs.js
+require_chunk_VBDAOXYI.u();
+var m = class extends require_chunk_VBDAOXYI.ur {
+	constructor(t) {
+		super(t), this.rootDir = path.resolve(t), fs.existsSync(path.join(this.rootDir)) || fs.mkdirSync(this.rootDir);
+	}
+	async init(t, e) {
+		return this.pg = t, { emscriptenOpts: {
+			...e,
+			preRun: [...e.preRun || [], (r) => {
+				let c = r.FS.filesystems.NODEFS;
+				r.FS.mkdir(require_chunk_VBDAOXYI.C), r.FS.mount(c, { root: this.rootDir }, require_chunk_VBDAOXYI.C);
+			}]
+		} };
+	}
+	async closeFs() {
+		this.pg.Module.FS.quit();
+	}
+};
+
+//#endregion
+exports.NodeFS = m;

package/dist/nodefs.js

@@ -0,0 +1,27 @@
+import { h as u, s as ur, t as C } from "./chunk-VBDAOXYI.js";
+import * as s from "fs";
+import * as o from "path";
+
+//#region ../node_modules/.pnpm/@electric-sql+pglite@0.3.14/node_modules/@electric-sql/pglite/dist/fs/nodefs.js
+u();
+var m = class extends ur {
+	constructor(t) {
+		super(t), this.rootDir = o.resolve(t), s.existsSync(o.join(this.rootDir)) || s.mkdirSync(this.rootDir);
+	}
+	async init(t, e) {
+		return this.pg = t, { emscriptenOpts: {
+			...e,
+			preRun: [...e.preRun || [], (r) => {
+				let c = r.FS.filesystems.NODEFS;
+				r.FS.mkdir(C), r.FS.mount(c, { root: this.rootDir }, C);
+			}]
+		} };
+	}
+	async closeFs() {
+		this.pg.Module.FS.quit();
+	}
+};
+
+//#endregion
+export { m as NodeFS };
+//# sourceMappingURL=nodefs.js.map

package/dist/nodefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodefs.js","names":["n","p","i"],"sources":["../../node_modules/.pnpm/@electric-sql+pglite@0.3.14/node_modules/@electric-sql/pglite/dist/fs/nodefs.js"],"sourcesContent":["import{d as i,e as p}from\"../chunk-VBDAOXYI.js\";import{j as n}from\"../chunk-QY3QWFKW.js\";n();import*as s from\"fs\";import*as o from\"path\";var m=class extends p{constructor(t){super(t),this.rootDir=o.resolve(t),s.existsSync(o.join(this.rootDir))||s.mkdirSync(this.rootDir)}async init(t,e){return this.pg=t,{emscriptenOpts:{...e,preRun:[...e.preRun||[],r=>{let c=r.FS.filesystems.NODEFS;r.FS.mkdir(i),r.FS.mount(c,{root:this.rootDir},i)}]}}}async closeFs(){this.pg.Module.FS.quit()}};export{m as NodeFS};\n//# sourceMappingURL=nodefs.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAAyFA,GAAG;AAA6C,IAAI,IAAE,cAAcC,GAAC;CAAC,YAAY,GAAE;AAAC,QAAM,EAAE,EAAC,KAAK,UAAQ,EAAE,QAAQ,EAAE,EAAC,EAAE,WAAW,EAAE,KAAK,KAAK,QAAQ,CAAC,IAAE,EAAE,UAAU,KAAK,QAAQ;;CAAC,MAAM,KAAK,GAAE,GAAE;AAAC,SAAO,KAAK,KAAG,GAAE,EAAC,gBAAe;GAAC,GAAG;GAAE,QAAO,CAAC,GAAG,EAAE,UAAQ,EAAE,GAAC,MAAG;IAAC,IAAI,IAAE,EAAE,GAAG,YAAY;AAAO,MAAE,GAAG,MAAMC,EAAE,EAAC,EAAE,GAAG,MAAM,GAAE,EAAC,MAAK,KAAK,SAAQ,EAACA,EAAE;KAAE;GAAC,EAAC;;CAAC,MAAM,UAAS;AAAC,OAAK,GAAG,OAAO,GAAG,MAAM"}