@orthacms/copilot-server 0.0.0-reserve.0

package/dist/lib/chat/application/dto/update-conversation.dto.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Longest title we accept.
+ *
+ * Generous next to what the server derives from a first message, because this
+ * one is typed by a human who may be filing a thread rather than naming it — and
+ * still bounded, since the rail renders it on one truncated line.
+ */
+export declare const MAX_TITLE_LENGTH = 200;
+/**
+ * The stored form of "let the host's resolver decide".
+ *
+ * **Legacy: accepted, no longer produced.** It was a real option in the picker
+ * back when the deployment had a `defaultProvider` for it to mean; both are
+ * gone, and the admin now opens a chat on the catalogue's first entry and names
+ * it per turn. Still accepted here because rows carrying it exist and an older
+ * client may still send it — a client that does gets its thread read back as
+ * "nobody picked", which lands on that same first entry. It is unambiguous
+ * against a `'<provider>:<model>'` key because it contains no colon.
+ */
+export declare const MODEL_CHOICE_DEFAULT = "default";
+/**
+ * Longest model choice we accept: a provider name plus a model id plus the
+ * separator. Bounded because it is stored and echoed back to the picker.
+ */
+export declare const MAX_MODEL_CHOICE_LENGTH = 200;
+/**
+ * Body of `PATCH /api/copilot/conversations/:id`.
+ *
+ * A **patch**, so every property is optional and only the ones present are
+ * written. The controller rejects a body with neither: an empty patch is a
+ * request that cannot mean anything, and silently answering 200 to it would
+ * report success for a write that never happened.
+ *
+ * Every property is declared because the host's `ValidationPipe` runs with
+ * `forbidNonWhitelisted` — an undeclared key is a 400 naming it.
+ */
+export declare class UpdateConversationDto {
+    /**
+     * Rename the thread.
+     *
+     * Trimmed before validation, so " " is the empty string and fails the
+     * length check rather than being stored as a title that renders as nothing.
+     */
+    title?: string;
+    /**
+     * Hide the thread from the list, or bring it back.
+     *
+     * Archiving is the only removal this API offers, and it is deliberately
+     * reversible — the transcript is kept, and `GET /conversations/:id` still
+     * serves it, so a link to an archived thread keeps working.
+     */
+    archived?: boolean;
+    /**
+     * Record the model picked for this thread, so reopening it in another tab
+     * offers the backend the person chose instead of the deployment default.
+     *
+     * `'<provider>:<model>'` — or the legacy `'default'`, see above —
+     * the same key the picker uses, split on its **first** colon (a model id
+     * routinely contains one; a provider name cannot). The controller checks the
+     * pair against `ModelRegistry.catalogue()`, so this can only ever name a
+     * backend the operator configured.
+     *
+     * It is a **memory, not a pin**: the run route still takes its provider and
+     * model per turn, and nothing here constrains the next one.
+     */
+    modelChoice?: string;
+}
+//# sourceMappingURL=update-conversation.dto.d.ts.map

