@orthacms/copilot-server 0.0.0-reserve.0

package/dist/lib/chat/http/controllers/list-conversations.controller.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListConversationsController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const conversation_repository_1 = require("../../infrastructure/persistence/conversation.repository");
+const list_conversations_query_dto_1 = require("../../application/dto/list-conversations-query.dto");
+/**
+ * `GET /api/copilot/conversations` — the signed-in user's threads in the open
+ * workspace, most recently used first.
+ *
+ * No `OriginGuard`: it guards state-changing requests, and this reads. The
+ * scoping that matters is in the repository, which filters on user **and**
+ * workspace — the guard proves the caller belongs to the workspace, and the
+ * query proves the threads belong to the caller.
+ */
+let ListConversationsController = class ListConversationsController {
+    conversations;
+    constructor(conversations) {
+        this.conversations = conversations;
+    }
+    async list(query, user, workspaceId) {
+        return {
+            items: await this.conversations.list(user.id, workspaceId, query.archived ?? false)
+        };
+    }
+};
+exports.ListConversationsController = ListConversationsController;
+tslib_1.__decorate([
+    (0, common_1.Get)('conversations'),
+    (0, swagger_1.ApiOperation)({ summary: 'List the current user’s copilot conversations' }),
+    tslib_1.__param(0, (0, common_1.Query)()),
+    tslib_1.__param(1, (0, identity_server_1.CurrentUser)()),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [list_conversations_query_dto_1.ListConversationsQueryDto, Object, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], ListConversationsController.prototype, "list", null);
+exports.ListConversationsController = ListConversationsController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.PermissionsGuard, workspaces_server_1.WorkspaceGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.COPILOT_USE),
+    (0, common_1.Controller)('copilot'),
+    tslib_1.__metadata("design:paramtypes", [conversation_repository_1.ConversationRepository])
+], ListConversationsController);

package/dist/lib/chat/http/controllers/list-models.controller.d.ts

@@ -0,0 +1,35 @@
+import { type ModelChoice, type ModelRegistry } from '@orthacms/copilot-domain';
+/** What the model picker renders. */
+export interface ModelCatalogue {
+    /**
+     * Every provider × model pair on offer, in registration order.
+     *
+     * The order carries the only default there is: `items[0]` is the first
+     * registered provider's first model, which is what a run that names
+     * neither gets, and what the picker opens on. There is no separate
+     * `defaultProvider` field for a client to reconcile with this list.
+     */
+    items: ModelChoice[];
+}
+/**
+ * `GET /api/copilot/models` — the backends a run may choose from.
+ *
+ * This is `ModelRegistry.catalogue()` served verbatim, which is what phase 0
+ * built it for: a user switches model mid-conversation by picking another row,
+ * and an operator changes what is on offer by changing the provider list in
+ * `plugins.ts` — the list is the whole configuration. The registry is
+ * fixed at boot from `plugins.ts`, so this leaks nothing an operator did not
+ * already choose to offer — **names only**, never a credential or a base URL.
+ *
+ * No `WorkspaceGuard`: the catalogue is deployment-wide, not workspace-owned,
+ * and the picker renders before a workspace is necessarily resolved. Gated on
+ * `copilot:use` like the rest of the surface. (Registering models at runtime,
+ * with encrypted credentials, is the separate phase-4 surface behind
+ * `copilot:configure`.)
+ */
+export declare class ListModelsController {
+    private readonly registry;
+    constructor(registry: ModelRegistry);
+    list(): ModelCatalogue;
+}
+//# sourceMappingURL=list-models.controller.d.ts.map

package/dist/lib/chat/http/controllers/list-models.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-models.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/chat/http/controllers/list-models.controller.ts"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,WAAW,EAChB,KAAK,aAAa,EACrB,MAAM,0BAA0B,CAAC;AAOlC,qCAAqC;AACrC,MAAM,WAAW,cAAc;IAC3B;;;;;;;OAOG;IACH,KAAK,EAAE,WAAW,EAAE,CAAC;CACxB;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAGa,oBAAoB;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAKpE,IAAI,IAAI,cAAc;CAGzB"}

