@segmentstream-cloud/ontology 0.14.0 → 0.15.0

package/dist/service/config.js

@@ -34,6 +34,11 @@ export const RUNTIME_IDENTITY_ENVIRONMENT_VARIABLES = {
     audience: "SEGMENTSTREAM_RUNTIME_OIDC_AUDIENCE",
     projectId: "VERCEL_PROJECT_ID",
 };
+/**
+ * The project's production domain, which Vercel sets: the agent of a deployment with runtime identity
+ * takes the messages of `agent_chat.send_message` there.
+ */
+export const AGENT_HOST_VARIABLE = "VERCEL_PROJECT_PRODUCTION_URL";
 /** The service cannot start: its configuration is incomplete or invalid. */
 export class OntologyServiceConfigError extends Schema.TaggedError()("OntologyServiceConfigError", { message: Schema.String }) {
 }
@@ -160,6 +165,9 @@ export function configFromEnv(environment = process.env) {
             : {}),
         ...(neonAuth === undefined ? {} : { neonAuth }),
         ...(runtimeIdentity === undefined ? {} : { runtimeIdentity }),
+        ...(runtimeIdentity === undefined || read(AGENT_HOST_VARIABLE) === ""
+            ? {}
+            : { agentUrl: normalizeUrl(AGENT_HOST_VARIABLE, `https://${read(AGENT_HOST_VARIABLE)}`) }),
         ...(localConnections === undefined ? {} : { localConnections }),
     };
 }

package/dist/service/handlers.d.ts

@@ -4,6 +4,7 @@ import type { Aggregates } from "./aggregate.js";
 import { type BuiltApi } from "./api.js";
 import type { AfterCommitHook } from "./config.js";
 import type { ReplicationKick } from "./replication.js";
+import type { AgentChannelFactory } from "./agent/channel.js";
 import type { ConnectionTransportFactory } from "./connections.js";
 import { type RateLimit } from "./rate-limit.js";
 import { OntologyBackend } from "./runtime-contract.js";
@@ -13,4 +14,4 @@ import { OntologyBackend } from "./runtime-contract.js";
  */
 export declare const SIGN_IN_CHECK_LIMIT: RateLimit;
 /** The handlers of every group of the API; they require {@link OntologyBackend}. */
-export declare function handlersLayer(built: BuiltApi, hooks: ReadonlyMap<string, AfterCommitHook>, connections: ConnectionTransportFactory, replicate: ReplicationKick, aggregates: Aggregates): Layer.Layer<HttpApiGroup.Service<"ontology", string>, never, OntologyBackend>;
+export declare function handlersLayer(built: BuiltApi, hooks: ReadonlyMap<string, AfterCommitHook>, connections: ConnectionTransportFactory, replicate: ReplicationKick, aggregates: Aggregates, agentChannel: AgentChannelFactory | undefined): Layer.Layer<HttpApiGroup.Service<"ontology", string>, never, OntologyBackend>;

package/dist/service/handlers.js

@@ -216,8 +216,8 @@ function storageHandlers(built) {
     }));
 }
 /** The handlers of every group of the API; they require {@link OntologyBackend}. */
