eve 0.65.0 → 0.66.1

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # eve
 
+## 0.66.1
+
+### Patch Changes
+
+- 055f1d1: `eve build` and `withEve` during `next build` now build mounted, source-backed workspace extensions before compiling the agent, as `eve dev` already does. Production builds no longer fail when a package manager skips the extension's `prepare` script, such as on a no-op install with a restored `node_modules` cache. An extension whose distribution is already current is not rebuilt, and a failed extension build names the package and the command to run.
+- faacecf: Follow a delegated child's activity from a client with `session.streamSubagent(called, options?)`. Pass a `subagent.called` event from that session. The client reads its `childStreamPath` with the session's host and credentials, so a remote child streams through the parent deployment's proxy route, and the child's cursor stays separate from the parent's. Eval sessions expose the same method with the eval client's credentials.
+- a490d88: `eveChannel({ trustedForwarders })` now receives what the forwarder asserts as a second argument. `assertion.principal` holds the stamped `current` and `initiator` contexts the forwarder asserts, so a receiver can limit a trusted forwarder to the identities it may speak for instead of accepting any principal it asserts.
+- 6e568dc: Allow Web Chat to scaffold as a peer application for standalone agents and agent workspaces, with explicit Next.js or Vercel services hosting. `withEve()` from `eve/next` can discover either project layout from an explicit `eveRoot`, so the peer application does not need to repeat agent paths.
+- d8ddf0d: Add bounded, conversation-scoped trace analysis to self-modification, with filtered search, compact timelines, and batched span payload inspection.
+- d6fc658: Keep a delegated agent task open when its model turn yields while background work started in that turn is still running. Deliver the final result after that work finishes, including usage accumulated across the yielded turns, instead of reporting the interim reply as completion.
+  
+  Propagate task cancellation to a yielded child's nested background work for self, local, and remote delegation, without waking the cancelled child on its nested task notifications. Preserve cancellation across replay and session handoff.
+  
+  Fail an unanswered delegated task when its yielded child session ends, and preserve the unreported usage in that terminal result.
+- 650b309: Use a quieter selected-row treatment and temporary drawer for interactive setup flows in the development TUI. `/add`, `/login`, and `/deploy` now emphasize the focused option with type weight instead of a caret, keep controls below the drawer, and `/login` supports inline connection completion such as `/login openai-api-key`.
+- d6fc658: Keep durable MCP invocations open for pending background subagents so clients receive the delegated result.
+
+## 0.66.0
+
+### Minor Changes
+
+- da906b6: Breaking: `ctx.getSkill()` and the `SkillHandle` and `SkillFile` types from `eve/skills` are removed. The model still reads skill supporting files with its sandbox tools; if your own tool or hook code needs that data, import it from a module in `lib/` instead. Existing extension builds keep loading unless they call `ctx.getSkill()`.
+- ee286fe: Pass a configured sandbox environment to `ctx.getSandbox(environment)` to preserve its provider-specific session capabilities in the returned eve sandbox handle. The common `SandboxSession` no longer exposes optional `setNetworkPolicy`; use the configured environment when accessing that capability.
+
+### Patch Changes
+
+- c541dec: Leave temperature at the model provider's default when generating compaction summaries so providers that reject explicit sampling parameters can compact normally.
+- 1b6366f: Tolerate concurrent Docker sandbox template publication when another Eve application publishes the same deterministic image first.
+- d50a774: Add the `eve/extensions/code` built-in extension for coding agents: mount it with `import code from "eve/extensions/code"` to get `apply_patch`, `gh`, `grep`, computer use, coding skills, and a read-only worker subagent. Sandbox, tool, and PR-watch helpers are exported from `eve/extensions/code/sandbox`, `eve/extensions/code/tools`, and `eve/extensions/code/prwatch`.
+- 23dda94: `subagent.called` and `subagent.completed` hooks can now call `ctx.getSandbox()` for the parent session, and sandbox changes they make are kept for the parent's next turn.
+- 5132625: Add inline, keyboard-navigable catalog completions for `/model` and `/add` in the development TUI.
+- 92505dd: Fix `Cannot read properties of undefined (reading 'push')` failures in turns with MCP tools such as Notion, and with the file-memory tools, when an app installs a different Zod version than eve bundles. Tool schemas now reach the AI SDK only as JSON Schema, MCP and other JSON Schema tools are advertised exactly as published and validated with a standard JSON Schema validator, and the `*_INPUT_SCHEMA` and `*_OUTPUT_SCHEMA` constants from `eve/tools/*` are JSON Schema-backed Standard Schemas instead of Zod objects.
+  
+  eve now ships a single private copy of Zod instead of bundling several. `eve/client` no longer exports `AgentInfoResultSchema`, `HealthResultSchema`, `inputOptionSchema`, `inputRequestKindSchema`, `inputRequestSchema`, or `inputResponseSchema`, and `eve/self-modification` no longer exports `selfModificationConfigSchema`; use the exported types together with `isInputRequest`, `isInputResponse`, and `parseInputResponse`.
+- 136d339: Load optional sandbox provider packages consistently from the application during preparation, start, and resume. Providers installed automatically by `eve dev` can now be used immediately without restarting the development server.
+- da906b6: Dynamic skills no longer start a sandbox to announce or load instructions. Skills that return supporting files are written only when their contents or sandbox change, and a changed package replaces its previous files instead of leaving stale ones behind.
+- 09fed04: The Slack channel's `views.open` and answered-card `chat.update` now go through the channel's own Slack API transport. Slack sees the same calls, and a `views.open` that fails after Slack responds is still logged and acknowledged.
+  
+  A failed `views.open` is now logged as `Slack views.open failed` with the error attached, where it was `Slack views.open returned non-2xx` with a `status` field. Alerts or log queries keyed on either need updating.
+
 ## 0.65.0
 
 ### Minor Changes

