@michelangelo-ai/rpc 0.9.0 → 0.10.0-rc.1

package/__tests__/services.test.ts

@@ -1,4 +1,6 @@
-import { expect, it, vi } from 'vitest';
+import { create } from '@bufbuild/protobuf';
+import { anyPack, StringValueSchema } from '@bufbuild/protobuf/wkt';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { request } from '../request';
 
@@ -40,8 +42,189 @@ it('decodes a ListPipelineRun response containing a TypedStruct Any field', asyn
     result as unknown as { pipelineRunList: { items: { status: { details: unknown[] } }[] } }
   ).pipelineRunList.items[0].status.details;
 
-  // The Any is decoded to { typeUrl, value: Uint8Array } by the registry.
-  // Without TypedStructSchema in the registry, fromJson throws before reaching here.
-  expect(details[0]).toMatchObject({ typeUrl: 'type.googleapis.com/michelangelo.api.TypedStruct' });
-  expect((details[0] as { value: unknown }).value).toBeInstanceOf(Uint8Array);
+  // The registry decodes the Any to a binary TypedStruct, and toPlainObject unpacks it to
+  // { typeUrl, value } where typeUrl names the inner config type and value is its plain
+  // JSON. Without TypedStructSchema in the registry, fromJson throws before reaching here.
+  expect(details[0]).toEqual({
+    typeUrl: 'type.googleapis.com/michelangelo.UniFlowConf',
+    value: {},
+  });
+});
+
+// Verifies the Any lands on the wire in the shape Envoy's grpc_json_transcoder expects.
+describe('outgoing request — Any-packing through the real service client', () => {
+  beforeEach(() => {
+    vi.mocked(global.fetch).mockClear();
+  });
+
+  function expectCriteria(
+    ...expected: Array<{ fieldName: string; operator: string; matchValue: unknown }>
+  ) {
+    const calls = vi.mocked(global.fetch).mock.calls;
+    const [, init] = calls.at(-1) as [string, RequestInit];
+    // cast: this test only cares about the shape it itself constructed
+    const body = JSON.parse(init.body as string) as {
+      listOptionsExt: { operation: { criterion: Record<string, unknown>[] } };
+    };
+    const criteria = body.listOptionsExt.operation.criterion;
+    expect(criteria).toHaveLength(expected.length);
+    for (const [i, criterion] of expected.entries()) {
+      expect(criteria[i]).toMatchObject(criterion);
+    }
+  }
+
+  it('packs a string matchValue into a StringValue Any', async () => {
+    await request('ListPipelineRun', {
+      listOptionsExt: {
+        operation: {
+          criterion: [
+            { fieldName: 'pipeline_run.pipeline_name', operator: 1, matchValue: 'my-pipeline' },
+          ],
+        },
+      },
+    } as never);
+
+    expectCriteria({
+      fieldName: 'pipeline_run.pipeline_name',
+      operator: 'CRITERION_OPERATOR_EQUAL',
+      matchValue: {
+        '@type': 'type.googleapis.com/google.protobuf.StringValue',
+        value: 'my-pipeline',
+      },
+    });
+  });
+
+  it('packs a boolean matchValue into a BoolValue Any', async () => {
+    await request('ListPipelineRun', {
+      listOptionsExt: {
+        operation: { criterion: [{ fieldName: 'x', operator: 1, matchValue: true }] },
+      },
+    } as never);
+
+    expectCriteria({
+      fieldName: 'x',
+      operator: 'CRITERION_OPERATOR_EQUAL',
+      matchValue: { '@type': 'type.googleapis.com/google.protobuf.BoolValue', value: true },
+    });
+  });
+
+  it('packs an integer matchValue into an Int64Value Any', async () => {
+    await request('ListPipelineRun', {
+      listOptionsExt: {
+        operation: { criterion: [{ fieldName: 'x', operator: 1, matchValue: 42 }] },
+      },
+    } as never);
+
+    expectCriteria({
+      fieldName: 'x',
+      operator: 'CRITERION_OPERATOR_EQUAL',
+      matchValue: { '@type': 'type.googleapis.com/google.protobuf.Int64Value', value: '42' },
+    });
+  });
+
+  it('packs a float matchValue into a DoubleValue Any', async () => {
+    await request('ListPipelineRun', {
+      listOptionsExt: {
+        operation: { criterion: [{ fieldName: 'x', operator: 1, matchValue: 1.5 }] },
+      },
+    } as never);
+
+    expectCriteria({
+      fieldName: 'x',
+      operator: 'CRITERION_OPERATOR_EQUAL',
+      matchValue: { '@type': 'type.googleapis.com/google.protobuf.DoubleValue', value: 1.5 },
+    });
+  });
+
+  it('sends an already-packed Any (real typeUrl/value) through unchanged', async () => {
+    const realAny = anyPack(
+      StringValueSchema,
+      create(StringValueSchema, { value: 'already-packed' })
+    );
+
+    await request('ListPipelineRun', {
+      listOptionsExt: {
+        operation: { criterion: [{ fieldName: 'x', operator: 1, matchValue: realAny }] },
+      },
+    } as never);
+
+    expectCriteria({
+      fieldName: 'x',
+      operator: 'CRITERION_OPERATOR_EQUAL',
+      matchValue: {
+        '@type': 'type.googleapis.com/google.protobuf.StringValue',
+        value: 'already-packed',
+      },
+    });
+  });
+
+  it('packs Any values across every entry of a repeated field, and leaves fieldName untouched', async () => {
+    await request('ListPipelineRun', {
+      listOptionsExt: {
+        operation: {
+          criterion: [
+            { fieldName: 'a', operator: 1, matchValue: 'one' },
+            { fieldName: 'b', operator: 1, matchValue: 'two' },
+          ],
+        },
+      },
+    } as never);
+
+    expectCriteria(
+      {
+        fieldName: 'a',
+        operator: 'CRITERION_OPERATOR_EQUAL',
+        matchValue: { '@type': 'type.googleapis.com/google.protobuf.StringValue', value: 'one' },
+      },
+      {
+        fieldName: 'b',
+        operator: 'CRITERION_OPERATOR_EQUAL',
+        matchValue: { '@type': 'type.googleapis.com/google.protobuf.StringValue', value: 'two' },
+      }
+    );
+  });
+
+  // Rejects rather than letting create() silently turn this into an empty, corrupted Any —
+  // callers already normalize thrown RPC errors, so this surfaces as a normal query error.
+  it('rejects when an Any field is given a value with no wrapper mapping', async () => {
+    await expect(
+      request('ListPipelineRun', {
+        listOptionsExt: {
+          operation: {
+            criterion: [{ fieldName: 'x', operator: 1, matchValue: { nested: 'object' } }],
+          },
+        },
+      } as never)
+    ).rejects.toThrow(/cannot auto-pack object/);
+  });
+
+  // A map<string, Any> field on an unrelated service/message, proving the packing is
+  // schema-driven rather than special-cased for Criterion.
+  it('packs a map<string, Any> field on CreateDeployment, an unrelated service method', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      status: 200,
+      headers: new Headers({ 'content-type': 'application/json' }),
+      json: () => Promise.resolve({}),
+    });
+
+    await request('CreateDeployment', {
+      metadata: { name: 'my-deployment' },
+      status: { providerStatus: { foo: 'bar-value', replicas: 3 } },
+    } as never);
+
+    const calls = (global.fetch as ReturnType<typeof vi.fn>).mock.calls;
+    const [, init] = calls.at(-1) as [string, RequestInit];
+    const body = JSON.parse(init.body as string) as {
+      deployment: { status: { providerStatus: Record<string, unknown> } };
+    };
+
+    expect(body.deployment.status.providerStatus.foo).toEqual({
+      '@type': 'type.googleapis.com/google.protobuf.StringValue',
+      value: 'bar-value',
+    });
+    expect(body.deployment.status.providerStatus.replicas).toEqual({
+      '@type': 'type.googleapis.com/google.protobuf.Int64Value',
+      value: '3',
+    });
+  });
 });

