eve 0.44.4 → 0.45.0

package/dist/src/chunks/{use-eve-agent-BJwaMe5k.js → use-eve-agent-C46Kan_I.js}

@@ -4,6 +4,7 @@ import { asSchema } from "ai";
 
 //#region src/protocol/routes.ts
 const EVE_ROUTE_PREFIX = "/eve/v1";
+const EVE_PRODUCTION_CRON_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/cron/:token`;
 const EVE_HEALTH_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/health`;
 const EVE_INFO_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/info`;
 const EVE_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session`;
@@ -54,6 +55,26 @@ var AgentInfoResponseError = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/client/health-response-error.ts
+var HealthResponseError = class extends Error {
+	issues;
+	constructor(issues = []) {
+		const detail = issues.length === 0 ? "" : ` (${issues.join("; ")})`;
+		super(`The server returned an unrecognized eve health response.${detail}`);
+		this.name = "HealthResponseError";
+		this.issues = issues;
+	}
+};
+
+//#endregion
+//#region src/client/health-schema.ts
+const HealthResultSchema = z.object({
+	ok: z.literal(true),
+	status: z.literal("ready"),
+	workflowId: z.string().min(1)
+}).strict();
+
 //#endregion
 //#region src/internal/http/basic-auth.ts
 function encodeBasicCredentials(username, password) {
@@ -64,26 +85,68 @@ function encodeBasicCredentials(username, password) {
 
 //#endregion
 //#region src/client/agent-info-schema.ts
+const owner = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("application") }).strict(),
+	z.object({
+		feature: z.string(),
+		kind: z.literal("framework")
+	}).strict(),
+	z.object({
+		kind: z.literal("extension"),
+		namespace: z.string(),
+		packageName: z.string()
+	}).strict()
+]);
+const moduleBacking = z.discriminatedUnion("kind", [z.object({
+	externalDependencies: z.array(z.string()),
+	extensionScope: z.object({
+		namespace: z.string(),
+		sourceRoot: z.string()
+	}).strict().optional(),
+	kind: z.literal("filesystem"),
+	sourcePath: z.string()
+}).strict(), z.object({
+	kind: z.literal("programmatic"),
+	moduleId: z.string(),
+	registryId: z.string(),
+	revision: z.string(),
+	semanticRevision: z.string().optional()
+}).strict()]);
+const binding = z.object({
+	backing: moduleBacking,
+	logicalPath: z.string(),
+	owner
+}).strict();
 const source = z.object({
+	binding: binding.optional(),
 	exportName: z.string().optional(),
 	logicalPath: z.string(),
-	sourceId: z.string().optional(),
-	sourceKind: z.string()
-});
-const entry = source.extend({ name: z.string() });
+	owner,
+	sourceId: z.string(),
+	sourceKind: z.enum([
+		"markdown",
+		"module",
+		"skill-package"
+	])
+}).strict();
+const entry = source.extend({ name: z.string() }).strict();
+const dynamicResolver = source.extend({
+	eventNames: z.array(z.string()),
+	slug: z.string()
+}).strict();
 const modelRouting = z.discriminatedUnion("kind", [z.object({
 	kind: z.literal("gateway"),
 	target: z.string(),
 	byok: z.string().optional()
-}), z.object({
+}).strict(), z.object({
 	kind: z.literal("external"),
 	provider: z.string()
-})]);
+}).strict()]);
 const modelEndpoint = z.union([
 	z.object({
 		kind: z.literal("external"),
 		provider: z.string()
-	}),
+	}).strict(),
 	z.object({
 		kind: z.literal("chatgpt"),
 		state: z.enum([
@@ -94,18 +157,18 @@ const modelEndpoint = z.union([
 			"unavailable"
 		]),
 		accountLabel: z.string().optional()
-	}),
+	}).strict(),
 	z.object({
 		kind: z.literal("gateway"),
 		connected: z.literal(true),
 		credential: z.enum(["api-key", "oidc"])
-	}),
+	}).strict(),
 	z.object({
 		kind: z.literal("gateway"),
 		connected: z.literal(false)
-	})
+	}).strict()
 ]);