package/dist/lib/chat/http/controllers/list-models.controller.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListModelsController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const copilot_domain_1 = require("@orthacms/copilot-domain");
+const identity_server_1 = require("@orthacms/identity-server");
+/**
+ * `GET /api/copilot/models` — the backends a run may choose from.
+ *
+ * This is `ModelRegistry.catalogue()` served verbatim, which is what phase 0
+ * built it for: a user switches model mid-conversation by picking another row,
+ * and an operator changes what is on offer by changing the provider list in
+ * `plugins.ts` — the list is the whole configuration. The registry is
+ * fixed at boot from `plugins.ts`, so this leaks nothing an operator did not
+ * already choose to offer — **names only**, never a credential or a base URL.
+ *
+ * No `WorkspaceGuard`: the catalogue is deployment-wide, not workspace-owned,
+ * and the picker renders before a workspace is necessarily resolved. Gated on
+ * `copilot:use` like the rest of the surface. (Registering models at runtime,
+ * with encrypted credentials, is the separate phase-4 surface behind
+ * `copilot:configure`.)
+ */
+let ListModelsController = class ListModelsController {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    list() {
+        return { items: this.registry.catalogue() };
+    }
+};
+exports.ListModelsController = ListModelsController;
+tslib_1.__decorate([
+    (0, common_1.Get)('models'),
+    (0, swagger_1.ApiOperation)({ summary: 'List the model backends a run may choose from' }),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", Object)
+], ListModelsController.prototype, "list", null);
+exports.ListModelsController = ListModelsController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.PermissionsGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.COPILOT_USE),
+    (0, common_1.Controller)('copilot'),
+    tslib_1.__param(0, (0, common_1.Inject)(copilot_domain_1.MODEL_REGISTRY)),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ListModelsController);

package/dist/lib/chat/http/controllers/proposals.controller.d.ts

@@ -0,0 +1,43 @@
+import { type PublicUser } from '@orthacms/identity-server';
+import { ProposalRepository, type ProposalView } from '../../infrastructure/persistence/proposal.repository';
+import { ConversationRepository } from '../../infrastructure/persistence/conversation.repository';
+import { ListProposalsQueryDto } from '../../application/dto/list-proposals-query.dto';
+/**
+ * `GET /api/copilot/proposals…` — the record of what the copilot changed.
+ *
+ * **Reads only.** These used to sit alongside `accept` and `reject`, and this
+ * was the accept boundary
+ * ([ADR-0005](../../../../../../docs/adr/0005-copilot-authority-model.md) §5).
+ * [ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)
+ * removed the human step, so a proposal is now a **receipt** rather than a
+ * decision waiting to be made: the engine applies it as it is drafted, and what
+ * is left to serve is the row saying what happened.
+ *
+ * They are still worth serving, and both callers prove it: the chat panel joins
+ * them onto a reopened thread so the cards come back, and the row is the paper
+ * trail a change made without review depends on. Keeping the read while
+ * deleting the write is the point — "undoable, never invisible" is now carried
+ * entirely by this record.
+ *
+ * No `OriginGuard`: nothing here is state-changing any more.
+ */
+export declare class ProposalsController {
+    private readonly proposals;
+    private readonly conversations;
+    constructor(proposals: ProposalRepository, conversations: ConversationRepository);
+    /**
+     * The list is **workspace**-scoped, not user-scoped, and that is the right
+     * shape: a proposal is the receipt for a change to the workspace's content,
+     * and every member can already read that content. What it must not become
+     * is a way to learn about someone else's *thread* — `GET
+     * /conversations/:id` 404s a thread that is not yours, and a filter that
+     * answered "yes, that id is in this workspace" would undo it from the other
+     * side. So the filter is only honoured for a conversation the caller owns;
+     * anything else is the same 404 the conversation route gives.
+     */
+    list(query: ListProposalsQueryDto, user: PublicUser, workspaceId: string): Promise<{
+        items: ProposalView[];
+    }>;
+    get(id: string, workspaceId: string): Promise<ProposalView>;
+}
+//# sourceMappingURL=proposals.controller.d.ts.map