package/dist/lib/chat/application/dto/update-conversation.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-conversation.dto.d.ts","sourceRoot":"","sources":["../../../../../src/lib/chat/application/dto/update-conversation.dto.ts"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,YAAY,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;;;;;;;GAUG;AACH,qBAAa,qBAAqB;IAC9B;;;;;OAKG;IAkBH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;OAMG;IAQH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;;;;;;;;;OAYG;IAYH,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/lib/chat/application/dto/update-conversation.dto.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateConversationDto = exports.MAX_MODEL_CHOICE_LENGTH = exports.MODEL_CHOICE_DEFAULT = exports.MAX_TITLE_LENGTH = void 0;
+const tslib_1 = require("tslib");
+const swagger_1 = require("@nestjs/swagger");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+/**
+ * Longest title we accept.
+ *
+ * Generous next to what the server derives from a first message, because this
+ * one is typed by a human who may be filing a thread rather than naming it — and
+ * still bounded, since the rail renders it on one truncated line.
+ */
+exports.MAX_TITLE_LENGTH = 200;
+/**
+ * The stored form of "let the host's resolver decide".
+ *
+ * **Legacy: accepted, no longer produced.** It was a real option in the picker
+ * back when the deployment had a `defaultProvider` for it to mean; both are
+ * gone, and the admin now opens a chat on the catalogue's first entry and names
+ * it per turn. Still accepted here because rows carrying it exist and an older
+ * client may still send it — a client that does gets its thread read back as
+ * "nobody picked", which lands on that same first entry. It is unambiguous
+ * against a `'<provider>:<model>'` key because it contains no colon.
+ */
+exports.MODEL_CHOICE_DEFAULT = 'default';
+/**
+ * Longest model choice we accept: a provider name plus a model id plus the
+ * separator. Bounded because it is stored and echoed back to the picker.
+ */
+exports.MAX_MODEL_CHOICE_LENGTH = 200;
+/**
+ * Body of `PATCH /api/copilot/conversations/:id`.
+ *
+ * A **patch**, so every property is optional and only the ones present are
+ * written. The controller rejects a body with neither: an empty patch is a
+ * request that cannot mean anything, and silently answering 200 to it would
+ * report success for a write that never happened.
+ *
+ * Every property is declared because the host's `ValidationPipe` runs with
+ * `forbidNonWhitelisted` — an undeclared key is a 400 naming it.
+ */
+class UpdateConversationDto {
+    /**
+     * Rename the thread.
+     *
+     * Trimmed before validation, so " " is the empty string and fails the
+     * length check rather than being stored as a title that renders as nothing.
+     */
+    title;
+    /**
+     * Hide the thread from the list, or bring it back.
+     *
+     * Archiving is the only removal this API offers, and it is deliberately
+     * reversible — the transcript is kept, and `GET /conversations/:id` still
+     * serves it, so a link to an archived thread keeps working.
+     */
+    archived;
+    /**
+     * Record the model picked for this thread, so reopening it in another tab
+     * offers the backend the person chose instead of the deployment default.
+     *
+     * `'<provider>:<model>'` — or the legacy `'default'`, see above —
+     * the same key the picker uses, split on its **first** colon (a model id
+     * routinely contains one; a provider name cannot). The controller checks the
+     * pair against `ModelRegistry.catalogue()`, so this can only ever name a
+     * backend the operator configured.
+     *
+     * It is a **memory, not a pin**: the run route still takes its provider and
+     * model per turn, and nothing here constrains the next one.
+     */
+    modelChoice;
+}
+exports.UpdateConversationDto = UpdateConversationDto;
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: String,
+        minLength: 1,
+        maxLength: exports.MAX_TITLE_LENGTH,
+        description: 'A new display title. Trimmed; must not be blank once trimmed.',
+        example: 'Invoice copy review'
+    }),
+    (0, class_validator_1.IsOptional)()
+    // Runs during transformation, i.e. **before** the validators below — so a
+    // title of spaces is measured as the empty string it is.
+    ,
+    (0, class_transformer_1.Transform)(({ value }) => typeof value === 'string' ? value.trim() : value),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MinLength)(1),
+    (0, class_validator_1.MaxLength)(exports.MAX_TITLE_LENGTH),
+    tslib_1.__metadata("design:type", String)
+], UpdateConversationDto.prototype, "title", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: Boolean,
+        description: 'Hide the thread from the default list (`true`) or restore it (`false`).'
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)(),
+    tslib_1.__metadata("design:type", Boolean)
+], UpdateConversationDto.prototype, "archived", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: String,
+        maxLength: exports.MAX_MODEL_CHOICE_LENGTH,
+        description: "The model picked for this thread: `default`, or `<provider>:<model>` naming a pair from `GET /api/copilot/models`. Doesn't constrain the next run.",
+        example: 'anthropic:claude-opus-5'
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MinLength)(1),
+    (0, class_validator_1.MaxLength)(exports.MAX_MODEL_CHOICE_LENGTH),
+    tslib_1.__metadata("design:type", String)
+], UpdateConversationDto.prototype, "modelChoice", void 0);

