eve 0.83.2 → 0.84.0

package/dist/src/shared/input.d.ts

@@ -1,103 +1,29 @@
 import { z } from "#compiled/zod/index.js";
-/**
- * One selectable option presented to the user in an input request.
- */
-export type InputOption = z.infer<typeof inputOptionSchema>;
-/** Zod schema for one input option. */
-export declare const inputOptionSchema: z.ZodObject<{
-    description: z.ZodOptional<z.ZodString>;
-    id: z.ZodString;
-    label: z.ZodString;
-    style: z.ZodOptional<z.ZodEnum<{
-        danger: "danger";
-        default: "default";
-        primary: "primary";
-    }>>;
-}, z.core.$strict>;
-/**
- * Framework-owned source of an input request.
- *
- * Consumers use this discriminator for behavior. The action tool name and
- * request id are presentation and identity fields, not request semantics.
- */
-export type InputRequestKind = z.infer<typeof inputRequestKindSchema>;
-/** Zod schema for the framework-owned source of an input request. */
-export declare const inputRequestKindSchema: z.ZodEnum<{
-    question: "question";
-    "session-limit": "session-limit";
-    "tool-approval": "tool-approval";
-}>;
-/** Unified input request surfaced when the agent needs user input. */
-export type InputRequest = z.infer<typeof inputRequestSchema>;
-/**
- * Zod schema for one input request.
- */
-export declare const inputRequestSchema: z.ZodObject<{
-    action: z.ZodObject<{
-        callId: z.ZodString;
-        input: z.ZodType<import("./json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./json.ts").JsonObject, unknown>>;
-        kind: z.ZodLiteral<"tool-call">;
-        toolName: z.ZodString;
-    }, z.core.$strict>;
-    allowFreeform: z.ZodOptional<z.ZodBoolean>;
-    display: z.ZodOptional<z.ZodEnum<{
-        confirmation: "confirmation";
-        select: "select";
-        text: "text";
-    }>>;
-    kind: z.ZodEnum<{
-        question: "question";
-        "session-limit": "session-limit";
-        "tool-approval": "tool-approval";
-    }>;
-    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        description: z.ZodOptional<z.ZodString>;
-        id: z.ZodString;
-        label: z.ZodString;
-        style: z.ZodOptional<z.ZodEnum<{
-            danger: "danger";
-            default: "default";
-            primary: "primary";
-        }>>;
-    }, z.core.$strict>>>;
-    prompt: z.ZodString;
-    requestId: z.ZodString;
-}, z.core.$strict>;
-/**
- * Unified input response submitted by the client for a pending request.
- */
-export type InputResponse = z.infer<typeof inputResponseSchema>;
-declare const validatedInputResponseBrand: unique symbol;
-/** Input response proven to match the strict durable wire schema. */
-export type ValidatedInputResponse = InputResponse & {
-    readonly [validatedInputResponseBrand]: true;
-};
-/**
- * Zod schema for one input response.
- */
-export declare const inputResponseSchema: z.ZodObject<{
+import type { Answer } from "#protocol/session-events/families/response.js";
+export type { Answer };
+/** Zod schema for one answer. */
+export declare const answerSchema: z.ZodObject<{
+    interactionId: z.ZodString;
     optionId: z.ZodOptional<z.ZodString>;
-    requestId: z.ZodString;
     text: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-/** Parses one response and preserves schema validation in its static type. */
-export declare function parseInputResponse(value: unknown): ValidatedInputResponse;
-/** Parses response arrays whose element types were widened before delivery. */
-export declare function parseInputResponses(value: unknown): readonly ValidatedInputResponse[];
-type IsWidenedInputResponse<TResponse extends InputResponse> = keyof TResponse extends keyof InputResponse ? keyof InputResponse extends keyof TResponse ? InputResponse extends TResponse ? true : false : false : false;
-type StrictInputResponse<TResponse extends InputResponse> = TResponse extends ValidatedInputResponse ? TResponse : IsWidenedInputResponse<TResponse> extends true ? never : TResponse & {
-    readonly [TKey in Exclude<keyof TResponse, keyof InputResponse>]: never;
+declare const validatedAnswerBrand: unique symbol;
+/** An answer proven to match the strict durable wire schema. */
+export type ValidatedAnswer = Answer & {
+    readonly [validatedAnswerBrand]: true;
+};
+/** Parses one answer and preserves schema validation in its static type. */
+export declare function parseAnswer(value: unknown): ValidatedAnswer;
+/** Parses answer arrays whose element types were widened before delivery. */
+export declare function parseAnswers(value: unknown): readonly ValidatedAnswer[];
+type IsWidenedAnswer<TAnswer extends Answer> = keyof TAnswer extends keyof Answer ? keyof Answer extends keyof TAnswer ? Answer extends TAnswer ? true : false : false : false;
+type StrictAnswer<TAnswer extends Answer> = TAnswer extends ValidatedAnswer ? TAnswer : IsWidenedAnswer<TAnswer> extends true ? never : TAnswer & {
+    readonly [TKey in Exclude<keyof TAnswer, keyof Answer>]: never;
 };
-/** Rejects extra response keys and imprecise arrays not proven by the strict schema. */
-export type StrictInputResponses<TResponses extends readonly InputResponse[]> = TResponses & {
-    readonly [TIndex in keyof TResponses]: TResponses[TIndex] extends InputResponse ? StrictInputResponse<TResponses[TIndex]> : TResponses[TIndex];
+/** Rejects extra answer keys and imprecise arrays not proven by the strict schema. */
+export type StrictAnswers<TAnswers extends readonly Answer[]> = TAnswers & {
+    readonly [TIndex in keyof TAnswers]: TAnswers[TIndex] extends Answer ? StrictAnswer<TAnswers[TIndex]> : TAnswers[TIndex];
 };
-/**
- * Returns true when a value matches the input request contract.
- */
-export declare function isInputRequest(value: unknown): value is InputRequest;
-/**
- * Returns true when a value matches the input response contract.
- */
-export declare function isInputResponse(value: unknown): value is ValidatedInputResponse;
-export {};
+/** Returns true when a value matches the answer contract. */
+export declare function isAnswer(value: unknown): value is ValidatedAnswer;
+export { APPROVE_OPTION_ID, DENY_OPTION_ID } from "#protocol/interaction-options.js";

package/dist/src/shared/input.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{runtimeToolCallActionRequestSchema}from"#shared/action-types.js";const inputOptionSchema=z.object({description:z.string().describe(`Optional additional context for this option.`).optional(),id:z.string().describe(`Stable identifier for the option.`),label:z.string().describe(`User-facing label for the option.`),style:z.enum([`primary`,`danger`,`default`]).describe(`Visual treatment hint for the option.`).optional()}).strict(),inputRequestKindSchema=z.enum([`question`,`session-limit`,`tool-approval`]),inputRequestSchema=z.object({action:runtimeToolCallActionRequestSchema,allowFreeform:z.boolean().describe(`Whether the user may answer with freeform text instead of selecting one of the provided options.`).optional(),display:z.enum([`confirmation`,`select`,`text`]).describe(`Rendering hint: the channel uses this to pick a UX treatment.`).optional(),kind:inputRequestKindSchema.describe(`Framework-owned request source used to resolve, route, and render the response.`),options:z.array(inputOptionSchema).describe(`Selectable answer options to present to the user.`).optional(),prompt:z.string().describe(`The prompt to present to the user.`),requestId:z.string().describe(`Stable identifier for this request.`)}).strict(),inputResponseSchema=z.object({optionId:z.string().optional(),requestId:z.string(),text:z.string().optional()}).strict();function parseInputResponse(e){return inputResponseSchema.parse(e)}function parseInputResponses(e){return inputResponseSchema.array().parse(e).map(e=>e)}function isInputRequest(e){return z.validate(inputRequestSchema,e)}function isInputResponse(e){return z.validate(inputResponseSchema,e)}export{inputOptionSchema,inputRequestKindSchema,inputRequestSchema,inputResponseSchema,isInputRequest,isInputResponse,parseInputResponse,parseInputResponses};
+import{z}from"#compiled/zod/index.js";import{APPROVE_OPTION_ID,DENY_OPTION_ID}from"#protocol/interaction-options.js";import{conforming}from"#protocol/session-events/common.js";const answerSchema=conforming()(z.object({interactionId:z.string(),optionId:z.string().optional(),text:z.string().optional()}).strict());function parseAnswer(e){return answerSchema.parse(e)}function parseAnswers(e){return answerSchema.array().parse(e).map(e=>e)}function isAnswer(e){return z.validate(answerSchema,e)}export{APPROVE_OPTION_ID,DENY_OPTION_ID,answerSchema,isAnswer,parseAnswer,parseAnswers};

package/dist/src/shared/instructions-definition.d.ts

@@ -8,16 +8,10 @@
  * static instructions execute once at build time. The compiler captures
  * the resulting content into the compiled manifest.
  */
-export type PublicInstructionsDefinition = {
+export interface PublicInstructionsDefinition {
     readonly content: string;
     readonly role?: "system" | "user";
-    readonly markdown?: never;
-} | {
-    /** @deprecated Use `content`. */
-    readonly markdown: string;
-    readonly content?: never;
-    readonly role?: never;
-};
+}
 export type InstructionsRole = "system" | "user";
 /**
  * Internal definition for an instructions prompt authored in markdown or

package/dist/src/shared/instrumentation-channel-kind.d.ts

@@ -1,3 +1,3 @@
-import type { InstrumentationChannelKind } from "#public/channels/index.js";
+import type { InstrumentationChannelKind } from "#shared/instrumentation-channel.js";
 export declare function isInstrumentationChannelKind(kind: string): kind is InstrumentationChannelKind;
 export declare function normalizeInstrumentationChannelKind(rawKind: string | undefined): InstrumentationChannelKind;

package/dist/src/shared/instrumentation-channel.d.ts

@@ -0,0 +1,12 @@
+/** Stable authored channel identity, distinct from its storage adapter key. */
+export type InstrumentationChannelKind = `channel:${string}` | "http" | "schedule" | "subagent" | "unknown";
+/** Base metadata for framework channel kinds. */
+export type InstrumentationChannelMetadata = Readonly<Record<string, unknown>>;
+/** Privacy-safe channel projection; metadata belongs to the channel. */
+export interface InstrumentationChannelForKind<K extends InstrumentationChannelKind> {
+    readonly kind: K;
+    readonly continuationToken?: string;
+    readonly metadata: InstrumentationChannelMetadata;
+}
+/** Channel shape received by instrumentation callbacks and dynamic resolvers. */
+export type InstrumentationChannel = InstrumentationChannelForKind<InstrumentationChannelKind>;

package/dist/src/shared/instrumentation-channel.js

@@ -0,0 +1 @@
+export{};

package/dist/src/shared/json.d.ts

@@ -1,21 +1,5 @@
-/**
- * JSON-serializable primitive values that can safely cross workflow and step boundaries.
- */
-export type JsonPrimitive = boolean | number | string | null;
-/**
- * JSON-serializable array values that can safely cross workflow and step boundaries.
- */
-export type JsonArray = readonly JsonValue[];
-/**
- * JSON-serializable object values that can safely cross workflow and step boundaries.
- */
-export interface JsonObject {
-    readonly [key: string]: JsonValue;
-}
-/**
- * JSON-serializable values that can safely cross workflow and step boundaries.
- */
-export type JsonValue = JsonArray | JsonObject | JsonPrimitive;
+import type { JsonObject, JsonValue } from "#protocol/session-events/json.js";
+export type { JsonArray, JsonObject, JsonPrimitive, JsonValue, } from "#protocol/session-events/json.js";
 /** Compares two already-validated JSON structures by value. */
 export declare function jsonValuesEqual(left: unknown, right: unknown): boolean;
 /**

package/dist/src/shared/memory-state.d.ts

@@ -1,48 +1,12 @@
-import type { ModelMessage } from "ai";
-import type { LockedMemorySlot } from "#context/keys.js";
-import type { SessionStateMap } from "#harness/types.js";
-import type { MemoryRecallResult, MemoryScopeResolverResult } from "#public/memory/index.js";
-export interface InternalMemoryLock extends LockedMemorySlot {
-    readonly namespaceKey: string;
-    readonly scopeKey: string;
-}
+import type { MemoryRecallResult, MemoryScope, MemoryScopeResolverResult } from "#public/memory/index.js";
 export interface NormalizedMemoryRecallMessage {
     readonly content: string;
     readonly itemKey?: string;
 }
-export interface MemoryRecallBatch {
-    readonly lock: InternalMemoryLock;
-    readonly messages: readonly NormalizedMemoryRecallMessage[];
-    readonly operationId: string;
-}
-export declare function createMemoryLock(input: {
+/** The scope a memory slot operates under. */
+export declare function createMemoryScope(input: {
     readonly namespace: string;
     readonly scope: Exclude<MemoryScopeResolverResult, null>;
     readonly slot: string;
-    readonly turn: LockedMemorySlot["turn"];
-    readonly visibility: LockedMemorySlot["visibility"];
-}): InternalMemoryLock;
+}): MemoryScope;
 export declare function validateMemoryRecallResult(result: MemoryRecallResult, slot: string): readonly NormalizedMemoryRecallMessage[];
-export declare function applyMemoryRecallBatches(input: {
-    readonly batches: readonly MemoryRecallBatch[];
-    readonly history: readonly ModelMessage[];
-    readonly state: SessionStateMap | undefined;
-}): {
-    readonly history: ModelMessage[];
-    readonly recalledMessages: ModelMessage[];
-    readonly state: SessionStateMap;
-};
-export declare function projectMemoryHistory(input: {
-    readonly locks: Readonly<Record<string, InternalMemoryLock>>;
-    readonly messages: readonly ModelMessage[];
-}): readonly ModelMessage[];
-export declare function projectMemoryHistoryFromSessionState(input: {
-    readonly messages: readonly ModelMessage[];
-    readonly state: SessionStateMap | undefined;
-}): readonly ModelMessage[];
-export declare function canonicalizeMemoryRecords(messages: readonly ModelMessage[]): {
-    readonly memory: ModelMessage[];
-    readonly ordinary: ModelMessage[];
-};
-export declare function shouldCanonicalizeMemory(messages: readonly ModelMessage[]): boolean;
-export declare function clearMemorySessionState(state: SessionStateMap | undefined): SessionStateMap;

package/dist/src/shared/memory-state.js

@@ -1 +1 @@
-import{createHash}from"node:crypto";import{createFrameworkUserMessage}from"#harness/messages.js";import{identityHistoryViewProjector}from"#shared/history-view.js";const MEMORY_NAMESPACE_MAX_BYTES=1024,MEMORY_SCOPE_COMPONENT_MAX_BYTES=1024,MEMORY_CANONICAL_KEY_INPUT_MAX_BYTES=4096,MEMORY_ITEM_ID_MAX_BYTES=1024,MEMORY_MESSAGE_METADATA_KEY=`eve.memory`,MEMORY_SESSION_STATE_KEY=`eve.memory`;function createMemoryLock(e){validateMemoryNamespace(e.namespace),validateMemoryScopeValue(e.scope);let t=encodeScalar(`namespace`,e.namespace),n=encodeScope(e.scope);if(t.byteLength+n.byteLength>MEMORY_CANONICAL_KEY_INPUT_MAX_BYTES)throw Error(`Memory slot "${e.slot}" namespace and scope encoding exceeds ${MEMORY_CANONICAL_KEY_INPUT_MAX_BYTES} UTF-8 bytes.`);let r=digest(`memns1_`,t),i=digest(`memscope1_`,n),a=Buffer.concat([Buffer.from(`eve-memory-composite-v1\0`),lengthPrefix(Buffer.from(r)),lengthPrefix(Buffer.from(i))]),o=Object.freeze({key:digest(`memscope1_`,a),namespace:e.namespace,value:Array.isArray(e.scope)?Object.freeze([...e.scope]):e.scope});return Object.freeze({namespaceKey:r,scope:o,scopeKey:i,slot:e.slot,turn:e.turn,visibility:e.visibility})}function validateMemoryRecallResult(e,t){if(e==null)return[];if(typeof e!=`object`||Array.isArray(e))throw Error(`Memory slot "${t}" recall() must return { messages }, null, or undefined.`);let n=Object.keys(e).filter(e=>e!==`messages`);if(n.length>0)throw Error(`Memory slot "${t}" recall() returned unknown key(s): ${n.join(`, `)}.`);if(!Array.isArray(e.messages))throw Error(`Memory slot "${t}" recall().messages must be an array.`);let r=new Set;return e.messages.map((e,n)=>{if(typeof e!=`object`||!e||Array.isArray(e))throw Error(`Memory slot "${t}" recall message ${n} must be an object.`);let i=Object.keys(e).filter(e=>e!==`content`&&e!==`id`);if(i.length>0)throw Error(`Memory slot "${t}" recall message ${n} has unknown key(s): ${i.join(`, `)}.`);if(typeof e.content!=`string`||e.content.trim().length===0)throw Error(`Memory slot "${t}" recall message ${n} content must be non-blank.`);if(e.id===void 0)return Object.freeze({content:e.content});if(typeof e.id!=`string`||e.id.length===0)throw Error(`Memory slot "${t}" recall message ${n} id must be non-empty.`);if(utf8Bytes(e.id)>MEMORY_ITEM_ID_MAX_BYTES)throw Error(`Memory slot "${t}" recall message ${n} id exceeds ${MEMORY_ITEM_ID_MAX_BYTES} UTF-8 bytes.`);if(r.has(e.id))throw Error(`Memory slot "${t}" recall() returned duplicate id "${e.id}".`);return r.add(e.id),Object.freeze({content:e.content,itemKey:digest(`memitem1_`,encodeScalar(`item`,e.id))})})}function applyMemoryRecallBatches(e){let t={...readMemorySessionState(e.state).operationDigests},n=latestKeyedRecords(e.history),r=[];for(let i of e.batches){let e=recallBatchDigest(i.messages),a=t[i.operationId];if(a!==void 0){if(a!==e)throw Error(`Memory recall operation "${i.operationId}" replayed with a different result.`);continue}t[i.operationId]=e;for(let[e,t]of i.messages.entries()){let a={batchIndex:e,itemKey:t.itemKey,namespaceKey:i.lock.namespaceKey,operationId:i.operationId,scopeKey:i.lock.scopeKey,slot:i.lock.slot,version:1};if(t.itemKey!==void 0){let e=memoryItemIdentity(a);if(n.get(e)?.content===t.content)continue;n.set(e,{attribution:a,content:t.content})}r.push(attributeMemoryRecord(t.content,a))}}let i=Object.fromEntries(Object.entries(t).slice(-1024));return{history:[...e.history,...r],recalledMessages:r,state:writeMemorySessionState(e.state,{locks:Object.fromEntries(e.batches.map(e=>[e.lock.slot,e.lock])),operationDigests:i})}}function projectMemoryHistory(e){let t=latestKeyedRecordIndexes(e.messages);return e.messages.flatMap((n,r)=>{let i=readMemoryRecordAttribution(n);if(i===null)return[n];let a=e.locks[i.slot];return a===void 0||a.namespaceKey!==i.namespaceKey||a.visibility===`scope`&&a.scopeKey!==i.scopeKey||i.itemKey!==void 0&&t.get(memoryItemIdentity(i))!==r?[]:[stripMemoryRecordAttribution(n)]})}function projectMemoryHistoryFromSessionState(e){let t=identityHistoryViewProjector(e);return projectMemoryHistory({locks:readMemorySessionState(e.state).locks,messages:t})}function canonicalizeMemoryRecords(e){let t=latestKeyedRecordIndexes(e),n=[],r=[];for(let[i,a]of e.entries()){let e=readMemoryRecordAttribution(a);if(e===null){r.push(a);continue}(e.itemKey===void 0||t.get(memoryItemIdentity(e))===i)&&n.push(a)}return{memory:n,ordinary:r}}function shouldCanonicalizeMemory(e){let t=0,n=0;for(let r of e)readMemoryRecordAttribution(r)!==null&&(t+=1,n+=serializedBytes(r));return t>512||n>262144}function clearMemorySessionState(e){if(e===void 0||!Object.hasOwn(e,MEMORY_SESSION_STATE_KEY))return e??{};let{[MEMORY_SESSION_STATE_KEY]:t,...n}=e;return n}function validateMemoryNamespace(e){if(e.trim().length===0)throw Error(`Memory namespace must be non-empty.`);if(utf8Bytes(e)>MEMORY_NAMESPACE_MAX_BYTES)throw Error(`Memory namespace exceeds ${MEMORY_NAMESPACE_MAX_BYTES} UTF-8 bytes.`)}function validateMemoryScopeValue(e){let t=Array.isArray(e)?e:[e];if(Array.isArray(e)&&t.length>16)throw Error(`Memory scope tuple exceeds 16 components.`);if(t.length===0)throw Error(`Memory scope tuple must not be empty.`);for(let[e,n]of t.entries()){if(typeof n!=`string`||n.trim().length===0)throw Error(`Memory scope component ${e} must be a non-empty string.`);if(utf8Bytes(n)>MEMORY_SCOPE_COMPONENT_MAX_BYTES)throw Error(`Memory scope component ${e} exceeds ${MEMORY_SCOPE_COMPONENT_MAX_BYTES} UTF-8 bytes.`)}}function encodeScope(e){return typeof e==`string`?encodeScalar(`scope-scalar`,e):Buffer.concat([Buffer.from(`scope-tuple-v1\0`),uint32(e.length),...e.map(e=>lengthPrefix(Buffer.from(e,`utf8`)))])}function encodeScalar(e,t){return Buffer.concat([Buffer.from(`${e}-v1\0`),lengthPrefix(Buffer.from(t,`utf8`))])}function lengthPrefix(e){return Buffer.concat([uint32(e.byteLength),e])}function uint32(e){let t=Buffer.allocUnsafe(4);return t.writeUInt32BE(e),t}function digest(e,t){return`${e}${createHash(`sha256`).update(t).digest(`base64url`)}`}function recallBatchDigest(e){return createHash(`sha256`).update(JSON.stringify(e)).digest(`base64url`)}function attributeMemoryRecord(e,t){return createFrameworkUserMessage(`memory.load`,e,{[MEMORY_MESSAGE_METADATA_KEY]:t})}function readMemoryRecordAttribution(e){if(typeof e!=`object`||!e)return null;let t=Reflect.get(e,`metadata`);if(typeof t!=`object`||!t)return null;let n=Reflect.get(t,MEMORY_MESSAGE_METADATA_KEY);if(typeof n!=`object`||!n)return null;let r=n;if(r.version!==1||typeof r.batchIndex!=`number`||typeof r.namespaceKey!=`string`||typeof r.operationId!=`string`||typeof r.scopeKey!=`string`||typeof r.slot!=`string`||r.itemKey!==void 0&&typeof r.itemKey!=`string`)throw Error(`Durable history contains invalid eve memory attribution.`);return r}function stripMemoryRecordAttribution(e){let t=Reflect.get(e,`metadata`);if(typeof t!=`object`||!t)return e;let{[MEMORY_MESSAGE_METADATA_KEY]:n,...r}=t,{metadata:i,...a}=e;return Object.keys(r).length===0?a:Object.assign(a,{metadata:r})}function latestKeyedRecordIndexes(e){let t=new Map;for(let[n,r]of e.entries()){let e=readMemoryRecordAttribution(r);e?.itemKey!==void 0&&t.set(memoryItemIdentity(e),n)}return t}function latestKeyedRecords(e){let t=new Map;for(let n of e){let e=readMemoryRecordAttribution(n);if(e?.itemKey===void 0)continue;let r=Reflect.get(n,`content`),i=typeof r==`string`?r:``;t.set(memoryItemIdentity(e),{attribution:e,content:i})}return t}function memoryItemIdentity(e){return JSON.stringify([e.slot,e.namespaceKey,e.scopeKey,e.itemKey])}function readMemorySessionState(e){let t=e?.[MEMORY_SESSION_STATE_KEY];if(typeof t!=`object`||!t||Array.isArray(t))return{locks:{},operationDigests:{}};let n=Reflect.get(t,`locks`),r=Reflect.get(t,`operationDigests`);return{locks:typeof n==`object`&&n&&!Array.isArray(n)?n:{},operationDigests:typeof r==`object`&&r&&!Array.isArray(r)?r:{}}}function writeMemorySessionState(e,t){return{...e,[MEMORY_SESSION_STATE_KEY]:t}}function serializedBytes(e){return Buffer.byteLength(JSON.stringify(e),`utf8`)}function utf8Bytes(e){return Buffer.byteLength(e,`utf8`)}export{applyMemoryRecallBatches,canonicalizeMemoryRecords,clearMemorySessionState,createMemoryLock,projectMemoryHistory,projectMemoryHistoryFromSessionState,shouldCanonicalizeMemory,validateMemoryRecallResult};
+import{createHash}from"node:crypto";const MEMORY_NAMESPACE_MAX_BYTES=1024,MEMORY_SCOPE_COMPONENT_MAX_BYTES=1024,MEMORY_CANONICAL_KEY_INPUT_MAX_BYTES=4096,MEMORY_ITEM_ID_MAX_BYTES=1024;function createMemoryScope(e){validateMemoryNamespace(e.namespace),validateMemoryScopeValue(e.scope);let t=encodeScalar(`namespace`,e.namespace),n=encodeScope(e.scope);if(t.byteLength+n.byteLength>MEMORY_CANONICAL_KEY_INPUT_MAX_BYTES)throw Error(`Memory slot "${e.slot}" namespace and scope encoding exceeds ${MEMORY_CANONICAL_KEY_INPUT_MAX_BYTES} UTF-8 bytes.`);let r=digest(`memns1_`,t),i=digest(`memscope1_`,n),a=Buffer.concat([Buffer.from(`eve-memory-composite-v1\0`),lengthPrefix(Buffer.from(r)),lengthPrefix(Buffer.from(i))]);return Object.freeze({key:digest(`memscope1_`,a),namespace:e.namespace,value:Array.isArray(e.scope)?Object.freeze([...e.scope]):e.scope})}function validateMemoryRecallResult(e,t){if(e==null)return[];if(typeof e!=`object`||Array.isArray(e))throw Error(`Memory slot "${t}" recall() must return { messages }, null, or undefined.`);let n=Object.keys(e).filter(e=>e!==`messages`);if(n.length>0)throw Error(`Memory slot "${t}" recall() returned unknown key(s): ${n.join(`, `)}.`);if(!Array.isArray(e.messages))throw Error(`Memory slot "${t}" recall().messages must be an array.`);let r=new Set;return e.messages.map((e,n)=>{if(typeof e!=`object`||!e||Array.isArray(e))throw Error(`Memory slot "${t}" recall message ${n} must be an object.`);let i=Object.keys(e).filter(e=>e!==`content`&&e!==`id`);if(i.length>0)throw Error(`Memory slot "${t}" recall message ${n} has unknown key(s): ${i.join(`, `)}.`);if(typeof e.content!=`string`||e.content.trim().length===0)throw Error(`Memory slot "${t}" recall message ${n} content must be non-blank.`);if(e.id===void 0)return Object.freeze({content:e.content});if(typeof e.id!=`string`||e.id.length===0)throw Error(`Memory slot "${t}" recall message ${n} id must be non-empty.`);if(utf8Bytes(e.id)>MEMORY_ITEM_ID_MAX_BYTES)throw Error(`Memory slot "${t}" recall message ${n} id exceeds ${MEMORY_ITEM_ID_MAX_BYTES} UTF-8 bytes.`);if(r.has(e.id))throw Error(`Memory slot "${t}" recall() returned duplicate id "${e.id}".`);return r.add(e.id),Object.freeze({content:e.content,itemKey:digest(`memitem1_`,encodeScalar(`item`,e.id))})})}function validateMemoryNamespace(e){if(e.trim().length===0)throw Error(`Memory namespace must be non-empty.`);if(utf8Bytes(e)>MEMORY_NAMESPACE_MAX_BYTES)throw Error(`Memory namespace exceeds ${MEMORY_NAMESPACE_MAX_BYTES} UTF-8 bytes.`)}function validateMemoryScopeValue(e){let t=Array.isArray(e)?e:[e];if(Array.isArray(e)&&t.length>16)throw Error(`Memory scope tuple exceeds 16 components.`);if(t.length===0)throw Error(`Memory scope tuple must not be empty.`);for(let[e,n]of t.entries()){if(typeof n!=`string`||n.trim().length===0)throw Error(`Memory scope component ${e} must be a non-empty string.`);if(utf8Bytes(n)>MEMORY_SCOPE_COMPONENT_MAX_BYTES)throw Error(`Memory scope component ${e} exceeds ${MEMORY_SCOPE_COMPONENT_MAX_BYTES} UTF-8 bytes.`)}}function encodeScope(e){return typeof e==`string`?encodeScalar(`scope-scalar`,e):Buffer.concat([Buffer.from(`scope-tuple-v1\0`),uint32(e.length),...e.map(e=>lengthPrefix(Buffer.from(e,`utf8`)))])}function encodeScalar(e,t){return Buffer.concat([Buffer.from(`${e}-v1\0`),lengthPrefix(Buffer.from(t,`utf8`))])}function lengthPrefix(e){return Buffer.concat([uint32(e.byteLength),e])}function uint32(e){let t=Buffer.allocUnsafe(4);return t.writeUInt32BE(e),t}function digest(e,t){return`${e}${createHash(`sha256`).update(t).digest(`base64url`)}`}function utf8Bytes(e){return Buffer.byteLength(e,`utf8`)}export{createMemoryScope,validateMemoryRecallResult};

package/dist/src/shared/message-content.d.ts

@@ -0,0 +1,19 @@
+export declare const MAX_MESSAGE_PARTS = 64;
+/** Text a person sends. */
+export interface MessageTextPart {
+    readonly type: "text";
+    readonly text: string;
+}
+/**
+ * A file a person sends. `data` is the file inline, as bytes, base64, or a `data:` URL; or a URL:
+ * eve loads URLs through the channel's `fetchFile` or its public HTTPS fallback.
+ */
+export interface MessageFilePart<TData extends Uint8Array | ArrayBuffer | string | URL = Uint8Array | ArrayBuffer | string | URL> {
+    readonly type: "file";
+    readonly mediaType: string;
+    readonly filename?: string;
+    readonly data: TData;
+}
+export type MessagePart<TData extends MessageFilePart["data"] = MessageFilePart["data"]> = MessageTextPart | MessageFilePart<TData>;
+/** What a person sends: text, or text and files. */
+export type MessageContent<TData extends MessageFilePart["data"] = MessageFilePart["data"]> = string | readonly MessagePart<TData>[];

package/dist/src/shared/message-content.js

@@ -0,0 +1 @@
+const MAX_MESSAGE_PARTS=64;export{MAX_MESSAGE_PARTS};

package/dist/src/shared/network-address.d.ts

@@ -27,3 +27,12 @@ export declare function isReservedIpAddress(host: string): boolean;
  * blocks loopback addresses.
  */
 export declare function isPrivateOrReservedIpAddress(host: string): boolean;
+/**
+ * Whether a framework request to an untrusted URL must not connect to
+ * `host`, an IP literal, resolved address, or hostname. Hostnames are only
+ * checked for the `localhost` namespace; callers must validate resolved
+ * addresses at connect time.
+ */
+export declare function isBlockedDestinationHost(host: string, options: {
+    readonly allowLoopback: boolean;
+}): boolean;

package/dist/src/shared/network-address.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{BlockList,isIP}from"node:net";const httpServerUrlSchema=z.url({protocol:/^https?$/}),reservedRanges=new BlockList;reservedRanges.addSubnet(`0.0.0.0`,8,`ipv4`),reservedRanges.addSubnet(`10.0.0.0`,8,`ipv4`),reservedRanges.addSubnet(`100.64.0.0`,10,`ipv4`),reservedRanges.addSubnet(`169.254.0.0`,16,`ipv4`),reservedRanges.addSubnet(`172.16.0.0`,12,`ipv4`),reservedRanges.addSubnet(`192.0.0.0`,24,`ipv4`),reservedRanges.addSubnet(`192.0.2.0`,24,`ipv4`),reservedRanges.addSubnet(`192.88.99.0`,24,`ipv4`),reservedRanges.addSubnet(`192.168.0.0`,16,`ipv4`),reservedRanges.addSubnet(`198.18.0.0`,15,`ipv4`),reservedRanges.addSubnet(`198.51.100.0`,24,`ipv4`),reservedRanges.addSubnet(`203.0.113.0`,24,`ipv4`),reservedRanges.addSubnet(`224.0.0.0`,4,`ipv4`),reservedRanges.addSubnet(`240.0.0.0`,4,`ipv4`),reservedRanges.addAddress(`::`,`ipv6`),reservedRanges.addSubnet(`::`,96,`ipv6`),reservedRanges.addSubnet(`64:ff9b::`,96,`ipv6`),reservedRanges.addSubnet(`64:ff9b:1::`,48,`ipv6`),reservedRanges.addSubnet(`100::`,64,`ipv6`),reservedRanges.addSubnet(`2001::`,23,`ipv6`),reservedRanges.addSubnet(`2001:db8::`,32,`ipv6`),reservedRanges.addSubnet(`2002::`,16,`ipv6`),reservedRanges.addSubnet(`fc00::`,7,`ipv6`),reservedRanges.addSubnet(`fe80::`,10,`ipv6`),reservedRanges.addSubnet(`ff00::`,8,`ipv6`);const loopbackRanges=new BlockList;loopbackRanges.addSubnet(`127.0.0.0`,8,`ipv4`),loopbackRanges.addAddress(`::1`,`ipv6`);function normalizeAddress(e){let t=e.trim().replace(/^\[(.*)\]$/u,`$1`),n=t.indexOf(`%`),r=n===-1?t:t.slice(0,n);if(r.toLowerCase().startsWith(`::ffff:`)){let e=r.slice(7);if(isIP(e)===4)return e}return r}function isLoopbackHostname(e){let t=normalizeAddress(e).toLowerCase().replace(/\.$/u,``);if(t===`localhost`||t.endsWith(`.localhost`))return!0;let n=isIP(t);return n!==0&&loopbackRanges.check(t,n===4?`ipv4`:`ipv6`)}function isLoopbackServerUrl(e){let t=httpServerUrlSchema.safeParse(e);return t.success&&isLoopbackHostname(new URL(t.data).hostname)}function isReservedIpAddress(e){let t=normalizeAddress(e);if(isLoopbackHostname(t))return!1;let n=isIP(t);return n!==0&&reservedRanges.check(t,n===4?`ipv4`:`ipv6`)}function isPrivateOrReservedIpAddress(e){return isLoopbackHostname(e)||isReservedIpAddress(e)}export{httpServerUrlSchema,isLoopbackHostname,isLoopbackServerUrl,isPrivateOrReservedIpAddress,isReservedIpAddress};
+import{z}from"#compiled/zod/index.js";import{BlockList,isIP}from"node:net";const httpServerUrlSchema=z.url({protocol:/^https?$/}),reservedRanges=new BlockList;reservedRanges.addSubnet(`0.0.0.0`,8,`ipv4`),reservedRanges.addSubnet(`10.0.0.0`,8,`ipv4`),reservedRanges.addSubnet(`100.64.0.0`,10,`ipv4`),reservedRanges.addSubnet(`169.254.0.0`,16,`ipv4`),reservedRanges.addSubnet(`172.16.0.0`,12,`ipv4`),reservedRanges.addSubnet(`192.0.0.0`,24,`ipv4`),reservedRanges.addSubnet(`192.0.2.0`,24,`ipv4`),reservedRanges.addSubnet(`192.88.99.0`,24,`ipv4`),reservedRanges.addSubnet(`192.168.0.0`,16,`ipv4`),reservedRanges.addSubnet(`198.18.0.0`,15,`ipv4`),reservedRanges.addSubnet(`198.51.100.0`,24,`ipv4`),reservedRanges.addSubnet(`203.0.113.0`,24,`ipv4`),reservedRanges.addSubnet(`224.0.0.0`,4,`ipv4`),reservedRanges.addSubnet(`240.0.0.0`,4,`ipv4`),reservedRanges.addAddress(`::`,`ipv6`),reservedRanges.addSubnet(`::`,96,`ipv6`),reservedRanges.addSubnet(`64:ff9b::`,96,`ipv6`),reservedRanges.addSubnet(`64:ff9b:1::`,48,`ipv6`),reservedRanges.addSubnet(`100::`,64,`ipv6`),reservedRanges.addSubnet(`2001::`,23,`ipv6`),reservedRanges.addSubnet(`2001:db8::`,32,`ipv6`),reservedRanges.addSubnet(`2002::`,16,`ipv6`),reservedRanges.addSubnet(`fc00::`,7,`ipv6`),reservedRanges.addSubnet(`fe80::`,10,`ipv6`),reservedRanges.addSubnet(`ff00::`,8,`ipv6`);const loopbackRanges=new BlockList;loopbackRanges.addSubnet(`127.0.0.0`,8,`ipv4`),loopbackRanges.addAddress(`::1`,`ipv6`);function normalizeAddress(e){let t=e.trim().replace(/^\[(.*)\]$/u,`$1`),n=t.indexOf(`%`),r=n===-1?t:t.slice(0,n);if(r.toLowerCase().startsWith(`::ffff:`)){let e=r.slice(7);if(isIP(e)===4)return e}return r}function isLoopbackHostname(e){let t=normalizeAddress(e).toLowerCase().replace(/\.$/u,``);if(t===`localhost`||t.endsWith(`.localhost`))return!0;let n=isIP(t);return n!==0&&loopbackRanges.check(t,n===4?`ipv4`:`ipv6`)}function isLoopbackServerUrl(e){let t=httpServerUrlSchema.safeParse(e);return t.success&&isLoopbackHostname(new URL(t.data).hostname)}function isReservedIpAddress(e){let t=normalizeAddress(e);if(isLoopbackHostname(t))return!1;let n=isIP(t);return n!==0&&reservedRanges.check(t,n===4?`ipv4`:`ipv6`)}function isPrivateOrReservedIpAddress(e){return isLoopbackHostname(e)||isReservedIpAddress(e)}function isBlockedDestinationHost(e,t){return t.allowLoopback?isReservedIpAddress(e):isPrivateOrReservedIpAddress(e)}export{httpServerUrlSchema,isBlockedDestinationHost,isLoopbackHostname,isLoopbackServerUrl,isPrivateOrReservedIpAddress,isReservedIpAddress};

package/dist/src/shared/sandbox-environment.d.ts

@@ -1,6 +1,6 @@
 import type { SessionAuth, SessionParent, SessionTurn } from "#context/keys.js";
 import type { SandboxProviderRuntime } from "#sandbox/provider.js";
-import type { RuntimeSandboxSession, RuntimeSandboxSessionFor, SandboxSession } from "#shared/sandbox-session.js";
+import type { RuntimeSandboxSession, SandboxSession } from "#shared/sandbox-session.js";
 declare const ENVIRONMENT: unique symbol;
 declare const PROVIDER_RUNTIME: unique symbol;
 export interface SandboxSelectorContext {
@@ -20,7 +20,7 @@ export interface SandboxEnvironmentIdentity {
     readonly provider: string;
 }
 export interface SandboxEnvironment<Options extends object | undefined = object, Session extends SandboxSession = SandboxSession> extends SandboxEnvironmentIdentity {
-    open(...args: SandboxOpenArguments<Options>): Promise<RuntimeSandboxSessionFor<Session>>;
+    open(...args: SandboxOpenArguments<Options>): Promise<RuntimeSandboxSession<Session>>;
 }
 interface ConstructorRuntime {
     open(input: {

package/dist/src/shared/sandbox-provider.d.ts

@@ -1,5 +1,5 @@
 export interface SandboxDeleteOptions {
-    readonly abortSignal?: AbortSignal;
+    readonly signal?: AbortSignal;
 }
 export interface SandboxProviderResourceFile {
     readonly content: string | Uint8Array;

package/dist/src/shared/sandbox-session.d.ts

@@ -1,79 +1,64 @@
 import type { SandboxDeleteOptions } from "#shared/sandbox-provider.js";
-/**
- * Options for running one command, or spawning one process, in a sandbox.
- * `env` holds per-call variables, merged over the sandbox's environment.
- * Aborting kills the process.
- */
+/** Options for running a command in the sandbox's working directory. */
 export interface SandboxRunOptions {
-    readonly abortSignal?: AbortSignal;
-    readonly command: string;
-    readonly env?: Readonly<Record<string, string>>;
+    command: string;
     /** Relative directories resolve from the workspace root, which is also the default. */
-    readonly workingDirectory?: string;
+    workingDirectory?: string;
+    /** Per-command environment overrides; avoids embedding credentials in command strings. */
+    env?: Record<string, string>;
+    signal?: AbortSignal;
 }
-/** Options for spawning one long-running process in a sandbox. */
-export type SandboxSpawnOptions = SandboxRunOptions;
-/** Result of one finished sandbox command. A nonzero `exitCode` does not throw. */
+/** Result of a completed sandbox command. */
 export interface SandboxCommandResult {
-    readonly exitCode: number;
-    readonly stderr: string;
-    readonly stdout: string;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+/** Options for starting a process without waiting for it to exit. */
+export interface SandboxSpawnOptions extends SandboxRunOptions {
 }
-/** Handle to a long-running process spawned via {@link SandboxSession.spawn}. */
+/** A running process with byte streams and explicit lifecycle operations. */
 export interface SandboxProcess {
     readonly pid?: number;
-    readonly stderr: ReadableStream<Uint8Array>;
     readonly stdout: ReadableStream<Uint8Array>;
-    /** Terminates the process. Idempotent. */
-    kill(): Promise<void>;
-    wait(): Promise<{
-        readonly exitCode: number;
+    readonly stderr: ReadableStream<Uint8Array>;
+    wait(): PromiseLike<{
+        exitCode: number;
     }>;
+    kill(): PromiseLike<void>;
 }
-/** Options for reading one file as a stream of bytes. */
+/** Options for reading a file; relative paths resolve from `/workspace`. */
 export interface SandboxReadFileOptions {
-    readonly abortSignal?: AbortSignal;
-    readonly path: string;
+    path: string;
+    signal?: AbortSignal;
 }
-/** Options for reading one file as raw bytes. */
-export type SandboxReadBinaryFileOptions = SandboxReadFileOptions;
-/**
- * Options for reading one text file from a sandbox.
- *
- * `"utf-8"` decodes with `TextDecoder` in fatal mode; other encodings fall
- * back to Node's `Buffer.toString(encoding)`. Line ranges are 1-based and
- * inclusive; `endLine` past the file's line count returns through EOF
- * without error.
- */
+/** Options for reading all bytes of a file. */
+export interface SandboxReadBinaryFileOptions extends SandboxReadFileOptions {
+}
+/** Text decoding and 1-based inclusive line selection. Missing files return `null`. */
 export interface SandboxReadTextFileOptions extends SandboxReadFileOptions {
-    readonly encoding?: string;
-    readonly endLine?: number;
-    readonly startLine?: number;
+    encoding?: string;
+    startLine?: number;
+    endLine?: number;
 }
-/** Options for writing one file from a stream of bytes. */
-export interface SandboxWriteFileOptions {
-    readonly abortSignal?: AbortSignal;
-    readonly content: ReadableStream<Uint8Array>;
-    readonly path: string;
+interface WriteOptions<T> {
+    path: string;
+    content: T;
+    signal?: AbortSignal;
 }
-/** Options for writing one file from raw bytes. */
-export interface SandboxWriteBinaryFileOptions {
-    readonly abortSignal?: AbortSignal;
-    readonly content: Uint8Array;
-    readonly path: string;
+/** Writes a byte stream, creating parent directories and overwriting existing content. */
+export interface SandboxWriteFileOptions extends WriteOptions<ReadableStream<Uint8Array>> {
 }
-/** Options for writing one text file to a sandbox. Encodes as UTF-8 unless `encoding` is set. */
-export interface SandboxWriteTextFileOptions {
-    readonly abortSignal?: AbortSignal;
-    readonly content: string;
-    readonly encoding?: string;
-    readonly path: string;
+/** Writes a complete byte buffer. */
+export interface SandboxWriteBinaryFileOptions extends WriteOptions<Uint8Array> {
 }
-/**
- * Options for writing several files from raw bytes in one batch.
- */
+/** Writes text with the requested encoding (UTF-8 by default). */
+export interface SandboxWriteTextFileOptions extends WriteOptions<string> {
+    encoding?: string;
+}
+/** Writes several already-resolved files from raw bytes in one batch. */
 export interface SandboxWriteFilesOptions {
-    readonly abortSignal?: AbortSignal;
+    readonly signal?: AbortSignal;
     readonly files: readonly {
         readonly content: Uint8Array;
         readonly path: string;
@@ -87,53 +72,43 @@ export interface SandboxWriteFilesOptions {
  * directories.
  */
 export interface SandboxRemovePathOptions {
-    readonly abortSignal?: AbortSignal;
+    readonly signal?: AbortSignal;
     readonly force?: boolean;
     readonly path: string;
     readonly recursive?: boolean;
 }
 /**
- * The sandbox session that authored tools, hooks, and `prepare` receive.
+ * eve-owned sandbox I/O that authored tools, hooks, and `prepare` receive.
  *
  * Relative paths resolve from the workspace root, where commands start by
  * default: `/workspace` on every built-in provider. Absolute paths pass
  * through unchanged. Writes create missing parent directories and overwrite
  * existing files. Reads resolve to `null` only when the path does not exist.
- *
- * The method set stays assignable to the AI SDK's
- * `Experimental_SandboxSession`, apart from its `description`.
  */
 export interface SandboxSession {
-    run(options: SandboxRunOptions): Promise<SandboxCommandResult>;
-    spawn(options: SandboxSpawnOptions): Promise<SandboxProcess>;
-    readFile(options: SandboxReadFileOptions): Promise<ReadableStream<Uint8Array> | null>;
-    readBinaryFile(options: SandboxReadBinaryFileOptions): Promise<Uint8Array | null>;
-    readTextFile(options: SandboxReadTextFileOptions): Promise<string | null>;
-    writeFile(options: SandboxWriteFileOptions): Promise<void>;
-    writeBinaryFile(options: SandboxWriteBinaryFileOptions): Promise<void>;
-    writeTextFile(options: SandboxWriteTextFileOptions): Promise<void>;
-    /**
-     * Writes several files in as few provider calls as the provider allows. A
-     * batch is not atomic: a rejected batch may leave earlier files written.
-     */
-    writeFiles(options: SandboxWriteFilesOptions): Promise<void>;
+    readonly run: (options: SandboxRunOptions) => PromiseLike<SandboxCommandResult>;
+    readonly spawn: (options: SandboxSpawnOptions) => PromiseLike<SandboxProcess>;
+    readonly readFile: (options: SandboxReadFileOptions) => PromiseLike<ReadableStream<Uint8Array> | null>;
+    readonly readBinaryFile: (options: SandboxReadBinaryFileOptions) => PromiseLike<Uint8Array | null>;
+    readonly readTextFile: (options: SandboxReadTextFileOptions) => PromiseLike<string | null>;
+    readonly writeFile: (options: SandboxWriteFileOptions) => PromiseLike<void>;
+    readonly writeBinaryFile: (options: SandboxWriteBinaryFileOptions) => PromiseLike<void>;
+    readonly writeTextFile: (options: SandboxWriteTextFileOptions) => PromiseLike<void>;
+    /** Writes several files in as few provider calls as possible; a rejected batch may leave earlier files written. */
+    readonly writeFiles: (options: SandboxWriteFilesOptions) => PromiseLike<void>;
     /**
      * Anchors a sandbox-relative path to the workspace root and returns the
      * resulting absolute path, so `resolvePath(".")` is the root itself. The
      * read and write methods already apply it.
      */
     resolvePath(path: string): string;
-    /** Removes one file or directory from the sandbox filesystem. */
     removePath(options: SandboxRemovePathOptions): Promise<void>;
 }
-export interface RuntimeSandboxSession extends SandboxSession {
-    /** Permanently deletes this sandbox and its disposable provider state. */
+/** A provider session plus the runtime's disposable-resource lifecycle. */
+export type RuntimeSandboxSession<Session extends SandboxSession = SandboxSession> = Session & {
+    /** Permanently deletes the sandbox and its disposable provider state. */
     delete(options?: SandboxDeleteOptions): Promise<void>;
-    /**
-     * Stops the backing sandbox compute while preserving the durable session.
-     * A later runtime callback reopens the session through its configured
-     * provider. Providers may also support resuming the same handle.
-     */
+    /** Stops compute while retaining the durable session for a later reopen. */
     stop(): Promise<void>;
-}
-export type RuntimeSandboxSessionFor<Session extends SandboxSession> = Session & Pick<RuntimeSandboxSession, "delete" | "stop">;
+};
+export {};

package/dist/src/shared/schedule-definition.d.ts

@@ -7,14 +7,14 @@ export type GenericScheduleRunHandler<TArgs> = (args: TArgs) => Promise<void> |
 /** Constraint shape that bounds the authored keys accepted by {@link defineSchedule}. */
 export interface GenericScheduleDefinitionFields<TArgs> {
     readonly cron: string;
-    readonly markdown?: string;
+    readonly content?: string;
     readonly run?: GenericScheduleRunHandler<TArgs>;
 }
 /**
  * Public definition for a schedule authored in TypeScript. Provide a required
- * `cron` expression plus exactly one of `markdown` or `run`:
+ * `cron` expression plus exactly one of `content` or `run`:
  *
- * - `markdown`: fire-and-forget agent invocation. The framework runs the agent
+ * - `content`: fire-and-forget agent invocation. The framework runs the agent
  *   on the prompt and discards the output (equivalent to the `<name>.md`
  *   markdown form).
  * - `run`: full handler ({@link GenericScheduleRunHandler}). Receives
@@ -25,10 +25,10 @@ export interface GenericScheduleDefinitionFields<TArgs> {
  */
 export type GenericScheduleDefinition<TArgs> = {
     readonly cron: string;
-    readonly markdown: string;
+    readonly content: string;
     readonly run?: never;
 } | {
     readonly cron: string;
-    readonly markdown?: never;
+    readonly content?: never;
     readonly run: GenericScheduleRunHandler<TArgs>;
 };

package/dist/src/shared/serialized-observability-state.d.ts

@@ -1,7 +1,5 @@
 export declare const SERIALIZED_INSTRUMENTATION_STATE_KEYS: {
     readonly activeChannelDeliveries: "eve.activeChannelDeliveries";
-    readonly actionScopes: "eve.harness.instrumentationActionScopes";
-    readonly inputScopes: "eve.harness.instrumentationInputScopes";
     readonly providerState: "eve.harness.instrumentationState";
 };
 /** Keeps instrumentation state needed to settle operations opened by a discarded step. */

package/dist/src/shared/serialized-observability-state.js

@@ -1 +1 @@
-const SERIALIZED_INSTRUMENTATION_STATE_KEYS={activeChannelDeliveries:`eve.activeChannelDeliveries`,actionScopes:`eve.harness.instrumentationActionScopes`,inputScopes:`eve.harness.instrumentationInputScopes`,providerState:`eve.harness.instrumentationState`};function preserveSerializedInstrumentationState(e,t){let n=e;for(let e of Object.values(SERIALIZED_INSTRUMENTATION_STATE_KEYS)){let r=t[e];r!==void 0&&(n={...n,[e]:r})}return n}export{SERIALIZED_INSTRUMENTATION_STATE_KEYS,preserveSerializedInstrumentationState};
+const SERIALIZED_INSTRUMENTATION_STATE_KEYS={activeChannelDeliveries:`eve.activeChannelDeliveries`,providerState:`eve.harness.instrumentationState`};function preserveSerializedInstrumentationState(e,t){let n=e;for(let e of Object.values(SERIALIZED_INSTRUMENTATION_STATE_KEYS)){let r=t[e];r!==void 0&&(n={...n,[e]:r})}return n}export{SERIALIZED_INSTRUMENTATION_STATE_KEYS,preserveSerializedInstrumentationState};

package/dist/src/shared/session-history.d.ts

@@ -2,10 +2,10 @@
  * One prior message passed as `history` to `send()` or `create()`.
  *
  * Entries become real user and assistant turns in the session's model history
- * and are published in the `history.imported` stream event.
+ * and are recorded on the `delivery.consumed` of the message that brings them.
  */
 export interface SessionHistoryMessage {
-    /** Optional app-owned id, echoed in `history.imported` so clients can join annotations. */
+    /** Optional app-owned id, echoed in `delivery.consumed` history so clients can join annotations. */
     readonly id?: string;
     readonly role: "user" | "assistant";
     /** Plain text. Channels render speaker attribution into this text when needed. */