@newheap/platform-ai-chat 0.8.1 → 0.10.0

package/agent-runs/index.d.ts

@@ -0,0 +1,384 @@
+import * as _angular_core from '@angular/core';
+import * as _newheap_platform_ai_chat from '@newheap/platform-ai-chat';
+import { AgentProposal, AgentThreadLookup, AgentTriggerReceipt, NhAssistantError, AgentProposalDecisionRight, AgentProposalFeedback, AgentProposalDecision, AgentExecutionResolution, AgentSubjectRole, AgentRun, AgentRunRetryMode, AgentThreadMemory, AgentArtifact, AgentConsultation, AgentSubjectWork, AgentSubjectWorkAgent } from '@newheap/platform-ai-chat';
+
+/**
+ * The approval inbox: pending agent proposals across subjects that the signed-in person may
+ * decide, earliest expiry first. Proposals are decided in place, one by one or together; the
+ * server checks each decision against the proposal's approval policy again. After a rejection the
+ * inbox asks, optionally, what was wrong, also when the rejected proposals have left the list.
+ * With live updates the inbox reloads by itself when agent work changes, for example when a
+ * colleague decided a proposal or a run proposed a new one. A proposal that closes because it no
+ * longer fits, for example because someone did the work by hand, stays as a closed card with the
+ * reason until it is dismissed.
+ */
+declare class NhAssistantAgentInboxComponent {
+    private readonly api;
+    private readonly proposalList;
+    private subscription?;
+    /** Limits the inbox to one agent. */
+    readonly agentId: _angular_core.InputSignal<string | undefined>;
+    /** Limits the inbox to one kind of subject, for example `project`. */
+    readonly subjectType: _angular_core.InputSignal<string | undefined>;
+    readonly itemsPerPage: _angular_core.InputSignal<number>;
+    readonly page: _angular_core.WritableSignal<number>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** True after the first successful load; later loads keep the list, and an open feedback question, in place. */
+    readonly loaded: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    readonly items: _angular_core.WritableSignal<AgentProposal[]>;
+    readonly total: _angular_core.WritableSignal<number>;
+    readonly pages: _angular_core.Signal<number>;
+    constructor();
+    load(): void;
+    goTo(page: number): void;
+    /**
+     * Reloads after a live update. Once the inbox is shown it reloads quietly: no loading state, and
+     * a failure keeps the list and an open feedback question in place. While a decision of the list
+     * is in flight it waits, because the decision reloads the inbox when it ends.
+     */
+    private refresh;
+    private fetch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentInboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentInboxComponent, "nh-assistant-agent-inbox", never, { "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "subjectType": { "alias": "subjectType"; "required": false; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NhAssistantAgentThreadTab = 'proposals' | 'runs' | 'consultations' | 'memory' | 'artifacts';
+/**
+ * The agent's work on one subject, for example an "Intake review" tab on a project page: the
+ * caller's role, a start action for participants, and the thread's proposals, runs, consultations
+ * by other assistants, working memory and files. Everything follows the caller's live role on the
+ * subject. With live updates the view reloads by itself when the thread's runs, proposals or
+ * feedback change, also when a colleague decided elsewhere.
+ */
+declare class NhAssistantAgentThreadViewComponent {
+    private readonly api;
+    private readonly proposalList;
+    private subscription?;
+    private proposalSubscription?;
+    private startSubscription?;
+    readonly agentId: _angular_core.InputSignal<string>;
+    readonly subjectType: _angular_core.InputSignal<string>;
+    readonly subjectId: _angular_core.InputSignal<string>;
+    /** Emits the thread's conversation id, so the host can open it in the assistant panel. */
+    readonly openConversation: _angular_core.OutputEmitterRef<string>;
+    readonly tab: _angular_core.WritableSignal<NhAssistantAgentThreadTab>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    readonly lookup: _angular_core.WritableSignal<AgentThreadLookup | null>;
+    readonly proposals: _angular_core.WritableSignal<AgentProposal[]>;
+    readonly message: _angular_core.WritableSignal<string>;
+    readonly starting: _angular_core.WritableSignal<boolean>;
+    readonly receipt: _angular_core.WritableSignal<AgentTriggerReceipt | null>;
+    readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly errorKeys: _angular_core.Signal<string[]>;
+    readonly thread: _angular_core.Signal<_newheap_platform_ai_chat.AgentThread | null>;
+    readonly role: _angular_core.Signal<_newheap_platform_ai_chat.AgentSubjectRole>;
+    readonly tabs: readonly NhAssistantAgentThreadTab[];
+    constructor();
+    load(): void;
+    loadProposals(): void;
+    onMessage(event: Event): void;
+    start(): void;
+    /**
+     * Whether a live update is about this view: its own thread, or, before the subject has a thread,
+     * a run that may have started it.
+     */
+    private concerns;
+    /**
+     * Reloads after a live update. Once the thread is shown it reloads quietly: no loading state, and
+     * a failure keeps what is shown, including an open feedback question. While a decision of the
+     * proposal list is in flight only the thread reloads, because the decision reloads the proposals
+     * when it ends.
+     */
+    private refresh;
+    private fetch;
+    private fetchProposals;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentThreadViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentThreadViewComponent, "nh-assistant-agent-thread-view", never, { "agentId": { "alias": "agentId"; "required": true; "isSignal": true; }; "subjectType": { "alias": "subjectType"; "required": true; "isSignal": true; }; "subjectId": { "alias": "subjectId"; "required": true; "isSignal": true; }; }, { "openConversation": "openConversation"; }, never, never, true, never>;
+}
+
+/** A feedback question: after a rejection above the list, or from a card's own action. */
+interface NhAssistantFeedbackRequest {
+    approvalIds: string[];
+    initial: AgentProposalFeedback | null;
+    placement: 'prompt' | 'card';
+    /** What was rejected, for a single rejection. */
+    summary: string | null;
+    /** The feedback was stored; the panel thanks the person until the next action. */
+    saved: boolean;
+}
+/**
+ * A list of agent proposals with their decision and execution state. People who may decide see
+ * approve and reject on pending proposals and the resolution of an execution with an unknown
+ * outcome; the server checks every decision again. With `selectable`, pending proposals can be
+ * approved or rejected together. Deciding takes one action. After a rejection the list asks,
+ * optionally and above the list, what was wrong; closed proposals keep a low-key action to give or
+ * change that feedback later. With `decisionRights` each proposal has its own right, for example
+ * from the agent work on a subject, and a pending proposal the viewer may not decide says who does.
+ * A proposal that no longer fits, for example because a person already did the work, shows why.
+ * With `holdClosedCards`, a list of open proposals keeps such a proposal, or one a newer proposal
+ * replaced, as a closed card when it closes while shown, or when an approval is refused because of
+ * it, until the person dismisses it. It reads those proposals by id with one lookup, never through
+ * their threads.
+ */
+declare class NhAssistantAgentProposalsComponent {
+    private readonly api;
+    private readonly host;
+    private readonly injector;
+    private subscription?;
+    readonly proposals: _angular_core.InputSignal<AgentProposal[]>;
+    /** Whether the caller may decide: an approver of the subjects or the inbox owner. */
+    readonly canDecide: _angular_core.InputSignal<boolean>;
+    /**
+     * The caller's live right per proposal, by approval id, for example from
+     * `AgentSubjectWork.openProposals`. A proposal with a right uses it instead of `canDecide`.
+     */
+    readonly decisionRights: _angular_core.InputSignal<ReadonlyMap<string, AgentProposalDecisionRight> | null>;
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    /**
+     * Keeps proposals that close as stale or are replaced while shown as closed cards with their
+     * explanation until they are dismissed. For lists of open proposals, which drop a proposal once
+     * it closes.
+     */
+    readonly holdClosedCards: _angular_core.InputSignal<boolean>;
+    /** Emits after a proposal or its feedback changed, so the host reloads its list. */
+    readonly changed: _angular_core.OutputEmitterRef<void>;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly selected: _angular_core.WritableSignal<ReadonlySet<string>>;
+    readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly errorKeys: _angular_core.Signal<string[]>;
+    /** Pending proposals the caller may decide. */
+    readonly pending: _angular_core.Signal<AgentProposal[]>;
+    readonly allSelected: _angular_core.Signal<boolean>;
+    /** The feedback question. It does not depend on `proposals`, which drop rejected proposals in the inbox. */
+    readonly feedback: _angular_core.WritableSignal<NhAssistantFeedbackRequest | null>;
+    /** Proposals that closed as stale while shown, kept until dismissed; newest first. */
+    readonly held: _angular_core.WritableSignal<AgentProposal[]>;
+    /** The held closed cards first, then the proposals the host gave. */
+    readonly shown: _angular_core.Signal<AgentProposal[]>;
+    private readonly lookups;
+    constructor();
+    /**
+     * The translation key of a proposal's status: the kind of a stale proposal, "replaced" for a
+     * superseded one, otherwise its status.
+     */
+    statusKey(proposal: AgentProposal): string;
+    /** True when the newer proposal that replaced this one is in the list. */
+    hasSuccessor(proposal: AgentProposal): boolean;
+    /** Moves focus to the newer proposal that replaced this one. */
+    showSuccessor(proposal: AgentProposal): void;
+    /** True for a closed card the list keeps until it is dismissed. */
+    isHeld(proposal: AgentProposal): boolean;
+    /** Removes a closed card. */
+    dismiss(proposal: AgentProposal): void;
+    /**
+     * Called by a host of open proposals after a live update replaced `previous` with `next`: keeps
+     * the shown pending proposals that left the list because they closed as stale or were replaced.
+     */
+    holdClosed(previous: readonly AgentProposal[], next: readonly AgentProposal[]): void;
+    /** Whether the caller may decide this proposal: its own right when one was given, otherwise `canDecide`. */
+    mayDecide(proposal: AgentProposal): boolean;
+    /**
+     * Who decides a pending proposal that has a right the caller lacks: another approver when
+     * four-eyes keeps out the person who started the work, otherwise an approver.
+     */
+    waitingForKey(proposal: AgentProposal): string | null;
+    toggle(proposal: AgentProposal): void;
+    toggleAll(): void;
+    decide(proposal: AgentProposal, decision: AgentProposalDecision): void;
+    decideSelected(decision: AgentProposalDecision): void;
+    resolve(proposal: AgentProposal, action: AgentExecutionResolution): void;
+    /** Opens the feedback question in the card of a closed proposal, with the caller's own feedback. */
+    giveFeedback(proposal: AgentProposal): void;
+    /** True while the feedback question for this proposal is open, above the list or in its card. */
+    isAsking(proposal: AgentProposal): boolean;
+    /** True when the card of this proposal shows the feedback question or its thanks. */
+    inCard(proposal: AgentProposal): boolean;
+    /** Keeps the panel, which now thanks the person, and lets the host reload the proposals. */
+    onFeedbackSaved(): void;
+    /** Closes the question; from a card, focus returns to the card's feedback action. */
+    onFeedbackDismissed(): void;
+    private ask;
+    /**
+     * Reads `proposals` again by id and keeps those that closed as stale or were replaced as closed
+     * cards, with their kind and explanation or their successor.
+     */
+    private holdStale;
+    private run;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentProposalsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentProposalsComponent, "nh-assistant-agent-proposals", never, { "proposals": { "alias": "proposals"; "required": true; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionRights": { "alias": "decisionRights"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "holdClosedCards": { "alias": "holdClosedCards"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+/**
+ * The runs of an agent thread, newest first: trigger, status, failure, usage, proposals and the
+ * summary the next run starts from. Participants cancel an open run; approvers resume or restart
+ * a failed or cancelled one. With live updates it reloads by itself when a run or proposal of the
+ * thread changes.
+ */
+declare class NhAssistantRunTimelineComponent {
+    private readonly api;
+    private subscription?;
+    private actionSubscription?;
+    readonly conversationId: _angular_core.InputSignal<string>;
+    readonly role: _angular_core.InputSignal<AgentSubjectRole>;
+    /** Emits after a run was cancelled or retried. */
+    readonly changed: _angular_core.OutputEmitterRef<void>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    readonly runs: _angular_core.WritableSignal<AgentRun[]>;
+    readonly busyRunId: _angular_core.WritableSignal<string | null>;
+    readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly errorKeys: _angular_core.Signal<string[]>;
+    readonly canCancel: _angular_core.Signal<boolean>;
+    readonly canRetry: _angular_core.Signal<boolean>;
+    constructor();
+    load(): void;
+    isOpen(run: AgentRun): boolean;
+    canRetryRun(run: AgentRun): boolean;
+    cancel(run: AgentRun): void;
+    retry(run: AgentRun, mode: AgentRunRetryMode): void;
+    private act;
+    /** A quiet load, after a live update, shows no loading state and keeps the runs when it fails. */
+    private fetch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantRunTimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantRunTimelineComponent, "nh-assistant-run-timeline", never, { "conversationId": { "alias": "conversationId"; "required": true; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+/**
+ * The working memory of an agent about the subject of a thread, read-only. The agent keeps it
+ * up to date itself; it is shown so that people can see what the agent remembers. With live
+ * updates it reloads by itself when a run of the thread changes.
+ */
+declare class NhAssistantAgentMemoryComponent {
+    private readonly api;
+    private subscription?;
+    readonly conversationId: _angular_core.InputSignal<string>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    readonly memory: _angular_core.WritableSignal<AgentThreadMemory | null>;
+    readonly formatted: _angular_core.Signal<string | null>;
+    constructor();
+    load(): void;
+    /** A quiet load, after a live update, shows no loading state and keeps the memory when it fails. */
+    private fetch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentMemoryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentMemoryComponent, "nh-assistant-agent-memory", never, { "conversationId": { "alias": "conversationId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The files the agent's tools saved in a thread, every version newest first. Files of the
+ * agent's own grant that the viewer may not read are listed as shielded and cannot be downloaded.
+ * With live updates the list reloads by itself when a run or proposal of the thread changes.
+ */
+declare class NhAssistantAgentArtifactsComponent {
+    private readonly api;
+    private readonly document;
+    private subscription?;
+    readonly conversationId: _angular_core.InputSignal<string>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    readonly downloadFailed: _angular_core.WritableSignal<boolean>;
+    readonly artifacts: _angular_core.WritableSignal<AgentArtifact[]>;
+    readonly downloadingId: _angular_core.WritableSignal<string | null>;
+    constructor();
+    load(): void;
+    download(artifact: AgentArtifact): Promise<void>;
+    /** A quiet load, after a live update, shows no loading state and keeps the files when it fails. */
+    private fetch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentArtifactsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentArtifactsComponent, "nh-assistant-agent-artifacts", never, { "conversationId": { "alias": "conversationId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Who consulted the thread's agent through another assistant, newest first: the person whose rights
+ * were used, the asking assistant, the outcome, the usage and the proposals left for approvers. The
+ * question and the answer stay in the asking conversation and are never shown here. With live
+ * updates the list reloads by itself when a run or proposal of the thread changes.
+ */
+declare class NhAssistantAgentConsultationsComponent {
+    private readonly api;
+    private subscription?;
+    readonly conversationId: _angular_core.InputSignal<string>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    readonly consultations: _angular_core.WritableSignal<AgentConsultation[]>;
+    readonly total: _angular_core.WritableSignal<number>;
+    constructor();
+    load(): void;
+    /** A quiet load, after a live update, shows no loading state and keeps the list when it fails. */
+    private fetch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentConsultationsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentConsultationsComponent, "nh-assistant-agent-consultations", never, { "conversationId": { "alias": "conversationId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** The outcome of starting one agent on the subject. */
+interface NhAssistantStartedAgent {
+    agentId: string;
+    receipt: AgentTriggerReceipt;
+}
+/**
+ * The agent work on one subject of the application, for example in a project's dialog: the open
+ * proposals of every agent on the subject with the viewer's own decision right, including who
+ * decides when the viewer may not and the optional question after a rejection, and per agent the
+ * conversation about the subject and, for participants, a start action. `agentId` names the agent
+ * whose conversation the host offers also before it worked on the subject. With live updates the
+ * view reloads by itself when agent work on its subject changes; a proposal that closes because it
+ * no longer fits stays as a closed card with the reason until it is dismissed. Opening a
+ * conversation uses `NhAssistantPanelService.openSubject` and emits `conversationOpened` afterwards.
+ */
+declare class NhAssistantSubjectSuggestionsComponent {
+    private readonly api;
+    private readonly panel;
+    private readonly store;
+    private readonly proposalList;
+    private subscription?;
+    private startSubscription?;
+    private destroyed;
+    /** The application's kind of subject, for example `project`. */
+    readonly subjectType: _angular_core.InputSignal<string>;
+    readonly subjectId: _angular_core.InputSignal<string>;
+    /** The agent whose conversation about the subject the host offers, also before it worked on it. */
+    readonly agentId: _angular_core.InputSignal<string | undefined>;
+    /** Emits once the panel opens the conversation, so a host in a dialog can make room for it. */
+    readonly conversationOpened: _angular_core.OutputEmitterRef<AgentThreadLookup>;
+    readonly headingId: string;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** True after the first successful load; later loads keep the list, and an open feedback question, in place. */
+    readonly loaded: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    /** The caller has no role on the subject, or it no longer exists. */
+    readonly unavailable: _angular_core.WritableSignal<boolean>;
+    readonly work: _angular_core.WritableSignal<AgentSubjectWork | null>;
+    /** The agent whose conversation is opening or which is starting. */
+    readonly opening: _angular_core.WritableSignal<string | null>;
+    readonly starting: _angular_core.WritableSignal<string | null>;
+    readonly started: _angular_core.WritableSignal<NhAssistantStartedAgent | null>;
+    readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly errorKeys: _angular_core.Signal<string[]>;
+    /** True while the assistant panel can show a conversation. */
+    readonly assistantEnabled: _angular_core.Signal<boolean>;
+    readonly agents: _angular_core.Signal<AgentSubjectWorkAgent[]>;
+    readonly proposals: _angular_core.Signal<_newheap_platform_ai_chat.AgentProposal[]>;
+    readonly decisionRights: _angular_core.Signal<ReadonlyMap<string, AgentProposalDecisionRight>>;
+    constructor();
+    load(): void;
+    /** The translation keys of an agent's name: from the server's status, then the convention. */
+    agentNameKeys(agentId: string): string[];
+    /** Readers may open an existing conversation; creating one needs the participant role. */
+    canOpen(agent: AgentSubjectWorkAgent): boolean;
+    open(agent: AgentSubjectWorkAgent): Promise<void>;
+    start(agent: AgentSubjectWorkAgent): void;
+    /**
+     * Reloads after a live update. Once the work is shown it reloads quietly: no loading state, and
+     * a failure keeps what is shown, including an open feedback question. While a decision of the
+     * list is in flight it waits, because the decision reloads the list when it ends.
+     */
+    private refresh;
+    private fetch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantSubjectSuggestionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantSubjectSuggestionsComponent, "nh-assistant-subject-suggestions", never, { "subjectType": { "alias": "subjectType"; "required": true; "isSignal": true; }; "subjectId": { "alias": "subjectId"; "required": true; "isSignal": true; }; "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; }, { "conversationOpened": "conversationOpened"; }, never, never, true, never>;
+}
+
+export { NhAssistantAgentArtifactsComponent, NhAssistantAgentConsultationsComponent, NhAssistantAgentInboxComponent, NhAssistantAgentMemoryComponent, NhAssistantAgentProposalsComponent, NhAssistantAgentThreadViewComponent, NhAssistantRunTimelineComponent, NhAssistantSubjectSuggestionsComponent };
+export type { NhAssistantAgentThreadTab };