package/README.md

@@ -61,7 +61,7 @@ Every authored directory has a typed helper. Import each from the matching subpa
 | `defineInstructions(...)`                                       | `eve/instructions`                    | `instructions.ts` (or `instructions.md`)         |
 | `defineTool(...)`, `defineDynamic(...)`, `disableTool(...)`     | `eve/tools`                           | `tools/<name>.ts`                                |
 | `bash`, `readFile`, `writeFile`, and other provided definitions | `eve/tools/<name>`                    | `tools/<name>.ts`                                |
-| `defineSkill(...)`, `getSkill(...)`                             | `eve/skills`                          | `skills/<name>.ts` (or `skills/<name>.md`)       |
+| `defineSkill(...)`                                              | `eve/skills`                          | `skills/<name>.ts` (or `skills/<name>.md`)       |
 | `defineHook(...)`                                               | `eve/hooks`                           | `hooks/<slug>.ts`                                |
 | `defineChannel(...)`, `POST`, `GET`                             | `eve/channels`                        | `channels/<name>.ts`                             |
 | `eveChannel(...)`, `slackChannel(...)`, `vercelOidc(...)`       | `eve/channels/eve`, `/slack`, `/auth` | reused from `channels/<name>.ts`                 |
@@ -73,7 +73,6 @@ Runtime accessors live on the subpath that owns the concern:
 
 - `getSession()` — current session, turn, auth, parent lineage (`eve/context`)
 - `getSandbox()` — live sandbox handle for the current agent (`eve/sandbox`)
