@michelangelo-ai/rpc 0.3.0-nightly.20260708 → 0.3.0-nightly.20260710

package/create-fetch-transport.ts

@@ -0,0 +1,36 @@
+import { toTranscoderError } from './grpc-transcoder-error';
+
+import type { JsonValue } from '@bufbuild/protobuf';
+import type { FetchTransport, FetchTransportOptions } from './types';
+
+export function createFetchTransport(options: FetchTransportOptions): FetchTransport {
+  const baseUrl = options.baseUrl.replace(/\/+$/, '');
+  const headers = {
+    'Content-Type': 'application/json',
+    'context-Ttl-Ms': '10000',
+    'grpc-timeout': '1000000m',
+    'Rpc-Caller': 'ma-studio',
+    'Rpc-Service': 'ma-apiserver',
+    'Rpc-Encoding': 'proto',
+    ...options.headers,
+  };
+
+  return {
+    async callUnary(serviceName, methodName, request) {
+      const response = await fetch(`${baseUrl}/${serviceName}/${methodName}`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(request),
+      });
+
+      // cast: response.json() returns Promise<any> per DOM types
+      const body = (await response.json().catch(() => null)) as JsonValue | null;
+
+      if (response.status < 200 || response.status >= 300) {
+        throw toTranscoderError(response, body);
+      }
+
+      return body;
+    },
+  };
+}

package/grpc-transcoder-error.ts

