@vinaverse/client 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/index.d.cts

@@ -1,4 +1,5 @@
-export { A as AnswerInput, h as AuthMode, b as CONTRACT, c as Card, d as CardKind, e as ClientErrorCode, j as ClientEvent, C as ClientSecret, k as Connection, l as ConversationEngine, m as ConversationState, F as FetchLike, n as Frame, H as HeldCard, f as HeldQuestion, M as Message, g as Proposal, P as ProposalOutcome, Q as Question, R as Reconnect, o as ServerEvent, p as ServerEventOf, q as ServerEventType, r as SessionEvents, S as SessionInfo, a as SessionOptions, s as SessionStatus, t as SseTarget, T as ToolLine, u as TranscriptItem, v as TurnInput, V as VinaverseClientError, w as VinaverseSession, W as WebSocketFactory, x as WebSocketLike, y as cardActionSse, i as isKnownCard, z as sseFrames, B as turnSse } from './session--W6JXfwo.cjs';
+export { C as CONTRACT } from './contract-Be2oVHNr.cjs';
+export { A as AnswerInput, h as AuthMode, a as Card, d as CardKind, e as ClientErrorCode, j as ClientEvent, k as ClientSecret, l as Connection, m as ConversationEngine, n as ConversationState, F as FetchLike, o as Frame, H as HeldCard, f as HeldQuestion, M as Message, P as Proposal, g as ProposalOutcome, Q as Question, R as Reconnect, S as Schemas, p as ServerEvent, q as ServerEventOf, r as ServerEventType, s as SessionEvents, t as SessionInfo, u as SessionOptions, v as SessionStatus, w as SseTarget, T as ToolLine, x as TranscriptItem, y as TurnInput, V as VinaverseClientError, z as VinaverseSession, B as WebSocketFactory, D as WebSocketLike, E as cardActionSse, G as components, i as isKnownCard, I as operations, J as paths, K as sseFrames, L as turnSse } from './session-D0ijOQX3.cjs';
 
 /**
  * The client secret, checked: an app holds only the session's `vv_cs_` secret, which the tenant's backend got from

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export { A as AnswerInput, h as AuthMode, b as CONTRACT, c as Card, d as CardKind, e as ClientErrorCode, j as ClientEvent, C as ClientSecret, k as Connection, l as ConversationEngine, m as ConversationState, F as FetchLike, n as Frame, H as HeldCard, f as HeldQuestion, M as Message, g as Proposal, P as ProposalOutcome, Q as Question, R as Reconnect, o as ServerEvent, p as ServerEventOf, q as ServerEventType, r as SessionEvents, S as SessionInfo, a as SessionOptions, s as SessionStatus, t as SseTarget, T as ToolLine, u as TranscriptItem, v as TurnInput, V as VinaverseClientError, w as VinaverseSession, W as WebSocketFactory, x as WebSocketLike, y as cardActionSse, i as isKnownCard, z as sseFrames, B as turnSse } from './session--W6JXfwo.js';
+export { C as CONTRACT } from './contract-Be2oVHNr.js';
+export { A as AnswerInput, h as AuthMode, a as Card, d as CardKind, e as ClientErrorCode, j as ClientEvent, k as ClientSecret, l as Connection, m as ConversationEngine, n as ConversationState, F as FetchLike, o as Frame, H as HeldCard, f as HeldQuestion, M as Message, P as Proposal, g as ProposalOutcome, Q as Question, R as Reconnect, S as Schemas, p as ServerEvent, q as ServerEventOf, r as ServerEventType, s as SessionEvents, t as SessionInfo, u as SessionOptions, v as SessionStatus, w as SseTarget, T as ToolLine, x as TranscriptItem, y as TurnInput, V as VinaverseClientError, z as VinaverseSession, B as WebSocketFactory, D as WebSocketLike, E as cardActionSse, G as components, i as isKnownCard, I as operations, J as paths, K as sseFrames, L as turnSse } from './session-D0ijOQX3.js';
 
 /**
  * The client secret, checked: an app holds only the session's `vv_cs_` secret, which the tenant's backend got from

package/dist/index.js

@@ -1,3 +1,4 @@
-export { CONTRACT, ConversationEngine, VinaverseClientError, VinaverseSession, cardActionSse, clientSecret, isKnownCard, sseFrames, turnSse } from './chunk-AWHPWRGT.js';
+export { CONTRACT } from './chunk-D56MNG3E.js';
+export { ConversationEngine, VinaverseClientError, VinaverseSession, cardActionSse, clientSecret, isKnownCard, sseFrames, turnSse } from './chunk-GWLLUOFY.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/runtime-6O0qIPmo.d.cts

@@ -0,0 +1,394 @@
+import { S as SessionRequest, b as ConversationSession, C as ConversationStore, f as ConversationPersistence, a as ConversationOptions } from './store-CxoHwd64.cjs';
+import { S as Schemas, k as ClientSecret } from './session-D0ijOQX3.cjs';
+
+/** Whose conversation: a person (null for a guest), the app's side, the business acted for, and the thread. */
+interface AgentKey {
+    readonly subject: string | null;
+    readonly mode: string;
+    readonly scope?: string | null;
+    /** Default `chat`; a flow of its own (a business setup, say) is another thread. */
+    readonly thread?: string;
+}
+type ScreenContext = Schemas['ScreenContext'];
+/**
+ * Where the person asks from, in the contract's vocabulary (`ScreenContext`: the screen, the entity, the filters): told
+ * to the agent as data (`Session.screen_context`), never as their words. The tenant's backend vouches for it.
+ */
+interface AgentPlace {
+    readonly screen: ScreenContext['screen'];
+    readonly entity?: {
+        readonly type: string;
+        readonly id: string;
+    } | null;
+    readonly filters?: ScreenContext['filters'];
+}
+/** How the person came in: the kit's parts say `launcher` and `ask`; an app adds `deep_link` or its own words. */
+type AgentEntryPoint = 'launcher' | 'ask' | 'deep_link' | (string & Record<never, never>);
+/** What the runtime asks the tenant's backend for: a session, for this key, told this place. */
+interface AgentSessionRequest extends SessionRequest {
+    readonly key: AgentKey;
+    /**
+     * This session creation's id: the same through its retries, so the backend uses it as the gateway's idempotency key
+     * and never opens twice; a new one for every creation (a first open, a resume, continue-here, a rollover). A creation
+     * that could not reach the backend keeps it, and its whole request, for the next try, the person's "try again" too,
+     * for 24 hours. An `unknown_open` answer is final: not retried under it.
+     */
+    readonly openId: string;
+    /** The runtime's `agent`, for a backend that serves more than one. */
+    readonly agent: string | null;
+    readonly place: AgentPlace | null;
+    /**
+     * The place's revision (`ScreenContext.revision`): higher than any the session was told before, and lower than any
+     * `updateContext` after it, so the API keeps the newest place across a session's rollover.
+     */
+    readonly placeRevision: number;
+    /** How the person came in (`launcher`, `ask`, `deep_link`, the app's own words), passed through. */
+    readonly entryPoint: AgentEntryPoint | null;
+}
+/** Why there is no session, typed, so an app never needs sentinel errors of its own. */
+type AgentFailureReason = 
+/** The conversation is over (its session's own end, or a refusal with no finer reason). */
+'ended'
+/** The conversation asked for does not exist for this person (deleted, or never theirs). */
+ | 'not_found'
+/** Past the time the conversation is kept. */
+ | 'expired'
+/** The conversation belongs to another business, mode or agent than the key's. */
+ | 'mismatch'
+/** The conversation's flow is completed; a new one starts when the person asks. */
+ | 'completed'
+/** The person may not act for this business or conversation. */
+ | 'forbidden'
+/** The server holds a newer screen context than the one told (an update, never a session). */
+ | 'conflict'
+/** The backend could not tell whether the session opened: unavailable, never retried, its `openId` kept for support. */
+ | 'unknown_open'
+/** The person's sign-in was refused by the tenant's API. */
+ | 'auth'
+/** The agent is switched off for this tenant, mode or person. */
+ | 'off' | 'rate_limited'
+/** No network, a timeout: retried, then said. */
+ | 'network'
+/** The tenant's API or Vinaverse failed (5xx): retried, then said. */
+ | 'server'
+/** The backend answered with a session the runtime will not use (not wss://, a field missing). */
+ | 'invalid_session' | 'unknown';
+/**
+ * A refusal from the backend, typed: `ended` (the conversation is over; a new one starts only when the person asks) or
+ * `unavailable` with its reason. An error with `retryable: true` (and its `reason`, `network` by default) is waited out
+ * by the retry policy, then said as `unreachable`.
+ */
+declare class AgentRefusal extends Error {
+    readonly kind: 'ended' | 'unavailable';
+    readonly reason: AgentFailureReason;
+    readonly code: string | null;
+    constructor(kind: 'ended' | 'unavailable', options?: {
+        readonly reason?: AgentFailureReason;
+        readonly code?: string;
+        readonly message?: string;
+    });
+}
+interface AgentStatus {
+    readonly available: boolean;
+    /** The floating launcher may show. */
+    readonly launcher: boolean;
+    readonly displayName: string | null;
+    readonly avatarUrl: string | null;
+    readonly features: {
+        readonly history: boolean;
+        readonly memory: boolean;
+        readonly businessAgent: boolean;
+        readonly businessSetup: boolean;
+    };
+}
+/** The status as the backend reads it; what it leaves out is off. */
+interface AgentStatusRead {
+    readonly available: boolean;
+    readonly launcher?: boolean;
+    readonly displayName?: string | null;
+    readonly avatarUrl?: string | null;
+    readonly features?: Partial<AgentStatus['features']>;
+}
+/** The status and where its read stands, so a screen tells "reading" from "could not read". */
+interface AgentStatusState {
+    readonly status: AgentStatus | null;
+    readonly reading: boolean;
+    readonly failed: boolean;
+}
+/** The tenant's backend: the one piece of integration an app writes. */
+interface AgentBackend {
+    /** A session from the tenant's API (it creates it at Vinaverse with its service key), or an `AgentRefusal`. */
+    openSession(request: AgentSessionRequest): Promise<ConversationSession>;
+    /**
+     * A fresh client secret for the same session (before its end): a `ClientSecret` `{ value, expires_at }`, or its
+     * value. A refusal (`session_closed`: the session is over) goes on with the conversation in a new session.
+     */
+    refreshSecret?(sessionId: string): Promise<ClientSecret | string>;
+    /**
+     * The person's place changed while the chat is open: the tenant's backend tells Vinaverse
+     * (`PUT /v1/sessions/{id}/context`). A place cleared (`tell({ place: null })`) comes as `{ screen: 'other' }`.
+     * `revision` only grows for a conversation, across its sessions. A conflict (`decodeBackendFailure`'s
+     * `context_conflict`, or a refusal with reason `conflict`, with the server's `currentRevision`) is sent once more
+     * above it, then said as `moved`. Absent, or refused otherwise, the kit offers a question about the new place.
+     */
+    updateContext?(sessionId: string, place: AgentPlace, revision: number): Promise<void>;
+    /** Whether the agent is offered, and what it can do. Absent: available, nothing extra. */
+    status?(signal?: AbortSignal): Promise<AgentStatusRead>;
+    /** A thumbs on a whole reply; best effort, never an error for the person. */
+    sendFeedback?(feedback: {
+        readonly sessionId: string;
+        readonly turnId: string;
+        readonly rating: AgentRating;
+    }): Promise<void>;
+    /** Sign-out: end the person's open sessions at the tenant's API. */
+    endSessions?(): Promise<void>;
+    /** History's delete: the tenant's API deletes the person's conversation (authenticated, theirs only). */
+    deleteConversation?(conversationId: string): Promise<void>;
+    /**
+     * History: the person's past conversations with the agent, newest activity first, a page at a time (`cursor` from
+     * the page before). The person comes from the backend's authentication, never from here.
+     */
+    listConversations?(query: {
+        readonly mode: string;
+        readonly scope: string | null;
+        readonly agent: string | null;
+        readonly limit?: number;
+        readonly cursor: string | null;
+    }, signal?: AbortSignal): Promise<Schemas['ConversationPage']>;
+    /** History: a past conversation's messages and cards, the newest page first, oldest first within a page. */
+    readConversation?(conversationId: string, page: {
+        readonly limit?: number;
+        readonly cursor: string | null;
+    }, signal?: AbortSignal): Promise<Schemas['TimelinePage']>;
+}
+type AgentRating = 'up' | 'down';
+type AgentFailure = 'ended' | 'unreachable' | 'unavailable';
+type AgentEventType = 'session_opened' | 'session_resumed' | 'session_retried' | 'session_failed' | 'conversation_ended' | 'context_updated' | 'rated' | 'chip_tapped' | 'card_action' | 'target_opened' | 'link_opened' | 'launcher_shown' | 'launcher_opened' | 'launcher_greeted' | 'greeting_closed' | 'message_sent' | 'reply_completed' | 'card_shown';
+/** For the app's analytics: what happened, for which conversation, with nothing the person said. */
+interface AgentEvent {
+    readonly type: AgentEventType;
+    /** The conversation, as a hash of its key (`hashKey`): stable, and never the person's id. */
+    readonly key?: string;
+    readonly sessionId?: string;
+    readonly failure?: AgentFailure;
+    readonly reason?: AgentFailureReason;
+    readonly attempt?: number;
+    readonly turnId?: string;
+    readonly rating?: AgentRating;
+    readonly cardId?: string;
+    readonly kind?: string;
+    /** Where the person opened from (`launcher`, `ask`, `deep_link`, the app's own words). */
+    readonly from?: AgentEntryPoint;
+}
+/** What a UI draws around the store: why there is no session, whether the person moved, the thumbs given. */
+interface AgentConversationState {
+    readonly failure: AgentFailure | null;
+    readonly reason: AgentFailureReason | null;
+    /** The API's own code for the failure (`conversation_expired`, …), when it gave one. */
+    readonly code: string | null;
+    /** The session was told another place than the one the person now asks from, and it could not be told live. */
+    readonly moved: boolean;
+    readonly ratings: ReadonlyMap<string, AgentRating>;
+    readonly sessionId: string | null;
+    /**
+     * The conversation the key holds: the one it continues before a session opens, then its session's. Null for a new
+     * one not yet opened. History's delete compares against it (`deleteConversation` does).
+     */
+    readonly conversationId: string | null;
+    /** The open the backend could not settle (`unknown_open`), for support; null otherwise. */
+    readonly openId: string | null;
+}
+interface AgentConversation {
+    /** The key as a string, for the app's own maps and the events. */
+    readonly key: string;
+    readonly store: ConversationStore;
+    /**
+     * A view attaches: kept, with its connection, while any view is attached. The first time, it starts. Returns the
+     * detach: with no view attached it is suspended (no pings; closed with `closeInBackground`) while its session lives
+     * (`keepAlive: 'session'`), and let go when it has none, is past its end, or `keepAlive` is `'view'`. Separate from the
+     * app's background, which the platform adapter tells the store.
+     */
+    show(open?: {
+        readonly place?: AgentPlace | null;
+        readonly entryPoint?: AgentEntryPoint | null;
+    }): () => void;
+    /**
+     * The place and the way in changed while a view is attached: told live where the backend can, else on the next
+     * session. `undefined` keeps what was told; `null` clears it.
+     */
+    tell(open: {
+        readonly place?: AgentPlace | null;
+        readonly entryPoint?: AgentEntryPoint | null;
+    }): void;
+    getState(): AgentConversationState;
+    subscribe(listener: () => void): () => void;
+    /** Asks for a session again, after the backend could not be reached. */
+    retry(): void;
+    /**
+     * Whether a reply can be rated: one this runtime saw given live. A reply restored from the device or a resumed
+     * transcript cannot be, until the API rates a turn by its conversation; the kits draw no thumbs for it.
+     */
+    canRate(turnId: string): boolean;
+    /** A thumbs on a whole reply, against the session it was given in; a change of mind only is sent again. */
+    rate(turnId: string, rating: AgentRating): void;
+    /**
+     * Sends the person's `text` once in this conversation's life (a chip tapped twice, a retried tap). It is shown as
+     * theirs: only words they typed or tapped, never the app's in their name.
+     */
+    sendOnce(text: string): void;
+}
+/** When the runtime tries the backend again: before each try, a delay; `isRetryable` decides which errors are waited out. */
+interface AgentRetryPolicy {
+    readonly delays: readonly number[];
+    readonly isRetryable?: (error: unknown) => boolean;
+}
+/** The time the runtime judges a session's end by: the server's, when the app has it (a clock synced from responses). */
+interface AgentClock {
+    now(): number;
+}
+interface AgentRuntimeOptions {
+    readonly backend: AgentBackend;
+    /**
+     * The agent this runtime talks to (its id at Vinaverse). It is part of every key, so two agents sharing the device's
+     * storage (`conversation.persistence`) never share a conversation. Default: none (one agent per storage namespace).
+     */
+    readonly agent?: string;
+    /** The store's own options (locale, time zone, deep-link prefixes, transport, persistence, closeInBackground…). */
+    readonly conversation?: Omit<ConversationOptions, 'getSession' | 'refreshSecret' | 'clock'>;
+    /** Default: 500, 1500, 3500 ms, for errors with `retryable: true`; applied to `openSession` and `refreshSecret`. */
+    readonly retry?: AgentRetryPolicy;
+    /** Default: the device's clock. Give the server's: a phone set wrong otherwise reuses a dead session or drops a live one. */
+    readonly clock?: AgentClock;
+    /** `session` (default): kept while its session lives with no view attached; `view`: let go when the last view goes. */
+    readonly keepAlive?: 'session' | 'view';
+    /** How long a status read stays fresh. Default 5 minutes. */
+    readonly statusStaleMs?: number;
+    /**
+     * DANGEROUS: for mocks and local development only. Lets a leg's session address be plaintext (`ws://`, `http://`),
+     * which would carry the person's messages and the session's secret unencrypted. Off by default, whatever transport
+     * the app supplies; outside `__DEV__` the runtime warns once.
+     */
+    readonly insecureAddresses?: AgentInsecureAddresses;
+    readonly onEvent?: (event: AgentEvent) => void;
+    /**
+     * Where the launcher remembers it greeted a person (the app's preferences store). Given here, the launcher reads and
+     * writes it through the runtime (`greetings`), a sign-out fences it, and `erase()` removes it.
+     */
+    readonly greetingStorage?: ConversationPersistence;
+    /**
+     * Keys an earlier version of the app or the kit wrote that no index lists, for a storage with neither `keys` nor
+     * `removePrefix`: removed by every sign-out from `conversation.persistence`, and by `erase()` from `greetingStorage`
+     * too. The migration that makes their removal certain on such a storage.
+     */
+    readonly legacyKeys?: readonly string[];
+    /** Where the runtime's warnings go (the app's logger, crash reporter); default `console.warn`. */
+    readonly onWarning?: (message: string, warning: AgentWarning) => void;
+}
+/**
+ * What a warning is about, for an app's logger to count without reading the message: `insecure_addresses` (a leg let
+ * off the wss:// and https:// check outside development), `callback_threw` (the app's `onEvent` or `onActivity` threw;
+ * `callback` names it), `events_dropped` (the oldest analytics events, while the salt is read).
+ */
+interface AgentWarning {
+    readonly code: 'insecure_addresses' | 'callback_threw' | 'events_dropped';
+    readonly callback?: 'onEvent' | 'onActivity';
+}
+/** The legs whose session address may be plaintext: `realtime` (the WebSocket), `turns` (HTTP). */
+interface AgentInsecureAddresses {
+    readonly realtime?: boolean;
+    readonly turns?: boolean;
+}
+interface AgentRuntime {
+    /** The app's backend, as given: history (`@vinaverse/client/history`) reads its pages through it. */
+    readonly backend: AgentBackend;
+    /** The key's conversation: the same while it lives; a new one after `startNew`, `dispose` or its end. */
+    conversation(key: AgentKey): AgentConversation;
+    /**
+     * The key's conversation as it stands, ending nothing and telling no one: for a render (`useSyncExternalStore`).
+     * One past its session's end is ended when it is next shown, and subscribers then read the key's next one.
+     */
+    peek(key: AgentKey): AgentConversation;
+    /** A new conversation for the key from the person's next opening; the old one is let go and forgotten. */
+    startNew(key: AgentKey): void;
+    /**
+     * Closes the key's conversation now; the next opening continues it in a new session. What the device kept of it and
+     * the conversation it continues stay: `forget` removes them.
+     */
+    dispose(key: AgentKey): void;
+    /**
+     * Closes the key's conversation and forgets it on this device: the conversation it continued and the transcript kept
+     * by `persistence`. History's "delete" calls it after the tenant's backend deleted the conversation.
+     */
+    forget(key: AgentKey): void;
+    /** Ends every conversation no view shows that is past its session's end. The kits call it when the app comes back. */
+    sweep(): void;
+    /**
+     * History's delete: the backend deletes the conversation, then the device forgets it, only where the key still
+     * continues that conversation (an older history entry never forgets the key's newer one).
+     */
+    deleteConversation(key: AgentKey, conversationId: string): Promise<void>;
+    /**
+     * The person's erasure on this device: a sign-out, plus the launcher's greeting records (`greetingStorage`) and the
+     * analytics salt, every key this version and alpha.5 or alpha.6 wrote. Keys no index lists (an earlier version's, a
+     * write lost with its process) are found only when the storage has `keys` or `removePrefix`.
+     */
+    erase(): Promise<void>;
+    /** The launcher's greeting storage, under the sign-out fence; null without `greetingStorage`. */
+    readonly greetings: ConversationPersistence | null;
+    /**
+     * The key goes on with this conversation (history's "Continue"): pinned for the key and opened through the backend's
+     * resume. One that is gone (404, 410: the backend's `AgentRefusal('ended')`) is said as `ended`, never replaced by a
+     * new one silently.
+     */
+    continue(key: AgentKey, conversationId: string): AgentConversation;
+    /**
+     * Every conversation closed and forgotten, and everything this runtime kept on the device (every transcript it ever
+     * wrote under `conversation.persistenceKey`, even of conversations already closed), the status and the name; then
+     * the backend is told to end the sessions at the same time. A late answer from before (a session, a status, a write)
+     * changes nothing. Kept on purpose: the launcher's greeting records and the analytics salt (`erase` takes them).
+     */
+    signOut(): Promise<void>;
+    /** The agent's status, read from the backend at most every `statusStaleMs`. */
+    status(): Promise<AgentStatus>;
+    getStatus(): AgentStatus | null;
+    /**
+     * The status with where its read stands: `reading` while one is out, `failed` when the last one could not be read
+     * (the status held before, if any, stays). One object until it changes, for `useSyncExternalStore`.
+     */
+    getStatusState(): AgentStatusState;
+    /**
+     * Which person's turn it is on this device: a number that changes at every sign-out and erasure. Work begun under an
+     * older one (a history page, a transcript) is dropped when it lands.
+     */
+    epoch(): number;
+    /** The agent's name: from the newest session, else from the status. */
+    getName(): string | null;
+    /** Told when the status or name changes, and when a key's conversation is let go (its next one is another). */
+    subscribe(listener: () => void): () => void;
+    /** An event from a kit or the app, passed to `onEvent`. */
+    emit(event: AgentEvent): void;
+}
+/**
+ * Where the launcher remembers that it greeted a person in a mode, the key its storage sees. Encoded so a guest
+ * (`null`) is never a person whose id is "guest".
+ */
+declare function greetedKey(subject: string | null, mode: string): string;
+/**
+ * A conversation's key as analytics sees it: SHA-256 of the install's salt and the key, 128 bits in hex. Stable per
+ * install (the runtime keeps the salt in the app's storage until `erase()`), never the person's id, and not
+ * recomputable from a guessed id without the salt.
+ */
+declare function hashKey(key: string, salt: string): string;
+/**
+ * The key as a string: one conversation per agent, person, mode, business and thread. Encoded as a JSON array, so no
+ * value can pass for another (a guest is `null`, never a subject named "guest"; a `|` in an id is just a character).
+ */
+declare function agentKey(key: AgentKey, agent?: string | null): string;
+declare function createAgentRuntime(options: AgentRuntimeOptions): AgentRuntime;
+/**
+ * An `AgentRefusal`, also one made by another copy of this package (the mock in `@vinaverse/client/testing`, the
+ * backend helpers in `@vinaverse/client/backend`, a second install): recognised by its name and kind, not its class.
+ */
+declare function isRefusal(error: unknown): error is AgentRefusal;
+
+export { type AgentBackend as A, type AgentClock as a, type AgentConversation as b, type AgentConversationState as c, type AgentEntryPoint as d, type AgentEvent as e, type AgentEventType as f, type AgentFailure as g, type AgentFailureReason as h, type AgentInsecureAddresses as i, type AgentKey as j, type AgentPlace as k, type AgentRating as l, AgentRefusal as m, type AgentRetryPolicy as n, type AgentRuntime as o, type AgentRuntimeOptions as p, type AgentSessionRequest as q, type AgentStatus as r, type AgentStatusRead as s, type AgentStatusState as t, type AgentWarning as u, agentKey as v, createAgentRuntime as w, greetedKey as x, hashKey as y, isRefusal as z };