-const agentModelBaseFields = {
+const modelBaseFields = {
 	contextWindowTokens: z.number().optional(),
 	providerOptions: z.unknown().optional(),
 	reasoning: z.enum([
@@ -120,15 +183,18 @@ const agentModelBaseFields = {
 	source: source.optional()
 };
 const agentModel = z.union([z.object({
-	...agentModelBaseFields,
+	...modelBaseFields,
+	endpoint: modelEndpoint.optional(),
 	id: z.string(),
-	routing: modelRouting,
-	endpoint: modelEndpoint.optional()
+	routing: modelRouting
 }).strict(), z.object({
-	...agentModelBaseFields,
+	...modelBaseFields,
 	endpoint: z.never().optional(),
 	id: z.never().optional(),
-	routing: z.object({ kind: z.literal("dynamic") }).strict()
+	routing: z.object({
+		kind: z.literal("dynamic"),
+		resolver: dynamicResolver
+	}).strict()
 }).strict()]);
 const tool = entry.extend({
 	description: z.string(),
@@ -137,71 +203,60 @@ const tool = entry.extend({
 	hasModelOutputProjection: z.boolean(),
 	hasOutputSchema: z.boolean(),
 	inputSchema: z.unknown(),
-	origin: z.enum(["authored", "framework"]),
 	outputSchema: z.unknown().optional(),
-	replacesFrameworkTool: z.boolean(),
 	requiresApproval: z.boolean()
-});
-const frameworkTool = tool.extend({
-	disabledByAuthor: z.boolean(),
-	replacedByAuthoredTool: z.boolean(),
-	status: z.enum([
-		"active",
-		"disabled",
-		"opt-in",
-		"replaced"
-	])
-});
-const dynamicResolver = source.extend({
-	eventNames: z.array(z.string()),
-	origin: z.enum(["authored", "framework"]),
-	slug: z.string()
-});
+}).strict();
 const skill = entry.extend({
 	description: z.string(),
 	license: z.string().optional(),
 	markdown: z.string(),
 	metadata: z.record(z.string(), z.string()).optional()
-});
+}).strict();
 const instructions = entry.extend({
 	content: z.string(),
 	role: z.enum(["system", "user"])
-});
+}).strict();
 const schedule = entry.extend({
 	cron: z.string(),
 	hasRun: z.boolean(),
 	markdown: z.string().optional()
-});
-const subagent = entry.extend({
-	description: z.string().optional(),
-	entryPath: z.string(),
-	nodeId: z.string(),
-	rootPath: z.string(),
-	summary: z.object({
-		channels: z.number(),
-		connections: z.number(),
-		hooks: z.number(),
-		instructions: z.boolean(),
-		schedules: z.number(),
-		skills: z.number(),
-		tools: z.number()
-	})
-});
-const channel = entry.extend({
+}).strict();
+const channelMethod = z.enum([
+	"GET",
+	"HEAD",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"OPTIONS",
+	"WEBSOCKET"
+]);
+const channelRoute = entry.extend({
 	adapterKind: z.string().optional(),
-	method: z.string(),
-	origin: z.enum(["authored", "framework"]),
+	method: channelMethod,
 	urlPath: z.string()
-});
-const frameworkChannel = channel.extend({
-	disabledByAuthor: z.boolean(),
-	replacedByAuthoredChannel: z.boolean(),
-	status: z.enum([
-		"active",
-		"disabled",
-		"replaced"
-	])
-});
+}).strict();
+const sourceDescriptor = z.object({
+	backing: z.union([moduleBacking, z.object({
+		kind: z.literal("resource"),
+		sourcePath: z.string()
+	}).strict()]),
+	layer: z.enum([
+		"framework-default",
+		"extension-package",
+		"extension-override",
+		"application"
+	]),
+	logicalPath: z.string(),
+	owner,
+	sourceId: z.string()
+}).strict();
+const shadowedChannelRoute = z.object({
+	method: channelMethod,
+	source: sourceDescriptor,
+	urlPath: z.string(),
+	winnerSourceId: z.string()
+}).strict();
 const connection = source.extend({
 	connectionName: z.string(),
 	description: z.string(),
@@ -211,11 +266,11 @@ const connection = source.extend({
 	protocol: z.string(),
 	toolFilter: z.unknown().optional(),
 	url: z.string()
-});
+}).strict();
 const hook = source.extend({
 	eventNames: z.array(z.string()),
 	slug: z.string()
-});
+}).strict();
 const sandbox = source.extend({
 	backendKind: z.string().optional(),
 	description: z.string().optional(),
@@ -223,64 +278,264 @@ const sandbox = source.extend({
 	hasOnSession: z.boolean(),
 	revalidationKey: z.string().optional(),
 	sourceHash: z.string().optional()
-});
+}).strict();
+const subagent = entry.extend({
+	configResolver: dynamicResolver.optional(),
+	description: z.string().optional(),
+	entryPath: z.string(),
+	nodeId: z.string(),
+	parentNodeId: z.string(),
+	rootPath: z.string(),
+	summary: z.object({
+		channels: z.number(),
+		connections: z.number(),
+		hooks: z.number(),
+		instructions: z.number(),
+		schedules: z.number(),
+		skills: z.number(),
+		tools: z.number()
+	}).strict()
+}).strict();
+const remoteAgent = entry.extend({
+	description: z.string(),
+	nodeId: z.string(),
+	parentNodeId: z.string(),
+	url: z.string().optional()
+}).strict();
+const kernelEffect = z.object({
+	action: z.enum([
+		"subagent-call",
+		"task-update",
+		"task-cancel"
+	]).optional(),
+	audience: z.array(z.enum([
+		"root-session",
+		"delegated-task-child",
+		"requires-request-input",
+		"requires-loadable-skill",
+		"below-subagent-depth"
+	])),
+	kind: z.enum([
+		"request-input",
+		"dispatch",
+		"provider-tool"
+	]),
+	sourceId: z.string()
+}).strict();
+const compositionDiagnostic = z.object({
+	kind: z.enum(["disabled", "shadowed"]),
+	logicalPath: z.string(),
+	owner,
+	sourceId: z.string(),
+	winnerSourceId: z.string().optional()
+}).strict();
+const workflow = z.discriminatedUnion("enabled", [z.object({
+	enabled: z.literal(false),
+	toolName: z.string()
+}).strict(), z.object({
+	enabled: z.literal(true),
+	source,
+	toolName: z.string()
+}).strict()]);
 const AgentInfoResultSchema = z.object({
 	agent: z.object({
 		agentRoot: z.string(),
 		appRoot: z.string(),
-		configSource: source.optional(),
+		config: source.extend({ binding }).strict(),
 		description: z.string().optional(),
 		model: agentModel,
 		name: z.string(),
+		nodeId: z.string(),
 		outputSchema: z.unknown().optional()
-	}),
-	capabilities: z.object({ devRoutes: z.boolean() }),
+	}).strict(),
+	capabilities: z.object({ devRoutes: z.boolean() }).strict(),
 	channels: z.object({
-		authored: z.array(channel),
-		available: z.array(channel),
-		disabledFramework: z.array(z.string()),
-		framework: z.array(frameworkChannel)
-	}),
+		routes: z.array(channelRoute),
+		shadowed: z.array(shadowedChannelRoute)
+	}).strict(),
+	composition: z.object({
+		disabled: z.array(compositionDiagnostic),
+		shadowed: z.array(compositionDiagnostic)
+	}).strict(),
 	connections: z.array(connection),
 	diagnostics: z.object({
 		discoveryErrors: z.number(),
 		discoveryWarnings: z.number()
-	}),
+	}).strict(),
 	hooks: z.array(hook),
 	instructions: z.object({
 		dynamic: z.array(dynamicResolver),
 		static: z.array(instructions)
-	}),
+	}).strict(),
+	instrumentation: source.optional(),
+	kernelEffects: z.array(kernelEffect),
 	kind: z.literal("eve-agent-info"),
 	mode: z.enum(["development", "production"]),
