@inkeep/agents-core 0.48.2 → 0.48.4

package/dist/utils/mock-provider.js

@@ -0,0 +1,117 @@
+//#region src/utils/mock-provider.ts
+function extractLastUserMessage(prompt) {
+	for (let i = prompt.length - 1; i >= 0; i--) {
+		const msg = prompt[i];
+		if (msg.role === "user") {
+			for (const part of msg.content) if (part.type === "text") return part.text.length > 200 ? `${part.text.slice(0, 200)}...` : part.text;
+		}
+	}
+	return "(no user message)";
+}
+function countInputChars(prompt) {
+	let chars = 0;
+	for (const msg of prompt) if ("content" in msg) {
+		if (typeof msg.content === "string") chars += msg.content.length;
+		else if (Array.isArray(msg.content)) {
+			for (const part of msg.content) if ("text" in part) chars += part.text.length;
+		}
+	}
+	return chars;
+}
+function buildMockResponse(modelName, prompt) {
+	const lastUserMessage = extractLastUserMessage(prompt);
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	return [
+		"Mock response.",
+		`Model: mock/${modelName}`,
+		`Input messages: ${prompt.length}`,
+		`Last user message: "${lastUserMessage}"`,
+		`Timestamp: ${timestamp}`
+	].join("\n");
+}
+var MockLanguageModel = class {
+	specificationVersion = "v2";
+	defaultObjectGenerationMode = void 0;
+	supportsImageUrls = false;
+	supportedUrls = {};
+	provider = "mock";
+	modelId;
+	constructor(modelId) {
+		this.modelId = modelId;
+	}
+	async doGenerate(options) {
+		const responseText = buildMockResponse(this.modelId, options.prompt);
+		const inputTokens = Math.ceil(countInputChars(options.prompt) / 4);
+		const outputTokens = Math.ceil(responseText.length / 4);
+		return {
+			content: [{
+				type: "text",
+				text: responseText
+			}],
+			finishReason: "stop",
+			usage: {
+				inputTokens,
+				outputTokens,
+				totalTokens: inputTokens + outputTokens
+			},
+			rawCall: {
+				rawPrompt: options.prompt,
+				rawSettings: {}
+			},
+			warnings: []
+		};
+	}
+	async doStream(options) {
+		const responseText = buildMockResponse(this.modelId, options.prompt);
+		const lines = responseText.split("\n");
+		const inputTokens = Math.ceil(countInputChars(options.prompt) / 4);
+		const outputTokens = Math.ceil(responseText.length / 4);
+		return {
+			stream: new ReadableStream({ async start(controller) {
+				controller.enqueue({
+					type: "stream-start",
+					warnings: []
+				});
+				const textId = "mock-text-0";
+				controller.enqueue({
+					type: "text-start",
+					id: textId
+				});
+				for (let i = 0; i < lines.length; i++) {
+					const delta = i < lines.length - 1 ? `${lines[i]}\n` : lines[i];
+					controller.enqueue({
+						type: "text-delta",
+						id: textId,
+						delta
+					});
+					if (i < lines.length - 1) await new Promise((resolve) => setTimeout(resolve, 5));
+				}
+				controller.enqueue({
+					type: "text-end",
+					id: textId
+				});
+				controller.enqueue({
+					type: "finish",
+					finishReason: "stop",
+					usage: {
+						inputTokens,
+						outputTokens,
+						totalTokens: inputTokens + outputTokens
+					}
+				});
+				controller.close();
+			} }),
+			rawCall: {
+				rawPrompt: options.prompt,
+				rawSettings: {}
+			},
+			warnings: []
+		};
+	}
+};
+function createMockModel(modelId) {
+	return new MockLanguageModel(modelId);
+}
+
+//#endregion
+export { MockLanguageModel, createMockModel };

package/dist/utils/model-factory.js

@@ -1,4 +1,5 @@
 import { getLogger } from "./logger.js";
+import { createMockModel } from "./mock-provider.js";
 import { anthropic, createAnthropic } from "@ai-sdk/anthropic";
 import { createAzure } from "@ai-sdk/azure";
 import { createGateway, gateway } from "@ai-sdk/gateway";
@@ -97,7 +98,7 @@ var ModelFactory = class ModelFactory {
 			hasProviderOptions: !!modelSettings.providerOptions
 		}, "Creating language model from config");
 		const providerConfig = ModelFactory.extractProviderConfig(modelSettings.providerOptions);
