@forwardimpact/librpc 0.1.106 → 0.1.107

package/src/generated/services/pathway/service.js

@@ -0,0 +1,154 @@
+/* eslint no-unused-vars: "off" */
+
+import { pathway, tool } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Pathway service implementation
+ */
+export class PathwayBase {
+  config;
+
+  /**
+   * Creates a new Pathway service instance
+   * @param {object} config - Service configuration
+   */
+  constructor(config) {
+    if (!config) throw new Error("config is required");
+    this.config = config;
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.ListJobsRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async ListJobs(req) {
+    throw new Error("ListJobs not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.DescribeJobRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async DescribeJob(req) {
+    throw new Error("DescribeJob not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.ListAgentProfilesRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async ListAgentProfiles(req) {
+    throw new Error("ListAgentProfiles not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.DescribeAgentProfileRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async DescribeAgentProfile(req) {
+    throw new Error("DescribeAgentProfile not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.DescribeProgressionRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async DescribeProgression(req) {
+    throw new Error("DescribeProgression not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.ListJobSoftwareRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async ListJobSoftware(req) {
+    throw new Error("ListJobSoftware not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.GetMarkersForProfileRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetMarkersForProfile(req) {
+    throw new Error("GetMarkersForProfile not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      ListJobs: async (call) => {
+        // Validate and convert request
+        const error = pathway.ListJobsRequest.verify(call.request);
+        if (error) throw new Error(`ListJobs: ${error}`);
+        const req = pathway.ListJobsRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ListJobs(req);
+      },
+      DescribeJob: async (call) => {
+        // Validate and convert request
+        const error = pathway.DescribeJobRequest.verify(call.request);
+        if (error) throw new Error(`DescribeJob: ${error}`);
+        const req = pathway.DescribeJobRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.DescribeJob(req);
+      },
+      ListAgentProfiles: async (call) => {
+        // Validate and convert request
+        const error = pathway.ListAgentProfilesRequest.verify(call.request);
+        if (error) throw new Error(`ListAgentProfiles: ${error}`);
+        const req = pathway.ListAgentProfilesRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ListAgentProfiles(req);
+      },
+      DescribeAgentProfile: async (call) => {
+        // Validate and convert request
+        const error = pathway.DescribeAgentProfileRequest.verify(call.request);
+        if (error) throw new Error(`DescribeAgentProfile: ${error}`);
+        const req = pathway.DescribeAgentProfileRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.DescribeAgentProfile(req);
+      },
+      DescribeProgression: async (call) => {
+        // Validate and convert request
+        const error = pathway.DescribeProgressionRequest.verify(call.request);
+        if (error) throw new Error(`DescribeProgression: ${error}`);
+        const req = pathway.DescribeProgressionRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.DescribeProgression(req);
+      },
+      ListJobSoftware: async (call) => {
+        // Validate and convert request
+        const error = pathway.ListJobSoftwareRequest.verify(call.request);
+        if (error) throw new Error(`ListJobSoftware: ${error}`);
+        const req = pathway.ListJobSoftwareRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ListJobSoftware(req);
+      },
+      GetMarkersForProfile: async (call) => {
+        // Validate and convert request
+        const error = pathway.GetMarkersForProfileRequest.verify(call.request);
+        if (error) throw new Error(`GetMarkersForProfile: ${error}`);
+        const req = pathway.GetMarkersForProfileRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetMarkersForProfile(req);
+      },
+    };
+  }
+}

package/src/generated/services/tenancy/client.js

@@ -0,0 +1,164 @@
+/* eslint no-unused-vars: "off" */
+
+import { Client } from "@forwardimpact/librpc/client.js";
+import { createAuth, createGrpc } from "@forwardimpact/librpc/base.js";
+import { createObserver } from "@forwardimpact/libtelemetry";
+import { tenancy } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Tenancy gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class TenancyClient extends Client {
+  /**
+   * Creates a new Tenancy client instance
+   * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
+   * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
+   * @param {Function} [authFn] - Optional authentication function
+   */
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
+  }
+
+  /**
+   * Call the `ResolveByChannelKey` RPC with request/response type conversion.
+   * @param { tenancy.ChannelTenantKey } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async ResolveByChannelKey(req) {
+    // Type validation
+    if (!(req instanceof tenancy.ChannelTenantKey)) {
+      throw new TypeError(
+        `ResolveByChannelKey: Expected parameter to be instanceof tenancy.ChannelTenantKey`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.ChannelTenantKey.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ResolveByChannelKey", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `ResolveByRepo` RPC with request/response type conversion.
+   * @param { tenancy.RepoKey } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async ResolveByRepo(req) {
+    // Type validation
+    if (!(req instanceof tenancy.RepoKey)) {
+      throw new TypeError(
+        `ResolveByRepo: Expected parameter to be instanceof tenancy.RepoKey`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.RepoKey.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ResolveByRepo", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `ResolveByTenantId` RPC with request/response type conversion.
+   * @param { tenancy.TenantIdKey } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async ResolveByTenantId(req) {
+    // Type validation
+    if (!(req instanceof tenancy.TenantIdKey)) {
+      throw new TypeError(
+        `ResolveByTenantId: Expected parameter to be instanceof tenancy.TenantIdKey`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.TenantIdKey.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ResolveByTenantId", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `UpsertByChannelKey` RPC with request/response type conversion.
+   * @param { tenancy.UpsertChannelKeyRequest } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async UpsertByChannelKey(req) {
+    // Type validation
+    if (!(req instanceof tenancy.UpsertChannelKeyRequest)) {
+      throw new TypeError(
+        `UpsertByChannelKey: Expected parameter to be instanceof tenancy.UpsertChannelKeyRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.UpsertChannelKeyRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("UpsertByChannelKey", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `UpsertByPair` RPC with request/response type conversion.
+   * @param { tenancy.UpsertPairRequest } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async UpsertByPair(req) {
+    // Type validation
+    if (!(req instanceof tenancy.UpsertPairRequest)) {
+      throw new TypeError(
+        `UpsertByPair: Expected parameter to be instanceof tenancy.UpsertPairRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.UpsertPairRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("UpsertByPair", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `SetState` RPC with request/response type conversion.
+   * @param { tenancy.SetStateRequest } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async SetState(req) {
+    // Type validation
+    if (!(req instanceof tenancy.SetStateRequest)) {
+      throw new TypeError(
+        `SetState: Expected parameter to be instanceof tenancy.SetStateRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.SetStateRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("SetState", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `SetRepo` RPC with request/response type conversion.
+   * @param { tenancy.SetRepoRequest } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async SetRepo(req) {
+    // Type validation
+    if (!(req instanceof tenancy.SetRepoRequest)) {
+      throw new TypeError(
+        `SetRepo: Expected parameter to be instanceof tenancy.SetRepoRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.SetRepoRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("SetRepo", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+}

package/src/generated/services/tenancy/service.js

@@ -0,0 +1,154 @@
+/* eslint no-unused-vars: "off" */
+
+import { tenancy } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Tenancy service implementation
+ */
+export class TenancyBase {
+  config;
+
+  /**
+   * Creates a new Tenancy service instance
+   * @param {object} config - Service configuration
+   */
+  constructor(config) {
+    if (!config) throw new Error("config is required");
+    this.config = config;
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.ChannelTenantKey } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async ResolveByChannelKey(req) {
+    throw new Error("ResolveByChannelKey not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.RepoKey } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async ResolveByRepo(req) {
+    throw new Error("ResolveByRepo not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.TenantIdKey } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async ResolveByTenantId(req) {
+    throw new Error("ResolveByTenantId not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.UpsertChannelKeyRequest } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async UpsertByChannelKey(req) {
+    throw new Error("UpsertByChannelKey not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.UpsertPairRequest } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async UpsertByPair(req) {
+    throw new Error("UpsertByPair not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.SetStateRequest } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async SetState(req) {
+    throw new Error("SetState not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { tenancy.SetRepoRequest } req - Request parameters
+   * @returns { Promise<tenancy.Tenant> } Response object
+   */
+  async SetRepo(req) {
+    throw new Error("SetRepo not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      ResolveByChannelKey: async (call) => {
+        // Validate and convert request
+        const error = tenancy.ChannelTenantKey.verify(call.request);
+        if (error) throw new Error(`ResolveByChannelKey: ${error}`);
+        const req = tenancy.ChannelTenantKey.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ResolveByChannelKey(req);
+      },
+      ResolveByRepo: async (call) => {
+        // Validate and convert request
+        const error = tenancy.RepoKey.verify(call.request);
+        if (error) throw new Error(`ResolveByRepo: ${error}`);
+        const req = tenancy.RepoKey.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ResolveByRepo(req);
+      },
+      ResolveByTenantId: async (call) => {
+        // Validate and convert request
+        const error = tenancy.TenantIdKey.verify(call.request);
+        if (error) throw new Error(`ResolveByTenantId: ${error}`);
+        const req = tenancy.TenantIdKey.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ResolveByTenantId(req);
+      },
+      UpsertByChannelKey: async (call) => {
+        // Validate and convert request
+        const error = tenancy.UpsertChannelKeyRequest.verify(call.request);
+        if (error) throw new Error(`UpsertByChannelKey: ${error}`);
+        const req = tenancy.UpsertChannelKeyRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.UpsertByChannelKey(req);
+      },
+      UpsertByPair: async (call) => {
+        // Validate and convert request
+        const error = tenancy.UpsertPairRequest.verify(call.request);
+        if (error) throw new Error(`UpsertByPair: ${error}`);
+        const req = tenancy.UpsertPairRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.UpsertByPair(req);
+      },
+      SetState: async (call) => {
+        // Validate and convert request
+        const error = tenancy.SetStateRequest.verify(call.request);
+        if (error) throw new Error(`SetState: ${error}`);
+        const req = tenancy.SetStateRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.SetState(req);
+      },
+      SetRepo: async (call) => {
+        // Validate and convert request
+        const error = tenancy.SetRepoRequest.verify(call.request);
+        if (error) throw new Error(`SetRepo: ${error}`);
+        const req = tenancy.SetRepoRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.SetRepo(req);
+      },
+    };
+  }
+}

package/src/generated/services/trace/client.js

@@ -0,0 +1,64 @@
+/* eslint no-unused-vars: "off" */
+
+import { Client } from "@forwardimpact/librpc/client.js";
+import { createAuth, createGrpc } from "@forwardimpact/librpc/base.js";
+import { createObserver } from "@forwardimpact/libtelemetry";
+import { trace } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Trace gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class TraceClient extends Client {
+  /**
+   * Creates a new Trace client instance
+   * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
+   * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
+   * @param {Function} [authFn] - Optional authentication function
+   */
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
+  }
+
+  /**
+   * Call the `RecordSpan` RPC with request/response type conversion.
+   * @param { trace.Span } req - Typed request message.
+   * @returns { Promise<trace.RecordResponse> } Typed response message.
+   */
+  async RecordSpan(req) {
+    // Type validation
+    if (!(req instanceof trace.Span)) {
+      throw new TypeError(
+        `RecordSpan: Expected parameter to be instanceof trace.Span`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = trace.Span.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("RecordSpan", request, (res) => trace.RecordResponse.fromObject(res));
+  }
+
+  /**
+   * Call the `QuerySpans` RPC with request/response type conversion.
+   * @param { trace.QueryRequest } req - Typed request message.
+   * @returns { Promise<trace.QueryResponse> } Typed response message.
+   */
+  async QuerySpans(req) {
+    // Type validation
+    if (!(req instanceof trace.QueryRequest)) {
+      throw new TypeError(
+        `QuerySpans: Expected parameter to be instanceof trace.QueryRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = trace.QueryRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("QuerySpans", request, (res) => trace.QueryResponse.fromObject(res));
+  }
+}

package/src/generated/services/trace/service.js

@@ -0,0 +1,64 @@
+/* eslint no-unused-vars: "off" */
+
+import { trace } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Trace service implementation
+ */
+export class TraceBase {
+  config;
+
+  /**
+   * Creates a new Trace service instance
+   * @param {object} config - Service configuration
+   */
+  constructor(config) {
+    if (!config) throw new Error("config is required");
+    this.config = config;
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { trace.Span } req - Request parameters
+   * @returns { Promise<trace.RecordResponse> } Response object
+   */
+  async RecordSpan(req) {
+    throw new Error("RecordSpan not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { trace.QueryRequest } req - Request parameters
+   * @returns { Promise<trace.QueryResponse> } Response object
+   */
+  async QuerySpans(req) {
+    throw new Error("QuerySpans not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      RecordSpan: async (call) => {
+        // Validate and convert request
+        const error = trace.Span.verify(call.request);
+        if (error) throw new Error(`RecordSpan: ${error}`);
+        const req = trace.Span.fromObject(call.request);
+        
+        // Call implementation
+        return await this.RecordSpan(req);
+      },
+      QuerySpans: async (call) => {
+        // Validate and convert request
+        const error = trace.QueryRequest.verify(call.request);
+        if (error) throw new Error(`QuerySpans: ${error}`);
+        const req = trace.QueryRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.QuerySpans(req);
+      },
+    };
+  }
+}

package/src/generated/services/vector/client.js

@@ -0,0 +1,44 @@
+/* eslint no-unused-vars: "off" */
+
+import { Client } from "@forwardimpact/librpc/client.js";
+import { createAuth, createGrpc } from "@forwardimpact/librpc/base.js";
+import { createObserver } from "@forwardimpact/libtelemetry";
+import { vector, tool } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Vector gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class VectorClient extends Client {
+  /**
+   * Creates a new Vector client instance
+   * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
+   * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
+   * @param {Function} [authFn] - Optional authentication function
+   */
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
+  }
+
+  /**
+   * Call the `SearchContent` RPC with request/response type conversion.
+   * @param { vector.TextQuery } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async SearchContent(req) {
+    // Type validation
+    if (!(req instanceof vector.TextQuery)) {
+      throw new TypeError(
+        `SearchContent: Expected parameter to be instanceof vector.TextQuery`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = vector.TextQuery.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("SearchContent", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+}

package/src/generated/services/vector/service.js

@@ -0,0 +1,46 @@
+/* eslint no-unused-vars: "off" */
+
+import { vector, tool } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Vector service implementation
+ */
+export class VectorBase {
+  config;
+
+  /**
+   * Creates a new Vector service instance
+   * @param {object} config - Service configuration
+   */
+  constructor(config) {
+    if (!config) throw new Error("config is required");
+    this.config = config;
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { vector.TextQuery } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async SearchContent(req) {
+    throw new Error("SearchContent not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      SearchContent: async (call) => {
+        // Validate and convert request
+        const error = vector.TextQuery.verify(call.request);
+        if (error) throw new Error(`SearchContent: ${error}`);
+        const req = vector.TextQuery.fromObject(call.request);
+        
+        // Call implementation
+        return await this.SearchContent(req);
+      },
+    };
+  }
+}