@agenticrun/sdk 0.1.0-alpha.0

package/dist/core-BxLvIHye.mjs

@@ -0,0 +1,1258 @@
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+//#region src/core/apiEndpoint.ts
+const defaultApiUrl = "https://api.agenticrun.de/v1";
+const createApiEndpoint = (apiUrl, path) => {
+	let endpoint;
+	try {
+		endpoint = new URL(apiUrl.trim());
+	} catch (cause) {
+		throw new TypeError("Agentic Run API URL is invalid.", { cause });
+	}
+	if (endpoint.protocol !== "http:" && endpoint.protocol !== "https:") throw new TypeError("Agentic Run API URL must use HTTP or HTTPS.");
+	if (endpoint.search || endpoint.hash) throw new TypeError("Agentic Run API URL must not contain a query or hash.");
+	endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+	return endpoint.href;
+};
+//#endregion
+//#region ../contracts/src/apiError.ts
+const apiErrorResponseSchema = z.object({ error: z.object({
+	code: z.string(),
+	message: z.string().optional()
+}).readonly() }).readonly();
+//#endregion
+//#region ../contracts/src/tenantChanges.ts
+const tenantChangeEventSchemas = [
+	z.object({
+		id: z.uuid(),
+		resourceId: z.uuid(),
+		resource: z.literal("workspace-key"),
+		action: z.enum([
+			"created",
+			"updated",
+			"deleted"
+		])
+	}),
+	z.object({
+		id: z.uuid(),
+		resourceId: z.uuid(),
+		resource: z.literal("provider-key"),
+		action: z.enum([
+			"created",
+			"updated",
+			"deleted"
+		])
+	}),
+	z.object({
+		id: z.uuid(),
+		resourceId: z.uuid(),
+		resource: z.literal("tracing-session"),
+		action: z.enum(["created", "updated"])
+	}),
+	z.object({
+		id: z.uuid(),
+		resourceId: z.uuid(),
+		resource: z.literal("agent"),
+		action: z.enum(["created", "updated"])
+	})
+];
+z.discriminatedUnion("resource", tenantChangeEventSchemas).readonly();
+z.object({
+	apiUrl: z.url(),
+	logtoAppId: z.string().min(1),
+	logtoEndpoint: z.url(),
+	logtoPostSignOutRedirectUri: z.url(),
+	logtoRedirectUri: z.url()
+});
+//#endregion
+//#region ../modules/src/credentials/providers.contract.ts
+const tokenPriceSchema = z.string().regex(/^(0|[1-9]\d*)(\.\d+)?$/).nullable();
+z.object({
+	currency: z.string().regex(/^[A-Z]{3}$/),
+	unit: z.literal("million_tokens"),
+	rates: z.object({
+		input: tokenPriceSchema,
+		cacheRead: tokenPriceSchema,
+		cacheWrite: tokenPriceSchema,
+		output: tokenPriceSchema,
+		reasoning: tokenPriceSchema
+	}).strict().readonly()
+}).strict().readonly();
+const providerCatalog = [
+	{
+		id: "openai",
+		name: "OpenAI",
+		active: true,
+		adapter: "openai",
+		keyHintLength: 7,
+		models: [
+			{
+				id: "gpt-5.6-sol",
+				name: "GPT-5.6 Sol",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "4.00",
+						cacheRead: "0.40",
+						cacheWrite: "5.00",
+						output: "20.00",
+						reasoning: "20.00"
+					}
+				}
+			},
+			{
+				id: "gpt-5.6-terra",
+				name: "GPT-5.6 Terra",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "2.00",
+						cacheRead: "0.20",
+						cacheWrite: "2.50",
+						output: "12.00",
+						reasoning: "12.00"
+					}
+				}
+			},
+			{
+				id: "gpt-5.6-luna",
+				name: "GPT-5.6 Luna",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "0.20",
+						cacheRead: "0.02",
+						cacheWrite: "0.25",
+						output: "1.20",
+						reasoning: "1.20"
+					}
+				}
+			}
+		]
+	},
+	{
+		id: "anthropic",
+		name: "Anthropic",
+		active: true,
+		adapter: "anthropic",
+		keyHintLength: 14,
+		models: [
+			{
+				id: "claude-fable-5",
+				name: "Claude Fable 5",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "10",
+						cacheRead: "1",
+						cacheWrite: null,
+						output: "50",
+						reasoning: "50"
+					}
+				}
+			},
+			{
+				id: "claude-opus-5",
+				name: "Claude Opus 5",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "5",
+						cacheRead: "0.50",
+						cacheWrite: null,
+						output: "25",
+						reasoning: "25"
+					}
+				}
+			},
+			{
+				id: "claude-sonnet-5",
+				name: "Claude Sonnet 5",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "2",
+						cacheRead: "0.20",
+						cacheWrite: null,
+						output: "10",
+						reasoning: "10"
+					}
+				}
+			},
+			{
+				id: "claude-haiku-4-5-20251001",
+				name: "Claude Haiku 4.5",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "1",
+						cacheRead: "0.10",
+						cacheWrite: null,
+						output: "5",
+						reasoning: "5"
+					}
+				}
+			}
+		]
+	},
+	{
+		id: "google",
+		name: "Google",
+		active: true,
+		adapter: "google",
+		keyHintLength: 8,
+		models: [
+			{
+				id: "gemini-3.7-flash",
+				name: "Gemini 3.7 Flash",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "0.75",
+						cacheRead: "0.075",
+						cacheWrite: null,
+						output: "3.75",
+						reasoning: "3.75"
+					}
+				}
+			},
+			{
+				id: "gemini-3.6-flash",
+				name: "Gemini 3.6 Flash",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "0.75",
+						cacheRead: "0.075",
+						cacheWrite: null,
+						output: "3.75",
+						reasoning: "3.75"
+					}
+				}
+			},
+			{
+				id: "gemini-3.5-flash",
+				name: "Gemini 3.5 Flash",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "1.50",
+						cacheRead: "0.15",
+						cacheWrite: null,
+						output: "9.00",
+						reasoning: "9.00"
+					}
+				}
+			},
+			{
+				id: "gemini-3.5-flash-lite",
+				name: "Gemini 3.5 Flash-Lite",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: "0.30",
+						cacheRead: "0.03",
+						cacheWrite: null,
+						output: "2.50",
+						reasoning: "2.50"
+					}
+				}
+			},
+			{
+				id: "gemini-3.1-flash-lite",
+				name: "Gemini 3.1 Flash-Lite",
+				active: true,
+				pricing: {
+					currency: "USD",
+					unit: "million_tokens",
+					rates: {
+						input: null,
+						cacheRead: null,
+						cacheWrite: null,
+						output: "1.50",
+						reasoning: "1.50"
+					}
+				}
+			}
+		]
+	},
+	{
+		id: "scaleway",
+		name: "Scaleway",
+		active: true,
+		adapter: "openai-compatible",
+		baseUrl: "https://api.scaleway.ai/v1",
+		keyHintLength: 4,
+		models: [
+			{
+				id: "glm-5.2",
+				name: "GLM 5.2",
+				active: true,
+				pricing: {
+					currency: "EUR",
+					unit: "million_tokens",
+					rates: {
+						input: "1.80",
+						cacheRead: null,
+						cacheWrite: null,
+						output: "5.50",
+						reasoning: null
+					}
+				}
+			},
+			{
+				id: "deepseek-v4-flash-0731",
+				name: "DeepSeek V4 Flash 0731",
+				active: true,
+				pricing: {
+					currency: "EUR",
+					unit: "million_tokens",
+					rates: {
+						input: "0.40",
+						cacheRead: "0.08",
+						cacheWrite: null,
+						output: "0.80",
+						reasoning: null
+					}
+				}
+			},
+			{
+				id: "qwen3.6-35b-a3b",
+				name: "Qwen 3.6 35B A3B",
+				active: true,
+				pricing: {
+					currency: "EUR",
+					unit: "million_tokens",
+					rates: {
+						input: "0.25",
+						cacheRead: null,
+						cacheWrite: null,
+						output: "1.50",
+						reasoning: null
+					}
+				}
+			},
+			{
+				id: "qwen3.5-397b-a17b",
+				name: "Qwen 3.5 397B A17B",
+				active: true,
+				pricing: {
+					currency: "EUR",
+					unit: "million_tokens",
+					rates: {
+						input: "0.60",
+						cacheRead: null,
+						cacheWrite: null,
+						output: "3.60",
+						reasoning: null
+					}
+				}
+			},
+			{
+				id: "gemma-4-26b-a4b-it",
+				name: "Gemma 4 26B A4B IT",
+				active: true,
+				pricing: {
+					currency: "EUR",
+					unit: "million_tokens",
+					rates: {
+						input: "0.25",
+						cacheRead: null,
+						cacheWrite: null,
+						output: "0.50",
+						reasoning: null
+					}
+				}
+			}
+		]
+	}
+];
+//#endregion
+//#region ../modules/src/credentials/providerKeys/providerKeys.contract.ts
+const providerIds = providerCatalog.map((provider) => provider.id);
+const providerKeyIdSchema$1 = z.uuid();
+const workspaceKeyIdSchema$1 = z.uuid();
+const providerKeyLabelSchema = z.string().trim().min(1).max(100);
+const providerKeyHintSchema = z.string().min(1).max(64);
+const encryptedProviderKeySchema = z.strictObject({
+	encryptionVersion: z.literal(1),
+	ciphertext: z.string().min(1).max(32768),
+	initializationVector: z.string().min(1).max(64),
+	wrappedDek: z.string().min(1).max(1024)
+}).readonly();
+const providerIdSchema = z.enum(providerIds);
+const providerKeyMetadataSchema = z.object({
+	id: providerKeyIdSchema$1,
+	provider: providerIdSchema,
+	label: providerKeyLabelSchema.nullable(),
+	keyHint: providerKeyHintSchema.nullable(),
+	version: z.int().positive(),
+	createdAt: z.iso.datetime(),
+	updatedAt: z.iso.datetime()
+}).readonly();
+const providerKeyEncryptionContextSchema = z.object({
+	organizationId: z.uuid(),
+	workspaceKey: z.object({
+		kid: workspaceKeyIdSchema$1,
+		publicKey: z.string().min(1).max(1024)
+	}).readonly()
+}).readonly();
+z.object({
+	providerKeys: z.array(providerKeyMetadataSchema).readonly(),
+	encryptionContext: providerKeyEncryptionContextSchema.nullable()
+}).readonly();
+z.object({ providerKey: providerKeyMetadataSchema }).readonly();
+z.strictObject({
+	id: providerKeyIdSchema$1,
+	workspaceKeyKid: workspaceKeyIdSchema$1,
+	provider: providerIdSchema,
+	label: providerKeyLabelSchema.optional(),
+	keyHint: providerKeyHintSchema.optional(),
+	encryptedProviderKey: encryptedProviderKeySchema
+}).readonly();
+z.strictObject({
+	workspaceKeyKid: workspaceKeyIdSchema$1,
+	label: providerKeyLabelSchema.optional(),
+	keyHint: providerKeyHintSchema.optional(),
+	encryptedProviderKey: encryptedProviderKeySchema,
+	version: z.int().positive()
+}).readonly();
+const affectedAgentSchema = z.object({
+	id: z.uuid(),
+	name: z.string().min(1).max(100)
+}).readonly();
+z.object({ affectedAgents: z.array(affectedAgentSchema).readonly() }).readonly();
+z.object({
+	deleted: z.literal(true),
+	affectedAgents: z.array(affectedAgentSchema).readonly()
+}).readonly();
+//#endregion
+//#region ../modules/src/agents/agentApiKeys/agentApiKeys.contract.ts
+const agentApiKeyIdSchema = z.uuid();
+const agentApiKeyLabelSchema = z.string().trim().min(1).max(100);
+const agentApiKeyMetadataSchema = z.object({
+	id: agentApiKeyIdSchema,
+	label: agentApiKeyLabelSchema.nullable(),
+	keyPrefix: z.string().min(1).max(32),
+	createdAt: z.iso.datetime(),
+	lastUsedAt: z.iso.datetime().nullable(),
+	revokedAt: z.iso.datetime().nullable()
+}).readonly();
+z.object({ apiKeys: z.array(agentApiKeyMetadataSchema).readonly() }).readonly();
+z.strictObject({ label: agentApiKeyLabelSchema.optional() }).readonly();
+const createdAgentApiKeySchema = z.object({
+	metadata: agentApiKeyMetadataSchema,
+	secret: z.string().regex(/^ar_agent_[A-Za-z0-9_-]{43}$/)
+}).readonly();
+z.object({ revoked: z.literal(true) }).readonly();
+//#endregion
+//#region ../modules/src/agents/agentConfigurations/agentConfigurations.contract.ts
+const agentIdSchema = z.uuid();
+const providerKeyIdSchema = z.uuid();
+const agentNameSchema = z.string().trim().min(1).max(100);
+const modelIdSchema = z.string().trim().min(1).max(200);
+const agentStatusSchema = z.enum(["active", "archived"]);
+const agentMetadataSchema = z.object({
+	id: agentIdSchema,
+	name: agentNameSchema,
+	providerKeyId: providerKeyIdSchema.nullable(),
+	provider: providerIdSchema.nullable(),
+	modelId: modelIdSchema,
+	status: agentStatusSchema,
+	version: z.int().positive(),
+	createdAt: z.iso.datetime(),
+	updatedAt: z.iso.datetime()
+}).readonly();
+z.object({ agents: z.array(agentMetadataSchema).readonly() }).readonly();
+z.object({ agent: agentMetadataSchema }).readonly();
+z.object({
+	agent: agentMetadataSchema,
+	apiKey: createdAgentApiKeySchema
+}).readonly();
+z.strictObject({
+	name: agentNameSchema,
+	providerKeyId: providerKeyIdSchema,
+	modelId: modelIdSchema
+}).readonly();
+z.strictObject({
+	name: agentNameSchema,
+	providerKeyId: providerKeyIdSchema,
+	modelId: modelIdSchema,
+	version: z.int().positive()
+}).readonly();
+z.strictObject({ version: z.int().positive() }).readonly();
+//#endregion
+//#region ../modules/src/agents/runtimeConfiguration/agentRuntimeConfiguration.contract.ts
+const agentRuntimeConfigurationResponseSchema = z.object({
+	agentId: z.uuid(),
+	agentConfigurationVersion: z.int().positive(),
+	organizationId: z.uuid(),
+	providerKeyId: z.uuid(),
+	provider: providerIdSchema,
+	modelId: z.string().min(1).max(200),
+	credential: z.object({
+		mode: z.literal("managed"),
+		apiKey: z.string().min(1)
+	}).readonly()
+}).readonly();
+//#endregion
+//#region src/core/runtimeConfiguration.ts
+const agentApiKeyPattern = /^ar_agent_[A-Za-z0-9_-]{43}$/;
+var AgenticRunApiError = class extends Error {
+	code;
+	statusCode;
+	constructor(statusCode, code, options = {}) {
+		super(`Agentic Run API request failed with ${statusCode} (${code}).`, { cause: options.cause });
+		this.name = "AgenticRunApiError";
+		this.code = code;
+		this.statusCode = statusCode;
+	}
+};
+const loadAgentRuntimeConfiguration = async ({ agentApiKey, apiUrl = defaultApiUrl, fetch = globalThis.fetch }) => {
+	if (!agentApiKeyPattern.test(agentApiKey)) throw new TypeError("Agentic Run Agent API key has an invalid format.");
+	const response = await fetch(createApiEndpoint(apiUrl, "agent/configuration"), { headers: { authorization: `Bearer ${agentApiKey}` } });
+	const body = await readJson(response);
+	if (!response.ok) {
+		const error = apiErrorResponseSchema.safeParse(body);
+		throw new AgenticRunApiError(response.status, error.success ? error.data.error.code : "request_failed");
+	}
+	const configuration = agentRuntimeConfigurationResponseSchema.safeParse(body);
+	if (!configuration.success) throw new AgenticRunApiError(response.status, "invalid_configuration_response", { cause: configuration.error });
+	return configuration.data;
+};
+const readJson = async (response) => {
+	try {
+		return await response.json();
+	} catch (cause) {
+		throw new AgenticRunApiError(response.status, "invalid_json_response", { cause });
+	}
+};
+//#endregion
+//#region ../modules/src/tracing/tracing.contract.ts
+const sessionStatusSchema = z.enum([
+	"idle",
+	"running",
+	"waiting_for_input",
+	"error",
+	"closed"
+]);
+const traceStatusSchema = z.enum([
+	"running",
+	"waiting_for_input",
+	"success",
+	"error",
+	"cancelled"
+]);
+const spanStatusSchema = z.enum([
+	"running",
+	"success",
+	"error",
+	"cancelled"
+]);
+const tracingLimits = {
+	attributesBytes: 32768,
+	attributesKeys: 64,
+	attributeKeyCharacters: 128,
+	attributeStringBytes: 8192,
+	attributeArrayEntries: 100,
+	contentBytes: 2097152,
+	spanEventsBytes: 262144,
+	spanEvents: 1e3,
+	spansPerBatch: 500,
+	lifecycleEventsPerBatch: 1002,
+	batchBytes: 10485760
+};
+const serializedByteLength = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+const attributeStringSchema = z.string().refine((value) => serializedByteLength(value) <= tracingLimits.attributeStringBytes, "Attribute string is too large");
+const attributeValueSchema = z.union([
+	attributeStringSchema,
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(attributeStringSchema).max(tracingLimits.attributeArrayEntries),
+	z.array(z.number()).max(tracingLimits.attributeArrayEntries),
+	z.array(z.boolean()).max(tracingLimits.attributeArrayEntries)
+]);
+const attributeKeySchema = z.string().trim().min(1).max(tracingLimits.attributeKeyCharacters).refine((key) => !key.startsWith("agenticrun."), "`agenticrun.*` attributes are reserved");
+const attributesSchema = z.record(attributeKeySchema, attributeValueSchema).superRefine((attributes, context) => {
+	if (Object.keys(attributes).length > tracingLimits.attributesKeys) context.addIssue({
+		code: "custom",
+		message: `Attributes may contain at most ${tracingLimits.attributesKeys} keys`
+	});
+	if (serializedByteLength(attributes) > tracingLimits.attributesBytes) context.addIssue({
+		code: "custom",
+		message: "Attributes object is too large"
+	});
+}).readonly();
+const identifierSchema = z.string().trim().min(1).max(512);
+const timestampSchema = z.iso.datetime();
+const contentTextSchema = z.string().max(tracingLimits.contentBytes);
+const textContentSchema = z.strictObject({
+	type: z.literal("text"),
+	text: contentTextSchema
+});
+const reasoningContentSchema = z.strictObject({
+	type: z.literal("reasoning"),
+	text: contentTextSchema
+});
+const jsonContentSchema = z.strictObject({
+	type: z.literal("json"),
+	value: z.json()
+});
+const toolCallContentSchema = z.strictObject({
+	type: z.literal("tool-call"),
+	toolName: z.string().trim().min(1).max(200),
+	callId: identifierSchema,
+	arguments: z.json()
+});
+const toolResultContentSchema = z.strictObject({
+	type: z.literal("tool-result"),
+	callId: identifierSchema,
+	result: z.json()
+});
+const messageContentBlockSchema = z.discriminatedUnion("type", [
+	textContentSchema,
+	reasoningContentSchema,
+	jsonContentSchema,
+	toolCallContentSchema,
+	toolResultContentSchema
+]).readonly();
+const messagesContentSchema = z.strictObject({
+	type: z.literal("messages"),
+	messages: z.array(z.strictObject({
+		id: identifierSchema.optional(),
+		role: z.enum([
+			"system",
+			"developer",
+			"user",
+			"assistant",
+			"tool"
+		]),
+		name: z.string().trim().min(1).max(200).optional(),
+		content: z.array(messageContentBlockSchema).min(1)
+	})).min(1)
+});
+const documentsContentSchema = z.strictObject({
+	type: z.literal("documents"),
+	documents: z.array(z.strictObject({
+		id: identifierSchema.optional(),
+		content: contentTextSchema,
+		attributes: attributesSchema.optional()
+	})).min(1)
+});
+const redactedContentSchema = z.strictObject({
+	type: z.literal("redacted"),
+	reason: z.string().trim().min(1).max(500).optional()
+});
+const omittedContentSchema = z.strictObject({
+	type: z.literal("omitted"),
+	reason: z.enum([
+		"disabled",
+		"unsupported",
+		"too-large",
+		"unavailable"
+	]),
+	originalBytes: z.int().nonnegative().optional()
+});
+const traceContentSchema = z.discriminatedUnion("type", [
+	messagesContentSchema,
+	textContentSchema,
+	jsonContentSchema,
+	toolCallContentSchema,
+	toolResultContentSchema,
+	documentsContentSchema,
+	redactedContentSchema,
+	omittedContentSchema
+]).refine((content) => serializedByteLength(content) <= tracingLimits.contentBytes, "Trace content is too large").readonly();
+const spanEventSchema = z.strictObject({
+	name: z.string().trim().min(1).max(200),
+	time: timestampSchema,
+	attributes: attributesSchema.optional()
+}).readonly();
+const spanEventsSchema = z.array(spanEventSchema).max(tracingLimits.spanEvents).refine((events) => serializedByteLength(events) <= tracingLimits.spanEventsBytes, "Span events are too large").readonly();
+const tokenUsageSchema = z.strictObject({
+	inputTokensTotal: z.int().nonnegative().optional(),
+	inputTokensCacheRead: z.int().nonnegative().optional(),
+	inputTokensCacheWrite: z.int().nonnegative().optional(),
+	outputTokensTotal: z.int().nonnegative().optional(),
+	outputTokensReasoning: z.int().nonnegative().optional(),
+	costUsd: z.number().nonnegative().optional()
+}).superRefine((usage, context) => {
+	if (usage.inputTokensTotal !== void 0 && usage.inputTokensCacheRead !== void 0 && usage.inputTokensCacheRead > usage.inputTokensTotal) context.addIssue({
+		code: "custom",
+		path: ["inputTokensCacheRead"],
+		message: "Cache-read tokens cannot exceed total input tokens"
+	});
+	if (usage.inputTokensTotal !== void 0 && usage.inputTokensCacheWrite !== void 0 && usage.inputTokensCacheWrite > usage.inputTokensTotal) context.addIssue({
+		code: "custom",
+		path: ["inputTokensCacheWrite"],
+		message: "Cache-write tokens cannot exceed total input tokens"
+	});
+	if (usage.inputTokensTotal !== void 0 && usage.inputTokensCacheRead !== void 0 && usage.inputTokensCacheWrite !== void 0 && usage.inputTokensCacheRead + usage.inputTokensCacheWrite > usage.inputTokensTotal) context.addIssue({
+		code: "custom",
+		path: ["inputTokensCacheWrite"],
+		message: "Combined cache tokens cannot exceed total input tokens"
+	});
+	if (usage.outputTokensTotal !== void 0 && usage.outputTokensReasoning !== void 0 && usage.outputTokensReasoning > usage.outputTokensTotal) context.addIssue({
+		code: "custom",
+		path: ["outputTokensReasoning"],
+		message: "Reasoning tokens cannot exceed total output tokens"
+	});
+}).readonly();
+const tracingSessionResolutionSchema = z.strictObject({
+	id: z.uuid(),
+	externalSessionId: identifierSchema.optional(),
+	attributes: attributesSchema.optional()
+}).readonly();
+const traceStartedEventSchema = z.strictObject({
+	type: z.literal("trace.started"),
+	id: z.uuid(),
+	sourceTraceId: identifierSchema.optional(),
+	agentConfigurationVersion: z.int().positive(),
+	startedAt: timestampSchema,
+	attributes: attributesSchema.optional()
+}).readonly();
+const traceCompletedEventSchema = z.strictObject({
+	type: z.literal("trace.completed"),
+	id: z.uuid(),
+	status: z.enum([
+		"success",
+		"error",
+		"cancelled"
+	]),
+	endedAt: timestampSchema
+}).readonly();
+const spanStartedEventSchema = z.strictObject({
+	type: z.literal("span.started"),
+	id: z.uuid(),
+	traceId: z.uuid(),
+	parentSpanId: z.uuid().optional(),
+	sourceSpanId: identifierSchema.optional(),
+	name: z.string().trim().min(1).max(200),
+	spanType: z.enum([
+		"agent",
+		"workflow",
+		"model",
+		"tool",
+		"retrieval",
+		"embedding",
+		"custom"
+	]),
+	startedAt: timestampSchema,
+	input: traceContentSchema.optional(),
+	attributes: attributesSchema.optional(),
+	tags: z.array(z.string().trim().min(1).max(100)).max(50).optional()
+}).readonly();
+const successfulSpanResultSchema = z.strictObject({
+	status: z.literal("success"),
+	output: traceContentSchema.optional()
+});
+const failedSpanResultSchema = z.strictObject({
+	status: z.literal("error"),
+	output: traceContentSchema.optional(),
+	error: z.strictObject({
+		type: z.string().trim().min(1).max(200),
+		message: z.string().max(32768)
+	})
+});
+const cancelledSpanResultSchema = z.strictObject({
+	status: z.literal("cancelled"),
+	output: traceContentSchema.optional(),
+	error: z.strictObject({
+		type: z.string().trim().min(1).max(200),
+		message: z.string().max(32768)
+	}).optional()
+});
+const spanResultSchema = z.discriminatedUnion("status", [
+	successfulSpanResultSchema,
+	failedSpanResultSchema,
+	cancelledSpanResultSchema
+]).readonly();
+const modelCallSchema = z.strictObject({
+	providerId: z.string().trim().min(1).max(200).nullable(),
+	modelId: z.string().trim().min(1).max(200).nullable(),
+	responseModelId: z.string().trim().min(1).max(200).optional()
+}).readonly();
+const spanCompletedEventSchema = z.strictObject({
+	type: z.literal("span.completed"),
+	id: z.uuid(),
+	traceId: z.uuid(),
+	endedAt: timestampSchema,
+	firstTokenAt: timestampSchema.optional(),
+	result: spanResultSchema,
+	events: spanEventsSchema.optional(),
+	usage: tokenUsageSchema.optional(),
+	model: modelCallSchema.optional(),
+	attributes: attributesSchema.optional()
+}).readonly();
+const tracingLifecycleEventSchema = z.discriminatedUnion("type", [
+	traceStartedEventSchema,
+	traceCompletedEventSchema,
+	spanStartedEventSchema,
+	spanCompletedEventSchema
+]);
+const tracingIngestionRequestSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	session: tracingSessionResolutionSchema,
+	events: z.array(tracingLifecycleEventSchema).min(1).max(tracingLimits.lifecycleEventsPerBatch)
+}).superRefine((request, context) => {
+	if (new Set(request.events.filter((event) => event.type.startsWith("span.")).map((event) => event.id)).size > tracingLimits.spansPerBatch) context.addIssue({
+		code: "custom",
+		path: ["events"],
+		message: "Batch contains too many spans"
+	});
+	if (serializedByteLength(request) > tracingLimits.batchBytes) context.addIssue({
+		code: "custom",
+		message: "Tracing batch is too large"
+	});
+}).readonly();
+const tracingIngestionResponseSchema = z.object({
+	sessionId: z.uuid(),
+	sessionCreated: z.boolean(),
+	acceptedEventCount: z.int().positive()
+}).readonly();
+//#endregion
+//#region ../modules/src/tracing/sessionInspection/sessionInspection.contract.ts
+const offset = z.coerce.number().int().min(0).max(2147483647).default(0);
+z.object({ offset });
+z.object({
+	traceOffset: offset,
+	spanOffset: offset
+});
+const timestamps = {
+	createdAt: z.iso.datetime(),
+	updatedAt: z.iso.datetime()
+};
+const attributes = z.record(z.string(), z.json());
+const costs = z.array(z.object({
+	currency: z.string(),
+	total: z.string(),
+	input: z.string().nullable(),
+	output: z.string().nullable(),
+	cacheRead: z.string().nullable(),
+	cacheWrite: z.string().nullable(),
+	reasoning: z.string().nullable()
+})).nullable().optional();
+const inspectedSessionSchema = z.object({
+	id: z.uuid(),
+	tenantId: z.uuid(),
+	agentId: z.uuid(),
+	agentName: z.string(),
+	externalId: z.string().nullable(),
+	status: sessionStatusSchema,
+	endedAt: z.iso.datetime().nullable(),
+	attributes,
+	...timestamps
+});
+const inspectedContentSchema = z.json().transform((value) => {
+	if (value === null) return null;
+	const parsed = traceContentSchema.safeParse(value);
+	return parsed.success ? parsed.data : {
+		type: "json",
+		value
+	};
+});
+const inspectedSpanSchema = z.object({
+	id: z.uuid(),
+	tenantId: z.uuid(),
+	traceId: z.uuid(),
+	parentSpanId: z.uuid().nullable(),
+	sourceSpanId: z.string().nullable(),
+	name: z.string(),
+	spanType: z.enum([
+		"agent",
+		"workflow",
+		"model",
+		"tool",
+		"retrieval",
+		"embedding",
+		"custom"
+	]),
+	status: spanStatusSchema,
+	startedAt: z.iso.datetime(),
+	endedAt: z.iso.datetime().nullable(),
+	firstTokenAt: z.iso.datetime().nullable(),
+	input: inspectedContentSchema,
+	output: inspectedContentSchema,
+	events: z.array(attributes),
+	attributes,
+	tags: z.array(z.string()),
+	errorType: z.string().nullable(),
+	errorMessage: z.string().nullable(),
+	inputTokensTotal: z.int().nullable(),
+	inputTokensCacheRead: z.int().nullable(),
+	inputTokensCacheWrite: z.int().nullable(),
+	outputTokensTotal: z.int().nullable(),
+	outputTokensReasoning: z.int().nullable(),
+	costs,
+	costUsd: z.string().nullable(),
+	...timestamps
+});
+const inspectedTraceSchema = z.object({
+	costs,
+	id: z.uuid(),
+	tenantId: z.uuid(),
+	sessionId: z.uuid(),
+	sourceTraceId: z.string().nullable(),
+	agentConfigurationVersion: z.int(),
+	status: traceStatusSchema,
+	startedAt: z.iso.datetime(),
+	endedAt: z.iso.datetime().nullable(),
+	attributes,
+	...timestamps,
+	spans: z.array(inspectedSpanSchema)
+});
+const sessionSummaryShape = {
+	startedAt: z.iso.datetime().nullable(),
+	traceCount: z.int().nonnegative(),
+	hasErrors: z.boolean(),
+	durationMs: z.number().nonnegative().nullable(),
+	inputTokens: z.int().nonnegative().nullable(),
+	outputTokens: z.int().nonnegative().nullable(),
+	costs,
+	costUsd: z.string().nullable(),
+	inputPreview: z.string().nullable()
+};
+z.object({
+	sessions: z.array(inspectedSessionSchema.extend(sessionSummaryShape)),
+	nextOffset: z.int().nonnegative().nullable()
+});
+z.object({
+	session: inspectedSessionSchema.extend({
+		...sessionSummaryShape,
+		traces: z.array(inspectedTraceSchema)
+	}),
+	nextTraceOffset: z.int().nonnegative().nullable(),
+	nextSpanOffset: z.int().nonnegative().nullable()
+});
+//#endregion
+//#region src/core/tracing/traceContent.ts
+const sensitiveKeyPattern = /(authorization|cookie|api[-_]?key|token|secret|password)/i;
+const isSensitiveAttributeKey = (key) => sensitiveKeyPattern.test(key);
+const validatedAttributes = (attributes) => {
+	const result = attributesSchema.safeParse(attributes);
+	return result.success && Object.keys(result.data).length > 0 ? result.data : void 0;
+};
+const safeJson = (value) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const json = JSON.stringify(value ?? null, (key, item) => {
+		if (key && sensitiveKeyPattern.test(key)) return "[REDACTED]";
+		if (typeof item === "bigint") return item.toString();
+		if (typeof item === "function" || typeof item === "symbol" || item === void 0) return null;
+		if (typeof item === "object" && item !== null) {
+			if (seen.has(item)) return "[Circular]";
+			seen.add(item);
+		}
+		return item;
+	});
+	return JSON.parse(json ?? "null");
+};
+const validatedContent = (content) => {
+	const result = traceContentSchema.safeParse(content);
+	return result.success ? result.data : omittedContent(content, "too-large");
+};
+const omittedContent = (value, reason) => ({
+	type: "omitted",
+	reason,
+	originalBytes: new TextEncoder().encode(JSON.stringify(safeJson(value))).byteLength
+});
+//#endregion
+//#region src/core/tracing/traceDelivery.ts
+const createTraceDelivery = ({ session: initialSession, transport, onSessionResolved }) => {
+	let session = initialSession;
+	let startDelivery = Promise.resolve();
+	let completionDelivery;
+	const deliver = async (events) => {
+		try {
+			const response = await transport.send({
+				schemaVersion: 1,
+				session,
+				events
+			});
+			if (!response) return false;
+			session = {
+				...session,
+				id: response.sessionId
+			};
+			onSessionResolved(response.sessionId);
+			return true;
+		} catch (error) {
+			console.warn("[Agentic Run] Trace delivery failed", { error: error instanceof Error ? error.name : "UnknownError" });
+			return false;
+		}
+	};
+	return {
+		start(events) {
+			startDelivery = deliver([...events]).then(() => void 0);
+			return startDelivery;
+		},
+		complete(events) {
+			if (!completionDelivery) {
+				const snapshot = [...events];
+				completionDelivery = (async () => {
+					await startDelivery;
+					if (!await deliver(snapshot)) await deliver(snapshot);
+				})();
+			}
+			return completionDelivery;
+		}
+	};
+};
+//#endregion
+//#region src/core/tracing/createTrace.ts
+const createTrace = (context, options) => {
+	const id = randomUUID();
+	const events = [{
+		type: "trace.started",
+		id,
+		agentConfigurationVersion: context.agentConfigurationVersion,
+		startedAt: now(),
+		...options.sourceTraceId ? { sourceTraceId: options.sourceTraceId } : {},
+		...options.attributes ? { attributes: validatedAttributes(options.attributes) } : {}
+	}];
+	let completed = false;
+	const delivery = createTraceDelivery(context);
+	const startSpan = (input) => {
+		const spanId = randomUUID();
+		let spanCompleted = false;
+		let firstTokenAt;
+		const model = input.spanType === "model" ? { ...context.model } : void 0;
+		const tags = input.tags?.map((tag) => tag.trim().slice(0, 100)).filter(Boolean).slice(0, 50);
+		events.push({
+			type: "span.started",
+			id: spanId,
+			traceId: id,
+			...input.parentSpanId ? { parentSpanId: input.parentSpanId } : {},
+			...input.sourceSpanId ? { sourceSpanId: input.sourceSpanId } : {},
+			name: input.name.trim().slice(0, 200) || input.spanType,
+			spanType: input.spanType,
+			startedAt: now(),
+			...input.input ? { input: validatedContent(input.input) } : {},
+			...input.attributes ? { attributes: validatedAttributes(input.attributes) } : {},
+			...tags?.length ? { tags } : {}
+		});
+		return {
+			id: spanId,
+			markFirstToken() {
+				if (!completed && !spanCompleted && firstTokenAt === void 0) firstTokenAt = now();
+			},
+			complete(result, details = {}) {
+				if (completed || spanCompleted) return;
+				spanCompleted = true;
+				events.push({
+					type: "span.completed",
+					id: spanId,
+					traceId: id,
+					endedAt: now(),
+					result: {
+						...result,
+						...result.output ? { output: validatedContent(result.output) } : {}
+					},
+					...firstTokenAt ? { firstTokenAt } : {},
+					...details.usage ? { usage: { ...details.usage } } : {},
+					...details.attributes ? { attributes: validatedAttributes(details.attributes) } : {},
+					...model ? { model: {
+						...model,
+						...details.responseModelId ? { responseModelId: details.responseModelId } : {}
+					} } : {}
+				});
+			}
+		};
+	};
+	return {
+		id,
+		rootSpan: startSpan(options.rootSpan),
+		started: delivery.start(events),
+		get completed() {
+			return completed;
+		},
+		startSpan(input) {
+			return completed ? void 0 : startSpan(input);
+		},
+		complete(status) {
+			if (!completed) {
+				completed = true;
+				events.push({
+					type: "trace.completed",
+					id,
+					status,
+					endedAt: now()
+				});
+			}
+			return delivery.complete(events);
+		}
+	};
+};
+const now = () => (/* @__PURE__ */ new Date()).toISOString();
+//#endregion
+//#region src/core/tracing/createTracingSession.ts
+const createTracingSessionFactory = (context) => (options = {}) => {
+	const sensitiveAttribute = Object.keys(options.attributes ?? {}).find(isSensitiveAttributeKey);
+	if (sensitiveAttribute) throw new TypeError(`Agentic Run tracing attribute "${sensitiveAttribute}" may contain sensitive data.`);
+	let session = tracingSessionResolutionSchema.parse({
+		id: options.id ?? randomUUID(),
+		...options.externalSessionId ? { externalSessionId: options.externalSessionId } : {},
+		...options.attributes ? { attributes: options.attributes } : {}
+	});
+	return {
+		get id() {
+			return session.id;
+		},
+		createTrace(input) {
+			return createTrace({
+				agentConfigurationVersion: context.agentConfigurationVersion,
+				model: {
+					providerId: context.provider,
+					modelId: context.model
+				},
+				session,
+				transport: context.transport,
+				onSessionResolved(id) {
+					session = {
+						...session,
+						id
+					};
+				}
+			}, input);
+		}
+	};
+};
+//#endregion
+//#region src/core/tracing/tracingTransport.ts
+const createTracingTransport = ({ agentApiKey, apiUrl, fetch, timeoutMs }) => {
+	const endpoint = createApiEndpoint(apiUrl, "agent/tracing");
+	return { async send(request) {
+		try {
+			const payload = tracingIngestionRequestSchema.parse(request);
+			const response = await fetch(endpoint, {
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${agentApiKey}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(payload),
+				signal: AbortSignal.timeout(timeoutMs)
+			});
+			if (!response.ok) {
+				console.warn("[Agentic Run] Trace delivery failed", { statusCode: response.status });
+				return;
+			}
+			const parsed = tracingIngestionResponseSchema.safeParse(await response.json());
+			if (!parsed.success || parsed.data.acceptedEventCount !== payload.events.length) {
+				console.warn("[Agentic Run] Trace delivery returned an invalid response");
+				return;
+			}
+			return parsed.data;
+		} catch (error) {
+			console.warn("[Agentic Run] Trace delivery failed", { error: error instanceof Error ? error.name : "UnknownError" });
+			return;
+		}
+	} };
+};
+//#endregion
+//#region ../env/src/index.ts
+const readString = (source, key) => {
+	return source[key]?.trim() || void 0;
+};
+const validateIntegerConstraints = (key, value, options) => {
+	if (options.min !== void 0 && value < options.min) throw new Error(`${key} must be at least ${options.min}`);
+	if (options.max !== void 0 && value > options.max) throw new Error(`${key} must be at most ${options.max}`);
+	return value;
+};
+const readInteger = (key, value, options) => {
+	const integer = typeof value === "number" ? value : Number(value);
+	if (!Number.isSafeInteger(integer) || typeof value === "string" && !/^[+-]?\d+$/.test(value)) throw new Error(`${key} must be an integer`);
+	return validateIntegerConstraints(key, integer, options);
+};
+const createEnvironment = (source) => {
+	const environment = (key, options) => {
+		const value = readString(source, key);
+		if (options?.type === "int") {
+			if (value !== void 0) return readInteger(key, value, options);
+			if ("default" in options && options.default !== void 0) return readInteger(key, options.default, options);
+			if (options.optional) return void 0;
+			throw new Error(`${key} is required`);
+		}
+		if (value !== void 0) return value;
+		if (options && "default" in options && options.default !== void 0) {
+			const defaultValue = options.default.trim();
+			if (defaultValue) return defaultValue;
+			throw new Error(`${key} default must not be empty`);
+		}
+		if (options?.optional) return void 0;
+		throw new Error(`${key} is required`);
+	};
+	return environment;
+};
+//#endregion
+//#region ../modules/src/credentials/workspaceKeys/workspaceKeys.contract.ts
+const workspaceKeyIdSchema = z.uuid();
+const workspaceKeyMetadataSchema = z.object({
+	kid: workspaceKeyIdSchema,
+	type: z.enum(["google_kms", "customer"])
+}).readonly();
+z.object({ workspaceKey: workspaceKeyMetadataSchema.nullable() }).readonly();
+//#endregion
+//#region src/core/createAgenticRunClient.ts
+var AgenticRunConfigurationError = class extends Error {
+	code;
+	constructor(code, message, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "AgenticRunConfigurationError";
+		this.code = code;
+	}
+};
+const createAgenticRunClient = async (options = {}) => {
+	const env = createEnvironment(process.env);
+	const agentApiKey = options.agentApiKey?.trim() ?? env("AGENTICRUN_AGENT_API_KEY");
+	const apiUrl = options.apiUrl?.trim() ?? env("AGENTICRUN_API_URL", { optional: true });
+	const tracingTimeoutMs = options.tracingTimeoutMs ?? 1e3;
+	if (!Number.isInteger(tracingTimeoutMs) || tracingTimeoutMs < 1) throw new TypeError("Agentic Run tracing timeout must be a positive integer.");
+	const configuration = await loadAgentRuntimeConfiguration({
+		agentApiKey,
+		apiUrl,
+		fetch: options.fetch
+	});
+	const provider = providerCatalog.find((candidate) => candidate.id === configuration.provider);
+	if (!provider?.active) throw new AgenticRunConfigurationError("unsupported_provider", `Agentic Run provider "${configuration.provider}" is not supported.`);
+	if (!provider.models.some((model) => model.id === configuration.modelId && model.active)) throw new AgenticRunConfigurationError("unsupported_model", `Agentic Run model "${configuration.modelId}" is not supported for provider "${configuration.provider}".`);
+	return {
+		configuration,
+		provider,
+		createSession: createTracingSessionFactory({
+			agentConfigurationVersion: configuration.agentConfigurationVersion,
+			model: configuration.modelId,
+			provider: configuration.provider,
+			transport: createTracingTransport({
+				agentApiKey,
+				apiUrl: apiUrl ?? "https://api.agenticrun.de/v1",
+				fetch: options.fetch ?? globalThis.fetch,
+				timeoutMs: tracingTimeoutMs
+			})
+		})
+	};
+};
+//#endregion
+export { safeJson as a, tokenUsageSchema as c, loadAgentRuntimeConfiguration as d, omittedContent as i, tracingLimits as l, createAgenticRunClient as n, validatedAttributes as o, isSensitiveAttributeKey as r, validatedContent as s, AgenticRunConfigurationError as t, AgenticRunApiError as u };