-	sandbox: sandbox.nullable(),
+	remoteAgents: z.object({
+		entries: z.array(remoteAgent),
+		total: z.number()
+	}).strict(),
+	sandbox,
 	schedules: z.array(schedule),
 	skills: z.object({
 		dynamic: z.array(dynamicResolver),
 		static: z.array(skill)
-	}),
+	}).strict(),
 	subagents: z.object({
 		local: z.array(subagent),
 		total: z.number()
-	}),
+	}).strict(),
 	tools: z.object({
-		authored: z.array(tool),
-		available: z.array(tool),
-		disabledFramework: z.array(z.string()),
 		dynamic: z.array(dynamicResolver),
-		framework: z.array(frameworkTool),
-		reserved: z.array(z.string())
-	}),
-	version: z.literal(2),
-	workflow: z.object({
-		enabled: z.boolean(),
-		toolName: z.string()
-	}),
+		static: z.array(tool)
+	}).strict(),
+	version: z.literal(3),
+	workflow,
 	workspace: z.object({
 		resourceRoot: z.unknown(),
 		rootEntries: z.array(z.string())
-	})
+	}).strict()
+}).strict().superRefine((value, context) => {
+	const assertUnique = (entries, identity, path) => {
+		const seen = /* @__PURE__ */ new Set();
+		entries.forEach((entry, index) => {
+			const key = identity(entry);
+			if (seen.has(key)) context.addIssue({
+				code: "custom",
+				message: `Duplicate public identity "${key}".`,
+				path: [...path, index]
+			});
+			seen.add(key);
+		});
+	};
+	const assertTotal = (total, entries, path) => {
+		if (!Number.isSafeInteger(total) || total < 0 || total !== entries.length) context.addIssue({
+			code: "custom",
+			message: `Expected total ${entries.length}, received ${total}.`,
+			path: [...path]
+		});
+	};
+	assertUnique(value.tools.static, (entry) => entry.name, ["tools", "static"]);
+	assertUnique(value.tools.dynamic, (entry) => entry.slug, ["tools", "dynamic"]);
+	assertUnique(value.skills.static, (entry) => entry.name, ["skills", "static"]);
+	assertUnique(value.skills.dynamic, (entry) => entry.slug, ["skills", "dynamic"]);
+	assertUnique(value.instructions.static, (entry) => entry.name, ["instructions", "static"]);
+	assertUnique(value.instructions.dynamic, (entry) => entry.slug, ["instructions", "dynamic"]);
+	assertUnique(value.schedules, (entry) => entry.name, ["schedules"]);
+	assertUnique(value.connections, (entry) => entry.connectionName, ["connections"]);
+	assertUnique(value.hooks, (entry) => entry.slug, ["hooks"]);
+	assertUnique(value.channels.routes, (entry) => `${entry.method} ${normalizeRoutePattern(entry.urlPath)}`, ["channels", "routes"]);
+	assertUnique(value.subagents.local, (entry) => entry.nodeId, ["subagents", "local"]);
+	assertUnique(value.remoteAgents.entries, (entry) => entry.nodeId, ["remoteAgents", "entries"]);
+	assertTotal(value.subagents.total, value.subagents.local, ["subagents", "total"]);
+	assertTotal(value.remoteAgents.total, value.remoteAgents.entries, ["remoteAgents", "total"]);
+	const boundSources = [
+		[value.agent.config, ["agent", "config"]],
+		...value.agent.model.source === void 0 ? [] : [[value.agent.model.source, [
+			"agent",
+			"model",
+			"source"
+		]]],
+		...value.agent.model.routing.kind === "dynamic" ? [[value.agent.model.routing.resolver, [
+			"agent",
+			"model",
+			"routing",
+			"resolver"
+		]]] : [],
+		...value.channels.routes.map((entry, index) => [entry, [
+			"channels",
+			"routes",
+			index
+		]]),
+		...value.connections.map((entry, index) => [entry, ["connections", index]]),
+		...value.hooks.map((entry, index) => [entry, ["hooks", index]]),
+		...value.instructions.dynamic.map((entry, index) => [entry, [
+			"instructions",
+			"dynamic",
+			index
+		]]),
+		...value.instructions.static.map((entry, index) => [entry, [
+			"instructions",
+			"static",
+			index
+		]]),
+		...value.instrumentation === void 0 ? [] : [[value.instrumentation, ["instrumentation"]]],
+		...value.remoteAgents.entries.map((entry, index) => [entry, [
+			"remoteAgents",
+			"entries",
+			index
+		]]),
+		...value.schedules.map((entry, index) => [entry, ["schedules", index]]),
+		...value.skills.dynamic.map((entry, index) => [entry, [
+			"skills",
+			"dynamic",
+			index
+		]]),
+		...value.skills.static.map((entry, index) => [entry, [
+			"skills",
+			"static",
+			index
+		]]),
+		...value.subagents.local.flatMap((entry, index) => entry.configResolver === void 0 ? [] : [[entry.configResolver, [
+			"subagents",
+			"local",
+			index,
+			"configResolver"
+		]]]),
+		...value.tools.dynamic.map((entry, index) => [entry, [
+			"tools",
+			"dynamic",
+			index
+		]]),
+		...value.tools.static.map((entry, index) => [entry, [
+			"tools",
+			"static",
+			index
+		]]),
+		...value.workflow.enabled ? [[value.workflow.source, ["workflow", "source"]]] : [],
+		[value.sandbox, ["sandbox"]]
+	];
+	for (const [entry, path] of boundSources) {
+		if (entry.sourceKind === "module" && entry.binding === void 0) {
+			context.addIssue({
+				code: "custom",
+				message: "Module source is missing its compiled binding.",
+				path: [...path, "binding"]
+			});
+			continue;
+		}
+		if (entry.sourceKind !== "module" && entry.binding !== void 0) {
+			context.addIssue({
+				code: "custom",
+				message: `${entry.sourceKind} source cannot carry a module binding.`,
+				path: [...path, "binding"]
+			});
+			continue;
+		}
+		if (entry.binding === void 0) continue;
+		if (entry.binding.logicalPath !== entry.logicalPath) context.addIssue({
+			code: "custom",
+			message: "Source and binding logical paths do not match.",
+			path: [
+				...path,
+				"binding",
+				"logicalPath"
+			]
+		});
+		if (JSON.stringify(entry.binding.owner) !== JSON.stringify(entry.owner)) context.addIssue({
+			code: "custom",
+			message: "Source and binding owners do not match.",
+			path: [
+				...path,
+				"binding",
+				"owner"
+			]
+		});
+	}
 });
