agents 0.26.0 → 0.28.0

package/dist/harness-B6B9S3rb.d.ts

@@ -0,0 +1,203 @@
+import {
+  _ as TranscriptMessage,
+  l as Json,
+  m as ResponseChunk
+} from "./protocol-CukuI73M.js";
+
+//#region src/experimental/channels/harness.d.ts
+type SessionId = string;
+/** One agent harness hosted in a Durable Object. */
+interface AgentHarness {
+  readonly sessions: HarnessSessions;
+  /** A handle on one session. Without an id, the harness's default session. */
+  session(id?: SessionId): HarnessSession;
+}
+interface HarnessSessions {
+  create(): Promise<HarnessSession>;
+  /** A new session that sees `from`'s history so far. */
+  fork(from: SessionId): Promise<HarnessSession>;
+  list(): Promise<SessionInfo[]>;
+}
+type SessionInfo = {
+  readonly id: SessionId;
+  readonly parent?: SessionId;
+  readonly busy: boolean;
+};
+interface HarnessSession {
+  readonly id: SessionId;
+  /** A harness that takes no tool answers rejects them. */
+  submit(
+    input: (HarnessInput | ToolAnswer) & HarnessInputFrom,
+    options?: SubmitOptions
+  ): Promise<Receipt>;
+  /** Stop one operation, or, without an id, everything in the session. */
+  abort(operationId?: string): Promise<boolean>;
+  wait(operationId: string, signal?: AbortSignal): Promise<OperationResult>;
+  /** Start a new context, optionally from a handoff note. */
+  reset(handoff?: string): Promise<void>;
+  /** The current state, then every change, in order. */
+  watch(): Promise<SessionWatch>;
+}
+type InputPart =
+  | {
+      readonly type: "text";
+      readonly text: string;
+    }
+  | {
+      readonly type: "file";
+      readonly mediaType: string;
+      readonly url: string;
+      readonly filename?: string;
+    };
+type HarnessInput = {
+  readonly parts: readonly InputPart[];
+  /**
+   * The caller's id for the user message this places. Default: the
+   * operation id.
+   */
+  readonly messageId?: string;
+};
+/**
+ * Who sent an input, once a conversation has several participants. (From the
+ * "later" draft, adopted early: a client tool's result is taken only from
+ * the participant whose client runs it.)
+ */
+type HarnessInputFrom = {
+  readonly from?: {
+    readonly participantId: string;
+  };
+};
+/**
+ * A reply to something the agent asked for. Like a message, it makes the
+ * agent act, so it is submitted, queued, deduplicated and settled as an
+ * operation. (From the "later" draft, adopted early.)
+ */
+type ToolAnswer =
+  | {
+      readonly type: "approval";
+      readonly approvalId: string;
+      readonly approved: boolean;
+      readonly reason?: string;
+    }
+  | {
+      readonly type: "tool-result";
+      readonly toolCallId: string;
+      readonly result:
+        | {
+            readonly ok: true;
+            readonly output: Json;
+          }
+        | {
+            readonly ok: false;
+            readonly errorText?: string;
+          };
+    };
+type SubmitOptions = {
+  /** Idempotency key. Submitting the same id twice returns the same receipt. */ readonly operationId?: string;
+  readonly whenBusy?: "followUp" | "steer";
+};
+type Receipt = {
+  readonly operationId: string;
+  readonly session: SessionId /** False when this operation id was already submitted. */;
+  readonly accepted: boolean;
+};
+type OperationStatus =
+  | {
+      readonly operationId: string;
+      readonly status: "queued";
+    }
+  | {
+      readonly operationId: string;
+      readonly status: "placed";
+    }
+  | {
+      readonly operationId: string;
+      readonly status: "done";
+      readonly text?: string;
+    }
+  | {
+      readonly operationId: string;
+      readonly status: "unanswered";
+      readonly reason?: string;
+    };
+type OperationResult = Extract<
+  OperationStatus,
+  | {
+      status: "done";
+    }
+  | {
+      status: "unanswered";
+    }
+> & {
+  readonly session: SessionId;
+};
+type SessionWatch = {
+  readonly state: SessionState;
+  start(listener: (events: readonly SessionEvent[]) => Promise<void>): void;
+  stop(): Promise<void> /** Settles when the watch ends, stopped or not. */;
+  readonly closed: Promise<void>;
+};
+/** Resume is from state: no event log, no cursors. */
+type SessionState = {
+  /** The active transcript, since the newest reset. */ readonly messages: readonly TranscriptMessage[] /** Operations not settled yet, oldest first. */;
+  readonly pending: readonly OperationStatus[] /** The run in progress, with its in-flight message. */;
+  readonly run?: {
+    readonly operations: readonly string[];
+    /**
+     * The in-flight message so far, as chunks, with parts still streaming
+     * left open. The watch's `chunk` events continue these parts. (The first
+     * draft had a `TranscriptMessage` here, which later chunks could not
+     * continue without showing the message twice.)
+     */
+    readonly partial?: readonly ResponseChunk[];
+  };
+};
+type SessionEvent =
+  | {
+      readonly type: "operation";
+      readonly status: OperationStatus;
+    }
+  | {
+      readonly type: "run-start";
+      readonly operations: readonly string[];
+    }
+  | {
+      readonly type: "run-end";
+      readonly operations: readonly string[];
+    } /** A streamed delta of the in-flight message. Part ids are unique per run. */
+  | {
+      readonly type: "chunk";
+      readonly chunk: ResponseChunk;
+    } /** A message saved to the transcript; replaces any message with its id. */
+  | {
+      readonly type: "message";
+      readonly message: TranscriptMessage;
+    }
+  /**
+   * The context was reset. Not in the first draft: without it a watcher
+   * could not tell the active transcript restarted. Messages that follow
+   * belong to the new context.
+   */
+  | {
+      readonly type: "reset";
+    };
+//#endregion
+export {
+  HarnessSessions as a,
+  OperationStatus as c,
+  SessionId as d,
+  SessionInfo as f,
+  ToolAnswer as g,
+  SubmitOptions as h,
+  HarnessSession as i,
+  Receipt as l,
+  SessionWatch as m,
+  HarnessInput as n,
+  InputPart as o,
+  SessionState as p,
+  HarnessInputFrom as r,
+  OperationResult as s,
+  AgentHarness as t,
+  SessionEvent as u
+};
+//# sourceMappingURL=harness-B6B9S3rb.d.ts.map