package/dist/lib/chat/http/controllers/proposals.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposals.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/chat/http/controllers/proposals.controller.ts"],"names":[],"mappings":"AAUA,OAAO,EAKH,KAAK,UAAU,EAClB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACH,kBAAkB,EAClB,KAAK,YAAY,EACpB,MAAM,sDAAsD,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,0DAA0D,CAAC;AAClG,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAEvF;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAGa,mBAAmB;IAExB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,aAAa;gBADb,SAAS,EAAE,kBAAkB,EAC7B,aAAa,EAAE,sBAAsB;IAG1D;;;;;;;;;OASG;IAGG,IAAI,CACG,KAAK,EAAE,qBAAqB,EACtB,IAAI,EAAE,UAAU,EACX,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC;QAAE,KAAK,EAAE,YAAY,EAAE,CAAA;KAAE,CAAC;IAyB/B,GAAG,CACuB,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,YAAY,CAAC;CAO3B"}

package/dist/lib/chat/http/controllers/proposals.controller.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProposalsController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const proposal_repository_1 = require("../../infrastructure/persistence/proposal.repository");
+const conversation_repository_1 = require("../../infrastructure/persistence/conversation.repository");
+const list_proposals_query_dto_1 = require("../../application/dto/list-proposals-query.dto");
+/**
+ * `GET /api/copilot/proposals…` — the record of what the copilot changed.
+ *
+ * **Reads only.** These used to sit alongside `accept` and `reject`, and this
+ * was the accept boundary
+ * ([ADR-0005](../../../../../../docs/adr/0005-copilot-authority-model.md) §5).
+ * [ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)
+ * removed the human step, so a proposal is now a **receipt** rather than a
+ * decision waiting to be made: the engine applies it as it is drafted, and what
+ * is left to serve is the row saying what happened.
+ *
+ * They are still worth serving, and both callers prove it: the chat panel joins
+ * them onto a reopened thread so the cards come back, and the row is the paper
+ * trail a change made without review depends on. Keeping the read while
+ * deleting the write is the point — "undoable, never invisible" is now carried
+ * entirely by this record.
+ *
+ * No `OriginGuard`: nothing here is state-changing any more.
+ */
+let ProposalsController = class ProposalsController {
+    proposals;
+    conversations;
+    constructor(proposals, conversations) {
+        this.proposals = proposals;
+        this.conversations = conversations;
+    }
+    /**
+     * The list is **workspace**-scoped, not user-scoped, and that is the right
+     * shape: a proposal is the receipt for a change to the workspace's content,
+     * and every member can already read that content. What it must not become
+     * is a way to learn about someone else's *thread* — `GET
+     * /conversations/:id` 404s a thread that is not yours, and a filter that
+     * answered "yes, that id is in this workspace" would undo it from the other
+     * side. So the filter is only honoured for a conversation the caller owns;
+     * anything else is the same 404 the conversation route gives.
+     */
+    async list(query, user, workspaceId) {
+        if (query.conversationId) {
+            const thread = await this.conversations.find(query.conversationId, user.id, workspaceId);
+            if (!thread) {
+                throw new common_1.NotFoundException(`No conversation "${query.conversationId}".`);
+            }
+        }
+        return {
+            items: await this.proposals.list(workspaceId, {
+                ...(query.status ? { status: query.status } : {}),
+                ...(query.conversationId
+                    ? { conversationId: query.conversationId }
+                    : {})
+            })
+        };
+    }
+    async get(id, workspaceId) {
+        const proposal = await this.proposals.find(id, workspaceId);
+        if (!proposal) {
+            throw new common_1.NotFoundException(`No proposal "${id}".`);
+        }
+        return proposal;
+    }
+};
+exports.ProposalsController = ProposalsController;
+tslib_1.__decorate([
+    (0, common_1.Get)('proposals'),
+    (0, swagger_1.ApiOperation)({ summary: 'List the workspace’s copilot changes' }),
+    tslib_1.__param(0, (0, common_1.Query)()),
+    tslib_1.__param(1, (0, identity_server_1.CurrentUser)()),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [list_proposals_query_dto_1.ListProposalsQueryDto, Object, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], ProposalsController.prototype, "list", null);
+tslib_1.__decorate([
+    (0, common_1.Get)('proposals/:id'),
+    (0, swagger_1.ApiOperation)({ summary: 'Read one copilot change' }),
+    tslib_1.__param(0, (0, common_1.Param)('id', common_1.ParseUUIDPipe)),
+    tslib_1.__param(1, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], ProposalsController.prototype, "get", null);
+exports.ProposalsController = ProposalsController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.PermissionsGuard, workspaces_server_1.WorkspaceGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.COPILOT_USE),
+    (0, common_1.Controller)('copilot'),
+    tslib_1.__metadata("design:paramtypes", [proposal_repository_1.ProposalRepository,
+        conversation_repository_1.ConversationRepository])
+], ProposalsController);

