@stigmer/mcp-server 3.3.0 → 3.4.1

package/src/gen/datastore.ts

@@ -0,0 +1,264 @@
+// Code generated by stigmer-codegen --target=mcp-ts. DO NOT EDIT.
+//
+// Flattened apply-input zod schema + toProto bridge for the Datastore resource.
+// Source proto package: ai.stigmer.agentic.datastore.v1
+
+import { generateSlug, visibilityFromString, enumFromString } from "./apply-runtime.js";
+import { create, fromJson, type JsonValue } from "@bufbuild/protobuf";
+import { ValueSchema } from "@bufbuild/protobuf/wkt";
+import { DatastoreSchema, type Datastore } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
+import { DatastoreSpecSchema, DatastoreRoleSchema, ChannelSenderSubjectSchema, DatastoreSubjectSchema, DatastoreRoleBindingSchema, DatastoreAuthorizationSchema, FieldDeclarationSchema, FieldType, UniqueWhereSchema, UniqueConstraintSchema, CheckConstraintSchema, ExistsConstraintSchema, DatastoreGrantSchema, DatastoreVerb, DatastoreGrantScope, CollectionDeclarationSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/spec_pb";
+import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
+import { ApiResourceRefSchema } from "@stigmer/protos/ai/stigmer/iam/iampolicy/v1/spec_pb";
+import { z } from "zod";
+
+/** DatastoreSpec declares typed record collections with constraints and role-aware access grants. @internal The manifest is authoritative for structure, never for living data: schema changes sync on apply (additive-plus change matrix, gating), and records enter exclusively through the record RPCs — there is no seed path (DD-010 SD-5 removed seed_records; console, agent tools, and import scripts are the population surfaces). Structural limits here are v1 guardrails — raising a max_items later is a non-breaking change. Max datastores per org (25) cannot be expressed on this message; it is a domain validation constant in the create pipelines. */
+export const DatastoreInputShape = {
+  name: z.string().describe("Human-readable name of the resource."),
+  slug: z.string().optional().describe("URL-friendly identifier (lowercase alphanumeric with hyphens). Auto-generated from name if omitted."),
+  org: z.string().describe("Organization that owns this resource (e.g. acme)."),
+  visibility: z.string().optional().describe("Resource visibility: PRIVATE or PUBLIC. Omit to leave unchanged on updates."),
+  labels: z.record(z.string()).optional().describe("Key-value labels for organization and filtering."),
+  tags: z.array(z.string()).optional().describe("Tags for categorization and discovery."),
+  description: z.string().optional().describe("Human-readable description of what this datastore holds."),
+  timezone: z.string().optional().describe("IANA timezone (e.g. 'Asia/Kolkata') for constraint evaluation. Bound as the constant 'tz' in check and exists constraint expressions. Optional; when unset, expressions that reference 'tz' are rejected at apply time. @internal IANA-name validity is domain validation (the proto layer cannot carry a timezone database)."),
+  authorization: z.lazy(() => DatastoreAuthorizationInputSchema).optional().describe("Record-layer authorization: roles, subject bindings, and the default role for unbound callers."),
+  collections: z.array(z.lazy(() => CollectionDeclarationInputSchema)).optional().describe("Record collections declared by this datastore. @internal Collection-name uniqueness within the datastore is domain validation (protovalidate CEL has no portable uniqueness check over message lists)."),
+} as const;
+
+export const DatastoreInputSchema = z.object(DatastoreInputShape);
+export type DatastoreInput = z.infer<typeof DatastoreInputSchema>;
+
+const DatastoreRoleInputSchema = z.object({
+  name: z.string().describe("Role name, referenced by bindings, grants, and default_role."),
+});
+type DatastoreRoleInput = z.infer<typeof DatastoreRoleInputSchema>;
+
+const ChannelSenderSubjectInputSchema = z.object({
+  sender_kind: z.string().describe("Sender identity namespace. Must be a namespace the platform's channel brokers can stamp — today 'whatsapp_phone'; unrecognized namespaces are refused at apply time (they could never match)."),
+  value: z.string().describe("Sender identity value within the namespace, in the exact wire shape the channel broker stamps. For 'whatsapp_phone' this is Meta's wa_id: DIGITS ONLY, no '+', no separators (e.g. '919800000001' — NOT the '+'-prefixed E.164 form). Apply-time validation refuses any other shape, because subject matching is exact string equality and a mis-shaped value would bind and silently never match. @internal Bearer-adjacent: never logged raw, never filterable, never echoed into validation error strings, and only ever compared against broker-stamped session metadata."),
+});
+type ChannelSenderSubjectInput = z.infer<typeof ChannelSenderSubjectInputSchema>;
+
+const ApiResourceRefInputSchema = z.object({
+  kind: z.string().describe("Type of the API resource being referenced This should be the resource kind as defined in ApiResourceKind enum. Examples: 'identity_account', 'team', 'organization', 'environment', 'cloud_resource', 'service', etc."),
+  id: z.string().describe("Unique identifier of the resource This is the resource's ID field (e.g., ia-01HQUSER123, tm-01HQTEAM456)"),
+  relation: z.string().optional().describe("Optional relation qualifier for the resource reference. Used when the reference needs additional context about the relationship. Primary use case: For team principals, this specifies the relation of the user to the team (e.g., 'member', 'admin'). Example: principal { kind: 'team', id: 'tm-123', relation: 'member' } means 'members of team tm-123' This field qualifies HOW the principal relates to this resource reference, NOT the permission being granted (that's IamPolicySpec.relation). @internal In OpenFGA tuple notation: team:tm-123#member (as the subject of the tuple)"),
+});
+type ApiResourceRefInput = z.infer<typeof ApiResourceRefInputSchema>;
+
+const DatastoreSubjectInputSchema = z.object({
+  channel_sender: z.lazy(() => ChannelSenderSubjectInputSchema).optional().describe("Channel sender identity, matched against the session metadata stamped by the channel broker."),
+  principal: z.lazy(() => ApiResourceRefInputSchema).optional().describe("Platform principal (an identity account today; teams later without schema change). @internal Matched by exact kind+id equality against the caller-derived subject; the relation qualifier is excluded from identity and rejected at apply. The id is the account id, never a slug or email — apply-time validation refuses unresolvable values with a membership-gated did-you-mean instead of letting them bind nothing silently (dont-dos/001)."),
+});
+type DatastoreSubjectInput = z.infer<typeof DatastoreSubjectInputSchema>;
+
+const DatastoreRoleBindingInputSchema = z.object({
+  subject: z.lazy(() => DatastoreSubjectInputSchema).describe("The caller identity this binding matches."),
+  role: z.string().describe("Name of a declared role."),
+});
+type DatastoreRoleBindingInput = z.infer<typeof DatastoreRoleBindingInputSchema>;
+
+const DatastoreAuthorizationInputSchema = z.object({
+  roles: z.array(z.lazy(() => DatastoreRoleInputSchema)).optional().describe("Role names referenced by bindings and grants (e.g. 'admin', 'patient')."),
+  bindings: z.array(z.lazy(() => DatastoreRoleBindingInputSchema)).optional().describe("Subject-to-role bindings. @internal Role-reference integrity (every binding names a declared role) is domain validation."),
+  default_role: z.string().optional().describe("Role an unbound caller resolves to. Applies to channel senders with no binding and platform principals with no binding. When empty, unbound callers are denied every verb."),
+});
+type DatastoreAuthorizationInput = z.infer<typeof DatastoreAuthorizationInputSchema>;
+
+const FieldDeclarationInputSchema = z.object({
+  name: z.string().describe("Field name, unique within the collection. Format: lowercase snake_case. The record envelope's system field names (id, created_at, updated_at, created_by), 'org', and 'partition' are reserved."),
+  type: z.string().describe("Value type for this field. Allowed values: string, integer, number, bool, timestamp, date, time, json."),
+  required: z.boolean().optional().describe("Whether a value must be present on every record. Absent optional fields evaluate as null in constraint expressions."),
+  default: z.unknown().optional().describe("Default value applied when the field is absent on insert. @internal Type compatibility between the default and the declared type is domain validation (google.protobuf.Value is untyped here)."),
+  enum_values: z.array(z.string()).optional().describe("Allowed values for string fields. Declaring enum_values on a non-string field is rejected."),
+  description: z.string().optional().describe("Human-readable description, surfaced to agents via describe_datastore."),
+});
+type FieldDeclarationInput = z.infer<typeof FieldDeclarationInputSchema>;
+
+const UniqueWhereInputSchema = z.object({
+  field: z.string().describe("Declared field the condition tests."),
+  equals: z.unknown().describe("Value the field must equal for the constraint to apply."),
+});
+type UniqueWhereInput = z.infer<typeof UniqueWhereInputSchema>;
+
+const UniqueConstraintInputSchema = z.object({
+  name: z.string().describe("Constraint name, unique within the collection."),
+  fields: z.array(z.string()).optional().describe("Declared fields whose combined values must be unique."),
+  where: z.lazy(() => UniqueWhereInputSchema).optional().describe("Limits the constraint to records matching this condition (e.g. only 'status == 'confirmed'' bookings must be unique per slot). @internal Structured, never an expression — it must compile to the substrate's partial-index dialect in both editions."),
+  message: z.string().describe("Error message returned on violation, written to be relayed to an end user by an agent (e.g. 'that slot is already booked')."),
+});
+type UniqueConstraintInput = z.infer<typeof UniqueConstraintInputSchema>;
+
+const CheckConstraintInputSchema = z.object({
+  name: z.string().describe("Constraint name, unique within the collection."),
+  expression: z.string().describe("CEL expression that must evaluate true for the record to be written."),
+  when: z.string().optional().describe("Optional CEL gate: the check applies only when this evaluates true."),
+  message: z.string().describe("Error message returned on violation, written to be relayed to an end user by an agent."),
+});
+type CheckConstraintInput = z.infer<typeof CheckConstraintInputSchema>;
+
+const ExistsConstraintInputSchema = z.object({
+  name: z.string().describe("Constraint name, unique within the collection."),
+  collection: z.string().describe("Target collection in the same datastore."),
+  where: z.string().describe("CEL condition matching candidate ('this') against target records ('that')."),
+  when: z.string().optional().describe("Optional CEL gate: the constraint applies only when this evaluates true."),
+  message: z.string().describe("Error message returned on violation, written to be relayed to an end user by an agent."),
+});
+type ExistsConstraintInput = z.infer<typeof ExistsConstraintInputSchema>;
+
+const DatastoreGrantInputSchema = z.object({
+  role: z.string().describe("Name of a declared role."),
+  verbs: z.array(z.string()).optional().describe("Verbs granted to the role on this collection. Allowed values: read, insert, update, delete."),
+  scope: z.string().optional().describe("Row scope of the grant. Defaults to all records. 'own' limits update and delete (and read) to records whose server-stamped created_by matches the caller. Allowed values: all, own."),
+  read_fields: z.array(z.string()).optional().describe("Field allowlist for the read verb: when set, reads by this role return only these fields, and filter conditions and order_by may reference only these fields. Empty means every field is readable. Entries name declared fields of the collection, or 'created_by' to expose the attribution subject. The system fields id, created_at, and updated_at are always readable. @internal The column-level GRANT SELECT of the record layer, closing the scope-all-reads-carry-PII residual (dont-dos/002): every record RPC response — find results AND write echoes — is projected to the caller's read-grant field set, and created_by is included only when listed (for channel senders it is the phone number, the most direct PII in the envelope). A caller with no read grant at all receives envelopes with id and timestamps only (write-only access). Empty = unrestricted is forced by proto3 repeated-field semantics (no presence) and mirrors 'scope' unset = all. Requires 'read' among the grant's verbs — read_fields on a write-only grant is declared intent with no effect and is refused at apply, same posture as the binding relation qualifier. Entry-to-declared-field resolution is domain validation (both editions, byte-identical messages)."),
+});
+type DatastoreGrantInput = z.infer<typeof DatastoreGrantInputSchema>;
+
+const CollectionDeclarationInputSchema = z.object({
+  name: z.string().describe("Collection name, unique within the datastore. Format: lowercase snake_case (e.g. 'bookings', 'schedule_exceptions')."),
+  description: z.string().optional().describe("Human-readable description of what records in this collection represent."),
+  fields: z.array(z.lazy(() => FieldDeclarationInputSchema)).optional().describe("Typed field declarations for records in this collection."),
+  uniques: z.array(z.lazy(() => UniqueConstraintInputSchema)).optional().describe("Uniqueness constraints, enforced by substrate indexes."),
+  checks: z.array(z.lazy(() => CheckConstraintInputSchema)).optional().describe("Single-record check constraints, evaluated on every insert and update."),
+  exists: z.array(z.lazy(() => ExistsConstraintInputSchema)).optional().describe("Cross-collection constraints requiring a matching record to exist."),
+  not_exists: z.array(z.lazy(() => ExistsConstraintInputSchema)).optional().describe("Cross-collection constraints requiring no matching record to exist."),
+  grants: z.array(z.lazy(() => DatastoreGrantInputSchema)).optional().describe("Per-role access grants for records in this collection. Deny by default: a role with no grant on a collection has no access to it."),
+});
+type CollectionDeclarationInput = z.infer<typeof CollectionDeclarationInputSchema>;
+
+
+/** Build the fully-formed Datastore proto from the flat MCP apply input. */
+export function datastoreInputToProto(input: DatastoreInput): Datastore {
+  const slug = input.slug && input.slug.length > 0 ? input.slug : generateSlug(input.name);
+  const spec = create(DatastoreSpecSchema);
+  if (input.description !== undefined) spec.description = input.description;
+  if (input.timezone !== undefined) spec.timezone = input.timezone;
+  if (input.authorization !== undefined) spec.authorization = datastoreAuthorizationInputToProto(input.authorization);
+  if (input.collections !== undefined) spec.collections = input.collections.map(collectionDeclarationInputToProto);
+  return Object.assign(create(DatastoreSchema), {
+    apiVersion: "agentic.stigmer.ai/v1",
+    kind: "Datastore",
+    metadata: Object.assign(create(ApiResourceMetadataSchema), {
+      name: input.name,
+      slug,
+      org: input.org,
+      ...(input.visibility !== undefined && { visibility: visibilityFromString(input.visibility) }),
+      ...(input.labels !== undefined && { labels: input.labels }),
+      ...(input.tags !== undefined && { tags: input.tags }),
+    }),
+    spec,
+  }) as Datastore;
+}
+
+function datastoreRoleInputToProto(input: DatastoreRoleInput) {
+  const result = create(DatastoreRoleSchema);
+  if (input.name !== undefined) result.name = input.name;
+  return result;
+}
+
+function channelSenderSubjectInputToProto(input: ChannelSenderSubjectInput) {
+  const result = create(ChannelSenderSubjectSchema);
+  if (input.sender_kind !== undefined) result.senderKind = input.sender_kind;
+  if (input.value !== undefined) result.value = input.value;
+  return result;
+}
+
+function apiResourceRefInputToProto(input: ApiResourceRefInput) {
+  const result = create(ApiResourceRefSchema);
+  if (input.kind !== undefined) result.kind = input.kind;
+  if (input.id !== undefined) result.id = input.id;
+  if (input.relation !== undefined) result.relation = input.relation;
+  return result;
+}
+
+function datastoreSubjectInputToProto(input: DatastoreSubjectInput) {
+  const result = create(DatastoreSubjectSchema);
+  if (input.channel_sender !== undefined) result.kind = { case: "channelSender", value: channelSenderSubjectInputToProto(input.channel_sender) };
+  if (input.principal !== undefined) result.kind = { case: "principal", value: apiResourceRefInputToProto(input.principal) };
+  return result;
+}
+
+function datastoreRoleBindingInputToProto(input: DatastoreRoleBindingInput) {
+  const result = create(DatastoreRoleBindingSchema);
+  if (input.subject !== undefined) result.subject = datastoreSubjectInputToProto(input.subject);
+  if (input.role !== undefined) result.role = input.role;
+  return result;
+}
+
+function datastoreAuthorizationInputToProto(input: DatastoreAuthorizationInput) {
+  const result = create(DatastoreAuthorizationSchema);
+  if (input.roles !== undefined) result.roles = input.roles.map(datastoreRoleInputToProto);
+  if (input.bindings !== undefined) result.bindings = input.bindings.map(datastoreRoleBindingInputToProto);
+  if (input.default_role !== undefined) result.defaultRole = input.default_role;
+  return result;
+}
+
+function fieldDeclarationInputToProto(input: FieldDeclarationInput) {
+  const result = create(FieldDeclarationSchema);
+  if (input.name !== undefined) result.name = input.name;
+  result.type = enumFromString(FieldType, input.type) as FieldType;
+  if (input.required !== undefined) result.required = input.required;
+  if (input.default !== undefined) result.default = fromJson(ValueSchema, input.default as JsonValue);
+  if (input.enum_values !== undefined) result.enumValues = input.enum_values;
+  if (input.description !== undefined) result.description = input.description;
+  return result;
+}
+
+function uniqueWhereInputToProto(input: UniqueWhereInput) {
+  const result = create(UniqueWhereSchema);
+  if (input.field !== undefined) result.field = input.field;
+  if (input.equals !== undefined) result.equals = fromJson(ValueSchema, input.equals as JsonValue);
+  return result;
+}
+
+function uniqueConstraintInputToProto(input: UniqueConstraintInput) {
+  const result = create(UniqueConstraintSchema);
+  if (input.name !== undefined) result.name = input.name;
+  if (input.fields !== undefined) result.fields = input.fields;
+  if (input.where !== undefined) result.where = uniqueWhereInputToProto(input.where);
+  if (input.message !== undefined) result.message = input.message;
+  return result;
+}
+
+function checkConstraintInputToProto(input: CheckConstraintInput) {
+  const result = create(CheckConstraintSchema);
+  if (input.name !== undefined) result.name = input.name;
+  if (input.expression !== undefined) result.expression = input.expression;
+  if (input.when !== undefined) result.when = input.when;
+  if (input.message !== undefined) result.message = input.message;
+  return result;
+}
+
+function existsConstraintInputToProto(input: ExistsConstraintInput) {
+  const result = create(ExistsConstraintSchema);
+  if (input.name !== undefined) result.name = input.name;
+  if (input.collection !== undefined) result.collection = input.collection;
+  if (input.where !== undefined) result.where = input.where;
+  if (input.when !== undefined) result.when = input.when;
+  if (input.message !== undefined) result.message = input.message;
+  return result;
+}
+
+function datastoreGrantInputToProto(input: DatastoreGrantInput) {
+  const result = create(DatastoreGrantSchema);
+  if (input.role !== undefined) result.role = input.role;
+  if (input.verbs !== undefined) result.verbs = input.verbs.map((v) => enumFromString(DatastoreVerb, v) as DatastoreVerb);
+  result.scope = enumFromString(DatastoreGrantScope, input.scope) as DatastoreGrantScope;
+  if (input.read_fields !== undefined) result.readFields = input.read_fields;
+  return result;
+}
+
+function collectionDeclarationInputToProto(input: CollectionDeclarationInput) {
+  const result = create(CollectionDeclarationSchema);
+  if (input.name !== undefined) result.name = input.name;
+  if (input.description !== undefined) result.description = input.description;
+  if (input.fields !== undefined) result.fields = input.fields.map(fieldDeclarationInputToProto);
+  if (input.uniques !== undefined) result.uniques = input.uniques.map(uniqueConstraintInputToProto);
+  if (input.checks !== undefined) result.checks = input.checks.map(checkConstraintInputToProto);
+  if (input.exists !== undefined) result.exists = input.exists.map(existsConstraintInputToProto);
+  if (input.not_exists !== undefined) result.notExists = input.not_exists.map(existsConstraintInputToProto);
+  if (input.grants !== undefined) result.grants = input.grants.map(datastoreGrantInputToProto);
+  return result;
+}
+

package/src/gen/environment.ts

@@ -0,0 +1,66 @@
+// Code generated by stigmer-codegen --target=mcp-ts. DO NOT EDIT.
+//
+// Flattened apply-input zod schema + toProto bridge for the Environment resource.
+// Source proto package: ai.stigmer.agentic.environment.v1
+
+import { generateSlug, visibilityFromString } from "./apply-runtime.js";
+import { create } from "@bufbuild/protobuf";
+import { EnvironmentSchema, type Environment } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
+import { EnvironmentSpecSchema, EnvironmentValueSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/spec_pb";
+import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
+import { z } from "zod";
+
+/** EnvironmentSpec defines the configurable properties of an environment. @internal The overview.md file provides the SDK-facing description and example YAML. */
+export const EnvironmentInputShape = {
+  name: z.string().describe("Human-readable name of the resource."),
+  slug: z.string().optional().describe("URL-friendly identifier (lowercase alphanumeric with hyphens). Auto-generated from name if omitted."),
+  org: z.string().describe("Organization that owns this resource (e.g. acme)."),
+  visibility: z.string().optional().describe("Resource visibility: PRIVATE or PUBLIC. Omit to leave unchanged on updates."),
+  labels: z.record(z.string()).optional().describe("Key-value labels for organization and filtering."),
+  tags: z.array(z.string()).optional().describe("Tags for categorization and discovery."),
+  description: z.string().optional().describe("Human-readable description for UI and listing display."),
+  data: z.record(z.lazy(() => EnvironmentValueInputSchema)).optional().describe("Key-value pairs containing configuration and secrets. Each value includes a flag indicating whether it is a secret."),
+} as const;
+
+export const EnvironmentInputSchema = z.object(EnvironmentInputShape);
+export type EnvironmentInput = z.infer<typeof EnvironmentInputSchema>;
+
+const EnvironmentValueInputSchema = z.object({
+  value: z.string().optional().describe("The configuration or secret string. @internal When is_secret is true the value is encrypted at rest and redacted in logs. When is_secret is false the value is stored as plaintext. Value can be empty when pre-declaring keys whose values are injected at runtime."),
+  is_secret: z.boolean().optional().describe("Whether this value should be treated as a secret. @internal When true: encrypted at rest, redacted in logs, requires can_read_secrets to reveal. When false: stored as plaintext, visible in audit logs."),
+  description: z.string().optional().describe("Human-readable description of what this value is used for."),
+});
+type EnvironmentValueInput = z.infer<typeof EnvironmentValueInputSchema>;
+
+
+/** Build the fully-formed Environment proto from the flat MCP apply input. */
+export function environmentInputToProto(input: EnvironmentInput): Environment {
+  const slug = input.slug && input.slug.length > 0 ? input.slug : generateSlug(input.name);
+  const spec = create(EnvironmentSpecSchema);
+  if (input.description !== undefined) spec.description = input.description;
+  if (input.data !== undefined) {
+    for (const [k, v] of Object.entries(input.data)) spec.data[k] = environmentValueInputToProto(v);
+  }
+  return Object.assign(create(EnvironmentSchema), {
+    apiVersion: "agentic.stigmer.ai/v1",
+    kind: "Environment",
+    metadata: Object.assign(create(ApiResourceMetadataSchema), {
+      name: input.name,
+      slug,
+      org: input.org,
+      ...(input.visibility !== undefined && { visibility: visibilityFromString(input.visibility) }),
+      ...(input.labels !== undefined && { labels: input.labels }),
+      ...(input.tags !== undefined && { tags: input.tags }),
+    }),
+    spec,
+  }) as Environment;
+}
+
+function environmentValueInputToProto(input: EnvironmentValueInput) {
+  const result = create(EnvironmentValueSchema);
+  if (input.value !== undefined) result.value = input.value;
+  if (input.is_secret !== undefined) result.isSecret = input.is_secret;
+  if (input.description !== undefined) result.description = input.description;
+  return result;
+}
+

package/src/server.ts

@@ -19,9 +19,15 @@ import type { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 
 import type { Config } from "./config.js";
+import { registerAgentExecutionTools } from "./domains/agentexecutions/tools.js";
 import { registerAgentResources } from "./domains/agents/resources.js";
 import { registerAgentTools } from "./domains/agents/tools.js";
 import type { BackendTarget } from "./domains/client.js";
+import { registerDatastoreResources } from "./domains/datastores/resources.js";
+import { registerDatastoreTools } from "./domains/datastores/tools.js";
+import { registerEnvironmentResources } from "./domains/environments/resources.js";
+import { registerEnvironmentTools } from "./domains/environments/tools.js";
+import { registerExecutionControlTools } from "./domains/executions/tools.js";
 import { registerMcpServerResources } from "./domains/mcpservers/resources.js";
 import { registerMcpServerTools } from "./domains/mcpservers/tools.js";
 import { registerRecordTools } from "./domains/records/tools.js";
@@ -86,12 +92,16 @@ function registerTools(server: McpServer, target: BackendTarget): void {
   const tools = [
     ...registerSearchTools(server, target),
     ...registerAgentTools(server, target),
+    ...registerAgentExecutionTools(server, target),
     ...registerMcpServerTools(server, target),
     ...registerSkillTools(server, target),
     ...registerWorkflowTools(server, target),
     ...registerValidateWorkflowYamlTool(server, target),
     ...registerTaskKindTools(server, target),
     ...registerWorkflowExecutionTools(server, target),
+    ...registerExecutionControlTools(server, target),
+    ...registerEnvironmentTools(server, target),
+    ...registerDatastoreTools(server, target),
     // The record tools also serve external MCP clients — as direct
     // principals with the org argument and honest annotations (the
     // agent-facing variant lives on the records-only roster).
@@ -111,6 +121,8 @@ function registerResources(server: McpServer, target: BackendTarget): void {
     ...registerMcpServerResources(server, target),
     ...registerSkillResources(server, target),
     ...registerWorkflowResources(server, target),
+    ...registerEnvironmentResources(server, target),
+    ...registerDatastoreResources(server, target),
   ];
   log.info("resources registered", { count: resources.length, resources });
 }