@opengeni/api-router 3.0.1 → 3.1.2

package/src/routes/canonical-human-identities.ts

@@ -23,6 +23,9 @@ import {
 import type { Context, Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { z } from "zod";
+import { admitManagedSignInMutation } from "./managed-sign-in-methods";
+import { managedAuthSecretRequestDigest } from "@opengeni/core/managed-auth-session-sets";
+import { deliverManagedSignInNotification } from "../auth/managed-sign-in-notifications";
 
 const BindingId = z.string().uuid();
 
@@ -86,6 +89,7 @@ async function mutate(
     operationId: string;
     expectedIdentityRevision: number;
     reason: string;
+    verifiedManagedRecovery?: boolean;
   },
 ): Promise<Response> {
   const identity = await requestIdentity(context, deps);
@@ -104,10 +108,27 @@ async function mutate(
         ...(input.providerId ? { providerId: input.providerId } : {}),
         ...(input.providerAccountId ? { providerAccountId: input.providerAccountId } : {}),
         reason: input.reason,
+        ...(input.verifiedManagedRecovery
+          ? {
+              verifiedRecovery: {
+                authSessionId: identity.authSessionId,
+                requestDigest: managedAuthSecretRequestDigest(
+                  deps.settings.betterAuthSecret!,
+                  input,
+                ),
+              },
+            }
+          : {}),
         ...(actorFence ? { actorFence } : {}),
       }),
     );
     if (actorFence) markManagedAuthRequestActorTransitionApplied(context.req.raw);