package/dist/lib/chat/http/controllers/tool-permission.controller.d.ts

@@ -0,0 +1,57 @@
+import { type PublicUser } from '@orthacms/identity-server';
+import { ToolPermissionBroker } from '../../application/tool-permission.broker';
+import { DecideToolPermissionDto } from '../../application/dto/decide-tool-permission.dto';
+import { ExtendToolPermissionDto } from '../../application/dto/extend-tool-permission.dto';
+/**
+ * `POST /api/copilot/runs/:runId/permission` — the answer to a parked run.
+ *
+ * **A second request against a run that is still streaming**, which is the only
+ * shape available: the run is an SSE response, and a response cannot be asked
+ * questions. The run yields a `tool-permission-request` carrying its `runId`
+ * and the call id, and this route resolves the promise it is awaiting.
+ *
+ * It intentionally does **not** re-check whether the caller may use the tool.
+ * That is not a gap: the offer filtered it, and `executeTool` re-authorizes
+ * against freshly resolved grants immediately after this returns. What this
+ * route decides is whether the user *wants* the call to happen, which is a
+ * different question from whether they are allowed to make it — and answering
+ * "yes" to a tool their role has since lost still ends in a refusal downstream.
+ *
+ * It very much **does** check whose run it is, and the guards above cannot do
+ * it for us. `copilot:use` is held by every role including viewers, and
+ * `WorkspaceGuard` proves the caller belongs to *the workspace they named* —
+ * neither says anything about the run. Without the owner check a colleague
+ * could allow (or refuse) a write in someone else's chat, and a member of an
+ * unrelated workspace could do it by naming their own: the `runId` is not a
+ * secret, it is handed to the client in the `run-started` frame.
+ *
+ * The 404 is load-bearing rather than cosmetic, and it is deliberately the same
+ * answer for "nothing is waiting" and "not yours". Nothing waiting means the
+ * decision arrived after the timeout, or the run is parked on another instance
+ * (the broker is in-memory — see its notes). Both are worth telling the client
+ * about, because in both cases the answer it just gave had no effect — and
+ * whether someone else's run exists is not information this route hands out.
+ */
+export declare class ToolPermissionController {
+    private readonly broker;
+    constructor(broker: ToolPermissionBroker);
+    decide(runId: string, body: DecideToolPermissionDto, user: PublicUser, workspaceId: string): void;
+    /**
+     * `POST /api/copilot/runs/:runId/permission/extend` — "I need more time".
+     *
+     * The prompt used to have a five-minute limit with no warning, no countdown
+     * and no way to ask for longer: it simply disappeared, and the model
+     * reported that nobody had answered. WCAG 2.2.1 requires that a time limit
+     * set by the content can be turned off, adjusted, or **extended after a
+     * warning** — and none of its exceptions apply here, since
+     * [ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)
+     * justifies the limit as cost, not correctness (`ORT-118`).
+     *
+     * Same guards, same ownership check and same 404 as {@link decide}: this
+     * grants time on a parked run, so who may ask is exactly who may answer.
+     */
+    extend(runId: string, body: ExtendToolPermissionDto, user: PublicUser, workspaceId: string): {
+        expiresAt: string;
+    };
+}
+//# sourceMappingURL=tool-permission.controller.d.ts.map

package/dist/lib/chat/http/controllers/tool-permission.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-permission.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/chat/http/controllers/tool-permission.controller.ts"],"names":[],"mappings":"AAWA,OAAO,EAMH,KAAK,UAAU,EAClB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAC3F,OAAO,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAE3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAGa,wBAAwB;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,oBAAoB;IAQzD,MAAM,CAC6B,KAAK,EAAE,MAAM,EACpC,IAAI,EAAE,uBAAuB,EACtB,IAAI,EAAE,UAAU,EACX,WAAW,EAAE,MAAM,GACxC,IAAI;IAiBP;;;;;;;;;;;;;OAaG;IAMH,MAAM,CAC6B,KAAK,EAAE,MAAM,EACpC,IAAI,EAAE,uBAAuB,EACtB,IAAI,EAAE,UAAU,EACX,WAAW,EAAE,MAAM,GACxC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE;CAY3B"}