-		if (provider === "azure" || Object.keys(providerConfig).length > 0) {
+		if (provider !== "mock" && (provider === "azure" || Object.keys(providerConfig).length > 0)) {
 			logger.info({ config: providerConfig }, `Applying custom ${provider} provider configuration`);
 			return ModelFactory.createProvider(provider, providerConfig).languageModel(modelName);
 		}
@@ -108,6 +109,7 @@ var ModelFactory = class ModelFactory {
 			case "openrouter": return openrouter(modelName);
 			case "gateway": return gateway(modelName);
 			case "nim": return nimDefault(modelName);
+			case "mock": return createMockModel(modelName);
 			case "custom": throw new Error("Custom provider requires configuration. Please provide baseURL in providerOptions.custom.baseURL or providerOptions.baseURL");
 			default: throw new Error(`Unsupported provider: ${provider}. Supported providers are: ${ModelFactory.BUILT_IN_PROVIDERS.join(", ")}. To access other models, use OpenRouter (openrouter/model-id), Vercel AI Gateway (gateway/model-id), NVIDIA NIM (nim/model-id), or Custom OpenAI-compatible (custom/model-id).`);
 		}
@@ -123,7 +125,8 @@ var ModelFactory = class ModelFactory {
 		"openrouter",
 		"gateway",
 		"nim",
-		"custom"
+		"custom",
+		"mock"
 	];
 	/**
 	* Parse model string to extract provider and model name

package/dist/utils/tracer-factory.d.ts

@@ -23,5 +23,17 @@ declare function setSpanWithError(span: Span, error: Error, logger?: {
  * Returns a no-op tracer if OpenTelemetry is not available
  */
 declare function getTracer(serviceName: string, serviceVersion?: string): Tracer;
+/**
+ * Force-flush all pending trace spans to the configured exporter.
+ *
+ * Uses the global TracerProvider registered by the OpenTelemetry SDK.
+ * This is safe to call from any package — it accesses the same provider
+ * that was set up in the host application's instrumentation.
+ *
+ * Use this in fire-and-forget handlers (e.g. Slack webhooks) where the
+ * HTTP response is sent before background work completes, so the
+ * per-request flush middleware runs too early to capture those spans.
+ */
+declare function flushTraces(): Promise<void>;
 //#endregion
-export { getTracer, setSpanWithError, unwrapError };
+export { flushTraces, getTracer, setSpanWithError, unwrapError };

package/dist/utils/tracer-factory.js

@@ -74,6 +74,26 @@ function getTracer(serviceName, serviceVersion) {
 		return noopTracer;
 	}
 }
+/**
+* Force-flush all pending trace spans to the configured exporter.
+*
+* Uses the global TracerProvider registered by the OpenTelemetry SDK.
+* This is safe to call from any package — it accesses the same provider
+* that was set up in the host application's instrumentation.
+*
+* Use this in fire-and-forget handlers (e.g. Slack webhooks) where the
+* HTTP response is sent before background work completes, so the
+* per-request flush middleware runs too early to capture those spans.
+*/
+async function flushTraces() {
+	try {
+		const provider = trace.getTracerProvider();
+		const delegate = typeof provider.getDelegate === "function" ? provider.getDelegate() : provider;
+		if (typeof delegate.forceFlush === "function") await delegate.forceFlush();
+	} catch (error) {
+		logger.warn({ error }, "Failed to flush traces");
+	}
+}
 
 //#endregion
-export { getTracer, setSpanWithError, unwrapError };
+export { flushTraces, getTracer, setSpanWithError, unwrapError };

package/dist/utils/wait-until.d.ts

@@ -0,0 +1,22 @@
+//#region src/utils/wait-until.d.ts
+type WaitUntilFn = (promise: Promise<unknown>) => void;
+/**
+ * Lazy-load and cache Vercel's `waitUntil` function.
+ *
+ * - On Vercel (`process.env.VERCEL` set): dynamically imports `@vercel/functions`
+ *   and returns `waitUntil`, which extends the serverless function lifetime
+ *   past the HTTP response so background work can complete.
+ * - Outside Vercel: returns `undefined`. Callers should let the promise
+ *   execute naturally via the Node.js event loop (fire-and-forget with
+ *   error handling).
+ * - Import failure: logs a warning and returns `undefined` (graceful degradation).
+ * - Result is cached after first call (lazy singleton). Concurrent callers
+ *   share the same import promise to avoid duplicate imports.
+ */
+declare function getWaitUntil(): Promise<WaitUntilFn | undefined>;
+/**
+ * Reset internal cache. Exposed only for testing.
+ */
+declare function _resetWaitUntilCache(): void;
+//#endregion
+export { _resetWaitUntilCache, getWaitUntil };

package/dist/utils/wait-until.js

@@ -0,0 +1,40 @@
+import { getLogger } from "./logger.js";
+
+//#region src/utils/wait-until.ts
+const logger = getLogger("wait-until");
+let _importPromise;
+/**
+* Lazy-load and cache Vercel's `waitUntil` function.
+*
+* - On Vercel (`process.env.VERCEL` set): dynamically imports `@vercel/functions`
+*   and returns `waitUntil`, which extends the serverless function lifetime
+*   past the HTTP response so background work can complete.
+* - Outside Vercel: returns `undefined`. Callers should let the promise
+*   execute naturally via the Node.js event loop (fire-and-forget with
+*   error handling).
+* - Import failure: logs a warning and returns `undefined` (graceful degradation).
+* - Result is cached after first call (lazy singleton). Concurrent callers
+*   share the same import promise to avoid duplicate imports.
+*/
+async function getWaitUntil() {
+	if (_importPromise) return _importPromise;
+	_importPromise = (async () => {
+		if (!process.env.VERCEL) return void 0;
+		try {
+			return (await import("@vercel/functions")).waitUntil;
+		} catch (e) {
+			logger.warn({ error: e }, "Failed to import @vercel/functions, waitUntil unavailable");
+			return;
+		}
+	})();
+	return _importPromise;
+}
+/**
+* Reset internal cache. Exposed only for testing.
+*/
+function _resetWaitUntilCache() {
+	_importPromise = void 0;
+}
+
+//#endregion
+export { _resetWaitUntilCache, getWaitUntil };