+    if (input.verifiedManagedRecovery)
+      await deliverManagedSignInNotification(
+        deps.db,
+        deps.managedEmailTransport,
+        input.operationId,
+      );
     return context.json(response);
   } catch (error) {
     return identityError(context, error);
@@ -132,6 +153,11 @@ export function registerCanonicalHumanIdentityRoutes(app: Hono, deps: ApiRouteDe
 
   app.post(`${base}/login-bindings`, async (context) => {
     const request = await parseBody(context, LinkCanonicalHumanLoginBindingRequest);
+    if (["google", "github", "credential"].includes(request.providerId.trim().toLowerCase())) {
+      throw new HTTPException(403, {
+        message: "Use personal sign-in method settings with fresh provider proof",
+      });
+    }
     return await mutate(context, deps, {
       operationType: "link",
       ...request,
@@ -141,6 +167,19 @@ export function registerCanonicalHumanIdentityRoutes(app: Hono, deps: ApiRouteDe
 
   app.delete(`${base}/login-bindings/:bindingId`, async (context) => {
     const request = await parseBody(context, CanonicalHumanBindingOperationRequest);
+    const actor = await requestIdentity(context, deps);
+    const projection = await getCanonicalHumanIdentityProjection(deps.db, actor.authUserId);
+    if (
+      projection.loginBindings.some(
+        (binding) =>
+          binding.id === bindingId(context) &&
+          ["google", "github", "credential"].includes(binding.providerId),
+      )
+    ) {
+      throw new HTTPException(403, {
+        message: "Use personal sign-in method settings with last-method protection",
+      });
+    }
     return await mutate(context, deps, {
       operationType: "unlink",
       bindingId: bindingId(context),
@@ -151,6 +190,19 @@ export function registerCanonicalHumanIdentityRoutes(app: Hono, deps: ApiRouteDe
 
   app.post(`${base}/login-bindings/:bindingId/recovery`, async (context) => {
     const request = await parseBody(context, CanonicalHumanBindingOperationRequest);
+    const actor = await requestIdentity(context, deps);
+    const projection = await getCanonicalHumanIdentityProjection(deps.db, actor.authUserId);
+    if (
+      projection.loginBindings.some(
+        (binding) =>
+          binding.id === bindingId(context) &&
+          ["google", "github", "credential"].includes(binding.providerId),
+      )
+    ) {
+      throw new HTTPException(403, {
+        message: "Managed-provider recovery cannot be initiated through raw binding management",
+      });
+    }
     return await mutate(context, deps, {
       operationType: "begin_recovery",
       bindingId: bindingId(context),
@@ -161,11 +213,20 @@ export function registerCanonicalHumanIdentityRoutes(app: Hono, deps: ApiRouteDe
 
   app.post(`${base}/login-bindings/:bindingId/recovery/complete`, async (context) => {
     const request = await parseBody(context, CanonicalHumanBindingOperationRequest);
+    const actor = await requestIdentity(context, deps);
+    const projection = await getCanonicalHumanIdentityProjection(deps.db, actor.authUserId);
+    const managed = projection.loginBindings.some(
+      (binding) =>
+        binding.id === bindingId(context) &&
+        ["google", "github", "credential"].includes(binding.providerId),
+    );
+    if (managed) await admitManagedSignInMutation(context, deps);
     return await mutate(context, deps, {
       operationType: "recover",
       bindingId: bindingId(context),
       ...request,
       operationId: request.operationId ?? randomUUID(),
+      ...(managed ? { verifiedManagedRecovery: true } : {}),
     });
   });
 }

package/src/routes/capabilities.ts

@@ -3,9 +3,21 @@ import {
   CreateCapabilityCatalogItemRequest,
   DiscoverMcpCapabilitiesResponse,
   EnableCapabilityRequest,
+  ConnectorToolPermissionsResponse,
+  UpdateConnectorToolPermissionsRequest,
+  SessionMcpToolPermissionsQuery,
+  SessionMcpToolPermissionsResponse,
+  UpdateSessionMcpToolPermissionsRequest,
 } from "@opengeni/contracts";
 import type { Hono } from "hono";
-import { requireAccessGrant } from "@opengeni/core";
+import {
+  requireAccessGrant,
+  requireAccessGrantAuthorization,
+  getConnectorToolPermissions,
+  updateConnectorToolPermissions,
+  getSessionMcpToolPermissions,
+  updateSessionMcpToolPermissions,
+} from "@opengeni/core";
 import type { ApiRouteDeps } from "@opengeni/core";
 import {
   buildCapabilityCatalog,
@@ -15,6 +27,7 @@ import {
   enableCapability,
   officialMcpRegistryUrl,
 } from "@opengeni/core";
+import { isPersonalConnectionOwnerPrincipal } from "../connection-ownership";
 import { boundedLimit } from "../http/common";
 import { z } from "zod";
 import pluginSnapshot from "../../../../data/catalog/plugins-snapshot.json";
@@ -22,6 +35,7 @@ const discoverablePlugins = pluginSnapshot.sources
   .flatMap((source) => source.entries.map((entry) => ({ ...entry, provider: source.provider })))
   .sort((a, b) => a.displayName.localeCompare(b.displayName) || a.id.localeCompare(b.id));
 import { inspectMcpAuthentication } from "../integrations/oauth-client";
+import { parseRequestJson } from "../http/request-body";
 
 export function registerCapabilityRoutes(app: Hono, deps: ApiRouteDeps): void {
   const { db, settings } = deps;
@@ -66,7 +80,7 @@ export function registerCapabilityRoutes(app: Hono, deps: ApiRouteDeps): void {
   });
   app.post("/v1/workspaces/:workspaceId/capabilities/discovery/mcp-auth", async (c) => {
     await requireAccessGrant(c, deps, c.req.param("workspaceId"), "workspace:read");
-    const { url } = z.object({ url: z.string().url().max(2048) }).parse(await c.req.json());
+    const { url } = await parseRequestJson(c, z.object({ url: z.string().url().max(2048) }));
     return c.json(await inspectMcpAuthentication(url, settings));
   });
 
@@ -75,7 +89,13 @@ export function registerCapabilityRoutes(app: Hono, deps: ApiRouteDeps): void {
     const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:read");
     return c.json(
       CapabilityCatalogResponse.parse(
-        await buildCapabilityCatalog({ db, workspaceId, settings, subjectId: grant.subjectId }),
+        await buildCapabilityCatalog({
+          db,
+          workspaceId,
+          settings,
+          subjectId: grant.subjectId,
+          accountId: grant.accountId,
+        }),
       ),
     );
   });
@@ -83,7 +103,7 @@ export function registerCapabilityRoutes(app: Hono, deps: ApiRouteDeps): void {
   app.post("/v1/workspaces/:workspaceId/capabilities", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "capabilities:manage");
-    const payload = CreateCapabilityCatalogItemRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, CreateCapabilityCatalogItemRequest);
     return c.json(
       await createCatalogItem({ db, accountId: grant.accountId, workspaceId, payload }),
       201,
@@ -110,10 +130,97 @@ export function registerCapabilityRoutes(app: Hono, deps: ApiRouteDeps): void {
     );
   });
 
+  app.get("/v1/workspaces/:workspaceId/capabilities/:capabilityId/tool-permissions", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const access = await requireAccessGrantAuthorization(c, deps, workspaceId, "workspace:read");
+    return c.json(
+      ConnectorToolPermissionsResponse.parse(
+        await getConnectorToolPermissions({
+          db,
+          settings,
+          workspaceId,
+          grant: access.grant,
+          capabilityId: decodeURIComponent(c.req.param("capabilityId")),
+          personalOwnerVerified: isPersonalConnectionOwnerPrincipal(access),
+          ...(c.req.query("connectionId") ? { connectionId: c.req.query("connectionId")! } : {}),
+          ...(c.req.query("instanceKey") ? { instanceKey: c.req.query("instanceKey")! } : {}),
+        }),
+      ),
+    );
+  });
+
+  app.patch(
+    "/v1/workspaces/:workspaceId/capabilities/:capabilityId/tool-permissions",
+    async (c) => {
+      const workspaceId = c.req.param("workspaceId");
+      const access = await requireAccessGrantAuthorization(
+        c,
+        deps,
+        workspaceId,
+        "capabilities:manage",
+      );
+      const payload = UpdateConnectorToolPermissionsRequest.safeParse(await c.req.json());
+      if (!payload.success) return c.json({ error: "Invalid connector permission target" }, 400);
+      await updateConnectorToolPermissions({
+        db,
+        settings,
+        workspaceId,
+        grant: access.grant,
+        capabilityId: decodeURIComponent(c.req.param("capabilityId")),
+        personalOwnerVerified: isPersonalConnectionOwnerPrincipal(access),
+        payload: payload.data,
+      });
+      return c.json({ saved: true });
+    },
+  );
+
+  // Host-attached session MCP servers: the host names the server id and exact
+  // URL it attaches; rules apply to that server in every workspace session.
+  app.get("/v1/workspaces/:workspaceId/session-mcp-tool-permissions", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const access = await requireAccessGrantAuthorization(c, deps, workspaceId, "workspace:read");
+    const query = SessionMcpToolPermissionsQuery.safeParse({
+      serverId: c.req.query("serverId"),
+      url: c.req.query("url"),
+    });
+    if (!query.success) return c.json({ error: "Invalid session MCP server" }, 400);
+    return c.json(
+      SessionMcpToolPermissionsResponse.parse(
+        await getSessionMcpToolPermissions({
+          db,
+          workspaceId,
+          grant: access.grant,
+          query: query.data,
+        }),
+      ),
+    );
+  });
+
+  app.patch("/v1/workspaces/:workspaceId/session-mcp-tool-permissions", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const access = await requireAccessGrantAuthorization(
+      c,
+      deps,
+      workspaceId,
+      "capabilities:manage",
+    );
+    const payload = UpdateSessionMcpToolPermissionsRequest.safeParse(
+      await c.req.json().catch(() => null),
+    );
+    if (!payload.success) return c.json({ error: "Invalid session MCP permission target" }, 400);
+    await updateSessionMcpToolPermissions({
+      db,
+      workspaceId,
+      grant: access.grant,
+      payload: payload.data,
+    });
+    return c.json({ saved: true });
+  });
+
   app.post("/v1/workspaces/:workspaceId/capabilities/:capabilityId/enable", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "capabilities:manage");
-    const payload = EnableCapabilityRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, EnableCapabilityRequest);
     const installation = await enableCapability({
       db,
       grant,

package/src/routes/channels.ts

@@ -16,6 +16,7 @@ import type { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { requireAccessGrant } from "@opengeni/core";
 import type { ApiRouteDeps } from "@opengeni/core";
+import { parseRequestJson } from "../http/request-body";
 
 // Workspace-shared channels organize root sessions ("workstreams") by work
 // type in the rail. Deliberately session-permission-gated (not workspace:admin):
@@ -42,7 +43,7 @@ export function registerChannelRoutes(app: Hono, deps: ApiRouteDeps): void {
   app.post("/v1/workspaces/:workspaceId/channels", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:create");
-    const payload = CreateChannelRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, CreateChannelRequest);
     try {
       const channel = await createChannel(db, {
         accountId: grant.accountId,
@@ -63,7 +64,7 @@ export function registerChannelRoutes(app: Hono, deps: ApiRouteDeps): void {
   app.patch("/v1/workspaces/:workspaceId/channels/:channelId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "sessions:create");
-    const payload = UpdateChannelRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, UpdateChannelRequest);
     try {
       const channel = await updateChannel(
         db,
@@ -86,7 +87,7 @@ export function registerChannelRoutes(app: Hono, deps: ApiRouteDeps): void {
   app.put("/v1/workspaces/:workspaceId/channels/order", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "sessions:create");
-    const payload = ReorderChannelsRequest.parse(await c.req.json());
+    const payload = await parseRequestJson(c, ReorderChannelsRequest);
     const channels = await reorderChannels(db, workspaceId, payload.channelIds);
     if (!channels) {
       throw new HTTPException(409, { message: "projects changed; refresh and try again" });

package/src/routes/chat-completions.ts

@@ -0,0 +1,235 @@
+import {
+  type ApiRouteDeps,
+  ModelCallError,
+  type ModelCallOutput,
+  type ModelCallService,
+  requireAccessGrant,
+} from "@opengeni/core";
+import type { Context, Hono } from "hono";
+import {
+  chatCompletionChunk,
+  chatCompletionError,
+  chatCompletionResponse,
+  chatCompletionUsage,
+  chatCompletionId,
+  parseChatCompletionRequest,
+} from "../model-calls/chat-completions";
+import { isModelCallAbort } from "../model-calls/service";
+
+/**
+ * OpenAI-compatible stateless model calls. A stock OpenAI SDK works with its
+ * base URL set to `/v1/workspaces/{workspaceId}` and an Opengeni API key.
+ * Running one costs what the same model call costs inside a session, and
+ * requires the same `sessions:create` authority.
+ */
+export function registerChatCompletionRoutes(
+  app: Hono,
+  deps: ApiRouteDeps & { modelCalls: ModelCallService | null },
+): void {
+  /** A public error, or null for a client abort (nothing left to answer). */
+  const publicError = (error: unknown, workspaceId: string): ModelCallError | null => {
+    if (error instanceof ModelCallError) return error;
+    if (isModelCallAbort(error)) return null;
+    deps.observability?.warn("chat completion failed unexpectedly", {
+      workspaceId,
+      errorName: error instanceof Error ? error.name : typeof error,
+    });
+    return new ModelCallError({
+      status: 500,
+      type: "api_error",
+      code: "internal_error",
+      message: "The model call failed.",
+    });
+  };
+
+  app.get("/v1/workspaces/:workspaceId/models", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:create");
+    if (!deps.modelCalls) return errorResponse(c, unavailable());
+    try {
+      const models = await deps.modelCalls.listModels({
+        grant,
+        accountId: grant.accountId,
+        workspaceId,
+        subjectId: grant.subjectId,
+      });
+      return c.json({
+        object: "list",
+        data: models.map((model) => ({
+          id: model.id,
+          object: "model",
+          created: 0,
+          owned_by: model.providerLabel,
+          name: model.label,
+        })),
+      });
+    } catch (error) {
+      return errorResponse(c, publicError(error, workspaceId));
+    }
+  });
+
+  app.post("/v1/workspaces/:workspaceId/chat/completions", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    const grant = await requireAccessGrant(c, deps, workspaceId, "sessions:create");
+    const service = deps.modelCalls;
+    if (!service) return errorResponse(c, unavailable());
+    let parsed: ReturnType<typeof parseChatCompletionRequest>;
+    try {
+      parsed = parseChatCompletionRequest(await c.req.json().catch(() => undefined));
+    } catch (error) {
+      return errorResponse(c, publicError(error, workspaceId));
+    }
+    // Server-generated: a client-chosen id would let a reused settlement key
+    // make later calls free.
+    const requestId = crypto.randomUUID();
+    const created = Math.floor(Date.now() / 1000);
+    const abort = new AbortController();
+    const clientSignal = c.req.raw.signal;
+    const onClientAbort = () => abort.abort();
+    if (clientSignal.aborted) abort.abort();
+    else clientSignal.addEventListener("abort", onClientAbort, { once: true });
+    const caller = {
+      grant,
+      accountId: grant.accountId,
+      workspaceId,
+      subjectId: grant.subjectId,
+      model: parsed.model,
+      request: parsed.request,
+      requestId,
+      signal: abort.signal,
+    };
+
+    if (!parsed.stream) {
+      try {
+        const output = await service.call(caller);
+        return c.json(
+          chatCompletionResponse({
+            requestId,
+            created,
+            model: output.model,
+            result: output.result,
+          }),
+        );
+      } catch (error) {
+        return errorResponse(c, publicError(error, workspaceId));
+      } finally {
+        clientSignal.removeEventListener("abort", onClientAbort);
+      }
+    }
+
+    // Streaming: the status is decided by the first model output. A refusal
+    // or failure before any output is an ordinary JSON error response.
+    const encoder = new TextEncoder();
+    let controller: ReadableStreamDefaultController<Uint8Array> | null = null;
+    let closed = false;
+    const body = new ReadableStream<Uint8Array>({
+      start(streamController) {
+        controller = streamController;
+      },
+      cancel() {
+        closed = true;
+        abort.abort();
+      },
+    });
+    const send = (payload: unknown) => {
+      if (closed || !controller) return;
+      const data = typeof payload === "string" ? payload : JSON.stringify(payload);
+      controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+    };
+    const close = () => {
+      if (closed || !controller) return;
+      closed = true;
+      controller.close();
+    };
+    let model: string | null = null;
+    let opened = false;
+    let signalOpened!: () => void;
+    const firstOutput = new Promise<void>((resolve) => {
+      signalOpened = resolve;
+    });
+    const chunk = (
+      delta: { role?: "assistant"; content?: string },
+      finishReason: null | ModelCallOutput["result"]["finishReason"],
+    ) =>
+      chatCompletionChunk({
+        requestId,
+        created,
+        model: model ?? parsed.model ?? "",
+        delta,
+        finishReason,
+        includeUsage: parsed.includeUsage,
+      });
+    const open = () => {
+      if (opened) return;
+      opened = true;
+      send(chunk({ role: "assistant", content: "" }, null));
+      signalOpened();
+    };
+    const completion = service.call({
+      ...caller,
+      onTextDelta: (delta) => {
+        open();
+        send(chunk({ content: delta }, null));
+      },
+    });
+    const first = await Promise.race([
+      firstOutput.then(() => ({ kind: "output" as const })),
+      completion.then(
+        (output) => ({ kind: "done" as const, output }),
+        (error: unknown) => ({ kind: "failed" as const, error }),
+      ),
+    ]);
+    if (first.kind === "failed" && !opened) {
+      clientSignal.removeEventListener("abort", onClientAbort);
+      return errorResponse(c, publicError(first.error, workspaceId));
+    }
+    open();
+    void completion
+      .then((output) => {
+        model = output.model;
+        send(chunk({}, output.result.finishReason));
+        if (parsed.includeUsage) {
+          send({
+            id: chatCompletionId(requestId),
+            object: "chat.completion.chunk",
+            created,
+            model: output.model,
+            choices: [],
+            usage: chatCompletionUsage(output.result.usage),
+          });
+        }
+        send("[DONE]");
+      })
+      .catch((error: unknown) => {
+        // Headers are already sent; report the failure in-band like OpenAI.
+        const failure = publicError(error, workspaceId);
+        if (failure) send(chatCompletionError(failure));
+      })
+      .finally(() => {
+        clientSignal.removeEventListener("abort", onClientAbort);
+        close();
+      });
+    return new Response(body, {
+      status: 200,
+      headers: {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        "x-accel-buffering": "no",
+      },
+    });
+  });
+}
+
+function unavailable(): ModelCallError {
+  return new ModelCallError({
+    status: 503,
+    type: "service_unavailable",
+    code: "unavailable",
+    message: "Model calls are unavailable on this deployment.",
+  });
+}
+
+function errorResponse(c: Context, error: ModelCallError | null): Response {
+  if (!error) return c.body(null, 499 as never);
+  return c.json(chatCompletionError(error), error.status as never);
+}