@valon-technologies/gestalt 0.0.1-alpha.18 → 0.0.1-alpha.20

package/src/invoker.ts

@@ -1,9 +1,9 @@
-import type { JsonObject, JsonValue } from "@bufbuild/protobuf";
 import { createClient, type Client, type Interceptor } from "@connectrpc/connect";
 import { createGrpcTransport } from "@connectrpc/connect-node";
 
 import { PluginInvoker as PluginInvokerService } from "./internal/gen/v1/plugin_pb.ts";
 import type { OperationResult, Request } from "./api.ts";
+import { structFromObject, type JsonObjectInput } from "./protocol.ts";
 
 /** Environment variable containing the plugin-invoker host-service target. */
 export const ENV_PLUGIN_INVOKER_SOCKET = "GESTALT_PLUGIN_INVOKER_SOCKET";
@@ -37,7 +37,7 @@ export interface PluginInvocationGrant {
 /** Options for invoking a plugin GraphQL surface. */
 export interface PluginGraphQLInvokeOptions extends PluginInvokeOptions {
   /** GraphQL variables encoded as a JSON object. */
-  variables?: Record<string, unknown>;
+  variables?: JsonObjectInput;
 }
 
 /**
@@ -72,14 +72,14 @@ export class PluginInvoker {
   async invoke(
     plugin: string,
     operation: string,
-    params: Record<string, unknown> = {},
+    params: JsonObjectInput = {},
     options?: PluginInvokeOptions,
   ): Promise<OperationResult> {
     const response = await this.client.invoke({
       invocationToken: this.invocationToken,
       plugin,
       operation,
-      params: toJsonObject(params),
+      params: structFromObject(params),
       connection: options?.connection ?? "",
       instance: options?.instance ?? "",
       idempotencyKey: options?.idempotencyKey?.trim() ?? "",
@@ -105,8 +105,8 @@ export class PluginInvoker {
       invocationToken: this.invocationToken,
       plugin,
       document: trimmedDocument,
-      ...(options?.variables
-        ? { variables: toJsonObject(options.variables) }
+      ...(options?.variables !== undefined
+        ? { variables: structFromObject(options.variables) }
         : {}),
       connection: options?.connection ?? "",
       instance: options?.instance ?? "",
@@ -199,32 +199,3 @@ function normalizeInvocationToken(requestOrToken: Request | string): string {
   }
   return trimmed;
 }
-
-function toJsonObject(params: Record<string, unknown>): JsonObject {
-  const output: JsonObject = {};
-  for (const [key, value] of Object.entries(params ?? {})) {
-    if (value === undefined) {
-      continue;
-    }
-    output[key] = toJsonValue(value);
-  }
-  return output;
-}
-
-function toJsonValue(value: unknown): JsonValue {
-  if (
-    value === null ||
-    typeof value === "string" ||
-    typeof value === "number" ||
-    typeof value === "boolean"
-  ) {
-    return value as JsonValue;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => toJsonValue(entry));
-  }
-  if (typeof value === "object") {
-    return toJsonObject(value as Record<string, unknown>);
-  }
-  throw new Error("plugin invoker: params must be JSON-serializable");
-}

package/src/plugin.ts

@@ -14,7 +14,7 @@ import {
   type Request,
   responseBrand,
   type Response,
-  type Subject,
+  type SubjectInput,
 } from "./api.ts";
 import {
   cloneHTTPSubjectRequest,
@@ -24,9 +24,9 @@ import {
   type HTTPSubjectResolver,
 } from "./http-subject.ts";
 import {
-  isRuntimeProvider,
-  RuntimeProvider,
-  type RuntimeProviderOptions,
+  isProviderBase,
+  ProviderBase,
+  type ProviderBaseOptions,
 } from "./provider.ts";
 import type { Schema } from "./schema.ts";
 
@@ -36,8 +36,8 @@ import type { Schema } from "./schema.ts";
 export type ConnectionMode =
   | "unspecified"
   | "none"
-  | "user"
-  | "platform";
+  | "subject"
+  | "user";
 
 /**
  * Metadata for a single connection parameter exposed by a provider.
@@ -118,7 +118,7 @@ export type PostConnectHandler = (
 /**
  * Runtime hooks required to implement a plugin provider.
  */
-export interface PluginDefinitionOptions extends RuntimeProviderOptions {
+export interface PluginDefinitionOptions extends ProviderBaseOptions {
   connectionMode?: ConnectionMode;
   authTypes?: string[];
   connectionParams?: Record<string, ConnectionParamDefinition>;
@@ -170,7 +170,7 @@ export function operation<In, Out>(
  * });
  * ```
  */
-export class PluginProvider extends RuntimeProvider {
+export class PluginProvider extends ProviderBase {
   readonly kind = "integration" as const;
   readonly iconSvg: string;
   readonly connectionMode: ConnectionMode;
@@ -243,7 +243,7 @@ export class PluginProvider extends RuntimeProvider {
   async resolveHTTPSubject(
     request: HTTPSubjectRequest,
     context: HTTPSubjectResolutionContext,
-  ): Promise<Subject | null | undefined> {
+  ): Promise<SubjectInput | null | undefined> {
     return await this.httpSubjectResolver?.(
       cloneHTTPSubjectRequest(request),
       cloneHTTPSubjectResolutionContext(context),
@@ -390,7 +390,7 @@ export function isPluginProvider(
 ): value is PluginProvider {
   return (
     value instanceof PluginProvider ||
-    (isRuntimeProvider(value) &&
+    (isProviderBase(value) &&
       "kind" in value &&
       (value as { kind?: unknown }).kind === "integration" &&
       "staticCatalog" in value &&
@@ -513,10 +513,10 @@ export function connectionModeToProtoValue(mode: ConnectionMode): number {
   switch (mode) {
     case "none":
       return 1;
+    case "subject":
+      return 2;
     case "user":
       return 2;
-    case "platform":
-      return 5;
     case "unspecified":
     default:
       return 0;

package/src/pluginruntime.ts

@@ -1,4 +1,4 @@
-import { create, type MessageInitShape } from "@bufbuild/protobuf";
+import { create } from "@bufbuild/protobuf";
 import { EmptySchema } from "@bufbuild/protobuf/wkt";
 import {
   Code,
@@ -9,52 +9,155 @@ import {
 import {
   HostedPluginSchema,
   ListPluginRuntimeSessionsResponseSchema,
-  PluginRuntimeEgressMode,
+  PreparePluginRuntimeWorkspaceResponseSchema,
+  PluginRuntimeEgressMode as ProtoPluginRuntimeEgressMode,
   PluginRuntimeProvider as PluginRuntimeProviderService,
   PluginRuntimeSessionSchema,
   PluginRuntimeSupportSchema,
-  type GetPluginRuntimeSessionRequest,
-  type HostedPlugin,
-  type ListPluginRuntimeSessionsRequest,
-  type PluginRuntimeSession,
-  type PluginRuntimeSupport,
-  type StartHostedPluginRequest,
-  type StartPluginRuntimeSessionRequest,
-  type StopPluginRuntimeSessionRequest,
+  type GetPluginRuntimeSessionRequest as ProtoGetPluginRuntimeSessionRequest,
+  type ListPluginRuntimeSessionsRequest as ProtoListPluginRuntimeSessionsRequest,
+  type PreparePluginRuntimeWorkspaceRequest as ProtoPreparePluginRuntimeWorkspaceRequest,
+  type RemovePluginRuntimeWorkspaceRequest as ProtoRemovePluginRuntimeWorkspaceRequest,
+  type StartHostedPluginRequest as ProtoStartHostedPluginRequest,
+  type StartPluginRuntimeSessionRequest as ProtoStartPluginRuntimeSessionRequest,
+  type StopPluginRuntimeSessionRequest as ProtoStopPluginRuntimeSessionRequest,
 } from "./internal/gen/v1/pluginruntime_pb.ts";
+import {
+  timestampFromDate,
+} from "./protocol.ts";
 import { errorMessage, type MaybePromise } from "./api.ts";
-import { RuntimeProvider, type RuntimeProviderOptions } from "./provider.ts";
-
-export type {
-  GetPluginRuntimeSessionRequest,
-  HostedPlugin,
-  ListPluginRuntimeSessionsRequest,
-  PluginRuntimeSession,
-  PluginRuntimeSupport,
-  StartHostedPluginRequest,
-  StartPluginRuntimeSessionRequest,
-  StopPluginRuntimeSessionRequest,
-};
-export { PluginRuntimeEgressMode };
-
-export interface PluginRuntimeProviderOptions extends RuntimeProviderOptions {
-  getSupport: () => MaybePromise<MessageInitShape<typeof PluginRuntimeSupportSchema>>;
+import { ProviderBase, type ProviderBaseOptions } from "./provider.ts";
+
+type PluginRuntimeProviderServiceImpl = Partial<
+  ServiceImpl<typeof PluginRuntimeProviderService>
+>;
+
+/** Native egress-mode constants for authored plugin runtime providers. */
+export const PluginRuntimeEgressMode = {
+  UNSPECIFIED: ProtoPluginRuntimeEgressMode.UNSPECIFIED,
+  NONE: ProtoPluginRuntimeEgressMode.NONE,
+  CIDR: ProtoPluginRuntimeEgressMode.CIDR,
+  HOSTNAME: ProtoPluginRuntimeEgressMode.HOSTNAME,
+} as const;
+export type PluginRuntimeEgressMode =
+  (typeof PluginRuntimeEgressMode)[keyof typeof PluginRuntimeEgressMode];
+
+export interface PluginRuntimeSupport {
+  canHostPlugins?: boolean | undefined;
+  egressMode?: PluginRuntimeEgressMode | undefined;
+  supportsPrepareWorkspace?: boolean | undefined;
+}
+
+export interface PluginRuntimeSessionLifecycle {
+  startedAt?: Date | undefined;
+  recommendedDrainAt?: Date | undefined;
+  expiresAt?: Date | undefined;
+}
+
+export interface PluginRuntimeSession {
+  id?: string | undefined;
+  state?: string | undefined;
+  metadata?: Record<string, string> | undefined;
+  lifecycle?: PluginRuntimeSessionLifecycle | undefined;
+  stateReason?: string | undefined;
+  stateMessage?: string | undefined;
+}
+
+export interface PluginRuntimeImagePullAuth {
+  dockerConfigJson?: string | undefined;
+}
+
+export interface StartPluginRuntimeSessionRequest {
+  pluginName: string;
+  template?: string | undefined;
+  image?: string | undefined;
+  metadata?: Record<string, string> | undefined;
+  imagePullAuth?: PluginRuntimeImagePullAuth | undefined;
+}
+
+export interface GetPluginRuntimeSessionRequest {
+  sessionId: string;
+}
+
+export interface ListPluginRuntimeSessionsRequest {}
+
+export interface StopPluginRuntimeSessionRequest {
+  sessionId: string;
+}
+
+export interface PluginRuntimeAgentWorkspaceGitCheckout {
+  url?: string | undefined;
+  ref?: string | undefined;
+  path?: string | undefined;
+}
+
+export interface PluginRuntimeAgentWorkspace {
+  checkouts?: readonly PluginRuntimeAgentWorkspaceGitCheckout[] | undefined;
+  cwd?: string | undefined;
+}
+
+export interface PluginRuntimePreparedAgentWorkspace {
+  root?: string | undefined;
+  cwd?: string | undefined;
+}
+
+export interface PreparePluginRuntimeWorkspaceRequest {
+  sessionId: string;
+  agentSessionId: string;
+  workspace?: PluginRuntimeAgentWorkspace | undefined;
+}
+
+export interface PreparePluginRuntimeWorkspaceResponse {
+  workspace?: PluginRuntimePreparedAgentWorkspace | undefined;
+}
+
+export interface RemovePluginRuntimeWorkspaceRequest {
+  sessionId: string;
+  agentSessionId: string;
+}
+
+export interface StartHostedPluginRequest {
+  sessionId: string;
+  pluginName: string;
+  command?: string | undefined;
+  args?: readonly string[] | undefined;
+  env?: Record<string, string> | undefined;
+  allowedHosts?: readonly string[] | undefined;
+  defaultAction?: string | undefined;
+  hostBinary?: string | undefined;
+}
+
+export interface HostedPlugin {
+  id?: string | undefined;
+  sessionId?: string | undefined;
+  pluginName?: string | undefined;
+  dialTarget?: string | undefined;
+}
+
+export interface PluginRuntimeProviderOptions extends ProviderBaseOptions {
+  getSupport: () => MaybePromise<PluginRuntimeSupport>;
   startSession: (
     request: StartPluginRuntimeSessionRequest,
-  ) => MaybePromise<MessageInitShape<typeof PluginRuntimeSessionSchema>>;
+  ) => MaybePromise<PluginRuntimeSession>;
   getSession: (
     request: GetPluginRuntimeSessionRequest,
-  ) => MaybePromise<MessageInitShape<typeof PluginRuntimeSessionSchema>>;
+  ) => MaybePromise<PluginRuntimeSession>;
   listSessions: (
     request: ListPluginRuntimeSessionsRequest,
-  ) => MaybePromise<MessageInitShape<typeof PluginRuntimeSessionSchema>[]>;
+  ) => MaybePromise<readonly PluginRuntimeSession[]>;
   stopSession: (request: StopPluginRuntimeSessionRequest) => MaybePromise<void>;
+  prepareWorkspace?: (
+    request: PreparePluginRuntimeWorkspaceRequest,
+  ) => MaybePromise<PreparePluginRuntimeWorkspaceResponse>;
+  removeWorkspace?: (
+    request: RemovePluginRuntimeWorkspaceRequest,
+  ) => MaybePromise<void>;
   startPlugin: (
     request: StartHostedPluginRequest,
-  ) => MaybePromise<MessageInitShape<typeof HostedPluginSchema>>;
+  ) => MaybePromise<HostedPlugin>;
 }
 
-export class PluginRuntimeProvider extends RuntimeProvider {
+export class PluginRuntimeProvider extends ProviderBase {
   readonly kind = "runtime" as const;
 
   private readonly getSupportHandler: PluginRuntimeProviderOptions["getSupport"];
@@ -62,6 +165,8 @@ export class PluginRuntimeProvider extends RuntimeProvider {
   private readonly getSessionHandler: PluginRuntimeProviderOptions["getSession"];
   private readonly listSessionsHandler: PluginRuntimeProviderOptions["listSessions"];
   private readonly stopSessionHandler: PluginRuntimeProviderOptions["stopSession"];
+  private readonly prepareWorkspaceHandler: PluginRuntimeProviderOptions["prepareWorkspace"];
+  private readonly removeWorkspaceHandler: PluginRuntimeProviderOptions["removeWorkspace"];
   private readonly startPluginHandler: PluginRuntimeProviderOptions["startPlugin"];
 
   constructor(options: PluginRuntimeProviderOptions) {
@@ -71,28 +176,30 @@ export class PluginRuntimeProvider extends RuntimeProvider {
     this.getSessionHandler = options.getSession;
     this.listSessionsHandler = options.listSessions;
     this.stopSessionHandler = options.stopSession;
+    this.prepareWorkspaceHandler = options.prepareWorkspace;
+    this.removeWorkspaceHandler = options.removeWorkspace;
     this.startPluginHandler = options.startPlugin;
   }
 
-  async getSupport(): Promise<MessageInitShape<typeof PluginRuntimeSupportSchema>> {
+  async getSupport(): Promise<PluginRuntimeSupport> {
     return await this.getSupportHandler();
   }
 
   async startSession(
     request: StartPluginRuntimeSessionRequest,
-  ): Promise<MessageInitShape<typeof PluginRuntimeSessionSchema>> {
+  ): Promise<PluginRuntimeSession> {
     return await this.startSessionHandler(request);
   }
 
   async getSession(
     request: GetPluginRuntimeSessionRequest,
-  ): Promise<MessageInitShape<typeof PluginRuntimeSessionSchema>> {
+  ): Promise<PluginRuntimeSession> {
     return await this.getSessionHandler(request);
   }
 
   async listSessions(
     request: ListPluginRuntimeSessionsRequest,
-  ): Promise<MessageInitShape<typeof PluginRuntimeSessionSchema>[]> {
+  ): Promise<readonly PluginRuntimeSession[]> {
     return await this.listSessionsHandler(request);
   }
 
@@ -100,9 +207,33 @@ export class PluginRuntimeProvider extends RuntimeProvider {
     await this.stopSessionHandler(request);
   }
 
+  async prepareWorkspace(
+    request: PreparePluginRuntimeWorkspaceRequest,
+  ): Promise<PreparePluginRuntimeWorkspaceResponse> {
+    if (!this.prepareWorkspaceHandler) {
+      throw new ConnectError(
+        "plugin runtime provider prepare workspace is not implemented",
+        Code.Unimplemented,
+      );
+    }
+    return await this.prepareWorkspaceHandler(request);
+  }
+
+  async removeWorkspace(
+    request: RemovePluginRuntimeWorkspaceRequest,
+  ): Promise<void> {
+    if (!this.removeWorkspaceHandler) {
+      throw new ConnectError(
+        "plugin runtime provider remove workspace is not implemented",
+        Code.Unimplemented,
+      );
+    }
+    await this.removeWorkspaceHandler(request);
+  }
+
   async startPlugin(
     request: StartHostedPluginRequest,
-  ): Promise<MessageInitShape<typeof HostedPluginSchema>> {
+  ): Promise<HostedPlugin> {
     return await this.startPluginHandler(request);
   }
 }
@@ -130,56 +261,210 @@ export function isPluginRuntimeProvider(
 
 export function createPluginRuntimeProviderService(
   provider: PluginRuntimeProvider,
-): Partial<ServiceImpl<typeof PluginRuntimeProviderService>> {
+): PluginRuntimeProviderServiceImpl {
   return {
     async getSupport() {
       return create(
         PluginRuntimeSupportSchema,
-        await invokePluginRuntimeProvider("get support", () =>
-          provider.getSupport(),
+        pluginRuntimeSupportToProto(
+          await invokePluginRuntimeProvider("get support", () =>
+            provider.getSupport(),
+          ),
         ),
       );
     },
     async startSession(request) {
       return create(
         PluginRuntimeSessionSchema,
-        await invokePluginRuntimeProvider("start session", () =>
-          provider.startSession(request),
+        pluginRuntimeSessionToProto(
+          await invokePluginRuntimeProvider("start session", () =>
+            provider.startSession(startSessionRequestFromProto(request)),
+          ),
         ),
       );
     },
     async getSession(request) {
       return create(
         PluginRuntimeSessionSchema,
-        await invokePluginRuntimeProvider("get session", () =>
-          provider.getSession(request),
+        pluginRuntimeSessionToProto(
+          await invokePluginRuntimeProvider("get session", () =>
+            provider.getSession(getSessionRequestFromProto(request)),
+          ),
         ),
       );
     },
     async listSessions(request) {
       return create(ListPluginRuntimeSessionsResponseSchema, {
-        sessions: await invokePluginRuntimeProvider("list sessions", () =>
-          provider.listSessions(request),
-        ),
+        sessions: (
+          await invokePluginRuntimeProvider("list sessions", () =>
+            provider.listSessions(listSessionsRequestFromProto(request)),
+          )
+        ).map(pluginRuntimeSessionToProto),
       });
     },
     async stopSession(request) {
       await invokePluginRuntimeProvider("stop session", () =>
-        provider.stopSession(request),
+        provider.stopSession(stopSessionRequestFromProto(request)),
+      );
+      return create(EmptySchema);
+    },
+    async prepareWorkspace(request) {
+      return create(
+        PreparePluginRuntimeWorkspaceResponseSchema,
+        prepareWorkspaceResponseToProto(
+          await invokePluginRuntimeProvider("prepare workspace", () =>
+            provider.prepareWorkspace(prepareWorkspaceRequestFromProto(request)),
+          ),
+        ),
+      );
+    },
+    async removeWorkspace(request) {
+      await invokePluginRuntimeProvider("remove workspace", () =>
+        provider.removeWorkspace(removeWorkspaceRequestFromProto(request)),
       );
       return create(EmptySchema);
     },
     async startPlugin(request) {
       return create(
         HostedPluginSchema,
-        await invokePluginRuntimeProvider("start plugin", () =>
-          provider.startPlugin(request),
+        hostedPluginToProto(
+          await invokePluginRuntimeProvider("start plugin", () =>
+            provider.startPlugin(startHostedPluginRequestFromProto(request)),
+          ),
         ),
       );
     },
   };
 }
 
+function startSessionRequestFromProto(
+  request: ProtoStartPluginRuntimeSessionRequest,
+): StartPluginRuntimeSessionRequest {
+  return {
+    pluginName: request.pluginName,
+    template: request.template,
+    image: request.image,
+    metadata: { ...request.metadata },
+    imagePullAuth: request.imagePullAuth === undefined
+      ? undefined
+      : { dockerConfigJson: request.imagePullAuth.dockerConfigJson },
+  };
+}
+
+function getSessionRequestFromProto(
+  request: ProtoGetPluginRuntimeSessionRequest,
+): GetPluginRuntimeSessionRequest {
+  return { sessionId: request.sessionId };
+}
+
+function listSessionsRequestFromProto(
+  _request: ProtoListPluginRuntimeSessionsRequest,
+): ListPluginRuntimeSessionsRequest {
+  return {};
+}
+
+function stopSessionRequestFromProto(
+  request: ProtoStopPluginRuntimeSessionRequest,
+): StopPluginRuntimeSessionRequest {
+  return { sessionId: request.sessionId };
+}
+
+function prepareWorkspaceRequestFromProto(
+  request: ProtoPreparePluginRuntimeWorkspaceRequest,
+): PreparePluginRuntimeWorkspaceRequest {
+  return {
+    sessionId: request.sessionId,
+    agentSessionId: request.agentSessionId,
+    workspace: request.workspace === undefined
+      ? undefined
+      : {
+          checkouts: request.workspace.checkouts.map((checkout) => ({
+            url: checkout.url,
+            ref: checkout.ref,
+            path: checkout.path,
+          })),
+          cwd: request.workspace.cwd,
+        },
+  };
+}
+
+function removeWorkspaceRequestFromProto(
+  request: ProtoRemovePluginRuntimeWorkspaceRequest,
+): RemovePluginRuntimeWorkspaceRequest {
+  return {
+    sessionId: request.sessionId,
+    agentSessionId: request.agentSessionId,
+  };
+}
+
+function startHostedPluginRequestFromProto(
+  request: ProtoStartHostedPluginRequest,
+): StartHostedPluginRequest {
+  return {
+    sessionId: request.sessionId,
+    pluginName: request.pluginName,
+    command: request.command,
+    args: [...request.args],
+    env: { ...request.env },
+    allowedHosts: [...request.allowedHosts],
+    defaultAction: request.defaultAction,
+    hostBinary: request.hostBinary,
+  };
+}
+
+function pluginRuntimeSupportToProto(support: PluginRuntimeSupport) {
+  return {
+    canHostPlugins: support.canHostPlugins ?? false,
+    egressMode: support.egressMode ?? PluginRuntimeEgressMode.UNSPECIFIED,
+    supportsPrepareWorkspace: support.supportsPrepareWorkspace ?? false,
+  };
+}
+
+function pluginRuntimeSessionToProto(session: PluginRuntimeSession) {
+  return {
+    id: session.id ?? "",
+    state: session.state ?? "",
+    metadata: { ...(session.metadata ?? {}) },
+    lifecycle: session.lifecycle === undefined
+      ? undefined
+      : {
+          startedAt: session.lifecycle.startedAt === undefined
+            ? undefined
+            : timestampFromDate(session.lifecycle.startedAt),
+          recommendedDrainAt: session.lifecycle.recommendedDrainAt === undefined
+            ? undefined
+            : timestampFromDate(session.lifecycle.recommendedDrainAt),
+          expiresAt: session.lifecycle.expiresAt === undefined
+            ? undefined
+            : timestampFromDate(session.lifecycle.expiresAt),
+        },
+    stateReason: session.stateReason ?? "",
+    stateMessage: session.stateMessage ?? "",
+  };
+}
+
+function prepareWorkspaceResponseToProto(
+  response: PreparePluginRuntimeWorkspaceResponse,
+) {
+  return {
+    workspace: response.workspace === undefined
+      ? undefined
+      : {
+          root: response.workspace.root ?? "",
+          cwd: response.workspace.cwd ?? "",
+        },
+  };
+}
+
+function hostedPluginToProto(plugin: HostedPlugin) {
+  return {
+    id: plugin.id ?? "",
+    sessionId: plugin.sessionId ?? "",
+    pluginName: plugin.pluginName ?? "",
+    dialTarget: plugin.dialTarget ?? "",
+  };
+}
+
 async function invokePluginRuntimeProvider<T>(
   label: string,
   fn: () => MaybePromise<T>,
@@ -187,6 +472,9 @@ async function invokePluginRuntimeProvider<T>(
   try {
     return await fn();
   } catch (error) {
+    if (error instanceof ConnectError) {
+      throw error;
+    }
     throw new ConnectError(
       `plugin runtime provider ${label}: ${errorMessage(error)}`,
       Code.Unknown,

package/src/protocol/v1.ts

@@ -0,0 +1,19 @@
+/**
+ * Low-level Gestalt v1 protocol bindings for advanced integration tests.
+ *
+ * Provider authoring code should prefer the root SDK exports. This module
+ * deliberately re-exports generated schemas, services, and message types for
+ * test harnesses and protocol fixtures.
+ */
+export * from "../internal/gen/v1/agent_pb.ts";
+export * from "../internal/gen/v1/authentication_pb.ts";
+export * from "../internal/gen/v1/authorization_pb.ts";
+export * from "../internal/gen/v1/cache_pb.ts";
+export * from "../internal/gen/v1/datastore_pb.ts";
+export * from "../internal/gen/v1/external_credential_pb.ts";
+export * from "../internal/gen/v1/plugin_pb.ts";
+export * from "../internal/gen/v1/pluginruntime_pb.ts";
+export * from "../internal/gen/v1/runtime_pb.ts";
+export * from "../internal/gen/v1/s3_pb.ts";
+export * from "../internal/gen/v1/secrets_pb.ts";
+export * from "../internal/gen/v1/workflow_pb.ts";