package/dist/{images-iiTDSyRu.js → images-Ce9SCu3X.js}

@@ -125,252 +125,6 @@ function normalizeThrownError(error, context) {
 		url: context.url
 	});
 }
-/** Key that per-call options live under in a framework's per-call options bag. */
-const PROVIDER_OPTIONS_KEY = "cloudflare";
-/** The id legs of a fallback list; model objects are their module's business. */
-function idLegs(fallback) {
-	return (fallback ?? []).filter((leg) => typeof leg === "string");
-}
-/** Strips `undefined` values so a later layer never blanks an earlier one. */
-function defined(value) {
-	const result = {};
-	for (const [key, entry] of Object.entries(value)) if (entry !== void 0) result[key] = entry;
-	return result;
-}
-function normalizeGateway(gateway) {
-	if (gateway === void 0) return {};
-	return typeof gateway === "string" ? { id: gateway } : defined(gateway);
-}
-/**
-* Folds one layer's flat gateway sugar into its `gateway` object. The flat key
-* wins over the nested one, and an explicit `undefined` on either never blanks
-* a lower layer.
-*/
-function layerGateway(options) {
-	if (options === void 0) return {};
-	return {
-		...normalizeGateway(options.gateway),
-		...defined({
-			cacheKey: options.cacheKey,
-			cacheTtl: options.cacheTtl,
-			collectLog: options.collectLog,
-			eventId: options.eventId,
-			id: options.id,
-			metadata: options.metadata,
-			requestTimeoutMs: options.requestTimeoutMs,
-			retries: options.retries,
-			skipCache: options.skipCache
-		})
-	};
-}
-/** The flat gateway sugar {@link layerGateway} folds into `gateway`. */
-const FLAT_GATEWAY_KEYS = [
-	"cacheKey",
-	"cacheTtl",
-	"collectLog",
-	"eventId",
-	"gateway",
-	"id",
-	"metadata",
-	"requestTimeoutMs",
-	"retries",
-	"skipCache"
-];
-/**
-* One layer's gateway options as a single object, both spellings folded in.
-* Exported so a module that collapses two option layers into one bag (a
-* fallback leg inheriting a chain's gateway) can merge them field by field
-* rather than replacing one object with the other.
-*
-* @experimental This surface is experimental and may change.
-*/
-function gatewayLayerOf(options) {
-	return layerGateway(options);
-}
-/** An option bag without the gateway keys, whichever spelling they used. */
-function withoutGatewayKeys(options) {
-	const rest = { ...options };
-	for (const key of FLAT_GATEWAY_KEYS) delete rest[key];
-	return defined(rest);
-}
-/**
-* Collapses two option layers into one bag, `override` winning field by field.
-*
-* The gateway keys of both are folded into a single `gateway` object, so
-* neither layer's flat sugar can out-rank the other's nested spelling when the
-* bag is resolved later, and `metadata` merges rather than replaces — the same
-* rules {@link resolveOptions} applies across its three layers.
-*
-* @experimental This surface is experimental and may change.
-*/
-function mergeModelOptions(base, override) {
-	if (base === void 0) return override;
-	if (override === void 0) return base;
-	const layers = [layerGateway(base), layerGateway(override)];
-	const gateway = Object.assign({}, ...layers);
-	const metadata = Object.assign({}, ...layers.map((layer) => layer.metadata));
-	const retries = mergeRetries(layers);
-	const headers = {
-		...base.headers,
-		...override.headers
-	};
-	return {
-		...withoutGatewayKeys(base),
-		...withoutGatewayKeys(override),
-		...Object.keys(headers).length > 0 ? { headers } : {},
-		gateway: {
-			...gateway,
-			...Object.keys(metadata).length > 0 ? { metadata } : {},
-			...retries === void 0 ? {} : { retries }
-		}
-	};
-}
-/**
-* Merges the retry policies field by field, so a provider-wide `backoff` still
-* applies when a call only sets `maxAttempts`. `undefined` on any layer means
-* "not set" and never blanks a lower one.
-*/
-function mergeRetries(layers) {
-	const merged = layers.reduce((result, layer) => ({
-		...result,
-		...layer.retries === void 0 ? {} : defined(layer.retries)
-	}), {});
-	return Object.keys(merged).length > 0 ? merged : void 0;
-}
-/**
-* Merges the option layers. Precedence is per-call
-* (`providerOptions.cloudflare`) > per-model (`ai(id, options)`) >
-* provider (`createAI({ ... })`).
-*
-* The provider layer takes the whole settings object as well as a bare
-* `gateway` value, so `createAI({ binding, id: "prod", cacheTtl: 60 })` reads
-* the same as `createAI({ binding, gateway: { id: "prod", cacheTtl: 60 } })`.
-*
-* @experimental This surface is experimental and may change.
-*/
-function resolveOptions(provider, model, call) {
-	const layers = typeof provider === "string" ? [
-		normalizeGateway(provider),
-		layerGateway(model),
-		layerGateway(call)
-	] : [
-		layerGateway(provider),
-		layerGateway(model),
-		layerGateway(call)
-	];
-	const gateway = Object.assign({}, ...layers);
-	const metadata = Object.assign({}, ...layers.map((layer) => layer.metadata));
-	const retries = mergeRetries(layers);
-	return {
-		chatTemplateKwargs: call?.chatTemplateKwargs ?? model?.chatTemplateKwargs,
-		fallback: idLegs(call?.fallback ?? model?.fallback),
-		gateway: {
-			...gateway,
-			id: gateway.id ?? "default",
-			...Object.keys(metadata).length > 0 ? { metadata } : {},
-			...retries === void 0 ? {} : { retries }
-		},
-		headers: {
-			...model?.headers,
-			...call?.headers
-		},
-		reasoningEffort: call?.reasoningEffort !== void 0 ? call.reasoningEffort : model?.reasoningEffort,
-		sessionAffinity: call?.sessionAffinity ?? model?.sessionAffinity
-	};
-}
-function asRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function asStringRecord(value) {
-	const record = asRecord(value);
-	if (record === void 0) return void 0;
-	const result = {};
-	for (const [key, entry] of Object.entries(record)) if (typeof entry === "string") result[key] = entry;
-	return result;
-}
-function asString(value) {
-	return typeof value === "string" ? value : void 0;
-}
-function asNumber(value) {
-	return typeof value === "number" ? value : void 0;
-}
-function asBoolean(value) {
-	return typeof value === "boolean" ? value : void 0;
-}
-function asReasoningEffort(value) {
-	if (value === null) return null;
-	if (value === "low" || value === "medium" || value === "high") return value;
-}
-/**
-* Metadata values the gateway accepts are scalars only; a nested object or
-* array would be rejected by the binding, so drop those rather than forward
-* them.
-*/
-function asMetadata(value) {
-	const record = asRecord(value);
-	if (record === void 0) return void 0;
-	const result = {};
-	for (const [key, entry] of Object.entries(record)) if (entry === null || typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean") result[key] = entry;
-	return result;
-}
-const BACKOFFS = [
-	"constant",
-	"linear",
-	"exponential"
-];
-/** Reads the retry policy field by field; the binding validates it strictly. */
-function asRetries(value) {
-	const record = asRecord(value);
-	if (record === void 0) return void 0;
-	const maxAttempts = asNumber(record.maxAttempts);
-	const backoff = asString(record.backoff);
-	const retries = defined({
-		backoff: BACKOFFS.find((entry) => entry === backoff),
-		maxAttempts: maxAttempts !== void 0 && Number.isInteger(maxAttempts) && maxAttempts >= 1 && maxAttempts <= 5 ? maxAttempts : void 0,
-		retryDelayMs: asNumber(record.retryDelayMs)
-	});
-	return Object.keys(retries).length > 0 ? retries : void 0;
-}
-/** Reads the shared gateway keys out of a loosely-typed record. */
-function parseGatewayFields(raw) {
-	return defined({
-		cacheKey: asString(raw.cacheKey),
-		cacheTtl: asNumber(raw.cacheTtl),
-		collectLog: asBoolean(raw.collectLog),
-		eventId: asString(raw.eventId),
-		id: asString(raw.id),
-		metadata: asMetadata(raw.metadata),
-		requestTimeoutMs: asNumber(raw.requestTimeoutMs),
-		retries: asRetries(raw.retries),
-		skipCache: asBoolean(raw.skipCache)
-	});
-}
-/**
-* Reads per-call options out of a loosely-typed options bag (the value a
-* framework keeps under {@link PROVIDER_OPTIONS_KEY}).
-*
-* The bag is plain JSON, so every field is read defensively: anything of an
-* unexpected type is dropped rather than thrown, because a malformed
-* observability hint should never fail a generation.
-*
-* @experimental This surface is experimental and may change.
-*/
-function parseModelOptions(value) {
-	const raw = asRecord(value);
-	if (raw === void 0) return void 0;
-	const nested = asRecord(raw.gateway);
-	const gateway = typeof raw.gateway === "string" ? raw.gateway : nested !== void 0 ? parseGatewayFields(nested) : void 0;
-	const fallback = Array.isArray(raw.fallback) ? raw.fallback.filter((entry) => typeof entry === "string") : void 0;
-	return defined({
-		...parseGatewayFields(raw),
-		chatTemplateKwargs: asRecord(raw.chatTemplateKwargs),
-		fallback,
-		gateway,
-		headers: asStringRecord(raw.headers),
-		reasoningEffort: asReasoningEffort(raw.reasoningEffort),
-		sessionAffinity: asString(raw.sessionAffinity)
-	});
-}
 //#endregion
 //#region src/models/core/transport.ts
 /** The reported `url` for a universal call made through the binding. */
@@ -1626,6 +1380,6 @@ function imageMediaTypeOf(base64) {
 	return "image/png";
 }
 //#endregion
-export { resolveOptions as C, isRetryableStatus as D, isAbortError as E, parseModelOptions as S, classifyStatus as T, isGatewayErrorEnvelope as _, normalizeChatCompletion as a, gatewayLayerOf as b, gatewaySlugForBaseUrl as c, resolveGatewayProvider as d, createTransport as f, headersToObject as g, errorFromResponse as h, normalizeChatCompletionsStream as i, isGatewayShapedUrl as l, errorFromGatewayEnvelope as m, imageMediaTypeOf as n, prepareChatCompletionsRequest as o, definedHeaders as p, sseDataStream as r, GATEWAY_PROVIDER_NAMES as s, buildImageInput as t, requireGatewayProvider as u, unwrapEnvelope as v, CloudflareAIError as w, mergeModelOptions as x, PROVIDER_OPTIONS_KEY as y };
+export { isRetryableStatus as S, isGatewayErrorEnvelope as _, normalizeChatCompletion as a, classifyStatus as b, gatewaySlugForBaseUrl as c, resolveGatewayProvider as d, createTransport as f, headersToObject as g, errorFromResponse as h, normalizeChatCompletionsStream as i, isGatewayShapedUrl as l, errorFromGatewayEnvelope as m, imageMediaTypeOf as n, prepareChatCompletionsRequest as o, definedHeaders as p, sseDataStream as r, GATEWAY_PROVIDER_NAMES as s, buildImageInput as t, requireGatewayProvider as u, unwrapEnvelope as v, isAbortError as x, CloudflareAIError as y };
 
-//# sourceMappingURL=images-iiTDSyRu.js.map
+//# sourceMappingURL=images-Ce9SCu3X.js.map