package/dist/lib/chat/http/controllers/tool-permission.controller.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolPermissionController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const tool_permission_broker_1 = require("../../application/tool-permission.broker");
+const decide_tool_permission_dto_1 = require("../../application/dto/decide-tool-permission.dto");
+const extend_tool_permission_dto_1 = require("../../application/dto/extend-tool-permission.dto");
+/**
+ * `POST /api/copilot/runs/:runId/permission` — the answer to a parked run.
+ *
+ * **A second request against a run that is still streaming**, which is the only
+ * shape available: the run is an SSE response, and a response cannot be asked
+ * questions. The run yields a `tool-permission-request` carrying its `runId`
+ * and the call id, and this route resolves the promise it is awaiting.
+ *
+ * It intentionally does **not** re-check whether the caller may use the tool.
+ * That is not a gap: the offer filtered it, and `executeTool` re-authorizes
+ * against freshly resolved grants immediately after this returns. What this
+ * route decides is whether the user *wants* the call to happen, which is a
+ * different question from whether they are allowed to make it — and answering
+ * "yes" to a tool their role has since lost still ends in a refusal downstream.
+ *
+ * It very much **does** check whose run it is, and the guards above cannot do
+ * it for us. `copilot:use` is held by every role including viewers, and
+ * `WorkspaceGuard` proves the caller belongs to *the workspace they named* —
+ * neither says anything about the run. Without the owner check a colleague
+ * could allow (or refuse) a write in someone else's chat, and a member of an
+ * unrelated workspace could do it by naming their own: the `runId` is not a
+ * secret, it is handed to the client in the `run-started` frame.
+ *
+ * The 404 is load-bearing rather than cosmetic, and it is deliberately the same
+ * answer for "nothing is waiting" and "not yours". Nothing waiting means the
+ * decision arrived after the timeout, or the run is parked on another instance
+ * (the broker is in-memory — see its notes). Both are worth telling the client
+ * about, because in both cases the answer it just gave had no effect — and
+ * whether someone else's run exists is not information this route hands out.
+ */
+let ToolPermissionController = class ToolPermissionController {
+    broker;
+    constructor(broker) {
+        this.broker = broker;
+    }
+    decide(runId, body, user, workspaceId) {
+        const delivered = this.broker.decide(runId, body.callId, body.decision, {
+            userId: user.id,
+            workspaceId
+        });
+        if (!delivered) {
+            throw new common_1.NotFoundException('That request is no longer waiting for an answer.');
+        }
+    }
+    /**
+     * `POST /api/copilot/runs/:runId/permission/extend` — "I need more time".
+     *
+     * The prompt used to have a five-minute limit with no warning, no countdown
+     * and no way to ask for longer: it simply disappeared, and the model
+     * reported that nobody had answered. WCAG 2.2.1 requires that a time limit
+     * set by the content can be turned off, adjusted, or **extended after a
+     * warning** — and none of its exceptions apply here, since
+     * [ADR-0009](../../../../../../docs/adr/0009-copilot-applies-directly.md)
+     * justifies the limit as cost, not correctness (`ORT-118`).
+     *
+     * Same guards, same ownership check and same 404 as {@link decide}: this
+     * grants time on a parked run, so who may ask is exactly who may answer.
+     */
+    extend(runId, body, user, workspaceId) {
+        const grantedMs = this.broker.extend(runId, body.callId, {
+            userId: user.id,
+            workspaceId
+        });
+        if (grantedMs === null) {
+            throw new common_1.NotFoundException('That request is no longer waiting for an answer.');
+        }
+        return { expiresAt: new Date(Date.now() + grantedMs).toISOString() };
+    }
+};
+exports.ToolPermissionController = ToolPermissionController;
+tslib_1.__decorate([
+    (0, common_1.Post)('runs/:runId/permission'),
+    (0, common_1.HttpCode)(204),
+    (0, common_1.UseGuards)(identity_server_1.OriginGuard),
+    (0, swagger_1.ApiOperation)({
+        summary: 'Allow or refuse one tool call in a running turn'
+    }),
+    tslib_1.__param(0, (0, common_1.Param)('runId', common_1.ParseUUIDPipe)),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, identity_server_1.CurrentUser)()),
+    tslib_1.__param(3, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, decide_tool_permission_dto_1.DecideToolPermissionDto, Object, String]),
+    tslib_1.__metadata("design:returntype", void 0)
+], ToolPermissionController.prototype, "decide", null);
+tslib_1.__decorate([
+    (0, common_1.Post)('runs/:runId/permission/extend'),
+    (0, common_1.UseGuards)(identity_server_1.OriginGuard),
+    (0, swagger_1.ApiOperation)({
+        summary: 'Give the user more time to answer a parked tool call'
+    }),
+    tslib_1.__param(0, (0, common_1.Param)('runId', common_1.ParseUUIDPipe)),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, identity_server_1.CurrentUser)()),
+    tslib_1.__param(3, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, extend_tool_permission_dto_1.ExtendToolPermissionDto, Object, String]),
+    tslib_1.__metadata("design:returntype", Object)
+], ToolPermissionController.prototype, "extend", null);
+exports.ToolPermissionController = ToolPermissionController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.PermissionsGuard, workspaces_server_1.WorkspaceGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.COPILOT_USE),
+    (0, common_1.Controller)('copilot'),
+    tslib_1.__metadata("design:paramtypes", [tool_permission_broker_1.ToolPermissionBroker])
+], ToolPermissionController);