-- `getSkill(identifier)` — handle for a named skill visible to the current agent (`eve/skills`)
 - `getContext(key)`, `requireContext(key)`, `hasContext(key)`, `setContext(key)`, `ensureContext(key, factory)` — unified context helpers (`eve/context`)
 
 The complete API reference, including types and lower-level runtime primitives, is in the [TypeScript API Reference](https://eve.dev/docs/reference/typescript-api).

package/dist/src/_virtual/_rolldown/runtime.js

@@ -1 +1 @@
-import"node:module";var __defProp=Object.defineProperty,__exportAll=(e,t)=>{let n={};for(var r in e)__defProp(n,r,{get:e[r],enumerable:!0});return t||__defProp(n,Symbol.toStringTag,{value:`Module`}),n};export{__exportAll};
+import"node:module";var __create=Object.create,__defProp=Object.defineProperty,__getOwnPropDesc=Object.getOwnPropertyDescriptor,__getOwnPropNames=Object.getOwnPropertyNames,__getProtoOf=Object.getPrototypeOf,__hasOwnProp=Object.prototype.hasOwnProperty,__commonJSMin=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),__copyProps=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=__getOwnPropNames(t),a=0,o=i.length,s;a<o;a++)s=i[a],!__hasOwnProp.call(e,s)&&s!==n&&__defProp(e,s,{get:(e=>t[e]).bind(null,s),enumerable:!(r=__getOwnPropDesc(t,s))||r.enumerable});return e},__toESM=(e,t,n)=>(n=e==null?{}:__create(__getProtoOf(e)),__copyProps(t||!e||!e.__esModule||!__hasOwnProp.call(e,`default`)?__defProp(n,`default`,{value:e,enumerable:!0}):n,e));export{__commonJSMin,__toESM};

package/dist/src/channel/forwarded-principal.d.ts

@@ -17,11 +17,31 @@ export interface ForwardedPrincipal {
     readonly initiator?: SessionAuthContext;
 }
 /**
- * Authorizes which transport-authenticated forwarders may assert a forwarded
- * principal. Receives the *verified* route-auth principal (who is asserting),
- * never the forwarded identity (what is asserted).
+ * What a forwarder asks the receiving deployment to adopt, passed to
+ * {@link TrustedForwarders} next to the verified forwarder.
  */