package/dist/lib/chat/application/proposal-applier.registry.d.ts

@@ -0,0 +1,27 @@
+import { type ProposalApplier } from '@orthacms/copilot-domain';
+/**
+ * The `kind` → applier lookup, filled by the plugins that own the writes.
+ *
+ * Same shape and same reasoning as {@link CopilotToolRegistry}: registration is
+ * a **runtime `register(...)` call**, because Nest cannot merge a
+ * multi-provider token across independent dynamic modules and every plugin here
+ * is one. A statically bound {@link COPILOT_PROPOSAL_APPLIER} is honoured too,
+ * for a host that binds exactly one.
+ *
+ * A duplicate `kind` is **refused, not overwritten**. Silently letting the last
+ * registration win would let a plugin registered later take over another's
+ * writes — the same shadowing the capability profile refuses for tool names,
+ * and rather more consequential here, since these are the things that mutate.
+ */
+export declare class ProposalApplierRegistry {
+    private readonly logger;
+    private readonly byKind;
+    constructor(injected?: ProposalApplier[] | ProposalApplier | null);
+    /** Registers an applier. Called by binding plugins at bootstrap. */
+    register(applier: ProposalApplier): void;
+    /** The applier for `kind`, or undefined when no plugin claimed it. */
+    get(kind: string): ProposalApplier | undefined;
+    /** Every registered kind — for diagnostics and the settings UI. */
+    kinds(): string[];
+}
+//# sourceMappingURL=proposal-applier.registry.d.ts.map

package/dist/lib/chat/application/proposal-applier.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposal-applier.registry.d.ts","sourceRoot":"","sources":["../../../../src/lib/chat/application/proposal-applier.registry.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,KAAK,eAAe,EACvB,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;;;GAaG;AACH,qBACa,uBAAuB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;IAEnE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsC;gBAKzD,QAAQ,GAAE,eAAe,EAAE,GAAG,eAAe,GAAG,IAAW;IAY/D,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAcxC,sEAAsE;IACtE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI9C,mEAAmE;IACnE,KAAK,IAAI,MAAM,EAAE;CAGpB"}

package/dist/lib/chat/application/proposal-applier.registry.js

@@ -0,0 +1,62 @@
+"use strict";
+var ProposalApplierRegistry_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProposalApplierRegistry = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const copilot_domain_1 = require("@orthacms/copilot-domain");
+/**
+ * The `kind` → applier lookup, filled by the plugins that own the writes.
+ *
+ * Same shape and same reasoning as {@link CopilotToolRegistry}: registration is
+ * a **runtime `register(...)` call**, because Nest cannot merge a
+ * multi-provider token across independent dynamic modules and every plugin here
+ * is one. A statically bound {@link COPILOT_PROPOSAL_APPLIER} is honoured too,
+ * for a host that binds exactly one.
+ *
+ * A duplicate `kind` is **refused, not overwritten**. Silently letting the last
+ * registration win would let a plugin registered later take over another's
+ * writes — the same shadowing the capability profile refuses for tool names,
+ * and rather more consequential here, since these are the things that mutate.
+ */
+let ProposalApplierRegistry = ProposalApplierRegistry_1 = class ProposalApplierRegistry {
+    logger = new common_1.Logger(ProposalApplierRegistry_1.name);
+    byKind = new Map();
+    constructor(injected = null) {
+        const initial = injected
+            ? Array.isArray(injected)
+                ? injected
+                : [injected]
+            : [];
+        for (const applier of initial) {
+            this.register(applier);
+        }
+    }
+    /** Registers an applier. Called by binding plugins at bootstrap. */
+    register(applier) {
+        const existing = this.byKind.get(applier.kind);
+        if (existing) {
+            this.logger.error(`Two appliers registered for proposal kind "${applier.kind}"; ` +
+                'keeping the first. This is a wiring bug — a proposal of ' +
+                'this kind would otherwise be applied by whichever plugin ' +
+                'happened to load last.');
+            return;
+        }
+        this.byKind.set(applier.kind, applier);
+    }
+    /** The applier for `kind`, or undefined when no plugin claimed it. */
+    get(kind) {
+        return this.byKind.get(kind);
+    }
+    /** Every registered kind — for diagnostics and the settings UI. */
+    kinds() {
+        return [...this.byKind.keys()];
+    }
+};
+exports.ProposalApplierRegistry = ProposalApplierRegistry;
+exports.ProposalApplierRegistry = ProposalApplierRegistry = ProposalApplierRegistry_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, common_1.Optional)()),
+    tslib_1.__param(0, (0, common_1.Inject)(copilot_domain_1.COPILOT_PROPOSAL_APPLIER)),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ProposalApplierRegistry);