@@ -0,0 +1,49 @@
+import type { GoogleRpcStatus } from './types';
+
+export class GrpcTranscoderError extends Error {
+  readonly code: number;
+  readonly details: unknown[];
+
+  constructor(message: string, code: number, details: unknown[] = []) {
+    super(message);
+    this.name = 'GrpcTranscoderError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+export function toTranscoderError(response: Response, body: unknown): GrpcTranscoderError {
+  if (isGoogleRpcStatus(body)) {
+    return new GrpcTranscoderError(body.message, body.code, body.details ?? []);
+  }
+  // Plain YARPC errors leave the body empty. Envoy surfaces the real code
+  // and message via grpc-status/grpc-message headers.
+  const headerStatus = response.headers.get('grpc-status');
+  const headerMessage = response.headers.get('grpc-message');
+  if (headerStatus !== null) {
+    return new GrpcTranscoderError(
+      headerMessage ? safeDecode(headerMessage) : response.statusText,
+      Number(headerStatus)
+    );
+  }
+  return new GrpcTranscoderError(
+    response.statusText || `Request failed with status ${response.status}`,
+    2
+  );
+}
+
+function isGoogleRpcStatus(value: unknown): value is GoogleRpcStatus {
+  if (typeof value !== 'object' || value === null) return false;
+  // cast: narrowing unknown to check shape
+  const candidate = value as GoogleRpcStatus;
+  return typeof candidate.code === 'number' && typeof candidate.message === 'string';
+}
+
+// grpc-message headers are percent-encoded per the gRPC HTTP/2 spec.
+function safeDecode(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}

package/handlers.ts

@@ -6,55 +6,35 @@ import type { ExtractUnaryRpc } from './types';
 
 let handlersPromise: Promise<Awaited<ReturnType<typeof createHandlers>>> | null = null;
 
+function unary<Fn>(fn: Fn): ExtractUnaryRpc<Fn> {
+  // cast: TS can't resolve ExtractUnaryRpc's conditional type against the unconstrained generic Fn
+  // from within this function; fn always satisfies it at call sites
+  return fn as unknown as ExtractUnaryRpc<Fn>;
+}
+
 async function createHandlers() {
   const services = await getServices();
 
   return {
-    ListDeployment: services.DeploymentService.listDeployment as ExtractUnaryRpc<
-      typeof services.DeploymentService.listDeployment
-    >,
-    GetDeployment: services.DeploymentService.getDeployment as ExtractUnaryRpc<
-      typeof services.DeploymentService.getDeployment
-    >,
-    ListInferenceServer: services.InferenceServerService.listInferenceServer as ExtractUnaryRpc<
-      typeof services.InferenceServerService.listInferenceServer
-    >,
-    GetInferenceServer: services.InferenceServerService.getInferenceServer as ExtractUnaryRpc<
-      typeof services.InferenceServerService.getInferenceServer
-    >,
-    ListProject: services.ProjectService.listProject as ExtractUnaryRpc<
-      typeof services.ProjectService.listProject
-    >,
-    GetProject: services.ProjectService.getProject as ExtractUnaryRpc<
-      typeof services.ProjectService.getProject
-    >,
-    GetPipeline: services.PipelineService.getPipeline as ExtractUnaryRpc<
-      typeof services.PipelineService.getPipeline
-    >,
-    ListPipeline: services.PipelineService.listPipeline as ExtractUnaryRpc<
-      typeof services.PipelineService.listPipeline
-    >,
-    ListPipelineRun: services.PipelineRunService.listPipelineRun as ExtractUnaryRpc<
-      typeof services.PipelineRunService.listPipelineRun
-    >,
-    GetPipelineRun: services.PipelineRunService.getPipelineRun as ExtractUnaryRpc<
-      typeof services.PipelineRunService.getPipelineRun
-    >,
-    ListTriggerRun: services.TriggerRunService.listTriggerRun as ExtractUnaryRpc<
-      typeof services.TriggerRunService.listTriggerRun
-    >,
-    GetTriggerRun: services.TriggerRunService.getTriggerRun as ExtractUnaryRpc<
-      typeof services.TriggerRunService.getTriggerRun
-    >,
+    ListDeployment: unary(services.DeploymentService.listDeployment),
+    GetDeployment: unary(services.DeploymentService.getDeployment),
+    ListInferenceServer: unary(services.InferenceServerService.listInferenceServer),
+    GetInferenceServer: unary(services.InferenceServerService.getInferenceServer),
+    ListProject: unary(services.ProjectService.listProject),
+    GetProject: unary(services.ProjectService.getProject),
+    GetPipeline: unary(services.PipelineService.getPipeline),
+    ListPipeline: unary(services.PipelineService.listPipeline),
+    ListPipelineRun: unary(services.PipelineRunService.listPipelineRun),
+    GetPipelineRun: unary(services.PipelineRunService.getPipelineRun),
+    ListTriggerRun: unary(services.TriggerRunService.listTriggerRun),
+    GetTriggerRun: unary(services.TriggerRunService.getTriggerRun),
     UpdateTriggerRun: (record: TriggerRun) =>
       services.TriggerRunService.updateTriggerRun({ triggerRun: record }),
     CreatePipelineRun: (record: PipelineRun) =>
       services.PipelineRunService.createPipelineRun({ pipelineRun: record }),
     UpdatePipelineRun: (record: PipelineRun) =>
       services.PipelineRunService.updatePipelineRun({ pipelineRun: record }),
-    ListModel: services.ModelService.listModel as ExtractUnaryRpc<
-      typeof services.ModelService.listModel
-    >,
+    ListModel: unary(services.ModelService.listModel),
   } as const;
 }
 

package/index.ts

@@ -31,4 +31,4 @@ export * from './gen/michelangelo/api/v2/trigger_run_svc_pb';
 export * from './gen/michelangelo/api/v2/user_pb';
 
 export { request } from './request';
-export { normalizeConnectError } from './normalize-connect-error';
+export { normalizeTranscoderError } from './normalize-transcoder-error';

package/normalize-transcoder-error.ts

@@ -0,0 +1,36 @@
+import { ApplicationError, GrpcStatusCode } from '@michelangelo-ai/core';
+
+import { GrpcTranscoderError } from './grpc-transcoder-error';
+
+import type { ErrorNormalizer } from '@michelangelo-ai/core';
+
+/**
+ * Normalizes errors thrown by the fetch transport into ApplicationError format.
+ *
+ * @example
+ * ```ts
+ * <ErrorProvider normalizeError={normalizeTranscoderError}>
+ *   {children}
+ * </ErrorProvider>
+ * ```
+ */
+export const normalizeTranscoderError: ErrorNormalizer = (
+  error: unknown
+): ApplicationError | null => {
+  if (!(error instanceof GrpcTranscoderError)) {
+    return null;
+  }
+
+  // cast: gRPC status codes 0-16 map directly to GrpcStatusCode enum values
+  const code = (
+    error.code in GrpcStatusCode ? error.code : GrpcStatusCode.UNKNOWN
+  ) as GrpcStatusCode;
+
+  return new ApplicationError(error.message, code, {
+    source: 'grpc-transcoder',
+    meta: {
+      details: error.details,
+    },
+    cause: error,
+  });
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@michelangelo-ai/rpc",
   "license": "Apache-2.0",
   "type": "module",
-  "version": "0.3.0-nightly.20260708",
+  "version": "0.3.0-nightly.20260710",
   "scripts": {
     "build": "vite build",
     "test": "cd ../../ && yarn test:rpc"
@@ -12,8 +12,7 @@
     "vite": "6.2.0"
   },
   "dependencies": {
-    "@connectrpc/connect": "^2.0.2",
-    "@connectrpc/connect-web": "^2.0.2",
+    "@bufbuild/protobuf": "^2.2.5",
     "@michelangelo-ai/core": "*"
   },
   "exports": {

package/request.ts

@@ -24,8 +24,13 @@ export async function request<RpcId extends keyof RpcHandlerType>(
   args: OmitTypeName<Parameters<RpcHandlerType[RpcId]>[0]>
 ): Promise<OmitTypeName<Awaited<ReturnType<RpcHandlerType[RpcId]>>>> {
   const handlers = await getRpcHandlers();
+  // cast: dynamic key lookup on handlers loses the specific RPC signature; we know RpcId is a valid
+  // key with matching handler shape
   const handler = handlers[rpcId] as (a: unknown) => Promise<unknown>;
+  // cast: handler returns unknown via dynamic dispatch; RpcId determines the concrete return type
   const response = (await handler(args)) as Awaited<ReturnType<RpcHandlerType[RpcId]>>;
+  // cast: toPlainObject returns unknown; RpcId determines the proto shape after stripping $typeName
+  // fields
   return toPlainObject(response) as OmitTypeName<Awaited<ReturnType<RpcHandlerType[RpcId]>>>;
 }
 
@@ -37,7 +42,7 @@ function toPlainObject(value: unknown): unknown {
   if (Array.isArray(value)) return value.map(toPlainObject);
 
   const result: Record<string, unknown> = {};
-  for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+  for (const [key, val] of Object.entries(value)) {
     if (key === '$typeName' || key === '$unknown') continue;
     result[key] = toPlainObject(val);
   }

package/runtime-config.ts

@@ -23,6 +23,7 @@ export async function getRuntimeConfig(): Promise<RuntimeConfig> {
 
   let config: RuntimeConfig;
   try {
+    // cast: response.json() returns any; the config endpoint's shape is asserted, not validated
     config = (await response.json()) as RuntimeConfig;
   } catch (error) {
     console.error(

package/services.ts

@@ -1,7 +1,6 @@
-import { createRegistry } from '@bufbuild/protobuf';
-import { createClient } from '@connectrpc/connect';
-import { createConnectTransport } from '@connectrpc/connect-web';
+import { create, createRegistry, fromJson, toJson } from '@bufbuild/protobuf';
 
+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';
@@ -12,41 +11,53 @@ import { ProjectService } from './gen/michelangelo/api/v2/project_svc_pb';
 import { TriggerRunService } from './gen/michelangelo/api/v2/trigger_run_svc_pb';
 import { getRuntimeConfig } from './runtime-config';
 
+import type { DescService } from '@bufbuild/protobuf';
+import type { FetchTransport, ServiceClient, Services } from './types';
+
 const typeRegistry = createRegistry(TypedStructSchema);
 
-import type { Interceptor } from '@connectrpc/connect';
-import type { Services } from './types';
+/**
+ * Builds a service client whose methods JSON-encode the request, POST it
+ * through the fetch transport, and decode the JSON response back into a
+ * protobuf-es message. Envoy's grpc_json_transcoder handles the JSON<->binary
+ * conversion on the wire, so this client only ever sees JSON.
+ */
+function createServiceClient<T extends DescService>(
+  service: T,
+  transport: FetchTransport
+): ServiceClient<T> {
+  const client: Record<string, (request: Record<string, unknown>) => Promise<unknown>> = {};
+
+  for (const method of service.methods) {
+    if (method.methodKind !== 'unary') continue;
 
-// This interceptor is used to set the headers for the RPC request to
-// be compatible with the Michelangelo API yarpc server.
-const callerInterceptor: Interceptor = (next) => async (req) => {
-  req.header.set('context-Ttl-Ms', '10000');
-  req.header.set('grpc-timeout', '1000000m');
-  req.header.set('Rpc-Caller', 'ma-studio');
-  req.header.set('Rpc-Service', 'ma-apiserver');
+    client[method.localName] = async (request) => {
+      const message = create(method.input, request);
+      const requestJson = toJson(method.input, message, { registry: typeRegistry });
+      const responseJson = await transport.callUnary(service.typeName, method.name, requestJson);
+      return fromJson(method.output, responseJson, { registry: typeRegistry });
+    };
+  }
 
-  return await next(req);
-};
+  // cast: dynamic method construction can't be statically typed
+  return client as ServiceClient<T>;
+}
 
 let servicesPromise: Promise<Services> | null = null;
 
 async function createServices(): Promise<Services> {
   const { apiBaseUrl } = await getRuntimeConfig();
 
-  const transport = createConnectTransport({
-    baseUrl: apiBaseUrl,
-    interceptors: [callerInterceptor],
-    jsonOptions: { registry: typeRegistry },
-  });
+  const transport = createFetchTransport({ baseUrl: apiBaseUrl });
 
   return {
-    DeploymentService: createClient(DeploymentService, transport),
-    InferenceServerService: createClient(InferenceServerService, transport),
-    ProjectService: createClient(ProjectService, transport),
-    PipelineService: createClient(PipelineService, transport),
-    PipelineRunService: createClient(PipelineRunService, transport),
-    TriggerRunService: createClient(TriggerRunService, transport),
-    ModelService: createClient(ModelService, transport),
+    DeploymentService: createServiceClient(DeploymentService, transport),
+    InferenceServerService: createServiceClient(InferenceServerService, transport),
+    ProjectService: createServiceClient(ProjectService, transport),
+    PipelineService: createServiceClient(PipelineService, transport),
+    PipelineRunService: createServiceClient(PipelineRunService, transport),
+    TriggerRunService: createServiceClient(TriggerRunService, transport),
+    ModelService: createServiceClient(ModelService, transport),
   } as const;
 }
 

package/transformations/common.ts

@@ -33,6 +33,9 @@ export function extractEntityFromResponse<T extends HasTypeName>(
     .toLowerCase();
 
   if (entityName in response) {
+    // cast: dynamic key access on response loses type; we've verified entityName exists in the
+    // response above (only true for Get/Create/Update prefixes; List/Delete are unstripped and
+    // unexercised — see #1461)
     return response[entityName] as ExtractEntityFromResponse<T>;
   }
 

package/types.ts

@@ -1,5 +1,11 @@
-import type { Message } from '@bufbuild/protobuf';
-import type { createClient } from '@connectrpc/connect';
+import type {
+  DescMethodUnary,
+  DescService,
+  JsonValue,
+  Message,
+  MessageInitShape,
+  MessageShape,
+} 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 { ModelService } from './gen/michelangelo/api/v2/model_svc_pb';
@@ -13,14 +19,49 @@ export interface RuntimeConfig {
   apiBaseUrl: string;
 }
 
+/**
+ * Shape of a `google.rpc.Status` error body, as produced by Envoy's
+ * grpc_json_transcoder filter when a unary RPC returns a non-OK gRPC status.
+ */
+export interface GoogleRpcStatus {
+  code: number;
+  message: string;
+  details?: unknown[];
+}
+
+export interface FetchTransportOptions {
+  /** Base URL of the Envoy-fronted API server, e.g. `https://api.example.com`. */
+  baseUrl: string;
+  /** Additional headers to send with every request, merged over the static defaults. */
+  headers?: Record<string, string>;
+}
+
+export interface FetchTransport {
+  /**
+   * Calls a unary RPC through Envoy's grpc_json_transcoder by POSTing JSON to
+   * `/{serviceName}/{methodName}` and returning the parsed JSON response.
+   */
+  callUnary(serviceName: string, methodName: string, request: unknown): Promise<JsonValue>;
+}
+
+/**
+ * Maps a service's generated method descriptors to a client object shaped
+ * like Connect's `Client<T>` — one async function per unary RPC.
+ */
+export type ServiceClient<T extends DescService> = {
+  [K in keyof T['method']]: T['method'][K] extends DescMethodUnary<infer I, infer O>
+    ? (request: MessageInitShape<I>) => Promise<MessageShape<O>>
+    : never;
+};
+
 export type Services = {
-  DeploymentService: ReturnType<typeof createClient<typeof DeploymentService>>;
-  InferenceServerService: ReturnType<typeof createClient<typeof InferenceServerService>>;
-  ProjectService: ReturnType<typeof createClient<typeof ProjectService>>;
-  PipelineService: ReturnType<typeof createClient<typeof PipelineService>>;
-  PipelineRunService: ReturnType<typeof createClient<typeof PipelineRunService>>;
-  TriggerRunService: ReturnType<typeof createClient<typeof TriggerRunService>>;
-  ModelService: ReturnType<typeof createClient<typeof ModelService>>;
+  DeploymentService: ServiceClient<typeof DeploymentService>;
+  InferenceServerService: ServiceClient<typeof InferenceServerService>;
+  ProjectService: ServiceClient<typeof ProjectService>;
+  PipelineService: ServiceClient<typeof PipelineService>;
+  PipelineRunService: ServiceClient<typeof PipelineRunService>;
+  TriggerRunService: ServiceClient<typeof TriggerRunService>;
+  ModelService: ServiceClient<typeof ModelService>;
 };
 
 /**

package/vite.config.ts

@@ -10,13 +10,7 @@ export default defineConfig({
       formats: ['es'],
     },
     rollupOptions: {
-      external: [
-        'react',
-        '@bufbuild/protobuf',
-        '@connectrpc/connect',
-        '@connectrpc/connect-web',
-        '@tanstack/react-query',
-      ],
+      external: ['react', '@bufbuild/protobuf', '@tanstack/react-query'],
     },
     outDir: 'dist',
     emptyOutDir: true,

package/normalize-connect-error.ts

@@ -1,82 +0,0 @@
-import { ConnectError } from '@connectrpc/connect';
-import { ApplicationError, GrpcStatusCode } from '@michelangelo-ai/core';
-
-import type { ErrorNormalizer } from '@michelangelo-ai/core';
-
-/**
- * Normalizes Connect RPC errors to ApplicationError format
- *
- * @param error - The error to normalize
- * @returns ApplicationError if it's a Connect error, null otherwise
- *
- * @example
- * ```ts
- * // Usage in error provider
- * const errorProvider = (
- *   <ErrorProvider normalizeError={normalizeConnectError}>
- *     {children}
- *   </ErrorProvider>
- * );
- * ```
- */
-export const normalizeConnectError: ErrorNormalizer = (error: unknown): ApplicationError | null => {
-  if (!(error instanceof ConnectError)) {
-    return null;
-  }
-
-  return new ApplicationError(error.message, mapConnectCodeToGrpc(error.code), {
-    source: 'connect-rpc',
-    meta: {
-      connectErrorName: error.name,
-      details: error.details,
-      metadata: error.metadata,
-    },
-    cause: error.cause ?? error,
-  });
-};
-
-/**
- * Maps Connect RPC status codes to gRPC status codes
- * Connect uses the same numeric codes as gRPC
- */
-function mapConnectCodeToGrpc(code: number): GrpcStatusCode {
-  // Connect uses the same numeric codes as gRPC, so we can map directly
-  switch (code) {
-    case 0:
-      return GrpcStatusCode.OK;
-    case 1:
-      return GrpcStatusCode.CANCELLED;
-    case 2:
-      return GrpcStatusCode.UNKNOWN;
-    case 3:
-      return GrpcStatusCode.INVALID_ARGUMENT;
-    case 4:
-      return GrpcStatusCode.DEADLINE_EXCEEDED;
-    case 5:
-      return GrpcStatusCode.NOT_FOUND;
-    case 6:
-      return GrpcStatusCode.ALREADY_EXISTS;
-    case 7:
-      return GrpcStatusCode.PERMISSION_DENIED;
-    case 8:
-      return GrpcStatusCode.RESOURCE_EXHAUSTED;
-    case 9:
-      return GrpcStatusCode.FAILED_PRECONDITION;
-    case 10:
-      return GrpcStatusCode.ABORTED;
-    case 11:
-      return GrpcStatusCode.OUT_OF_RANGE;
-    case 12:
-      return GrpcStatusCode.UNIMPLEMENTED;
-    case 13:
-      return GrpcStatusCode.INTERNAL;
-    case 14:
-      return GrpcStatusCode.UNAVAILABLE;
-    case 15:
-      return GrpcStatusCode.DATA_LOSS;
-    case 16:
-      return GrpcStatusCode.UNAUTHENTICATED;
-    default:
-      return GrpcStatusCode.UNKNOWN;
-  }
-}