@meshmakers/octo-ai-console 3.3.1210 → 3.4.70

package/types/meshmakers-octo-ai-console.d.ts

@@ -203,6 +203,92 @@ interface IssueAiCredentialTicketResponseDto {
     readonly scope: AiCredentialTicketScope;
 }
 
+/**
+ * Body for `POST /{tenantId}/v1/credentials/github-pat`. The plaintext token is
+ * validated against GitHub's `/user` endpoint before encryption — a refused
+ * token comes back as HTTP 422 + `error: 'github_refused_token'`.
+ */
+interface RegisterAiGitHubPatRequestDto {
+    /** Operator-supplied label so PATs are tellable apart in the list view. */
+    readonly name: string;
+    /** Plaintext token. Never persisted client-side; cleared from the form on submit. */
+    readonly token: string;
+    /** Free-form scope hint — purely informational. */
+    readonly scope?: string;
+}
+/**
+ * Wire shape returned by `GET /{tenantId}/v1/credentials/github-pat`. Carries
+ * neither the plaintext token nor the encrypted ciphertext — only enough to
+ * render a row + offer Revoke.
+ */
+interface AiGitHubPatDto {
+    /** Binding rtId — pass to delete. */
+    readonly rtId: string;
+    /** Operator-supplied label from registration. */
+    readonly name: string;
+    /** Operator-supplied free-form scope hint. */
+    readonly scope: string;
+    /** Last four characters of the plaintext token preceded by "…" (e.g. "…ABCD"). */
+    readonly maskedTail: string;
+    /**
+     * GitHub login the token authenticated as during registration. Null when the
+     * binding's ciphertext is unreadable (rotation gone wrong) — UI should hint
+     * "revoke and re-register" in that case.
+     */
+    readonly gitHubLogin?: string | null;
+}
+
+/**
+ * Wire shape returned by `GET /{tenantId}/v1/app-templates` (#4145). Each entry
+ * is one option in the Studio's "New App from Template" wizard. The wizard
+ * fills the goal placeholders and uses `jobKind` when it POSTs `/sessions`.
+ *
+ * Mirrors `AppTemplateResponse` in the adapter
+ * (`src/AiServices/TenantApi/v1/Models/AppTemplateResponse.cs`). The JSON is
+ * camel-cased on the wire; the C# DTO is PascalCased server-side.
+ */
+interface AiAppTemplateDto {
+    /** Stable identifier the wizard echoes on submit (`crud-list`, `dashboard`, `form-only`). */
+    readonly id: string;
+    /** Display name for the template picker. */
+    readonly name: string;
+    /** One-paragraph description shown next to the picker entry. */
+    readonly description: string;
+    /**
+     * JobKind enum key the adapter expects when the wizard POSTs the session.
+     * The wire is the CK enum key as string — see `AiJobKind` for the values
+     * the adapter currently emits. Today every Phase-1 template uses
+     * `Application`.
+     */
+    readonly jobKind: AiJobKind;
+    /**
+     * Handlebars-style template the wizard interpolates with operator inputs
+     * (e.g. `{{projectName}}`, `{{primaryEntity}}`). The rendered text is what
+     * goes onto `CreateSessionRequestDto.goal` — the adapter never interpolates,
+     * so the operator sees the final Goal in the wizard before submit.
+     */
+    readonly goalTemplate: string;
+    /**
+     * Names of the placeholders the wizard must collect before enabling Submit.
+     * Drives the form's required-field gate without the wizard having to parse
+     * `goalTemplate`.
+     */
+    readonly requiredPlaceholders: readonly string[];
+}
+/**
+ * The shape the wizard emits on Submit. The host page is expected to render
+ * `goal` (interpolated from the picked template) into a
+ * `CreateSessionRequestDto` and call `createSession` on the adapter client.
+ */
+interface AiNewAppSubmission {
+    readonly templateId: string;
+    readonly jobKind: AiJobKind;
+    readonly projectName: string;
+    readonly primaryEntity: string;
+    /** The fully interpolated Goal string — what the wizard would POST on submit. */
+    readonly goal: string;
+}
+
 /**
  * Configuration the host application supplies via {@link provideOctoAiConsole}.
  * Every field is required so the library never falls back to a hard-coded URL or
@@ -320,6 +406,31 @@ declare class AiAdapterClientService {
      * once the worker has acknowledged.
      */
     cancelSession(sessionId: string): Observable<AiSessionDto>;