package/dist/lib/chat/application/run-engine.service.d.ts

@@ -0,0 +1,243 @@
+import { type AttachmentResolver, type CopilotRunEvent, type ModelRegistry, type ModelResolver, type RunLimits } from '@orthacms/copilot-domain';
+import { ToolRegistry } from '@orthacms/tools-server';
+import type { CopilotPluginConfig } from '../../types/copilot-config';
+import { ConversationRepository } from '../infrastructure/persistence/conversation.repository';
+import { ProposalRepository } from '../infrastructure/persistence/proposal.repository';
+import { CapabilityProfileService } from './capability-profile.service';
+import { DecideProposalService } from './decide-proposal.service';
+import { ToolPermissionBroker } from './tool-permission.broker';
+import { SkillCatalogService } from '../../skills/application/skill-catalog.service';
+import { type SurfaceContext } from './system-prompt';
+/** What the controller hands the engine to start one turn. */
+export interface StartRunInput {
+    /** The user the run acts as. */
+    userId: string;
+    /**
+     * That user's email. Carried so an auto-applied proposal can freeze the
+     * same actor snapshot onto its audit event that a hand-made edit would —
+     * without a lookup in the one path where getting the actor wrong is least
+     * acceptable.
+     */
+    userEmail: string;
+    /** The user's role, for resolving the capability profile. */
+    roleId: string;
+    /** The workspace the run is scoped to; membership already proven. */
+    workspaceId: string;
+    /** Continue this thread, or start a new one when absent. */
+    conversationId?: string;
+    /** What the user typed. */
+    message: string;
+    /**
+     * Media asset ids the user attached, already uploaded under their own
+     * authority. Resolved against the run's workspace before anything is
+     * persisted; an id that does not resolve ends the run.
+     */
+    attachments?: readonly string[];
+    /**
+     * Skill **names** the person attached to this turn.
+     *
+     * Names, never the instruction text: the catalogue is the only thing that
+     * can say what a name means, and a request carrying a body would let anyone
+     * holding `copilot:use` write their own system prompt. The same rule
+     * attachments follow, for a sharper reason.
+     */
+    skills?: readonly string[];
+    /** Where the user is. */
+    context: SurfaceContext;
+    /** The admin UI's locale — the language to answer in. */
+    uiLocale: string;
+    /** Content-type summaries for the workspace. */
+    typeSummaries: readonly string[];
+    /**
+     * The backend this turn should run on. Either half may be omitted: no
+     * provider means the host's resolver picks, and no model means that
+     * provider's default. A user switching model mid-conversation simply sends
+     * a different pair on the next turn — nothing is pinned to the thread.
+     */
+    choice?: {
+        provider?: string;
+        model?: string;
+    };
+    /** Aborted when the client disconnects. */
+    signal: AbortSignal;
+}
+/**
+ * Thrown when a run names a provider or model that isn't registered. The
+ * controller turns it into an error frame rather than a 500 — it is a bad
+ * request, and by the time we know, the stream is usually already open.
+ */
+export declare class UnknownModelChoiceError extends Error {
+    constructor(message: string);
+}
+/** Thrown when a run cannot start at all — the controller maps it to a 4xx. */
+export declare class CopilotDisabledError extends Error {
+    constructor();
+}
+/**
+ * The run engine: a **bounded** loop that calls the model, executes the tools
+ * it asks for, feeds the results back, and stops on a final answer or a ceiling
+ * ([`docs/design/copilot.md`](../../../../../../docs/design/copilot.md) §5).
+ *
+ * It is an async generator rather than a service that writes to a response.
+ * That keeps the transport out of the engine — the SSE controller serializes
+ * whatever this yields — and it is what makes the loop testable without a
+ * socket: a test drains the generator and asserts on the event sequence.
+ */
+export declare class RunEngine {
+    private readonly registry;
+    private readonly resolver;
+    private readonly config;
+    private readonly profiles;
+    private readonly tools;
+    private readonly conversations;
+    private readonly proposals;
+    private readonly decisions;
+    private readonly permissions;
+    private readonly skills;
+    private readonly attachments;
+    private readonly logger;
+    /** The ceilings this engine enforces. */
+    private readonly limits;
+    constructor(registry: ModelRegistry, resolver: ModelResolver, config: CopilotPluginConfig, profiles: CapabilityProfileService, tools: ToolRegistry, conversations: ConversationRepository, proposals: ProposalRepository, decisions: DecideProposalService, permissions: ToolPermissionBroker, skills: SkillCatalogService, attachments?: AttachmentResolver | null, limits?: RunLimits | null);
+    /** Runs one turn, yielding events as they happen. */
+    run(input: StartRunInput): AsyncGenerator<CopilotRunEvent>;
+    /**
+     * The loop itself: model call → tool calls → repeat. Returns the reason the
+     * run ended.
+     */
+    private loop;
+    /** One model call, reduced to text, tool uses, usage and a stop reason. */
+    private streamTurn;
+    /**
+     * Authorizes, validates and runs one tool call, and writes its audit row.
+     *
+     * **Never throws.** Every failure — unknown tool, revoked permission,
+     * malformed arguments, a tool that blew up — comes back as a tool *error*
+     * the model can recover from, and the run continues (design §5, step 6).
+     * Turning a model mistake into a 500 would lose the whole turn.
+     */
+    /**
+     * Decides whether `call` needs the user's say-so, and parks the run if so.
+     *
+     * Returns `null` when it may just run — which is the overwhelmingly common
+     * case, because **only write tools ask**. Prompting on reads was
+     * considered and rejected: a model does three or four searches before it
+     * answers anything, so a fresh chat would open with four prompts, and
+     * everyone would learn to click through them without reading. That is worse
+     * than not asking, because it also devalues the prompt that matters.
+     *
+     * Otherwise it hands back the frame to emit and a `settle` to await, rather
+     * than doing both itself — the caller is the generator, and only a
+     * generator can `yield`.
+     */
+    private mayRun;
+    private executeTool;
+    /**
+     * Persists a `propose` tool's draft, applies it, and produces both the
+     * model's receipt and the client's proposal card.
+     *
+     * Applies it **always** — the per-workspace auto-apply opt-in this doc used
+     * to name was deleted with the policy table
+     * ([ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)
+     * §4). The row is still written first, and that ordering is now the only
+     * thing carrying "undoable, never invisible".
+     *
+     * **The model is told what happened, not handed the patch back.** It
+     * already knows what it asked for; echoing the whole change would spend the
+     * tokens twice and invite the model to "confirm" by proposing again. What
+     * it needs is the id, the summary, and whether the write landed — which is
+     * what makes it say "I've fixed the headline" or "that did not save",
+     * rather than the pre-ADR-0009 "I've drafted this, accept it below" for a
+     * change that has already happened.
+     */
+    private recordProposal;
+    /**
+     * Records the receipt for an `effect: 'apply'` tool — one that does its own
+     * writing instead of handing back a draft for the engine to apply.
+     *
+     * The registry has always allowed the effect and
+     * [ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)
+     * §5 still offers such a tool "exactly when a `read` one with the same
+     * `requires` would be", while §2 keeps the `copilot_proposals` row as "the
+     * whole paper trail" and names a binder that writes directly as the failure
+     * the split exists to prevent. Both were true at once: an `apply` tool
+     * parked for permission like a write, ran like a write, and left nothing
+     * behind. Nothing shipped declares the effect today, which is why it went
+     * unnoticed — and is exactly why the next binder to reach for it must not
+     * have to know this.
+     *
+     * Two differences from {@link recordProposal}, both forced by the effect:
+     *
+     * - **The row is written after the fact.** The write has already happened
+     *   by the time the handler returns; there was never a moment this engine
+     *   could have stopped it. The permission prompt is what does that.
+     * - **`kind` is `tool.<name>` and has no applier.** There is nothing left
+     *   to carry out. The row exists to be read — which is the whole of what
+     *   "undoable, never invisible" asks of it here.
+     *
+     * The model still gets the handler's own return value: for an `apply` tool
+     * the return value is a *result*, not a change (`ToolEffect`).
+     */
+    private recordApplied;
+    /**
+     * One tool call that did not happen: the audit row, the block the model is
+     * told, and the frame the UI draws.
+     *
+     * Shared by `executeTool`'s own refusals and by the loop's time-limit
+     * check, so a call refused before it was ever dispatched is recorded
+     * exactly like one refused after — a reviewer reading `copilot_tool_calls`
+     * should not have to know which stage said no.
+     */
+    private toolFailure;
+    /** Writes one `copilot_tool_calls` row. Never fails the run. */
+    private audit;
+    /**
+     * Turns the attached asset ids into what the model is told about them.
+     *
+     * Three refusals, each a different wrong thing to do:
+     *
+     * - **No resolver bound** — the deployment has no media plugin, so there is
+     *   nothing that could have produced these ids. Failing beats describing
+     *   files nobody can look up.
+     * - **An id that did not resolve** — it belongs to another workspace, or to
+     *   a file deleted between the upload and the send. The resolver is
+     *   workspace-scoped and omits what it cannot see, so the two are
+     *   indistinguishable here, which is deliberate: telling a caller *which*
+     *   of their ids exists elsewhere is an oracle.
+     * - Neither case is reported per-id. One message names the count, because
+     *   the user's recourse is the same either way — re-attach the file.
+     */
+    private resolveAttachments;
+    /**
+     * The persisted transcript, as the port's message shape.
+     *
+     * A turn's attachments are folded back in as a **fenced text block**, which
+     * is what makes them survive into later turns: "summarise the file I sent"
+     * on turn three has to reach a manifest written on turn one, and the
+     * transcript is the only thing carried forward. Fenced because a file name
+     * is user-authored text arriving in the prompt — the same treatment a tool
+     * result gets, for the same reason.
+     *
+     * The rows are then run through `normalizeTranscript`, which is what makes
+     * a *continued* conversation replayable at all. A run is stored as one
+     * assistant row holding text, `tool_use` **and** `tool_result` blocks
+     * together — the shape the transcript UI reads — and Anthropic rejects that
+     * on the way back in: a tool result has to ride on a user turn after the
+     * assistant turn that asked for it. It also drops `tool_use` blocks left
+     * unanswered by a run that was aborted mid-step, which is the same 400
+     * wearing a different message. The repair is here rather than at the write
+     * so it also fixes the threads already in the database.
+     */
+    private loadHistory;
+}
+/**
+ * Thrown when a turn's attachments cannot be resolved. Surfaced by the
+ * controller as an error frame rather than a 500 — like `UnknownModelChoiceError`
+ * it is a bad request, and by the time we know, the stream is already open.
+ */
+export declare class AttachmentError extends Error {
+    constructor(message: string);
+}
+/** The prompt version this engine builds with, for the run record. */
+export declare const ENGINE_PROMPT_VERSION = 10;
+//# sourceMappingURL=run-engine.service.d.ts.map

package/dist/lib/chat/application/run-engine.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-engine.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/chat/application/run-engine.service.ts"],"names":[],"mappings":"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"}