-export type TrustedForwarders = (forwarder: SessionAuthContext) => boolean | Promise<boolean>;
+export interface ForwardedAssertion {
+    /**
+     * The session principals the forwarder asserts, present when it forwards a
+     * principal and absent when only remote parent lineage is being trusted.
+     * Both contexts are already stamped with {@link FORWARDED_BY_ATTRIBUTE}, and
+     * `initiator` is `current` when the sender omitted it. `initiator` takes
+     * effect only on session creation: continuation requests install only
+     * `current`, so there `initiator` is the asserted value, not the session's
+     * pinned initiator.
+     */
+    readonly principal?: {
+        readonly current: SessionAuthContext;
+        readonly initiator: SessionAuthContext;
+    };
+}
+/**
+ * Authorizes a transport-authenticated forwarder to supply eve delegation
+ * context. Receives the *verified* route-auth principal (who is asserting) and
+ * the principals it asserts, so a receiver can limit each forwarder to the
+ * identities it may speak for.
+ */
+export type TrustedForwarders = (forwarder: SessionAuthContext, assertion: ForwardedAssertion) => boolean | Promise<boolean>;
 export type ForwardedPrincipalParseResult = {
     readonly forwardedPrincipal: ForwardedPrincipal;
     readonly ok: true;
@@ -48,8 +68,8 @@ export type ResolvedForwardedPrincipal = {
  * Gates the `forwardedPrincipal` body field and resolves the
  * effective session principals. Returns the failure `Response` on rejection:
  * 403 when the channel accepts no forwarded principal or the predicate
- * refuses the forwarder, 400 on a malformed payload, 500 when the authored
- * predicate throws. Accepted contexts are stamped with
+ * refuses the forwarder or what it asserts, 400 on a malformed payload, 500
+ * when the authored predicate throws. Accepted contexts are stamped with
  * {@link FORWARDED_BY_ATTRIBUTE} before they are returned, so a custom
  * `onMessage` always sees the transport forwarder on the replaced principal.
  */

package/dist/src/channel/forwarded-principal.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{createLogger,logError}from"#internal/logging.js";const log=createLogger(`channel.forwarded-principal`),FORWARDED_BY_ATTRIBUTE=`eve:forwarded-by`,attributeValueSchema=z.union([z.string(),z.array(z.string()).readonly()]),forwardedPrincipalContextSchema=z.object({attributes:z.record(z.string(),attributeValueSchema).readonly(),authenticator:z.string().min(1),issuer:z.string().min(1).optional(),principalId:z.string().min(1),principalType:z.string().min(1),subject:z.string().min(1).optional()}).strict(),forwardedPrincipalSchema=z.object({current:forwardedPrincipalContextSchema,initiator:forwardedPrincipalContextSchema.optional()}).strict();async function resolveForwardedPrincipal(e){let t=e.payload.forwardedPrincipal;if(t===void 0)return{accepted:!1,auth:e.forwarder};if(e.trustedForwarders===void 0)return Response.json({error:`This deployment does not accept a forwarded principal.`,ok:!1},{status:403});let n=parseForwardedPrincipal(t);if(!n.ok)return Response.json({error:n.message,ok:!1},{status:400});let r;try{r=await e.trustedForwarders(e.forwarder)}catch(t){let n=logError(log,`trustedForwarders handler failed`,t,{forwarder:e.forwarder.principalId});return Response.json({error:`trustedForwarders handler failed.`,errorId:n,ok:!1},{status:500})}if(!r)return Response.json({error:`Caller is not authorized to assert a forwarded principal.`,ok:!1},{status:403});let i=stampForwardedBy(n.forwardedPrincipal.current,e.forwarder.principalId);return{accepted:!0,auth:i,initiatorAuth:n.forwardedPrincipal.initiator===void 0?i:stampForwardedBy(n.forwardedPrincipal.initiator,e.forwarder.principalId)}}function parseForwardedPrincipal(e){let t=forwardedPrincipalSchema.safeParse(e);if(t.success){let e=toSessionAuthContext(t.data.current);return{forwardedPrincipal:t.data.initiator===void 0?{current:e}:{current:e,initiator:toSessionAuthContext(t.data.initiator)},ok:!0}}return{cause:t.error,message:formatForwardedPrincipalParseError(t.error),ok:!1}}function stampForwardedBy(e,t){return{...e,attributes:{...e.attributes,[FORWARDED_BY_ATTRIBUTE]:t}}}function toSessionAuthContext(e){let t={attributes:e.attributes,authenticator:e.authenticator,principalId:e.principalId,principalType:e.principalType};return e.issuer!==void 0&&(t.issuer=e.issuer),e.subject!==void 0&&(t.subject=e.subject),t}function formatForwardedPrincipalParseError(e){return`Invalid forwardedPrincipal metadata: ${e.issues.map(e=>`${e.path.length===0?`forwardedPrincipal`:`forwardedPrincipal.${e.path.join(`.`)}`}: ${e.message}`).join(`; `)}`}export{FORWARDED_BY_ATTRIBUTE,parseForwardedPrincipal,resolveForwardedPrincipal,stampForwardedBy};
+import{z}from"#compiled/zod/index.js";import{createLogger,logError}from"#internal/logging.js";const log=createLogger(`channel.forwarded-principal`),FORWARDED_BY_ATTRIBUTE=`eve:forwarded-by`,attributeValueSchema=z.union([z.string(),z.array(z.string()).readonly()]),forwardedPrincipalContextSchema=z.object({attributes:z.record(z.string(),attributeValueSchema).readonly(),authenticator:z.string().min(1),issuer:z.string().min(1).optional(),principalId:z.string().min(1),principalType:z.string().min(1),subject:z.string().min(1).optional()}).strict(),forwardedPrincipalSchema=z.object({current:forwardedPrincipalContextSchema,initiator:forwardedPrincipalContextSchema.optional()}).strict();async function resolveForwardedPrincipal(e){let t=e.payload.forwardedPrincipal;if(t===void 0)return{accepted:!1,auth:e.forwarder};if(e.trustedForwarders===void 0)return Response.json({error:`This deployment does not accept a forwarded principal.`,ok:!1},{status:403});let n=parseForwardedPrincipal(t);if(!n.ok)return Response.json({error:n.message,ok:!1},{status:400});let r=stampForwardedBy(n.forwardedPrincipal.current,e.forwarder.principalId),i=n.forwardedPrincipal.initiator===void 0?r:stampForwardedBy(n.forwardedPrincipal.initiator,e.forwarder.principalId),a;try{a=await e.trustedForwarders(e.forwarder,{principal:{current:r,initiator:i}})}catch(t){let n=logError(log,`trustedForwarders handler failed`,t,{forwarder:e.forwarder.principalId});return Response.json({error:`trustedForwarders handler failed.`,errorId:n,ok:!1},{status:500})}return a?{accepted:!0,auth:r,initiatorAuth:i}:Response.json({error:`Caller is not authorized to assert a forwarded principal.`,ok:!1},{status:403})}function parseForwardedPrincipal(e){let t=forwardedPrincipalSchema.safeParse(e);if(t.success){let e=toSessionAuthContext(t.data.current);return{forwardedPrincipal:t.data.initiator===void 0?{current:e}:{current:e,initiator:toSessionAuthContext(t.data.initiator)},ok:!0}}return{cause:t.error,message:formatForwardedPrincipalParseError(t.error),ok:!1}}function stampForwardedBy(e,t){return{...e,attributes:{...e.attributes,[FORWARDED_BY_ATTRIBUTE]:t}}}function toSessionAuthContext(e){let t={attributes:e.attributes,authenticator:e.authenticator,principalId:e.principalId,principalType:e.principalType};return e.issuer!==void 0&&(t.issuer=e.issuer),e.subject!==void 0&&(t.subject=e.subject),t}function formatForwardedPrincipalParseError(e){return`Invalid forwardedPrincipal metadata: ${e.issues.map(e=>`${e.path.length===0?`forwardedPrincipal`:`forwardedPrincipal.${e.path.join(`.`)}`}: ${e.message}`).join(`; `)}`}export{FORWARDED_BY_ATTRIBUTE,parseForwardedPrincipal,resolveForwardedPrincipal,stampForwardedBy};

package/dist/src/chunks/{use-eve-agent-BIouJCii.js → use-eve-agent-Di1u2zKu.js}

@@ -1,6 +1,7 @@
 import { computed, onScopeDispose, shallowRef } from "vue";
 import { z } from "#compiled/zod/index.js";
 import { asSchema } from "ai";
+import { Validator } from "#compiled/@cfworker/json-schema/index.js";
 
 //#region src/protocol/routes.ts
 const EVE_ROUTE_PREFIX = "/eve/v1";
@@ -545,6 +546,8 @@ var ClientError = class extends Error {
 	body;
 	headers;
 	constructor(status, body, headers) {
+		const normalizedHeaders = Object.freeze(Object.fromEntries(new Headers(headers).entries()));
+		const contentType = normalizedHeaders["content-type"]?.toLowerCase();
 		let message = body || `Server returned ${status}.`;
 		let code;
 		try {
@@ -553,13 +556,15 @@ var ClientError = class extends Error {
 				if (typeof parsed.error === "string") message = parsed.error;
 				if (typeof parsed.code === "string") code = parsed.code;
 			}
-		} catch {}
+		} catch {
+			if (contentType?.includes("text/html")) message = `Server returned ${status} with an HTML response. Check the eve route and development server configuration.`;
+		}
 		super(message);
 		this.name = "ClientError";
 		this.code = code;
 		this.status = status;
 		this.body = body;
-		this.headers = Object.freeze(Object.fromEntries(new Headers(headers).entries()));
+		this.headers = normalizedHeaders;
 	}
 };
 
@@ -1183,7 +1188,7 @@ async function openStreamBody(input) {
 	if (input.requestTailIndex === true) searchParams.includeTailIndex = "1";
 	for (let attempt = 0; attempt < openRetryPolicy.maxAttempts; attempt += 1) {
 		input.signal?.throwIfAborted();
-		const url = createClientUrl(input.host, createEveSessionStreamRoutePath(input.sessionId), Object.keys(searchParams).length > 0 ? searchParams : void 0);
+		const url = createClientUrl(input.host, input.path, Object.keys(searchParams).length > 0 ? searchParams : void 0);
 		const headers = await input.resolveHeaders();
 		input.signal?.throwIfAborted();
 		const connectionController = new AbortController();
@@ -1436,7 +1441,22 @@ const JSON_SCHEMA_TARGET = "draft-07";
 function serializeOutputSchema(source) {
 	return serializeSchema(source, "output");
 }
-const UNSPECIFIED_INPUT_SCHEMA = z.fromJSONSchema({});
+function defineJsonSchema(schema, check) {
+	const emit = () => structuredClone(schema);
+	const toolSchema = { "~standard": {
+		version: 1,
+		vendor: "eve",
+		validate: createJsonSchemaValidator(schema, check),
+		jsonSchema: {
+			input: emit,
+			output: emit
+		}
+	} };
+	plainJsonSchemas.add(toolSchema);
+	return toolSchema;
+}
+const plainJsonSchemas = /* @__PURE__ */ new WeakSet();
+const UNSPECIFIED_INPUT_SCHEMA = defineJsonSchema({});
 function serializeSchema(source, direction) {
 	if (source === null || source === void 0) return source;
 	return toJsonObject(source, direction);
@@ -1463,6 +1483,231 @@ function getStandardSchemaProperties(value) {
 	const standard = value["~standard"];
 	return typeof standard === "object" && standard !== null ? standard : void 0;
 }
+function createJsonSchemaValidator(schema, check) {
+	let validator;
+	let warned = false;
+	const passThrough = (value, reason) => {
+		if (!warned) {
+			warned = true;
+			console.warn(`[eve] Tool schema cannot validate values locally; passing them through unvalidated: ${reason}`);
+		}
+		return { value };
+	};
+	return (value) => {
+		if (validator === void 0) {
+			const built = buildValidator(schema);
+			if (typeof built === "string") {
+				validator = null;
+				return passThrough(value, built);
+			}
+			validator = built;
+		}
+		if (validator === null) return { value };
+		let result;
+		try {
+			result = validator.validate(value);
+		} catch (error) {
+			if (value === void 0) return { issues: [{ message: "Expected a JSON value." }] };
+			return passThrough(value, toErrorMessage(error));
+		}
+		if (!result.valid) return { issues: toIssues(result.errors) };
+		const filled = applyDefaults(schema, schema, value);
+		const message = check?.(filled);
+		return message === void 0 ? { value: filled } : { issues: [{ message }] };
+	};
+}
+function applyDefaults(root, schema, value) {
+	let result = value;
+	for (const node of followRefs(root, schema)) {
+		const { items, properties } = node;
+		if (isObject(result) && isObject(properties)) result = fillProperties(root, properties, result);
+		else if (Array.isArray(result) && isObject(items)) {
+			const list = result;
+			const next = list.map((item) => applyDefaults(root, items, item));
+			if (next.some((item, index) => item !== list[index])) result = next;
+		}
+	}
+	return result;
+}
+function fillProperties(root, properties, value) {
+	let result = value;
+	for (const [key, property] of Object.entries(properties)) {
+		const current = Object.hasOwn(value, key) ? value[key] : void 0;
+		const next = current === void 0 ? findDefault(root, property) : applyDefaults(root, property, current);
+		if (next === current) continue;
+		if (result === value) result = { ...value };
+		result[key] = next;
+	}
+	return result;
+}
+function findDefault(root, schema) {
+	for (const node of followRefs(root, schema)) if ("default" in node) return structuredClone(node.default);
+}
+function* followRefs(root, schema) {
+	const seen = /* @__PURE__ */ new Set();
+	let node = schema;
+	while (isObject(node) && !seen.has(node)) {
+		seen.add(node);
+		yield node;
+		node = resolveLocalRef(root, node.$ref);
+	}
+}
+function resolveLocalRef(root, ref) {
+	if (typeof ref !== "string" || ref !== "#" && !ref.startsWith("#/")) return void 0;
+	let node = root;
+	for (const segment of decodePointer(ref)) {
+		if (typeof node !== "object" || node === null || !Object.hasOwn(node, segment)) return;
+		node = node[segment];
+	}
+	return node;
+}
+function buildValidator(schema) {
+	try {
+		const copy = structuredClone(schema);
+		return prepareForValidation(copy) ?? new Validator(copy, "2020-12", false);
+	} catch (error) {
+		return toErrorMessage(error);
+	}
+}
+const JSON_TYPES = /* @__PURE__ */ new Set([
+	"array",
+	"boolean",
+	"integer",
+	"null",
+	"number",
+	"object",
+	"string"
+]);
+const EXCLUSIVE_BOUNDS = [["exclusiveMinimum", "minimum"], ["exclusiveMaximum", "maximum"]];
+const SUBSCHEMA_KEYWORDS = [
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+];
+const SUBSCHEMA_LIST_KEYWORDS = [
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+];
+const SUBSCHEMA_MAP_KEYWORDS = [
+	"$defs",
+	"definitions",
+	"dependencies",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+];
+function prepareForValidation(schema) {
+	if (typeof schema === "boolean") return void 0;
+	if (typeof schema !== "object" || schema === null || Array.isArray(schema)) return "a subschema is neither an object nor a boolean";
+	const node = schema;
+	delete node.format;
+	for (const [flag, bound] of EXCLUSIVE_BOUNDS) {
+		if (typeof node[flag] !== "boolean") continue;
+		if (node[flag] && typeof node[bound] === "number") {
+			node[flag] = node[bound];
+			delete node[bound];
+		} else delete node[flag];
+	}
+	const { enum: values, pattern, required, type } = node;
+	if (type !== void 0 && !(Array.isArray(type) ? type.every(isJsonType) : isJsonType(type))) return `unsupported type ${JSON.stringify(type)}`;
+	if (values !== void 0 && !Array.isArray(values)) return "`enum` is not an array";
+	if (required !== void 0 && !(Array.isArray(required) && required.every((key) => typeof key === "string"))) return "`required` is not an array of strings";
+	if (pattern !== void 0 && !isRegExpSource(pattern)) return `invalid pattern ${JSON.stringify(pattern)}`;
+	for (const keyword of SUBSCHEMA_KEYWORDS) if (keyword in node) {
+		const problem = prepareForValidation(node[keyword]);
+		if (problem !== void 0) return problem;
+	}
+	const items = node.items;
+	for (const subschema of Array.isArray(items) ? items : items === void 0 ? [] : [items]) {
+		const problem = prepareForValidation(subschema);
+		if (problem !== void 0) return problem;
+	}
+	for (const keyword of SUBSCHEMA_LIST_KEYWORDS) {
+		const list = node[keyword];
+		if (list === void 0) continue;
+		if (!Array.isArray(list)) return `\`${keyword}\` is not an array`;
+		for (const subschema of list) {
+			const problem = prepareForValidation(subschema);
+			if (problem !== void 0) return problem;
+		}
+	}
+	for (const keyword of SUBSCHEMA_MAP_KEYWORDS) {
+		const map = node[keyword];
+		if (map === void 0) continue;
+		if (typeof map !== "object" || map === null || Array.isArray(map)) return `\`${keyword}\` is not an object`;
+		for (const [key, subschema] of Object.entries(map)) {
+			if (keyword === "patternProperties" && !isRegExpSource(key)) return `invalid pattern ${JSON.stringify(key)}`;
+			if (keyword === "dependencies" && Array.isArray(subschema)) continue;
+			const problem = prepareForValidation(subschema);
+			if (problem !== void 0) return problem;
+		}
+	}
+}
+function isJsonType(value) {
+	return typeof value === "string" && JSON_TYPES.has(value);
+}
+function isRegExpSource(value) {
+	if (typeof value !== "string") return false;
+	try {
+		new RegExp(value, "u");
+		return true;
+	} catch {
+		return false;
+	}
+}
+const CLOSED_OBJECT_KEYWORD = /\/(?:additional|unevaluated)Properties$/;
+function toIssues(errors) {
+	const failures = [];
+	for (let index = 0; index < errors.length; index++) {
+		const unit = errors[index];
+		const rejected = errors[index + 1];
+		if (CLOSED_OBJECT_KEYWORD.test(unit.keywordLocation) && rejected?.keyword === "false") {
+			const key = decodePointer(rejected.instanceLocation).at(-1);
+			failures.push({
+				keyword: "false",
+				location: rejected.instanceLocation,
+				message: `Unrecognized key: ${JSON.stringify(key)}`,
+				object: unit.instanceLocation
+			});
+			index++;
+		} else failures.push({
+			keyword: unit.keyword,
+			location: unit.instanceLocation,
+			message: unit.error
+		});
+	}
+	const relevant = failures.filter((failure) => failure.object === void 0 || !failures.some((other) => other.object === void 0 && (other.location === failure.location || other.location.startsWith(`${failure.location}/`))));
+	return relevant.filter((failure, index) => {
+		const next = relevant[index + 1];
+		if (next === void 0) return true;
+		if (next.location.startsWith(`${failure.location}/`)) return false;
+		return !(failure.keyword === "$ref" && next.location === failure.location);
+	}).map(({ location, message, object }) => {
+		const path = decodePointer(object ?? location);
+		return path.length === 0 ? { message } : {
+			message,
+			path
+		};
+	});
+}
+function decodePointer(location) {
+	return location.split("/").slice(1).map((segment) => {
+		let decoded = segment;
+		try {
+			decoded = decodeURIComponent(segment);
+		} catch {}
+		return decoded.replaceAll("~1", "/").replaceAll("~0", "~");
+	});
+}
 
 //#endregion
 //#region src/client/session.ts
@@ -1568,6 +1813,22 @@ var ClientSession = class ClientSession {
 		if (options?.follow === false && (options.startIndex ?? this.#state.streamIndex) < 0) throw new Error("stream({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.");
 		return this.#streamAndAdvance(options);
 	}
+	streamSubagent(called, options) {
+		if (called.data.sessionId !== this.#state.sessionId) throw new Error(`streamSubagent() requires a subagent.called event from session ${this.#state.sessionId}, but it came from session ${called.data.sessionId}.`);
+		if (typeof called.data.childStreamPath !== "string") throw new Error(`streamSubagent() requires a subagent.called event with childStreamPath, but call ${called.data.callId} has none. The event was recorded by an older eve version.`);
+		const startIndex = options?.startIndex ?? 0;
+		if (options?.follow === false && startIndex < 0) throw new Error("streamSubagent({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.");
+		return followStreamIterable({
+			follow: options?.follow,
+			host: this.#context.host,
+			path: called.data.childStreamPath,
+			redirect: this.#context.redirect,
+			resolveHeaders: () => this.#context.resolveHeaders(),
+			signal: options?.signal,
+			startIndex,
+			streamReconnectPolicy: options?.streamReconnectPolicy
+		});
+	}
 	[followSession](options) {
 		return this.#streamAndAdvance({
 			...options,
@@ -1647,8 +1908,8 @@ var ClientSession = class ClientSession {
 			host: this.#context.host,
 			keepAlive: input.keepAlive,
 			resolveHeaders: () => this.#context.resolveHeaders(input.resolveHeaders?.() ?? input.headers),
+			path: createEveSessionStreamRoutePath(this.#state.sessionId),
 			redirect: this.#context.redirect,
-			sessionId: this.#state.sessionId,
 			signal: input.signal,
 			startIndex: input.startIndex,
 			streamReconnectPolicy: input.streamReconnectPolicy,