package/dist/lib/chat/http/controllers/update-conversation.controller.d.ts

@@ -0,0 +1,37 @@
+import { type ModelRegistry } from '@orthacms/copilot-domain';
+import { type PublicUser } from '@orthacms/identity-server';
+import { ConversationRepository, type ConversationView } from '../../infrastructure/persistence/conversation.repository';
+import { UpdateConversationDto } from '../../application/dto/update-conversation.dto';
+/**
+ * `PATCH /api/copilot/conversations/:id` — rename a thread, file it away, bring
+ * it back, or record the model picked for it.
+ *
+ * **Archiving is the only removal this API offers, and it is reversible.** A
+ * thread's proposals are the receipts for changes that were actually made to
+ * the caller's content (ADR-0009), so deleting a conversation would take the
+ * only record of those edits with it. Hiding it from the list is the part
+ * people want; destroying the audit trail is not, and if a hard delete is ever
+ * added it needs to answer for the proposals first.
+ *
+ * A thread the caller doesn't own is a **404, not a 403** — the repository
+ * filters on user and workspace and reports "not found" either way, so an id
+ * cannot be probed for existence. `OriginGuard` because this changes state.
+ */
+export declare class UpdateConversationController {
+    private readonly conversations;
+    private readonly models;
+    constructor(conversations: ConversationRepository, models: ModelRegistry);
+    update(id: string, body: UpdateConversationDto, user: PublicUser, workspaceId: string): Promise<ConversationView>;
+    /**
+     * Refuses a choice that names no registered backend.
+     *
+     * The column is read back into the picker and offered as the next run's
+     * `provider`/`model`, so an unchecked string is a value the user writes and
+     * the UI then renders — and a run that would fail on a backend that does not
+     * exist. Checking against `catalogue()` keeps the stored value inside what
+     * the operator configured at boot, which is the same boundary the run route
+     * enforces when a request names a provider.
+     */
+    private assertKnownModel;
+}
+//# sourceMappingURL=update-conversation.controller.d.ts.map

package/dist/lib/chat/http/controllers/update-conversation.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-conversation.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/chat/http/controllers/update-conversation.controller.ts"],"names":[],"mappings":"AAYA,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAMH,KAAK,UAAU,EAClB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACH,sBAAsB,EACtB,KAAK,gBAAgB,EACxB,MAAM,0DAA0D,CAAC;AAClE,OAAO,EAEH,qBAAqB,EACxB,MAAM,+CAA+C,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,qBAGa,4BAA4B;IAEjC,OAAO,CAAC,QAAQ,CAAC,aAAa;IACN,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAD9B,aAAa,EAAE,sBAAsB,EACb,MAAM,EAAE,aAAa;IAQ5D,MAAM,CACoB,EAAE,EAAE,MAAM,EAC9B,IAAI,EAAE,qBAAqB,EACpB,IAAI,EAAE,UAAU,EACX,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;IAuC5B;;;;;;;;;OASG;IACH,OAAO,CAAC,gBAAgB;CAoB3B"}

