@lumavox/client 0.0.0-stage → 0.1.1

package/dist/gen/types.gen.d.ts

@@ -0,0 +1,776 @@
+export type ClientOptions = {
+    baseUrl: `${string}://${string}` | (string & {});
+};
+export type ErrorResponse = {
+    error: ErrorInfo;
+};
+export type ErrorInfo = {
+    /**
+     * Machine-readable error category
+     */
+    type: string;
+    /**
+     * Human-readable explanation
+     */
+    message: string;
+    /**
+     * Echo of X-Request-Id — include when reporting issues
+     */
+    request_id: string;
+    /**
+     * Field-level validation errors (422 only)
+     */
+    details?: Array<{
+        [key: string]: string;
+    }> | null;
+};
+export type SessionDetail = {
+    agent_id: string;
+    created_at: string;
+    /**
+     * Who this conversation is with. Send it again to open another conversation with the same person, carrying their memory.
+     */
+    end_user_id: string;
+    id: string;
+    /**
+     * The conversation so far, oldest first.
+     *
+     * **The most recent 50 by default**, not the whole transcript — a long conversation is not something a caller can be handed in one response. `next_before` says whether there are older ones and how to reach them; `limit` on `GET /v1/agent/sessions/{session_id}` raises or lowers the page, up to 200.
+     *
+     * **Empty on a new conversation, including for an agent that has an opening line**. The opening line — generated or scripted — is the first turn on `/v1/agent/stream`, so it is written when a client connects rather than when the session is created. Opening a session makes no model call and no speech call of any kind.
+     */
+    messages: Array<MessageInfo>;
+    /**
+     * Pass as `before` on `GET /v1/agent/sessions/{session_id}` to read the page of **older** messages.
+     *
+     * Null when `messages` reaches the beginning of the conversation — so paging is `while (next_before) fetch(before: next_before)` and never ends on an empty page.
+     *
+     * It is a `seq`, the position of the oldest message returned, and `before` is exclusive. Positions are sparse — a conversation greeted twice has a gap — so nothing that counts rows can be substituted for it.
+     */
+    next_before?: number | null;
+    /**
+     * How this agent stands with this person, as the conversation opens.
+     *
+     * **Null when the agent has `relation_enabled` off**, which is not the same as "they have no history": the counters run for every pair regardless, and returning one for an agent that keeps none would show a relationship the model is not being told about.
+     *
+     * It belongs to the **person**, not the conversation, so it carries across every session with the same `end_user_id`. Here so that rendering it at conversation start needs no second call; `GET /v1/agent/relations` is still how you read it any other time, and the socket's `relation` event is how you learn it moved mid-turn — which is rare, and is the only time it changes.
+     */
+    relation?: RelationInfo | null;
+    /**
+     * True when this is a conversation that already existed rather than a new one — see `resume` on the request.
+     *
+     * Worth branching on: a resumed session arrives with its `messages` already populated and its `turn_seq` past zero, so a client that assumed an empty transcript will render nothing until the next turn.
+     */
+    resumed?: boolean;
+    title: string | null;
+    turn_seq: number;
+    updated_at: string;
+};
+export type MessageInfo = {
+    content: string;
+    created_at: string;
+    id: string;
+    /**
+     * On a reply: what the agent looked up in its knowledge for it — each lookup's query, outcome and the entries it found, with their scores. Null when nothing was looked up.
+     */
+    knowledge?: MessageKnowledge | null;
+    /**
+     * How the agent said it felt when it wrote this reply, when the agent reports moods. Null on user messages, on agents with emotion off, and on any reply where the model did not report a usable one.
+     */
+    mood?: string | null;
+    /**
+     * How strongly, 0 to 1. Null when the model gave a label without a number — the label is the half it gets right.
+     */
+    mood_intensity?: number | null;
+    /**
+     * `user` or `assistant`.
+     */
+    role: string;
+};
+export type MessageKnowledge = {
+    lookups?: Array<KnowledgeLookupInfo>;
+    /**
+     * How the agent read its knowledge on this turn: `lookup` or `prompt`.
+     */
+    mode: string;
+};
+export type KnowledgeLookupInfo = {
+    hits?: Array<KnowledgeCitation>;
+    /**
+     * `found`, `none` (nothing relevant enough), or `failed` (the lookup itself could not be done).
+     */
+    outcome: string;
+    query: string;
+    /**
+     * `first` — looked up before the reply; `tool` — the model asked for it.
+     */
+    via: string;
+};
+export type KnowledgeCitation = {
+    entry_id: string;
+    score: number;
+    title: string;
+};
+export type RelationInfo = {
+    agent_id: string;
+    /**
+     * The agent's name, so a list of these is readable without resolving ids.
+     */
+    agent_name: string | null;
+    /**
+     * Separate sessions, ever. A stronger signal of familiarity than `turns` — twenty short visits is a longer acquaintance than one long conversation.
+     */
+    conversations: number;
+    /**
+     * How much the agent has told **them** about itself, -1 to 1 — the asymmetric half of knowing each other, and the one nothing can count.
+     *
+     * Deliberately not part of `tier`: an agent can have opened up to somebody it has come to dislike, and folding this into affection would make that state unrepresentable.
+     */
+    disclosure: number;
+    /**
+     * The person, as `eu_...`.
+     */
+    end_user_id: string;
+    first_met_at?: string | null;
+    last_seen_at?: string | null;
+    /**
+     * One line the model wrote about them. **Replaced, not appended** — it is rendered into every future prompt for this pair, so it is bounded by design.
+     */
+    note?: string | null;
+    /**
+     * How many times the model has recorded a change. Zero on a long history means the tool is not being called, which is the first thing to check when a relationship is not moving.
+     */
+    recorded: number;
+    /**
+     * The relationship as the model is told it — bands and counted phrases, never numbers. **Empty string** when there is nothing worth saying yet, in which case nothing about them is added to the prompt at all — which is a real state and not a missing value.
+     */
+    summary: string;
+    /**
+     * What the agent would call this relationship, and what it is actually told: **Despised, Disliked, Acquaintances, Friends** or **Good Friends**.
+     *
+     * Derived on every read from the axes below and never stored, so it cannot go stale. The rule is one sentence: *warmth and trust set the direction, familiarity sets how far it can go* — a first conversation caps at Acquaintances however well it went, and the ceiling rises as they talk. Dislike is not capped: an agent can take against somebody on one remark.
+     */
+    tier: string;
+    /**
+     * -1 to 1, on the same scale.
+     */
+    trust: number;
+    /**
+     * Turns exchanged, ever. Counted, not judged.
+     */
+    turns: number;
+    /**
+     * -1 to 1. Zero is indifference, which is where every relationship starts.
+     */
+    warmth: number;
+};
+export type SessionCreateRequest = {
+    /**
+     * Which agent this conversation is with.
+     */
+    agent_id: string;
+    /**
+     * Optional, and only ever the token's own end user — their id from `POST /v1/end-users`, or your own id for them.
+     *
+     * **A conversation is always the person the ephemeral token was minted for**: the token says who is talking, so this can only confirm it, and naming anybody else is a **403**. What the agent remembers about them — durable facts and the standing relationship — is theirs, and carries into every conversation with any of your agents.
+     *
+     * Set once, when the session opens. It cannot change afterwards.
+     */
+    end_user_id?: string | null;
+    /**
+     * Whether to continue this person's most recent conversation with this agent instead of starting a new one.
+     *
+     * **Unset is the useful default**: it resumes when this person has a conversation with this agent from the last 7 days to continue, and starts a new one otherwise. That matches what 'open a conversation with this person' usually means, and it stops an integration that opens a session per page load from scattering somebody's history across a dozen fragments.
+     *
+     * `false` always starts a new conversation — this is what a 'new chat' button should send. `true` is the same as leaving it unset; it exists so the intent can be stated rather than implied.
+     *
+     * Nothing is lost by starting fresh: durable facts and the standing relationship belong to the *person*, not the conversation, and are carried into every new one.
+     *
+     * The response's `resumed` says which happened.
+     */
+    resume?: boolean | null;
+    /**
+     * Optional label.
+     */
+    title?: string | null;
+};
+export type SessionInfo = {
+    agent_id: string;
+    created_at: string;
+    /**
+     * Who this conversation is with. Send it again to open another conversation with the same person, carrying their memory.
+     */
+    end_user_id: string;
+    id: string;
+    title: string | null;
+    turn_seq: number;
+    updated_at: string;
+};
+export type CompactionInfo = {
+    /**
+     * The last message this summary covers. Anything after it is still sent to the model verbatim.
+     */
+    after_seq: number;
+    /**
+     * Durable facts written to long-term memory by this call. Zero when extraction was not asked for, or when there was nothing worth keeping.
+     */
+    facts_stored?: number;
+    input_tokens?: number | null;
+    /**
+     * What produced the summary.
+     */
+    model?: string | null;
+    output_tokens?: number | null;
+    session_id: string;
+    /**
+     * What the next turn will start from.
+     */
+    summary: string;
+    /**
+     * `manual` or `automatic`.
+     */
+    trigger: string;
+};
+export type CompactRequest = {
+    /**
+     * Whether to also extract durable facts about the end user, in the same model call.
+     *
+     * Unset uses the agent's own setting.
+     */
+    extract_facts?: boolean | null;
+};
+export type FactList = {
+    end_user_id: string;
+    facts: Array<FactInfo>;
+};
+export type FactInfo = {
+    /**
+     * Which agent was being talked to when this was learned.
+     */
+    agent_id?: string | null;
+    created_at?: string | null;
+    id: string;
+    text: string;
+    updated_at?: string | null;
+};
+export type ForgottenFacts = {
+    deleted: number;
+    end_user_id: string;
+};
+export type RelationList = {
+    relations: Array<RelationInfo>;
+    /**
+     * Relations matching the filter, ignoring `limit`. Larger than the list means it was truncated — this endpoint returns the most recently active first and has no cursor, so narrow by `end_user_id` rather than paging if you are looking for somebody specific.
+     */
+    total: number;
+};
+export type ListSessionsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number | null;
+    };
+    url: '/v1/agent/sessions';
+};
+export type ListSessionsErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * The token is valid but its scopes do not cover this capability
+     */
+    403: ErrorResponse;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+};
+export type ListSessionsError = ListSessionsErrors[keyof ListSessionsErrors];
+export type ListSessionsResponses = {
+    /**
+     * Conversations for this agent or end user, newest first
+     */
+    200: Array<SessionInfo>;
+};
+export type ListSessionsResponse = ListSessionsResponses[keyof ListSessionsResponses];
+export type CreateSessionData = {
+    body: SessionCreateRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/agent/sessions';
+};
+export type CreateSessionErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * An ephemeral token, for an agent or person it is not bound to
+     */
+    403: unknown;
+    /**
+     * Unknown agent id
+     */
+    404: unknown;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+};
+export type CreateSessionError = CreateSessionErrors[keyof CreateSessionErrors];
+export type CreateSessionResponses = {
+    /**
+     * The conversation — new or continued, per `resumed`
+     */
+    201: SessionDetail;
+};
+export type CreateSessionResponse = CreateSessionResponses[keyof CreateSessionResponses];
+export type DeleteSessionData = {
+    body?: never;
+    path: {
+        session_id: string;
+    };
+    query?: never;
+    url: '/v1/agent/sessions/{session_id}';
+};
+export type DeleteSessionErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * The token is valid but its scopes do not cover this capability
+     */
+    403: ErrorResponse;
+    /**
+     * Unknown session id
+     */
+    404: unknown;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+};
+export type DeleteSessionError = DeleteSessionErrors[keyof DeleteSessionErrors];
+export type DeleteSessionResponses = {
+    /**
+     * The session and its messages are gone
+     */
+    200: SessionInfo;
+};
+export type DeleteSessionResponse = DeleteSessionResponses[keyof DeleteSessionResponses];
+export type GetSessionDetailData = {
+    body?: never;
+    path: {
+        session_id: string;
+    };
+    query?: {
+        /**
+         * How many messages to return, counting back from the newest. The page itself is ordered oldest-first regardless.
+         */
+        limit?: number;
+        /**
+         * Return only messages before this `seq`, exclusive. Take it from the previous response's `next_before`.
+         */
+        before?: number | null;
+    };
+    url: '/v1/agent/sessions/{session_id}';
+};
+export type GetSessionDetailErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * The token is valid but its scopes do not cover this capability
+     */
+    403: ErrorResponse;
+    /**
+     * Unknown session id
+     */
+    404: unknown;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+};
+export type GetSessionDetailError = GetSessionDetailErrors[keyof GetSessionDetailErrors];
+export type GetSessionDetailResponses = {
+    /**
+     * The conversation and one page of its messages
+     */
+    200: SessionDetail;
+};
+export type GetSessionDetailResponse = GetSessionDetailResponses[keyof GetSessionDetailResponses];
+export type CompactData = {
+    body: CompactRequest;
+    path: {
+        session_id: string;
+    };
+    query?: never;
+    url: '/v1/agent/sessions/{session_id}/compact';
+};
+export type CompactErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * The token is valid but its scopes do not cover this capability
+     */
+    403: ErrorResponse;
+    /**
+     * Unknown session id
+     */
+    404: unknown;
+    /**
+     * A turn was processed while this was running
+     */
+    409: unknown;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+    /**
+     * The model provider failed or timed out
+     */
+    502: unknown;
+    /**
+     * GEMINI_API_KEY is not configured
+     */
+    503: unknown;
+};
+export type CompactError = CompactErrors[keyof CompactErrors];
+export type CompactResponses = {
+    /**
+     * The summary that replaced the turns it covers
+     */
+    200: CompactionInfo;
+};
+export type CompactResponse = CompactResponses[keyof CompactResponses];
+export type ExtractData = {
+    body?: never;
+    path: {
+        session_id: string;
+    };
+    query?: never;
+    url: '/v1/agent/sessions/{session_id}/extract';
+};
+export type ExtractErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * The token is valid but its scopes do not cover this capability
+     */
+    403: ErrorResponse;
+    /**
+     * Unknown session id
+     */
+    404: unknown;
+    /**
+     * A turn was processed while this was running
+     */
+    409: unknown;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+    /**
+     * The model provider failed or timed out
+     */
+    502: unknown;
+    /**
+     * GEMINI_API_KEY is not configured
+     */
+    503: unknown;
+};
+export type ExtractError = ExtractErrors[keyof ExtractErrors];
+export type ExtractResponses = {
+    /**
+     * The facts pulled out of the conversation and stored
+     */
+    200: CompactionInfo;
+};
+export type ExtractResponse = ExtractResponses[keyof ExtractResponses];
+export type ForgetUserFactsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        end_user_id?: string;
+    };
+    url: '/v1/agent/facts';
+};
+export type ForgetUserFactsErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * The token is valid but its scopes do not cover this capability
+     */
+    403: ErrorResponse;
+    /**
+     * Unknown end user id
+     */
+    404: unknown;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+};
+export type ForgetUserFactsError = ForgetUserFactsErrors[keyof ForgetUserFactsErrors];
+export type ForgetUserFactsResponses = {
+    /**
+     * How many stored facts were deleted
+     */
+    200: ForgottenFacts;
+};
+export type ForgetUserFactsResponse = ForgetUserFactsResponses[keyof ForgetUserFactsResponses];
+export type ListFactsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        end_user_id?: string;
+    };
+    url: '/v1/agent/facts';
+};
+export type ListFactsErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * The token is valid but its scopes do not cover this capability
+     */
+    403: ErrorResponse;
+    /**
+     * Unknown end user id
+     */
+    404: unknown;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+};
+export type ListFactsError = ListFactsErrors[keyof ListFactsErrors];
+export type ListFactsResponses = {
+    /**
+     * What the platform remembers about this end user
+     */
+    200: FactList;
+};
+export type ListFactsResponse = ListFactsResponses[keyof ListFactsResponses];
+export type ForgetFactData = {
+    body?: never;
+    path: {
+        fact_id: string;
+    };
+    query?: never;
+    url: '/v1/agent/facts/{fact_id}';
+};
+export type ForgetFactErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * The token is valid but its scopes do not cover this capability
+     */
+    403: ErrorResponse;
+    /**
+     * No such fact for this organisation
+     */
+    404: unknown;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+};
+export type ForgetFactError = ForgetFactErrors[keyof ForgetFactErrors];
+export type ForgetFactResponses = {
+    /**
+     * The fact is gone
+     */
+    200: ForgottenFacts;
+};
+export type ForgetFactResponse = ForgetFactResponses[keyof ForgetFactResponses];
+export type ListRelationsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        agent_id?: string;
+        end_user_id?: string;
+        limit?: number | null;
+    };
+    url: '/v1/agent/relations';
+};
+export type ListRelationsErrors = {
+    /**
+     * Validation Exception
+     */
+    400: {
+        status_code: number;
+        detail: string;
+        extra?: {
+            [key: string]: unknown;
+        } | Array<unknown> | null;
+    };
+    /**
+     * Missing or invalid API token
+     */
+    401: ErrorResponse;
+    /**
+     * The token is valid but its scopes do not cover this capability
+     */
+    403: ErrorResponse;
+    /**
+     * Unknown agent id, or unknown end user id
+     */
+    404: unknown;
+    /**
+     * Request failed validation
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+};
+export type ListRelationsError = ListRelationsErrors[keyof ListRelationsErrors];
+export type ListRelationsResponses = {
+    /**
+     * How the agent feels about each person, most recent first
+     */
+    200: RelationList;
+};
+export type ListRelationsResponse = ListRelationsResponses[keyof ListRelationsResponses];