@stigmer/mcp-server 3.2.3 → 3.4.0

package/src/domains/workflowexecutions/run.ts

@@ -0,0 +1,87 @@
+// Workflow-execution start path for the run_workflow tool.
+//
+// Mirrors the CLI's workflow run branch (client-apps/cli/src/commands/run.ts +
+// resources/run/create.ts): resolve the org/slug reference to the workflow ID,
+// then create the execution. Asynchronous like run_agent — the tool returns
+// the created execution (wex_* ID) and observation happens through the
+// existing get_workflow_execution / get_workflow_execution_events tools.
+
+import { createClient } from "@connectrpc/connect";
+import { create as createMessage } from "@bufbuild/protobuf";
+import { WorkflowQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/query_pb";
+import { WorkflowExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
+import { WorkflowExecutionCommandController } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/command_pb";
+import { WorkflowExecutionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/spec_pb";
+import { ExecutionValueSchema } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
+import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import { executionName, toExecutionValues } from "../agentexecutions/run.js";
+import { withTransport } from "../client.js";
+import { toProtoJson } from "../marshal.js";
+import { rpcError } from "../rpcerr.js";
+
+/** apiVersion stamped on created executions; mirrors the CLI's run stack. */
+const API_VERSION = "agentic.stigmer.ai/v1";
+
+export interface RunWorkflowArgs {
+  readonly org: string;
+  readonly workflow: string;
+  readonly message?: string;
+  readonly runtimeEnv?: Record<string, string>;
+}
+
+/**
+ * Start a workflow execution: resolve org/slug → workflow ID, then create the
+ * execution. Returns the created execution as protojson.
+ */
+export async function runWorkflow(
+  serverAddress: string,
+  token: string,
+  args: RunWorkflowArgs,
+): Promise<string> {
+  const desc = `workflow "${args.workflow}" in org "${args.org}"`;
+  return withTransport(serverAddress, token, async (transport, callOptions) => {
+    const query = createClient(WorkflowQueryController, transport);
+    let workflowId: string;
+    try {
+      const workflow = await query.getByReference(
+        { org: args.org, kind: ApiResourceKind.workflow, slug: args.workflow },
+        callOptions,
+      );
+      workflowId = workflow.metadata?.id ?? "";
+    } catch (err) {
+      throw rpcError(err, desc);
+    }
+
+    // Workflow tasks resolve their org through the runtime env; the CLI
+    // injects STIGMER_ORG_ID the same way, so a caller-supplied value wins.
+    const runtimeEnv = toExecutionValues(args.runtimeEnv);
+    if (runtimeEnv.STIGMER_ORG_ID === undefined) {
+      runtimeEnv.STIGMER_ORG_ID = createMessage(ExecutionValueSchema, {
+        value: args.org,
+        isSecret: false,
+      });
+    }
+
+    const execution = createMessage(WorkflowExecutionSchema, {
+      apiVersion: API_VERSION,
+      kind: "WorkflowExecution",
+      metadata: createMessage(ApiResourceMetadataSchema, { name: executionName(), org: args.org }),
+      spec: createMessage(WorkflowExecutionSpecSchema, {
+        workflowId,
+        // Empty message means "just run" — the CLI applies the same default.
+        triggerMessage: (args.message ?? "") === "" ? "execute" : args.message,
+        runtimeEnv,
+      }),
+    });
+
+    const command = createClient(WorkflowExecutionCommandController, transport);
+    try {
+      const created = await command.create(execution, callOptions);
+      return toProtoJson(WorkflowExecutionSchema, created);
+    } catch (err) {
+      throw rpcError(err, `execution of ${desc}`);
+    }
+  });
+}

package/src/domains/workflowexecutions/tools.ts

@@ -1,8 +1,10 @@
-// MCP tools for querying workflow execution status and event logs.
-// Go parity: mcp-server/internal/domains/workflowexecutions/tools.go.
-//
-// Backed by WorkflowExecutionQueryController (get, getEventLog). These are
-// diagnostic reads for running/failed executions.
+// MCP tools for the WorkflowExecution domain: start a run (run_workflow),
+// observe it (get_workflow_execution, get_workflow_execution_events — backed
+// by WorkflowExecutionQueryController.get/getEventLog), and answer its
+// human_input tasks (list_pending_approvals, submit_workflow_task_approval).
+// The observation tools predate the rest and their names/descriptions are
+// part of the original Go-parity contract
+// (mcp-server/internal/domains/workflowexecutions/tools.go).
 
 import type { MessageInitShape } from "@bufbuild/protobuf";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -18,9 +20,47 @@ import { resolveToken, withClient, type BackendTarget } from "../client.js";
 import { toProtoJson } from "../marshal.js";
 import { rpcError } from "../rpcerr.js";
 import { textOrError } from "../toolresult.js";
+import { listPendingApprovals, submitWorkflowTaskApproval } from "./approvals.js";
+import { runWorkflow } from "./run.js";
 
 /** Register the workflow-execution tools; returns the registered tool names. */
 export function registerWorkflowExecutionTools(server: McpServer, target: BackendTarget): string[] {
+  server.registerTool(
+    "run_workflow",
+    {
+      description:
+        "Start a workflow execution (asynchronous). Returns immediately with the created execution " +
+        "(wex_* ID) while the run continues in the background — poll get_workflow_execution and " +
+        "get_workflow_execution_events to observe progress and diagnose failures.",
+      inputSchema: {
+        org: z.string().describe("Organization slug that owns the workflow (e.g. stigmer)."),
+        workflow: z
+          .string()
+          .describe("Workflow slug — the unique identifier within the org (e.g. release-notes)."),
+        message: z
+          .string()
+          .optional()
+          .describe("Trigger message passed to the workflow. Omit to run with the default trigger."),
+        runtime_env: z
+          .record(z.string())
+          .optional()
+          .describe(
+            "Non-secret runtime environment values (name → value) injected into the run. " +
+              "Secrets must come from Environments referenced by the workflow, never through this tool.",
+          ),
+      },
+    },
+    (args, extra) =>
+      textOrError(() =>
+        runWorkflow(target.serverAddress, resolveToken(extra, target.apiKey), {
+          org: args.org,
+          workflow: args.workflow,
+          message: args.message,
+          runtimeEnv: args.runtime_env,
+        }),
+      ),
+  );
+
   server.registerTool(
     "get_workflow_execution",
     {
@@ -67,7 +107,81 @@ export function registerWorkflowExecutionTools(server: McpServer, target: Backen
       ),
   );
 
-  return ["get_workflow_execution", "get_workflow_execution_events"];
+  server.registerTool(
+    "list_pending_approvals",
+    {
+      description:
+        "List workflow tasks waiting for a human decision across an organization — an approvals " +
+        "inbox. Each entry carries the execution ID, task name, requester, timeout, and the form " +
+        "schema when the task defines one; respond with submit_workflow_task_approval. " +
+        "(Agent-execution approvals are not listed here — they surface in get_agent_execution's " +
+        "status.pending_approvals.)",
+      inputSchema: {
+        org: z.string().describe("Organization slug to scope the query (e.g. stigmer)."),
+        page_size: z
+          .number()
+          .int()
+          .optional()
+          .describe("Maximum entries per page (default 20, max 100)."),
+        page_token: z
+          .string()
+          .optional()
+          .describe("Pagination token from a previous response's next_page_token."),
+      },
+    },
+    (args, extra) =>
+      textOrError(() =>
+        listPendingApprovals(target.serverAddress, resolveToken(extra, target.apiKey), {
+          org: args.org,
+          pageSize: args.page_size,
+          pageToken: args.page_token,
+        }),
+      ),
+  );
+
+  server.registerTool(
+    "submit_workflow_task_approval",
+    {
+      description:
+        "Submit a reviewer decision for a workflow human_input task that is waiting for a signal. " +
+        "outcome must match one of the task's configured outcome names (default: approve or deny). " +
+        "When the task defines a form_schema (see list_pending_approvals), provide matching " +
+        "form_data. Returns the updated workflow execution.",
+      inputSchema: {
+        execution_id: z.string().describe("Workflow execution ID (wex_* format)."),
+        task_name: z.string().describe("Name of the waiting human_input task."),
+        outcome: z
+          .string()
+          .describe(
+            "Decision outcome. Must match a configured outcome name of the task " +
+              "(e.g. approve, deny, needs_revision); approve/deny when none are configured.",
+          ),
+        comment: z.string().optional().describe("Reviewer comment, stored in the audit trail."),
+        form_data: z
+          .record(z.unknown())
+          .optional()
+          .describe("Response form data conforming to the task's form_schema, when it defines one."),
+      },
+    },
+    (args, extra) =>
+      textOrError(() =>
+        submitWorkflowTaskApproval(target.serverAddress, resolveToken(extra, target.apiKey), {
+          executionId: args.execution_id,
+          taskName: args.task_name,
+          outcome: args.outcome,
+          comment: args.comment,
+          formData: args.form_data,
+        }),
+      ),
+  );
+
+  return [
+    "run_workflow",
+    "get_workflow_execution",
+    "get_workflow_execution_events",
+    "list_pending_approvals",
+    "submit_workflow_task_approval",
+  ];
 }
 
 /** Fetch a single workflow execution by id. */

package/src/domains/workflows/tools.ts

@@ -1,5 +1,7 @@
-// MCP tools for the Workflow domain (CRUD: get, apply, delete).
-// Go parity: mcp-server/internal/domains/workflows/tools.go.
+// MCP tools for the Workflow domain (CRUD: get, apply, delete) plus the
+// versioning surface (version param on get, list_workflow_versions,
+// tag_workflow_version). The CRUD names/descriptions are part of the original
+// Go-parity contract (mcp-server/internal/domains/workflows/tools.go).
 //
 // The workflow-specific tools (validate_workflow_yaml, task-kind registry) live
 // in sibling files.
@@ -13,22 +15,36 @@ import { textOrError } from "../toolresult.js";
 import { applyWorkflow } from "./apply.js";
 import { deleteWorkflow } from "./delete.js";
 import { fetchWorkflow } from "./fetch.js";
+import { fetchWorkflowVersion, listWorkflowVersions, tagWorkflowVersion } from "./versions.js";
 
 /** Register the Workflow CRUD tools; returns the registered tool names. */
 export function registerWorkflowTools(server: McpServer, target: BackendTarget): string[] {
   server.registerTool(
     "get_workflow",
     {
-      description: "Get full details of a Stigmer workflow by its org and slug.",
+      description:
+        "Get full details of a Stigmer workflow by its org and slug. Pass 'version' (a full " +
+        "SHA-256 version hash from list_workflow_versions) to fetch a historical version instead — " +
+        "that returns the version entry with its validated YAML rather than the live workflow. " +
+        "Tags are not accepted here; resolve a tag to its hash via list_workflow_versions first.",
       inputSchema: {
         org: z.string().describe("Organization slug that owns the workflow."),
         slug: z.string().describe("Workflow slug — unique identifier within the org."),
+        version: z
+          .string()
+          .optional()
+          .describe(
+            "Full 64-character SHA-256 version hash of a historical version. Omit for the live workflow.",
+          ),
       },
     },
     (args, extra) =>
-      textOrError(() =>
-        fetchWorkflow(target.serverAddress, resolveToken(extra, target.apiKey), args.org, args.slug),
-      ),
+      textOrError(() => {
+        const token = resolveToken(extra, target.apiKey);
+        return args.version !== undefined && args.version !== ""
+          ? fetchWorkflowVersion(target.serverAddress, token, args.org, args.slug, args.version)
+          : fetchWorkflow(target.serverAddress, token, args.org, args.slug);
+      }),
   );
 
   server.registerTool(
@@ -64,5 +80,72 @@ export function registerWorkflowTools(server: McpServer, target: BackendTarget):
       ),
   );
 
-  return ["get_workflow", "apply_workflow", "delete_workflow"];
+  server.registerTool(
+    "list_workflow_versions",
+    {
+      description:
+        "List a workflow's version history (newest first): version hash, tag, who applied it and " +
+        "when, and which version is current. Every apply that changes the workflow creates a new " +
+        "immutable version identified by its content hash. Entries omit the version YAML — fetch " +
+        "one version's full content with get_workflow and its hash.",
+      inputSchema: {
+        org: z.string().describe("Organization slug that owns the workflow."),
+        slug: z.string().describe("Workflow slug — unique identifier within the org."),
+        page_size: z
+          .number()
+          .int()
+          .optional()
+          .describe("Maximum versions per page (default 50, max 100)."),
+        page_token: z
+          .string()
+          .optional()
+          .describe("Pagination token from a previous response's next_page_token."),
+      },
+    },
+    (args, extra) =>
+      textOrError(() =>
+        listWorkflowVersions(target.serverAddress, resolveToken(extra, target.apiKey), {
+          org: args.org,
+          slug: args.slug,
+          pageSize: args.page_size,
+          pageToken: args.page_token,
+        }),
+      ),
+  );
+
+  server.registerTool(
+    "tag_workflow_version",
+    {
+      description:
+        "Assign a tag (e.g. stable, production) to a specific workflow version. Tags are mutable " +
+        "pointers: re-tagging with an existing name moves it from its previous version, and a " +
+        "version holds at most one tag. Get version hashes from list_workflow_versions. Returns " +
+        "the updated workflow.",
+      inputSchema: {
+        org: z.string().describe("Organization slug that owns the workflow."),
+        slug: z.string().describe("Workflow slug — unique identifier within the org."),
+        version: z.string().describe("Full 64-character SHA-256 hash of the version to tag."),
+        tag: z
+          .string()
+          .describe("Tag to assign: alphanumeric with dots, hyphens, or underscores (e.g. stable, v1.0)."),
+      },
+    },
+    (args, extra) =>
+      textOrError(() =>
+        tagWorkflowVersion(target.serverAddress, resolveToken(extra, target.apiKey), {
+          org: args.org,
+          slug: args.slug,
+          versionHash: args.version,
+          tag: args.tag,
+        }),
+      ),
+  );
+
+  return [
+    "get_workflow",
+    "apply_workflow",
+    "delete_workflow",
+    "list_workflow_versions",
+    "tag_workflow_version",
+  ];
 }

package/src/domains/workflows/versions.ts

@@ -0,0 +1,147 @@
+// Workflow versioning paths: the version timeline (listVersions), a pinned
+// historical version (getVersion, surfaced through get_workflow's optional
+// version argument), and tag assignment (tagVersion).
+//
+// Version identity is the SHA-256 content hash of the validated CNCF YAML;
+// tags are mutable pointers onto hashes. getVersion and tagVersion address by
+// workflow ID + full hash — no tag or slug resolution server-side — so the
+// tools here do the org/slug → ID two-step, and tag → hash mapping goes
+// through the timeline (the tool descriptions teach the model that sequence).
+//
+// The timeline projection strips validated_yaml from every entry: the backend
+// embeds each version's full workflow YAML, which would multiply a 50-entry
+// page into 50 documents. The timeline answers "what versions exist"; the
+// YAML of one version comes from get_workflow with that version's hash.
+
+import { createClient } from "@connectrpc/connect";
+import type { MessageInitShape } from "@bufbuild/protobuf";
+import {
+  type ListWorkflowVersionsInputSchema,
+  ListWorkflowVersionsResponseSchema,
+  WorkflowVersionEntrySchema,
+} from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/version_pb";
+import { WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
+import { WorkflowCommandController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/command_pb";
+import { WorkflowQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/query_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import { withClient, withTransport } from "../client.js";
+import { toProtoJson } from "../marshal.js";
+import { rpcError } from "../rpcerr.js";
+
+export interface ListWorkflowVersionsArgs {
+  readonly org: string;
+  readonly slug: string;
+  readonly pageSize?: number;
+  readonly pageToken?: string;
+}
+
+/**
+ * List a workflow's version history (newest first), with validated_yaml
+ * stripped from every entry (see file header).
+ */
+export async function listWorkflowVersions(
+  serverAddress: string,
+  token: string,
+  args: ListWorkflowVersionsArgs,
+): Promise<string> {
+  return withClient(WorkflowQueryController, serverAddress, token, async (client, callOptions) => {
+    const req: MessageInitShape<typeof ListWorkflowVersionsInputSchema> = {
+      org: args.org,
+      slug: args.slug,
+      pageToken: args.pageToken ?? "",
+    };
+    // Forward page_size only when set, letting the server apply its default.
+    if ((args.pageSize ?? 0) > 0) {
+      req.pageSize = args.pageSize;
+    }
+    try {
+      const resp = await client.listVersions(req, callOptions);
+      const data = JSON.parse(
+        toProtoJson(ListWorkflowVersionsResponseSchema, resp),
+      ) as Record<string, unknown>;
+      if (Array.isArray(data.versions)) {
+        for (const entry of data.versions as Array<Record<string, unknown>>) {
+          delete entry.validated_yaml;
+        }
+      }
+      return JSON.stringify(data, null, 2);
+    } catch (err) {
+      throw rpcError(err, `versions of workflow "${args.slug}" in org "${args.org}"`);
+    }
+  });
+}
+
+/**
+ * Fetch one historical version of a workflow: resolve org/slug → ID, then
+ * getVersion by full hash. Returns the WorkflowVersionEntry (hash, tag,
+ * provenance, and the version's validated YAML) as protojson.
+ */
+export async function fetchWorkflowVersion(
+  serverAddress: string,
+  token: string,
+  org: string,
+  slug: string,
+  versionHash: string,
+): Promise<string> {
+  const desc = `version "${versionHash}" of workflow "${slug}" in org "${org}"`;
+  return withTransport(serverAddress, token, async (transport, callOptions) => {
+    const query = createClient(WorkflowQueryController, transport);
+    try {
+      const workflow = await query.getByReference(
+        { org, kind: ApiResourceKind.workflow, slug },
+        callOptions,
+      );
+      const entry = await query.getVersion(
+        { workflowId: workflow.metadata?.id ?? "", versionHash },
+        callOptions,
+      );
+      return toProtoJson(WorkflowVersionEntrySchema, entry);
+    } catch (err) {
+      throw rpcError(err, desc);
+    }
+  });
+}
+
+export interface TagWorkflowVersionArgs {
+  readonly org: string;
+  readonly slug: string;
+  readonly versionHash: string;
+  readonly tag: string;
+}
+
+/**
+ * Assign (or move) a tag onto a workflow version: resolve org/slug → ID, then
+ * tagVersion. Returns the updated workflow as protojson.
+ */
+export async function tagWorkflowVersion(
+  serverAddress: string,
+  token: string,
+  args: TagWorkflowVersionArgs,
+): Promise<string> {
+  const desc = `tag "${args.tag}" on workflow "${args.slug}" in org "${args.org}"`;
+  return withTransport(serverAddress, token, async (transport, callOptions) => {
+    const query = createClient(WorkflowQueryController, transport);
+    let id: string;
+    try {
+      const workflow = await query.getByReference(
+        { org: args.org, kind: ApiResourceKind.workflow, slug: args.slug },
+        callOptions,
+      );
+      id = workflow.metadata?.id ?? "";
+    } catch (err) {
+      throw rpcError(err, desc);
+    }
+
+    const command = createClient(WorkflowCommandController, transport);
+    try {
+      const workflow = await command.tagVersion(
+        { workflowId: id, versionHash: args.versionHash, tag: args.tag },
+        callOptions,
+      );
+      return toProtoJson(WorkflowSchema, workflow);
+    } catch (err) {
+      throw rpcError(err, desc);
+    }
+  });
+}

package/src/gen/agent.ts

@@ -6,7 +6,7 @@
 import { generateSlug, visibilityFromString } from "./apply-runtime.js";
 import { create } from "@bufbuild/protobuf";
 import { AgentSchema, type Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
-import { AgentSpecSchema, ToolApprovalOverrideSchema, McpServerUsageSchema, McpAccessSchema, SubAgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
+import { AgentSpecSchema, ToolApprovalOverrideSchema, McpServerUsageSchema, McpAccessSchema, SubAgentSchema, DatastoreUsageSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
 import { EnvVarDeclarationSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/spec_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { ApiResourceReferenceSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
@@ -28,6 +28,7 @@ export const AgentInputShape = {
   skill_refs: z.array(z.lazy(() => SkillRefInputSchema)).optional().describe("Skill resources providing additional knowledge to the agent."),
   sub_agents: z.array(z.lazy(() => SubAgentInputSchema)).optional().describe("Sub-agents that can be delegated to. Sub-agents can access a subset of the parent's MCP servers and tools."),
   env: z.record(z.lazy(() => EnvVarDeclarationInputSchema)).optional().describe("Environment variable declarations for this agent. Keys are variable names; values describe their metadata and optionality."),
+  datastore_usages: z.array(z.lazy(() => DatastoreUsageInputSchema)).optional().describe("Datastores this agent can use. Each entry must reference a Datastore resource by slug."),
 } as const;
 
 export const AgentInputSchema = z.object(AgentInputShape);
@@ -83,6 +84,17 @@ const EnvVarDeclarationInputSchema = z.object({
 });
 type EnvVarDeclarationInput = z.infer<typeof EnvVarDeclarationInputSchema>;
 
+const DatastoreRefInputSchema = z.object({
+  org: z.string().optional().describe("Organization that owns the referenced resource. When non-empty: must be a valid org slug (lowercase alphanumeric with hyphens, starts with a letter, 1-63 characters). Example: 'stigmer', 'acme-corp'. When empty: the reference is relative — the server resolves it to the parent resource's organization at write time. All stored and returned references always have org populated (absolute form). Use empty org for same-org references (the common case). Use explicit org for cross-org references (e.g., marketplace resources)."),
+  slug: z.string().describe("Resource slug (user-friendly identifier, unique within org). Format: lowercase alphanumeric with hyphens, must start with a letter and end with a letter or digit (e.g., 'web-search', 'code-reviewer'). Length: 2-63 characters."),
+});
+type DatastoreRefInput = z.infer<typeof DatastoreRefInputSchema>;
+
+const DatastoreUsageInputSchema = z.object({
+  datastore_ref: z.lazy(() => DatastoreRefInputSchema).describe("Reference to the Datastore resource."),
+});
+type DatastoreUsageInput = z.infer<typeof DatastoreUsageInputSchema>;
+
 
 /** Build the fully-formed Agent proto from the flat MCP apply input. */
 export function agentInputToProto(input: AgentInput): Agent {
@@ -97,6 +109,7 @@ export function agentInputToProto(input: AgentInput): Agent {
   if (input.env !== undefined) {
     for (const [k, v] of Object.entries(input.env)) spec.env[k] = envVarDeclarationInputToProto(v);
   }
+  if (input.datastore_usages !== undefined) spec.datastoreUsages = input.datastore_usages.map(datastoreUsageInputToProto);
   return Object.assign(create(AgentSchema), {
     apiVersion: "agentic.stigmer.ai/v1",
     kind: "Agent",
@@ -171,3 +184,17 @@ function envVarDeclarationInputToProto(input: EnvVarDeclarationInput) {
   return result;
 }
 
+function datastoreRefInputToProto(input: DatastoreRefInput) {
+  return create(ApiResourceReferenceSchema, {
+    org: input.org,
+    slug: input.slug,
+    kind: ApiResourceKind.datastore,
+  });
+}
+
+function datastoreUsageInputToProto(input: DatastoreUsageInput) {
+  const result = create(DatastoreUsageSchema);
+  if (input.datastore_ref !== undefined) result.datastoreRef = datastoreRefInputToProto(input.datastore_ref);
+  return result;
+}
+