+    /**
+     * `DELETE /{tenantId}/v1/sessions/{sessionId}` — hard-delete a terminal
+     * session. The server refuses non-terminal sessions with HTTP 409 and the
+     * <code>invalid_state_transition</code> error code, so callers should cancel
+     * first when the session is still in flight. 204 on success; the response
+     * has no body.
+     */
+    deleteSession(sessionId: string): Observable<void>;
+    /**
+     * `POST /{tenantId}/v1/sessions/{sessionId}/messages` — append a follow-up
+     * user turn to a `Completed` session. The adapter re-materialises the
+     * workspace (fresh credential snapshot), recovers Claude's session id from
+     * the persisted `system/init` event of the original turn, and spawns
+     * <code>claude --resume &lt;id&gt;</code> so the conversation context
+     * carries over. The next turn's events stream on the same SignalR channel
+     * as the prior turn — there is no separate subscription to set up.
+     *
+     * Server response is 202 with the updated session DTO (status flipped back
+     * to `Running`); the caller can use the returned status to drive an
+     * optimistic UI update. Non-Completed sessions return 409 with
+     * <code>invalid_state_transition</code>; a session whose first turn died
+     * before claude emitted init returns 409 with
+     * <code>claude_session_id_not_captured</code>.
+     */
+    sendMessage(sessionId: string, text: string): Observable<AiSessionDto>;
     /**
      * `GET /{tenantId}/v1/sessions/{sessionId}/events?sinceSequence=N` — replay
      * persisted events for a session. UI uses this on reconnect to backfill any
@@ -342,6 +453,34 @@ declare class AiAdapterClientService {
      * on a different machine — they use the bastion CLI, not the Studio.
      */
     issueCredentialTicket(request: IssueAiCredentialTicketRequestDto): Observable<IssueAiCredentialTicketResponseDto>;
+    /**
+     * `POST /{tenantId}/v1/credentials/github-pat` — register a GitHub Personal
+     * Access Token (#4124). The adapter validates the token against GitHub's
+     * `/user` endpoint before encryption; a refused token surfaces as HTTP 422
+     * with `error: 'github_refused_token'`. The response is intentionally minimal
+     * (`{ rtId }`); the host re-fetches the list so the rendering path stays
+     * shared with refresh.
+     */
+    registerGitHubPat(request: RegisterAiGitHubPatRequestDto): Observable<{
+        rtId: string;
+    }>;
+    /**
+     * `GET /{tenantId}/v1/credentials/github-pat` — list registered PATs with a
+     * masked tail + GitHub login. Plaintext never crosses the wire.
+     */
+    listGitHubPats(): Observable<AiGitHubPatDto[]>;
+    /**
+     * `DELETE /{tenantId}/v1/credentials/github-pat/{rtId}` — revoke a PAT. The
+     * ciphertext is deleted, not soft-tombstoned. Returns void on 204.
+     */
+    deleteGitHubPat(rtId: string): Observable<void>;
+    /**
+     * `GET /{tenantId}/v1/app-templates` — list the Custom-App templates the
+     * adapter exposes for the wizard (#4145). Phase-1 returns the same three
+     * static entries for every tenant; the wire shape is stable so per-tenant
+     * overrides can ride it without an SPA bump.
+     */
+    getAppTemplates(): Observable<AiAppTemplateDto[]>;
     private tenantBase;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiAdapterClientService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<AiAdapterClientService>;