package/handlers.ts

@@ -3,6 +3,8 @@ import { create } from '@bufbuild/protobuf';
 import { UserInfoSchema } from './gen/michelangelo/api/v2/user_pb';
 import { getServices } from './services';
 
+import type { Deployment } from './gen/michelangelo/api/v2/deployment_pb';
+import type { InferenceServer } from './gen/michelangelo/api/v2/inference_server_pb';
 import type { PipelineRun } from './gen/michelangelo/api/v2/pipeline_run_pb';
 import type { TriggerRun } from './gen/michelangelo/api/v2/trigger_run_pb';
 import type { ExtractUnaryRpc } from './types';
@@ -36,8 +38,17 @@ async function createHandlers() {
   return {
     ListDeployment: unary(services.DeploymentService.listDeployment),
     GetDeployment: unary(services.DeploymentService.getDeployment),
+    CreateDeployment: (record: Deployment, headers?: Record<string, string>) => {
+      const actorName = headers?.['x-user-name'];
+      if (actorName && record.spec) {
+        record.spec.owner = create(UserInfoSchema, { name: actorName });
+      }
+      return services.DeploymentService.createDeployment({ deployment: record }, headers);
+    },
     ListInferenceServer: unary(services.InferenceServerService.listInferenceServer),
     GetInferenceServer: unary(services.InferenceServerService.getInferenceServer),
+    CreateInferenceServer: (record: InferenceServer, headers?: Record<string, string>) =>
+      services.InferenceServerService.createInferenceServer({ inferenceServer: record }, headers),
     ListProject: unary(services.ProjectService.listProject),
     GetProject: unary(services.ProjectService.getProject),
     GetPipeline: unary(services.PipelineService.getPipeline),
@@ -47,6 +58,13 @@ async function createHandlers() {
     GetPipelineRun: unary(services.PipelineRunService.getPipelineRun),
     ListTriggerRun: unary(services.TriggerRunService.listTriggerRun),
     GetTriggerRun: unary(services.TriggerRunService.getTriggerRun),
+    CreateTriggerRun: (record: TriggerRun, headers?: Record<string, string>) => {
+      const actorName = headers?.['x-user-name'];
+      if (actorName && record.spec) {
+        record.spec.actor = create(UserInfoSchema, { name: actorName });
+      }
+      return services.TriggerRunService.createTriggerRun({ triggerRun: record }, headers);
+    },
     UpdateTriggerRun: (record: TriggerRun, headers?: Record<string, string>) =>
       services.TriggerRunService.updateTriggerRun({ triggerRun: record }, headers),
     CreatePipelineRun: (record: PipelineRun, headers?: Record<string, string>) => {
@@ -59,6 +77,8 @@ async function createHandlers() {
     UpdatePipelineRun: (record: PipelineRun, headers?: Record<string, string>) =>
       services.PipelineRunService.updatePipelineRun({ pipelineRun: record }, headers),
     ListModel: unary(services.ModelService.listModel),
+    GetModel: unary(services.ModelService.getModel),
+    ListModelFamily: unary(services.ModelFamilyService.listModelFamily),
   } as const;
 }
 

package/pack-any-fields.ts

@@ -0,0 +1,92 @@
+import { create } from '@bufbuild/protobuf';
+import {
+  anyPack,
+  BoolValueSchema,
+  DoubleValueSchema,
+  Int64ValueSchema,
+  StringValueSchema,
+} from '@bufbuild/protobuf/wkt';
+
+import type { DescField, DescMessage } from '@bufbuild/protobuf';
+
+const ANY_TYPE_NAME = 'google.protobuf.Any';
+
+/**
+ * Walks a request object against its proto descriptor, packing JS primitives into well-known
+ * wrapper types wherever the schema has a `google.protobuf.Any` field.
+ *
+ * @example
+ * packAnyFields(CriterionSchema, { fieldName: "x", matchValue: "my-pipeline" })
+ * // matchValue -> anyPack(StringValueSchema, create(StringValueSchema, { value: "my-pipeline" }))
+ */
+export function packAnyFields(desc: DescMessage, value: unknown): unknown {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return value;
+
+  const result: Record<string, unknown> = {};
+  for (const [key, val] of Object.entries(value)) {
+    const field: DescField | undefined = desc.field[key];
+    result[key] = field ? packField(field, val) : val;
+  }
+  return result;
+}
+
+function packField(field: DescField, value: unknown): unknown {
+  if (value === null || value === undefined) return value;
+
+  switch (field.fieldKind) {
+    case 'message':
+      return packMessageValue(field.message, value);
+    case 'list':
+      if (field.listKind === 'message') {
+        // cast: repeated fields are always arrays at runtime
+        return (value as unknown[]).map((item) => packMessageValue(field.message, item));
+      }
+      return value;
+    case 'map': {
+      const mapValueMessage = field.message;
+      if (!mapValueMessage) return value;
+      // cast: map fields are always plain objects at runtime, keyed by the (stringified)
+      // map key regardless of its declared scalar type
+      const mapValue = value as Record<string, unknown>;
+      return Object.fromEntries(
+        Object.entries(mapValue).map(([key, item]) => [
+          key,
+          packMessageValue(mapValueMessage, item),
+        ])
+      );
+    }
+    default:
+      return value;
+  }
+}
+
+function packMessageValue(desc: DescMessage, value: unknown): unknown {
+  if (desc.typeName !== ANY_TYPE_NAME) {
+    return packAnyFields(desc, value);
+  }
+
+  // Already a packed Any object (has typeUrl) — pass through
+  if (typeof value === 'object' && value !== null && 'typeUrl' in value) {
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    return anyPack(StringValueSchema, create(StringValueSchema, { value }));
+  }
+  if (typeof value === 'boolean') {
+    return anyPack(BoolValueSchema, create(BoolValueSchema, { value }));
+  }
+  if (typeof value === 'number') {
+    if (Number.isInteger(value)) {
+      return anyPack(Int64ValueSchema, create(Int64ValueSchema, { value: BigInt(value) }));
+    }
+    return anyPack(DoubleValueSchema, create(DoubleValueSchema, { value }));
+  }
+
+  // create() doesn't validate an Any's shape, so passing this through would silently produce
+  // an empty Any (typeUrl: '') instead of a visible error.
+  throw new Error(
+    `packAnyFields: cannot auto-pack ${typeof value} into google.protobuf.Any — ` +
+      `expected a string, number, or boolean primitive`
+  );
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@michelangelo-ai/rpc",
   "license": "Apache-2.0",
   "type": "module",
-  "version": "0.9.0",
+  "version": "0.10.0-rc.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/michelangelo-ai/michelangelo"
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.2.5",
-    "@michelangelo-ai/core": "0.9.0"
+    "@michelangelo-ai/core": "0.10.0-rc.1"
   },
   "exports": {
     ".": {

package/request.ts

@@ -1,5 +1,9 @@
+import { fromBinary, toJson } from '@bufbuild/protobuf';
+
+import { TypedStructSchema } from './gen/michelangelo/api/typed_struct_pb';
 import { getRpcHandlers } from './handlers';
 
+import type { Any } from '@bufbuild/protobuf/wkt';
 import type { OmitTypeName, RpcHandlerType } from './types';
 
 /**
@@ -43,6 +47,9 @@ function toPlainObject(value: unknown): unknown {
   if (value instanceof Uint8Array) return value; // preserve bytes fields (e.g. google.protobuf.Any.value)
   if (Array.isArray(value)) return value.map(toPlainObject);
 
+  const typedStruct = unpackTypedStructAny(value);
+  if (typedStruct) return typedStruct;
+
   const result: Record<string, unknown> = {};
   for (const [key, val] of Object.entries(value)) {
     if (key === '$typeName' || key === '$unknown') continue;
@@ -50,3 +57,17 @@ function toPlainObject(value: unknown): unknown {
   }
   return result;
 }
+
+const TYPED_STRUCT_TYPE_URL = `type.googleapis.com/${TypedStructSchema.typeName}`;
+
+// google.protobuf.Any fields survive fromJson as { typeUrl, value: Uint8Array } — the binary
+// payload is useless to consumers. When the payload is a michelangelo.api.TypedStruct
+// (e.g. PipelineManifest.content), expand it to { typeUrl, value } where typeUrl names the
+// inner config type and value is its plain JSON. Other Any payloads are left untouched.
+function unpackTypedStructAny(value: object): unknown {
+  if (!('$typeName' in value) || value.$typeName !== 'google.protobuf.Any') return undefined;
+  // cast: the $typeName check above identifies this as a google.protobuf.Any message
+  const any = value as Any;
+  if (any.typeUrl !== TYPED_STRUCT_TYPE_URL) return undefined;
+  return toJson(TypedStructSchema, fromBinary(TypedStructSchema, any.value));
+}

package/services.ts

@@ -1,20 +1,38 @@
 import { create, createRegistry, fromJson, toJson } from '@bufbuild/protobuf';
+import {
+  BoolValueSchema,
+  DoubleValueSchema,
+  Int64ValueSchema,
+  StringValueSchema,
+} from '@bufbuild/protobuf/wkt';
 
 import { createFetchTransport } from './create-fetch-transport';
 import { TypedStructSchema } from './gen/michelangelo/api/typed_struct_pb';
 import { DeploymentService } from './gen/michelangelo/api/v2/deployment_svc_pb';
 import { InferenceServerService } from './gen/michelangelo/api/v2/inference_server_svc_pb';
+import { ModelFamilyService } from './gen/michelangelo/api/v2/model_family_svc_pb';
 import { ModelService } from './gen/michelangelo/api/v2/model_svc_pb';
 import { PipelineRunService } from './gen/michelangelo/api/v2/pipeline_run_svc_pb';
 import { PipelineService } from './gen/michelangelo/api/v2/pipeline_svc_pb';
 import { ProjectService } from './gen/michelangelo/api/v2/project_svc_pb';
 import { TriggerRunService } from './gen/michelangelo/api/v2/trigger_run_svc_pb';
+import { packAnyFields } from './pack-any-fields';
 import { getRuntimeConfig } from './runtime-config';
 
 import type { DescService } from '@bufbuild/protobuf';
 import type { FetchTransport, ServiceClient, Services } from './types';
 
-const typeRegistry = createRegistry(TypedStructSchema);
+// These wrapper schemas are registered so criteria that wrap a matchValue in a
+// google.protobuf.Any (e.g. ListOptionsExt filters, packed by packAnyFields) can be
+// JSON-encoded — protobuf-es resolves an Any's typeUrl against this registry to serialize
+// it as a well-known type.
+const typeRegistry = createRegistry(
+  TypedStructSchema,
+  StringValueSchema,
+  BoolValueSchema,
+  Int64ValueSchema,
+  DoubleValueSchema
+);
 
 /**
  * Builds a service client whose methods JSON-encode the request, POST it
@@ -35,7 +53,10 @@ function createServiceClient<T extends DescService>(
     if (method.methodKind !== 'unary') continue;
 
     client[method.localName] = async (request, headers) => {
-      const message = create(method.input, request);
+      // cast: packAnyFields recurses generically over `unknown`; called with a Record it
+      // returns one, just with Any fields packed into the shape create() expects
+      const packedRequest = packAnyFields(method.input, request) as Record<string, unknown>;
+      const message = create(method.input, packedRequest);
       const requestJson = toJson(method.input, message, { registry: typeRegistry });
       const responseJson = await transport.callUnary(
         service.typeName,
@@ -66,6 +87,7 @@ async function createServices(): Promise<Services> {
     PipelineRunService: createServiceClient(PipelineRunService, transport),
     TriggerRunService: createServiceClient(TriggerRunService, transport),
     ModelService: createServiceClient(ModelService, transport),
+    ModelFamilyService: createServiceClient(ModelFamilyService, transport),
   } as const;
 }
 

package/types.ts

@@ -8,6 +8,7 @@ import type {
 } from '@bufbuild/protobuf';
 import type { DeploymentService } from './gen/michelangelo/api/v2/deployment_svc_pb';
 import type { InferenceServerService } from './gen/michelangelo/api/v2/inference_server_svc_pb';
+import type { ModelFamilyService } from './gen/michelangelo/api/v2/model_family_svc_pb';
 import type { ModelService } from './gen/michelangelo/api/v2/model_svc_pb';
 import type { PipelineRunService } from './gen/michelangelo/api/v2/pipeline_run_svc_pb';
 import type { PipelineService } from './gen/michelangelo/api/v2/pipeline_svc_pb';
@@ -67,6 +68,7 @@ export type Services = {
   PipelineRunService: ServiceClient<typeof PipelineRunService>;
   TriggerRunService: ServiceClient<typeof TriggerRunService>;
   ModelService: ServiceClient<typeof ModelService>;
+  ModelFamilyService: ServiceClient<typeof ModelFamilyService>;
 };
 
 /**