package/dist/lib/chat/http/controllers/update-conversation.controller.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateConversationController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const copilot_domain_1 = require("@orthacms/copilot-domain");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const conversation_repository_1 = require("../../infrastructure/persistence/conversation.repository");
+const update_conversation_dto_1 = require("../../application/dto/update-conversation.dto");
+/**
+ * `PATCH /api/copilot/conversations/:id` — rename a thread, file it away, bring
+ * it back, or record the model picked for it.
+ *
+ * **Archiving is the only removal this API offers, and it is reversible.** A
+ * thread's proposals are the receipts for changes that were actually made to
+ * the caller's content (ADR-0009), so deleting a conversation would take the
+ * only record of those edits with it. Hiding it from the list is the part
+ * people want; destroying the audit trail is not, and if a hard delete is ever
+ * added it needs to answer for the proposals first.
+ *
+ * A thread the caller doesn't own is a **404, not a 403** — the repository
+ * filters on user and workspace and reports "not found" either way, so an id
+ * cannot be probed for existence. `OriginGuard` because this changes state.
+ */
+let UpdateConversationController = class UpdateConversationController {
+    conversations;
+    models;
+    constructor(conversations, models) {
+        this.conversations = conversations;
+        this.models = models;
+    }
+    async update(id, body, user, workspaceId) {
+        // An empty patch cannot mean anything, and answering 200 to it would
+        // report success for a write that never happened. The pipe cannot catch
+        // this: every property is legitimately optional on its own.
+        if (body.title === undefined &&
+            body.archived === undefined &&
+            body.modelChoice === undefined) {
+            throw new common_1.BadRequestException('Provide a title, an archived flag, a model choice, or several.');
+        }
+        if (body.modelChoice !== undefined) {
+            this.assertKnownModel(body.modelChoice);
+        }
+        const updated = await this.conversations.update(id, user.id, workspaceId, {
+            ...(body.title !== undefined ? { title: body.title } : {}),
+            ...(body.archived !== undefined
+                ? { archived: body.archived }
+                : {}),
+            ...(body.modelChoice !== undefined
+                ? { modelChoice: body.modelChoice }
+                : {})
+        });
+        if (!updated) {
+            throw new common_1.NotFoundException('Conversation not found.');
+        }
+        return updated;
+    }
+    /**
+     * Refuses a choice that names no registered backend.
+     *
+     * The column is read back into the picker and offered as the next run's
+     * `provider`/`model`, so an unchecked string is a value the user writes and
+     * the UI then renders — and a run that would fail on a backend that does not
+     * exist. Checking against `catalogue()` keeps the stored value inside what
+     * the operator configured at boot, which is the same boundary the run route
+     * enforces when a request names a provider.
+     */
+    assertKnownModel(choice) {
+        if (choice === update_conversation_dto_1.MODEL_CHOICE_DEFAULT) {
+            return;
+        }
+        // The first colon only: a provider name cannot contain one, and a model
+        // id routinely does (`llama3.1:8b`).
+        const separator = choice.indexOf(':');
+        const provider = separator > 0 ? choice.slice(0, separator) : '';
+        const model = separator > 0 ? choice.slice(separator + 1) : '';
+        const known = this.models
+            .catalogue()
+            .some((entry) => entry.provider === provider && entry.model === model);
+        if (!known) {
+            throw new common_1.BadRequestException('That model choice names no registered backend.');
+        }
+    }
+};
+exports.UpdateConversationController = UpdateConversationController;
+tslib_1.__decorate([
+    (0, common_1.Patch)('conversations/:id'),
+    (0, common_1.UseGuards)(identity_server_1.OriginGuard),
+    (0, swagger_1.ApiOperation)({
+        summary: 'Rename, archive, or set the model of a copilot conversation'
+    }),
+    tslib_1.__param(0, (0, common_1.Param)('id', common_1.ParseUUIDPipe)),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, identity_server_1.CurrentUser)()),
+    tslib_1.__param(3, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, update_conversation_dto_1.UpdateConversationDto, Object, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], UpdateConversationController.prototype, "update", null);
+exports.UpdateConversationController = UpdateConversationController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.PermissionsGuard, workspaces_server_1.WorkspaceGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.COPILOT_USE),
+    (0, common_1.Controller)('copilot'),
+    tslib_1.__param(1, (0, common_1.Inject)(copilot_domain_1.MODEL_REGISTRY)),
+    tslib_1.__metadata("design:paramtypes", [conversation_repository_1.ConversationRepository, Object])
+], UpdateConversationController);