@@ -426,38 +565,159 @@ declare class AiSessionStreamService {
  * the component takes the array as an input signal and emits the rtId on
  * row click. Keeping it data-source-agnostic lets refinery wire its own
  * Apollo cache while a bastion CLI could pass static fixtures in a Storybook.
+ *
+ * Cancel and Delete are surfaced as inline per-row actions and emitted as
+ * separate outputs — the host owns the confirmation dialog and the actual
+ * REST call. The component only knows which actions are valid for which
+ * status, so a Running session never offers Delete and a Completed session
+ * never offers Cancel.
  */
 declare class AiSessionListComponent {
     readonly sessions: _angular_core.InputSignal<AiSessionDto[]>;
     readonly selectedSessionId: _angular_core.InputSignal<string | null>;
     readonly sessionSelected: _angular_core.OutputEmitterRef<string>;
+    readonly cancelRequested: _angular_core.OutputEmitterRef<string>;
+    readonly deleteRequested: _angular_core.OutputEmitterRef<string>;
     protected readonly orderedSessions: _angular_core.Signal<AiSessionDto[]>;
+    /**
+     * Terminal status set, kept in sync with the C# `AiAgentSessionService.IsTerminal`
+     * predicate. Delete is gated to this set; Cancel is gated to its complement.
+     * If the wire enum grows a new terminal kind, both predicates must be
+     * updated here AND on the server.
+     */
+    private static readonly TERMINAL_STATUSES;
+    protected canCancel(status: AiSessionStatus): boolean;
+    protected canDelete(status: AiSessionStatus): boolean;
     protected onSelect(sessionRtId: string): void;
+    protected onCancel(sessionRtId: string, event: MouseEvent): void;
+    protected onDelete(sessionRtId: string, event: MouseEvent): void;
     protected age(startedAt: string): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiSessionListComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiSessionListComponent, "mm-ai-session-list", never, { "sessions": { "alias": "sessions"; "required": true; "isSignal": true; }; "selectedSessionId": { "alias": "selectedSessionId"; "required": false; "isSignal": true; }; }, { "sessionSelected": "sessionSelected"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiSessionListComponent, "mm-ai-session-list", never, { "sessions": { "alias": "sessions"; "required": true; "isSignal": true; }; "selectedSessionId": { "alias": "selectedSessionId"; "required": false; "isSignal": true; }; }, { "sessionSelected": "sessionSelected"; "cancelRequested": "cancelRequested"; "deleteRequested": "deleteRequested"; }, never, never, true, never>;
+}
+
+/**
+ * Token-usage summary extracted from an `assistant` or `result` payload.
+ * Fields beyond `input` / `output` are optional because the upstream worker
+ * (claude-code stream-json) sometimes omits them on rate-limited or
+ * cache-only turns.
+ */
+interface ParsedTokenUsage {
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead?: number;
+    readonly cacheCreation?: number;
+}
+/**
+ * A single content fragment inside an assistant event. The worker emits a
+ * mix of `text` and `tool_use` parts per message — sometimes one of each in
+ * the same payload — and the renderer needs to walk them in order to keep
+ * the conversational flow intact (text → "I'll run X" → tool_use card).
+ */
+type ParsedAssistantPart = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'tool_use';
+    readonly id: string;
+    readonly toolName: string;
+    readonly input: unknown;
+};
+/**
+ * Discriminated union the chat-stream renders on. The component switches over
+ * `kind` and pulls only the fields it needs per branch — no `any` walks of
+ * the original payload at render time.
+ *
+ * `raw` is kept on every variant so a debug-view ("show me the original
+ * stream-json") can surface it on demand without re-parsing.
+ */
+type ParsedView = {
+    readonly kind: 'system';
+    readonly subKind: 'init' | 'hook' | 'rate-limit' | 'other';
+    readonly summary: string;
+    readonly raw: unknown;
+} | {
+    readonly kind: 'assistant';
+    readonly parts: readonly ParsedAssistantPart[];
+    readonly model: string | null;
+    readonly usage: ParsedTokenUsage | null;
+    readonly raw: unknown;
+} | {
+    readonly kind: 'tool-result';
+    readonly toolUseId: string;
+    readonly content: string;
+    readonly isError: boolean;
+    readonly raw: unknown;
+} | {
+    readonly kind: 'result';
+    readonly text: string;
+    readonly durationMs: number;
+    readonly usage: ParsedTokenUsage | null;
+    readonly costUsd: number | null;
+    readonly reason: string;
+    readonly isError: boolean;
+    readonly raw: unknown;
+} | {
+    readonly kind: 'status-change';
+    readonly status: string;
+    readonly raw: unknown;
+} | {
+    readonly kind: 'unknown';
+    readonly summary: string;
+    readonly raw: unknown;
+};
+/**
+ * Result of one parse step — wraps the source event so the renderer can still
+ * carry `sequence` / `at` / `actorRef` through to the template.
+ */
+interface ParsedEvent {
+    readonly event: AiSessionEventDto;
+    readonly view: ParsedView;
 }
 
 /**
- * Read-only transcript of a session, derived from the events stream. The
- * component takes the events as an input signal so the host owns lifetime —
- * a parent that's already wired `AiSessionStreamService.events$` into a
- * `toSignal()` just hands the same signal in.
+ * Read-only transcript of a session, derived from the events stream.
  *
- * Markdown rendering is deliberately minimal in Phase 1: the component shows
- * the raw payload (already JSON or stream-json) in a `<pre>` block. The
- * concept §10 calls for proper markdown + code-block highlighting; that
- * upgrade lands behind a `markdown` Input once we've picked a renderer
- * (markdown-it vs marked) and verified its CSP behaviour.
+ * The component takes raw `AiSessionEventDto` entries, runs them through the
+ * `event-parser` to produce a typed `ParsedView` per event, and renders each
+ * kind with its own treatment — assistant bubbles for chat text, expandable
+ * cards for tool calls + tool results, single-line collapsed strips for the
+ * system / hook noise, and a stats panel for the terminal `result` summary.
+ *
+ * Markdown rendering inside assistant text is still deferred (concept §10);
+ * for now the parser hands plain text to the template and the SCSS preserves
+ * line breaks via `white-space: pre-wrap`. Picking a renderer (markdown-it vs
+ * marked) is gated on a CSP review and a markdown-corpus regression test.
  */
 declare class AiChatStreamComponent {
     readonly events: _angular_core.InputSignal<AiSessionEventDto[]>;
     /**
-     * Sorted by sequence so out-of-order arrival (the SignalR + REST backfill
-     * union) renders deterministically.
+     * Sorted + parsed. Recomputes whenever the input signal changes; the sort
+     * is stable so live appends from SignalR keep prior render positions.
+     */
+    protected readonly parsedEvents: _angular_core.Signal<ParsedEvent[]>;
+    /**
+     * Per-event "show raw JSON" toggle. Keyed by sequence so live appends
+     * don't flicker existing toggles closed. A `Set<number>` rather than a
+     * record so add / delete avoids `keyof` shenanigans.
+     */
+    private readonly expandedSet;
+    protected isExpanded(sequence: number): boolean;
+    protected toggleRaw(sequence: number): void;
+    /**
+     * `HH:MM:SS` formatter — full ISO is too noisy in a 30-event transcript.
+     * Returns the input unchanged if parsing fails so we don't pretend events
+     * we can't read are recent.
      */
-    protected readonly orderedEvents: _angular_core.Signal<AiSessionEventDto[]>;
-    protected variant(kind: AiSessionEventDto['kind']): string;
+    protected formatTime(iso: string): string;
+    /** Compact "1234 tok" for the assistant header. */
+    protected formatTokenCount(n: number): string;
+    /** Duration in either `ms` (sub-second) or `s.SS`. */
+    protected formatDuration(ms: number): string;
+    /** Cost in EUR-style decimals; null + zero collapse to a dash. */
+    protected formatCost(usd: number | null | undefined): string;
+    /** Pretty-print arbitrary tool_use input or raw blocks for the expandable detail panel. */
+    protected formatRaw(value: unknown): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiChatStreamComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatStreamComponent, "mm-ai-chat-stream", never, { "events": { "alias": "events"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -571,5 +831,59 @@ declare class AiCredentialTicketIssueComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiCredentialTicketIssueComponent, "mm-ai-credential-ticket-issue", never, {}, {}, never, never, true, never>;
 }
 
-export { AI_ADAPTER_OPTIONS, AI_SESSION_STREAM_CONNECTION_FACTORY, AiAdapterClientService, AiApprovalModalComponent, AiChatStreamComponent, AiCredentialTicketIssueComponent, AiJobStatusBadgeComponent, AiQuotaIndicatorComponent, AiSessionListComponent, AiSessionStreamService, AiToolCallComponent, provideOctoAiConsole };
-export type { AiAdapterOptions, AiApprovalDecidedDto, AiApprovalDecisionDto, AiApprovalOutcome, AiApprovalReason, AiApprovalRequestedDto, AiCredentialTicketScope, AiHubConnectionLike, AiJobKind, AiQuotaSeverity, AiQuotaSnapshotDto, AiQuotaWarningDto, AiSessionDto, AiSessionEventDto, AiSessionEventKind, AiSessionStatus, AiSessionStatusChangedDto, AiSessionStream, AiSessionStreamConnectionFactory, AiToolCallDto, CreateSessionRequestDto, CreateSessionResponseDto, IssueAiCredentialTicketRequestDto, IssueAiCredentialTicketResponseDto };
+/**
+ * "New App from Template" wizard (#4145). Presentation-only — the host fetches
+ * the template catalogue via {@link AiAdapterClientService.getAppTemplates},
+ * feeds it into the `templates` input, and listens for `submit` / `cancel` to
+ * call `createSession`.
+ *
+ * The component is intentionally framework-agnostic (no Kendo, no CDK overlay)
+ * so consumers can wrap it in whatever modal shell they already have — same
+ * convention as `AiApprovalModalComponent`.
+ *
+ * The interpolation engine is *deliberately* dumb: a regex substitution over
+ * `{{placeholder}}` tokens. The wizard only collects two inputs (project name +
+ * primary entity), and a full Handlebars dependency for two tokens would be
+ * overkill. If a future template needs richer rendering, switch this to
+ * `handlebars.precompile`-at-build-time and re-evaluate.
+ */
+declare class AiNewAppDialogComponent {
+    /** Available templates from the adapter — typically 3 in Phase 1. */
+    readonly templates: _angular_core.InputSignal<readonly AiAppTemplateDto[]>;
+    /** Tenant name shown in the dialog header so the operator confirms the scope. */
+    readonly tenantName: _angular_core.InputSignal<string>;
+    /**
+     * Emitted on Submit with the fully interpolated Goal + the picked template id.
+     * Named `confirmed` (not `submit`) because Angular flags native-event collisions
+     * — `submit` is a DOM event and triggers `@angular-eslint/no-output-native`.
+     */
+    readonly confirmed: _angular_core.OutputEmitterRef<AiNewAppSubmission>;
+    /**
+     * Emitted on Cancel / dismiss. The host hides the wizard on this signal.
+     * Named `cancelled` for the same reason `confirmed` is not `submit`.
+     */
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    /** rtId-style id of the picked template, or empty until the operator picks one. */
+    protected readonly selectedTemplateId: _angular_core.WritableSignal<string>;
+    protected readonly projectName: _angular_core.WritableSignal<string>;
+    protected readonly primaryEntity: _angular_core.WritableSignal<string>;
+    protected readonly selectedTemplate: _angular_core.Signal<AiAppTemplateDto | null>;
+    /**
+     * Rendered Goal string the operator sees in the preview block. Stays empty
+     * until a template is picked AND every required placeholder has a value, so
+     * the operator never sees a half-interpolated string.
+     */
+    protected readonly renderedGoal: _angular_core.Signal<string>;
+    /** True when every placeholder the picked template declares has a non-empty value. */
+    protected readonly allRequiredFilled: _angular_core.Signal<boolean>;
+    protected onSubmit(): void;
+    protected onCancel(): void;
+    /** Read the signal that backs the named placeholder, or `null` if unknown. */
+    private valueFor;
+    private interpolate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiNewAppDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiNewAppDialogComponent, "mm-ai-new-app-dialog", never, { "templates": { "alias": "templates"; "required": true; "isSignal": true; }; "tenantName": { "alias": "tenantName"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+export { AI_ADAPTER_OPTIONS, AI_SESSION_STREAM_CONNECTION_FACTORY, AiAdapterClientService, AiApprovalModalComponent, AiChatStreamComponent, AiCredentialTicketIssueComponent, AiJobStatusBadgeComponent, AiNewAppDialogComponent, AiQuotaIndicatorComponent, AiSessionListComponent, AiSessionStreamService, AiToolCallComponent, provideOctoAiConsole };
+export type { AiAdapterOptions, AiAppTemplateDto, AiApprovalDecidedDto, AiApprovalDecisionDto, AiApprovalOutcome, AiApprovalReason, AiApprovalRequestedDto, AiCredentialTicketScope, AiGitHubPatDto, AiHubConnectionLike, AiJobKind, AiNewAppSubmission, AiQuotaSeverity, AiQuotaSnapshotDto, AiQuotaWarningDto, AiSessionDto, AiSessionEventDto, AiSessionEventKind, AiSessionStatus, AiSessionStatusChangedDto, AiSessionStream, AiSessionStreamConnectionFactory, AiToolCallDto, CreateSessionRequestDto, CreateSessionResponseDto, IssueAiCredentialTicketRequestDto, IssueAiCredentialTicketResponseDto, RegisterAiGitHubPatRequestDto };