-export function handlersLayer(built, hooks, connections, replicate, aggregates) {
-    const operationsOf = (backend) => makeOperations(backend, built.plan, hooks, connections, replicate);
+export function handlersLayer(built, hooks, connections, replicate, aggregates, agentChannel) {
+    const operationsOf = (backend) => makeOperations(backend, built.plan, hooks, connections, replicate, agentChannel);
     const layers = [
         serviceHandlers(built, operationsOf, aggregates.model),
         ...(built.plan.ontology.manifest.entities.some((entity) => entity.properties.some((property) => property.type === "blob"))

package/dist/service/mcp/server.d.ts

@@ -4,6 +4,7 @@ import type { Aggregates } from "../aggregate.js";
 import type { BuiltApi } from "../api.js";
 import { type TokenVerifier } from "../authentication.js";
 import type { AfterCommitHook } from "../config.js";
+import type { AgentChannelFactory } from "../agent/channel.js";
 import type { ConnectionTransportFactory } from "../connections.js";
 import { RequestId } from "../errors.js";
 import type { ReplicationKick } from "../replication.js";
@@ -23,6 +24,8 @@ export interface McpServerOptions {
     readonly verifyRuntime?: RuntimeTokenVerifier | undefined;
     /** The facade the aggregate routes run; the aggregate tool runs its model-level aggregate. */
     readonly aggregates: Aggregates;
+    /** The workspace's agent, for `agent_chat.send_message`; `undefined` without one. */
+    readonly agentChannel?: AgentChannelFactory | undefined;
 }
 /**
  * The ontology's MCP server at `POST /mcp`: Streamable HTTP without sessions, so any instance can

package/dist/service/mcp/server.js

@@ -417,7 +417,7 @@ export function mcpLayer(options) {
         const server = {
             built: options.built,
             tools,
-            operations: makeOperations(backend, options.built.plan, options.hooks, options.connections, options.replicate),
+            operations: makeOperations(backend, options.built.plan, options.hooks, options.connections, options.replicate, options.agentChannel),
             aggregate: options.aggregates.model,
         };
         yield* router.add("POST", MCP_PATH, handlePost(server, options.verifyToken, options.verifyRuntime, backend));

package/dist/service/operations.d.ts

@@ -5,6 +5,7 @@ import type { Query, QueryResult } from "../query.js";
 import { CurrentPrincipal } from "./authentication.js";
 import type { AfterCommitHook } from "./config.js";
 import type { ReplicationKick } from "./replication.js";
+import type { AgentChannelFactory } from "./agent/channel.js";
 import { type ConnectionTransportFactory } from "./connections.js";
 import { InvalidActionInput, RequestId } from "./errors.js";
 import type { ApiPlan, PlannedAction, PlannedEntity, Traversal } from "./plan.js";
@@ -59,8 +60,11 @@ export interface Caller {
     readonly permissions: ReadonlyArray<string>;
 }
 type Backend = OntologyBackend["Service"];
-/** The operations of a planned ontology, bound to its backend, after-commit hooks and connections. */
-export declare function makeOperations(backend: Backend, plan: ApiPlan, hooks: ReadonlyMap<string, AfterCommitHook>, connections: ConnectionTransportFactory, replicate: ReplicationKick): {
+/**
+ * The operations of a planned ontology, bound to its backend, after-commit hooks, connections and,
+ * on deployments with one, the workspace's agent.
+ */
+export declare function makeOperations(backend: Backend, plan: ApiPlan, hooks: ReadonlyMap<string, AfterCommitHook>, connections: ConnectionTransportFactory, replicate: ReplicationKick, agentChannel?: AgentChannelFactory): {
     /** A page of records. Requires `read` on the entity and on every entity the query reaches. */
     find: (planned: PlannedEntity, query: Query) => Effect.Effect<QueryResult<Readonly<Record<string, unknown>>>, PermissionDenied | import("../index.js").InvalidQuery, CurrentPrincipal>;
     /** One record. Requires `read` on the entity. */

package/dist/service/operations.js

@@ -6,6 +6,7 @@ import { PermissionDenied } from "../errors.js";
 import { toCamelCase } from "../names.js";
 import { missingPermission, permissionOf, READ_VERB } from "../permissions.js";
 import { CurrentPrincipal } from "./authentication.js";
+import { AgentChannel } from "../agent-chat.js";
 import { OIDC_TOKEN_HEADER } from "./connections.js";
 import { InvalidActionInput, RequestId } from "./errors.js";
 /**
@@ -145,12 +146,12 @@ function traverseOf(backend, targets, planned, traversal, id, query) {
         return page(yield* backend.find({ entity: traversal.target, query: { ...query, where } }));
     });
 }
-function runActionOf(backend, ontology, hooks, connections, replicate) {
+function runActionOf(backend, ontology, hooks, connections, replicate, agentChannel) {
     return (planned, { name, generated }, call) => Effect.gen(function* () {
         const principal = yield* CurrentPrincipal;
         const requestId = yield* RequestId;
         const hook = hooks.get(`${planned.name}.${name}`);
-        const outcome = yield* backend.runAction({
+        const run = backend.runAction({
             entity: planned.name,
             action: name,
             input: call.input,
@@ -175,6 +176,10 @@ function runActionOf(backend, ontology, hooks, connections, replicate) {
                 }
                 : {}),
         });
+        // Built-in actions reach the workspace's agent through it, when the deployment has one.
+        const outcome = yield* agentChannel === undefined
+            ? run
+            : run.pipe(Effect.provideService(AgentChannel, agentChannel({ identityToken: call.identityToken, store: backend.agents })));
         const { issues } = outcome.validation;
         if (!outcome.validation.ok && !call.validateOnly) {
             return yield* new InvalidActionInput({ issues });
@@ -208,8 +213,11 @@ function callerOf(backend) {
         };
     });
 }
-/** The operations of a planned ontology, bound to its backend, after-commit hooks and connections. */
-export function makeOperations(backend, plan, hooks, connections, replicate) {
+/**
+ * The operations of a planned ontology, bound to its backend, after-commit hooks, connections and,
+ * on deployments with one, the workspace's agent.
+ */
+export function makeOperations(backend, plan, hooks, connections, replicate, agentChannel) {
     const targets = relationshipTargets(plan);
     return {
         /** A page of records. Requires `read` on the entity and on every entity the query reaches. */
@@ -221,7 +229,7 @@ export function makeOperations(backend, plan, hooks, connections, replicate) {
         /** The records a relationship reaches from one record, as a page of the target entity. */
         traverse: (planned, traversal, id, query) => traverseOf(backend, targets, planned, traversal, id, query),
         /** Runs an action as the caller, with the action's after-commit hook and connections. */
-        runAction: runActionOf(backend, plan.ontology, hooks, connections, replicate),
+        runAction: runActionOf(backend, plan.ontology, hooks, connections, replicate, agentChannel),
         /** The caller's user, roles and permissions. It needs no permission. */
         caller: callerOf(backend),
     };

package/dist/service/runtime-contract.d.ts

@@ -180,6 +180,13 @@ export interface AgentMember {
     readonly name: string;
     readonly principal: Principal;
 }
+/** A group chat the agent saw, as `POST /api/ontology/agent/chats/seen` answers. */
+export interface SeenChat {
+    readonly id: string;
+    readonly title: string;
+    readonly purpose: string | null;
+    readonly whenToUse: string | null;
+}
 /**
  * Where the app's agent keeps pairing codes and the identities they create: the runtime's agent
  * tables in the workspace database. Codes are stored only as SHA-256 hashes. Expiry is checked
@@ -218,6 +225,25 @@ export interface AgentStore {
     readonly member: (userId: string) => Effect.Effect<AgentMember | undefined>;
     /** The member a runtime caller acts for: active, and with a live identity. */
     readonly actingMember: (userId: string) => Effect.Effect<Principal | undefined>;
+    /**
+     * Records a message the agent saw in a group chat: creates the `agent_chat` or keeps its title
+     * current, records when the chat last had a message (at most every 15 minutes, so that history
+     * keeps it without a row per message), links the writer to its members when they are an active
+     * member, and unlinks `leftMemberId`, a member who left, when linked. With `agentLeft`, the agent
+     * itself left the chat: every member is unlinked, and the chat stays. With `migratedFrom`, the
+     * chat had that id before it became a supergroup: its record moves to `externalId`, or, when both
+     * ids have one, the new record takes the old one's members, and its purpose and when to use where
+     * it has none. Concurrent calls for one chat leave one record.
+     */
+    readonly seeChat: (input: {
+        readonly provider: string;
+        readonly externalId: string;
+        readonly title: string;
+        readonly memberId?: string;
+        readonly leftMemberId?: string;
+        readonly agentLeft?: true;
+        readonly migratedFrom?: string;
+    }) => Effect.Effect<SeenChat>;
 }
 declare const OntologyBackend_base: Context.ServiceClass<OntologyBackend, "@segmentstream-cloud/ontology/OntologyBackend", {
     readonly blobs?: BlobRuntime;

package/dist/service/service.js

@@ -4,6 +4,7 @@ import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { storageMaintenanceAuthenticationLayer } from "../storage/maintenance-auth.js";
 import { nameToWire } from "../authoring-names.js";
 import { sqlServiceRuntime } from "../runtime/service-binding.js";
+import { deployedAgentChannel } from "./agent/channel.js";
 import { agentLayer } from "./agent/server.js";
 import { makeAggregates } from "./aggregate.js";
 import { platformAggregates } from "./aggregate-platform.js";
@@ -89,11 +90,15 @@ export function createOntologyService(ontology, config) {
             ? deployedConnections(config)
             : localConnections(config.localConnections));
     const replicate = deployedReplication(config);
+    // The agent's runtime identity is configured only on deployments that have an agent.
+    const agentChannel = config.runtimeIdentity === undefined || config.agentUrl === undefined
+        ? undefined
+        : deployedAgentChannel(config.agentUrl);
     const aggregates = makeAggregates({
         manifest: ontology.manifest,
         transport: platformAggregates({ ...config, manifestHash: ontology.manifest.hash }),
     });
-    const routes = HttpApiBuilder.layer(built.api).pipe(Layer.provide(handlersLayer(built, hooks, connections, replicate, aggregates)), Layer.provide([
+    const routes = HttpApiBuilder.layer(built.api).pipe(Layer.provide(handlersLayer(built, hooks, connections, replicate, aggregates, agentChannel)), Layer.provide([
         authenticationLayer(verifyToken, exchangeSession, verifyRuntime),
         ErrorResponsesLive,
         storageMaintenanceAuthenticationLayer(config.storageMaintenanceKey),
@@ -108,6 +113,7 @@ export function createOntologyService(ontology, config) {
             verifyRuntime,
             replicate,
             aggregates,
+            agentChannel,
         }), oauthLayer({ verifyToken }));
     const agent = agentLayer({ verifyToken, verifyRuntime, exchangeSession });
     const application = Layer.mergeAll(routes, mcp, agent, DocsRoute, UnmatchedRoutes).pipe(Layer.provide(backend), Layer.provide(HttpServer.layerServices));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream-cloud/ontology",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Define a SegmentStream workspace app's ontology: entities, relationships, roles and actions, written with Effect.",
   "license": "Apache-2.0",
   "author": "SegmentStream",