+function normalizeRoutePattern(path) {
+	return path.replace(/^\/+|\/+$/g, "").split("/").map((segment) => segment.startsWith(":") || /^\[[^\]]+\]$/.test(segment) ? ":" : segment).join("/");
+}
 
 //#endregion
 //#region src/shared/guards.ts
@@ -960,7 +1215,7 @@ function isPlainObject(value) {
 }
 
 //#endregion
-//#region src/shared/tool-schema.ts
+//#region src/tools/schema.ts
 const JSON_SCHEMA_TARGET = "draft-07";
 function serializeOutputSchema(source) {
 	return serializeSchema(source, "output");
@@ -1239,7 +1494,18 @@ var Client = class {
 			const body = await response.text();
 			throw new ClientError(response.status, body, response.headers);
 		}
-		return await response.json();
+		let payload;
+		try {
+			payload = await response.json();
+		} catch {
+			throw new HealthResponseError();
+		}
+		const result = HealthResultSchema.safeParse(payload);
+		if (!result.success) throw new HealthResponseError(result.error.issues.slice(0, 5).map((issue) => {
+			const path = issue.path.join(".");
+			return path.length === 0 ? issue.message : `${path}: ${issue.message}`;
+		}));
+		return result.data;
 	}
 	async info() {
 		const response = await this.fetch(EVE_INFO_ROUTE_PATH);
@@ -1430,7 +1696,10 @@ var EveAgentStore = class {
 		};
 	}
 	async send(input) {
-		if (this.#activeTurn !== void 0) return await this.#sendFollowUp(this.#activeTurn, input);
+		if (this.#activeTurn !== void 0) {
+			if (this.#status === "resuming") throw new Error("eve session is resuming.");
+			return await this.#sendFollowUp(this.#activeTurn, input);
+		}
 		const response = Promise.withResolvers();
 		const completion = Promise.withResolvers();
 		const turn = {
@@ -1503,7 +1772,7 @@ var EveAgentStore = class {
 		return promise;
 	}
 	async #resume() {
-		if (this.#status === "streaming" || this.#status === "submitted") throw new Error("eve session is already processing a turn.");
+		if (this.#status === "resuming" || this.#status === "streaming" || this.#status === "submitted") throw new Error("eve session is already processing a turn.");
 		if (this.#session === void 0) throw new Error("An eve session is required before resuming.");
 		const response = Promise.withResolvers();
 		const completion = Promise.withResolvers();
@@ -1522,24 +1791,31 @@ var EveAgentStore = class {
 		this.#activeTurn = turn;
 		turn.resolveResponse(void 0);
 		this.#error = void 0;
-		this.#status = "submitted";
+		this.#status = "resuming";
 		this.#publish();
 		try {
-			const replayed = [];
+			const hasCompleteInitialPrefix = this.#events.length === session.state.streamIndex;
+			const replayed = hasCompleteInitialPrefix ? [...this.#events] : [];
 			for await (const event of session.stream({
 				follow: false,
 				signal: turn.abortController.signal,
-				startIndex: 0
+				startIndex: hasCompleteInitialPrefix ? session.state.streamIndex : 0
 			})) {
 				if (!this.#isActiveTurn(turn)) return;
 				replayed.push(event);
-				this.#acceptServerEvent(event, false);
+				this.#acceptServerEvent(event, {
+					publish: false,
+					transitionToStreaming: false
+				});
 			}
 			if (!this.#isActiveTurn(turn)) return;
-			this.#publish();
+			const replayTail = replayed.at(-1);
+			if (replayTail !== void 0) this.#applyTerminalStreamFailure(replayTail);
 			const replaySettled = isSettledSessionTail(replayed);
-			if (!replaySettled || replayed.at(-1)?.type === "session.waiting") {
+			if (this.#error === void 0 && (!replaySettled || replayTail?.type === "session.waiting")) {
 				const pendingAuthorizations = collectPendingAuthorizations(replayed);
+				if (!replaySettled) this.#status = "streaming";
+				this.#publish();
 				for await (const event of session.stream({
 					signal: turn.abortController.signal,
 					streamReconnectPolicy: replaySettled ? { reconnect: false } : void 0
@@ -1549,6 +1825,9 @@ var EveAgentStore = class {
 					updatePendingAuthorizations(pendingAuthorizations, event);
 					if (isCurrentTurnBoundaryEvent(event) && (event.type !== "session.waiting" || pendingAuthorizations.size === 0)) break;
 				}
+			} else {
+				this.#status = this.#error === void 0 ? "ready" : "error";
+				this.#publish();
 			}
 			await this.#followSteeredTurns(turn);
 			if (this.#isActiveTurn(turn)) this.#status = this.#error === void 0 ? "ready" : "error";
@@ -1690,14 +1969,14 @@ var EveAgentStore = class {
 			type: "client.input.responded"
 		});
 	}
-	#acceptServerEvent(event, publish = true) {
+	#acceptServerEvent(event, options = {}) {
 		if (!this.#seenEvents.admit(event)) return;
 		this.#events = [...this.#events, event];
 		this.#applyServerEvent(event);
 		this.#callbacks.onEvent?.(event);
-		this.#status = "streaming";
+		if (options.transitionToStreaming ?? true) this.#status = "streaming";
 		this.#applyTerminalStreamFailure(event);
-		if (publish) this.#publish();
+		if (options.publish ?? true) this.#publish();
 	}
 	#applyServerEvent(event) {
 		const pendingSubmission = this.#pendingMessageSubmissions[0];