@forwardimpact/librpc 0.1.106 → 0.1.108

package/src/generated/definitions/pathway.js

@@ -0,0 +1,155 @@
+import { pathway, tool } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Pathway
+ * Generated at build time
+ */
+export const PathwayServiceDefinition = {
+  ListJobs: {
+    path: '/pathway.Pathway/ListJobs',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(pathway.ListJobsRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return pathway.ListJobsRequest.toObject(
+        pathway.ListJobsRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  DescribeJob: {
+    path: '/pathway.Pathway/DescribeJob',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(pathway.DescribeJobRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return pathway.DescribeJobRequest.toObject(
+        pathway.DescribeJobRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  ListAgentProfiles: {
+    path: '/pathway.Pathway/ListAgentProfiles',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(pathway.ListAgentProfilesRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return pathway.ListAgentProfilesRequest.toObject(
+        pathway.ListAgentProfilesRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  DescribeAgentProfile: {
+    path: '/pathway.Pathway/DescribeAgentProfile',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(pathway.DescribeAgentProfileRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return pathway.DescribeAgentProfileRequest.toObject(
+        pathway.DescribeAgentProfileRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  DescribeProgression: {
+    path: '/pathway.Pathway/DescribeProgression',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(pathway.DescribeProgressionRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return pathway.DescribeProgressionRequest.toObject(
+        pathway.DescribeProgressionRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  ListJobSoftware: {
+    path: '/pathway.Pathway/ListJobSoftware',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(pathway.ListJobSoftwareRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return pathway.ListJobSoftwareRequest.toObject(
+        pathway.ListJobSoftwareRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+  GetMarkersForProfile: {
+    path: '/pathway.Pathway/GetMarkersForProfile',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(pathway.GetMarkersForProfileRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return pathway.GetMarkersForProfileRequest.toObject(
+        pathway.GetMarkersForProfileRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/tenancy.js

@@ -0,0 +1,155 @@
+import { tenancy } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Tenancy
+ * Generated at build time
+ */
+export const TenancyServiceDefinition = {
+  ResolveByChannelKey: {
+    path: '/tenancy.Tenancy/ResolveByChannelKey',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(tenancy.ChannelTenantKey.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return tenancy.ChannelTenantKey.toObject(
+        tenancy.ChannelTenantKey.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tenancy.Tenant.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tenancy.Tenant.toObject(
+        tenancy.Tenant.decode(value)
+      );
+    },
+  },
+  ResolveByRepo: {
+    path: '/tenancy.Tenancy/ResolveByRepo',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(tenancy.RepoKey.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return tenancy.RepoKey.toObject(
+        tenancy.RepoKey.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tenancy.Tenant.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tenancy.Tenant.toObject(
+        tenancy.Tenant.decode(value)
+      );
+    },
+  },
+  ResolveByTenantId: {
+    path: '/tenancy.Tenancy/ResolveByTenantId',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(tenancy.TenantIdKey.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return tenancy.TenantIdKey.toObject(
+        tenancy.TenantIdKey.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tenancy.Tenant.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tenancy.Tenant.toObject(
+        tenancy.Tenant.decode(value)
+      );
+    },
+  },
+  UpsertByChannelKey: {
+    path: '/tenancy.Tenancy/UpsertByChannelKey',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(tenancy.UpsertChannelKeyRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return tenancy.UpsertChannelKeyRequest.toObject(
+        tenancy.UpsertChannelKeyRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tenancy.Tenant.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tenancy.Tenant.toObject(
+        tenancy.Tenant.decode(value)
+      );
+    },
+  },
+  UpsertByPair: {
+    path: '/tenancy.Tenancy/UpsertByPair',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(tenancy.UpsertPairRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return tenancy.UpsertPairRequest.toObject(
+        tenancy.UpsertPairRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tenancy.Tenant.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tenancy.Tenant.toObject(
+        tenancy.Tenant.decode(value)
+      );
+    },
+  },
+  SetState: {
+    path: '/tenancy.Tenancy/SetState',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(tenancy.SetStateRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return tenancy.SetStateRequest.toObject(
+        tenancy.SetStateRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tenancy.Tenant.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tenancy.Tenant.toObject(
+        tenancy.Tenant.decode(value)
+      );
+    },
+  },
+  SetRepo: {
+    path: '/tenancy.Tenancy/SetRepo',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(tenancy.SetRepoRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return tenancy.SetRepoRequest.toObject(
+        tenancy.SetRepoRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tenancy.Tenant.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tenancy.Tenant.toObject(
+        tenancy.Tenant.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/trace.js

@@ -0,0 +1,50 @@
+import { trace } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Trace
+ * Generated at build time
+ */
+export const TraceServiceDefinition = {
+  RecordSpan: {
+    path: '/trace.Trace/RecordSpan',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(trace.Span.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return trace.Span.toObject(
+        trace.Span.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(trace.RecordResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return trace.RecordResponse.toObject(
+        trace.RecordResponse.decode(value)
+      );
+    },
+  },
+  QuerySpans: {
+    path: '/trace.Trace/QuerySpans',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(trace.QueryRequest.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return trace.QueryRequest.toObject(
+        trace.QueryRequest.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(trace.QueryResponse.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return trace.QueryResponse.toObject(
+        trace.QueryResponse.decode(value)
+      );
+    },
+  },
+};

package/src/generated/definitions/vector.js

@@ -0,0 +1,29 @@
+import { vector, tool } from "@forwardimpact/libtype";
+
+/**
+ * Pre-compiled gRPC service definition for Vector
+ * Generated at build time
+ */
+export const VectorServiceDefinition = {
+  SearchContent: {
+    path: '/vector.Vector/SearchContent',
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => {
+      return Buffer.from(vector.TextQuery.encode(value).finish());
+    },
+    requestDeserialize: (value) => {
+      return vector.TextQuery.toObject(
+        vector.TextQuery.decode(value)
+      );
+    },
+    responseSerialize: (value) => {
+      return Buffer.from(tool.ToolCallResult.encode(value).finish());
+    },
+    responseDeserialize: (value) => {
+      return tool.ToolCallResult.toObject(
+        tool.ToolCallResult.decode(value)
+      );
+    },
+  },
+};

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

@@ -0,0 +1,264 @@
+/* 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 { bridge, common } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Bridge gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class BridgeClient extends Client {
+  /**
+   * Creates a new Bridge 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 `LoadDiscussion` RPC with request/response type conversion.
+   * @param { bridge.LoadDiscussionRequest } req - Typed request message.
+   * @returns { Promise<bridge.Discussion> } Typed response message.
+   */
+  async LoadDiscussion(req) {
+    // Type validation
+    if (!(req instanceof bridge.LoadDiscussionRequest)) {
+      throw new TypeError(
+        `LoadDiscussion: Expected parameter to be instanceof bridge.LoadDiscussionRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.LoadDiscussionRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("LoadDiscussion", request, (res) => bridge.Discussion.fromObject(res));
+  }
+
+  /**
+   * Call the `LoadDiscussionByCorrelation` RPC with request/response type conversion.
+   * @param { bridge.LoadByCorrelationRequest } req - Typed request message.
+   * @returns { Promise<bridge.Discussion> } Typed response message.
+   */
+  async LoadDiscussionByCorrelation(req) {
+    // Type validation
+    if (!(req instanceof bridge.LoadByCorrelationRequest)) {
+      throw new TypeError(
+        `LoadDiscussionByCorrelation: Expected parameter to be instanceof bridge.LoadByCorrelationRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.LoadByCorrelationRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("LoadDiscussionByCorrelation", request, (res) => bridge.Discussion.fromObject(res));
+  }
+
+  /**
+   * Call the `ListOpenRecesses` RPC with request/response type conversion.
+   * @param { bridge.ListOpenRecessesRequest } req - Typed request message.
+   * @returns { Promise<bridge.OpenRecessList> } Typed response message.
+   */
+  async ListOpenRecesses(req) {
+    // Type validation
+    if (!(req instanceof bridge.ListOpenRecessesRequest)) {
+      throw new TypeError(
+        `ListOpenRecesses: Expected parameter to be instanceof bridge.ListOpenRecessesRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.ListOpenRecessesRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ListOpenRecesses", request, (res) => bridge.OpenRecessList.fromObject(res));
+  }
+
+  /**
+   * Call the `SaveDiscussion` RPC with request/response type conversion.
+   * @param { bridge.Discussion } req - Typed request message.
+   * @returns { Promise<common.Empty> } Typed response message.
+   */
+  async SaveDiscussion(req) {
+    // Type validation
+    if (!(req instanceof bridge.Discussion)) {
+      throw new TypeError(
+        `SaveDiscussion: Expected parameter to be instanceof bridge.Discussion`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.Discussion.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("SaveDiscussion", request, (res) => common.Empty.fromObject(res));
+  }
+
+  /**
+   * Call the `HasOrigin` RPC with request/response type conversion.
+   * @param { bridge.OriginKey } req - Typed request message.
+   * @returns { Promise<bridge.HasOriginResponse> } Typed response message.
+   */
+  async HasOrigin(req) {
+    // Type validation
+    if (!(req instanceof bridge.OriginKey)) {
+      throw new TypeError(
+        `HasOrigin: Expected parameter to be instanceof bridge.OriginKey`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.OriginKey.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("HasOrigin", request, (res) => bridge.HasOriginResponse.fromObject(res));
+  }
+
+  /**
+   * Call the `RecordOrigin` RPC with request/response type conversion.
+   * @param { bridge.Origin } req - Typed request message.
+   * @returns { Promise<common.Empty> } Typed response message.
+   */
+  async RecordOrigin(req) {
+    // Type validation
+    if (!(req instanceof bridge.Origin)) {
+      throw new TypeError(
+        `RecordOrigin: Expected parameter to be instanceof bridge.Origin`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.Origin.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("RecordOrigin", request, (res) => common.Empty.fromObject(res));
+  }
+
+  /**
+   * Call the `Sweep` RPC with request/response type conversion.
+   * @param { bridge.SweepRequest } req - Typed request message.
+   * @returns { Promise<bridge.SweepResponse> } Typed response message.
+   */
+  async Sweep(req) {
+    // Type validation
+    if (!(req instanceof bridge.SweepRequest)) {
+      throw new TypeError(
+        `Sweep: Expected parameter to be instanceof bridge.SweepRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.SweepRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("Sweep", request, (res) => bridge.SweepResponse.fromObject(res));
+  }
+
+  /**
+   * Call the `PutPendingDispatch` RPC with request/response type conversion.
+   * @param { bridge.PutPendingDispatchRequest } req - Typed request message.
+   * @returns { Promise<common.Empty> } Typed response message.
+   */
+  async PutPendingDispatch(req) {
+    // Type validation
+    if (!(req instanceof bridge.PutPendingDispatchRequest)) {
+      throw new TypeError(
+        `PutPendingDispatch: Expected parameter to be instanceof bridge.PutPendingDispatchRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.PutPendingDispatchRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("PutPendingDispatch", request, (res) => common.Empty.fromObject(res));
+  }
+
+  /**
+   * Call the `ResolvePendingDispatch` RPC with request/response type conversion.
+   * @param { bridge.ResolvePendingDispatchRequest } req - Typed request message.
+   * @returns { Promise<bridge.PendingDispatch> } Typed response message.
+   */
+  async ResolvePendingDispatch(req) {
+    // Type validation
+    if (!(req instanceof bridge.ResolvePendingDispatchRequest)) {
+      throw new TypeError(
+        `ResolvePendingDispatch: Expected parameter to be instanceof bridge.ResolvePendingDispatchRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.ResolvePendingDispatchRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ResolvePendingDispatch", request, (res) => bridge.PendingDispatch.fromObject(res));
+  }
+
+  /**
+   * Call the `VerifyPendingDispatch` RPC with request/response type conversion.
+   * @param { bridge.VerifyPendingDispatchRequest } req - Typed request message.
+   * @returns { Promise<common.Empty> } Typed response message.
+   */
+  async VerifyPendingDispatch(req) {
+    // Type validation
+    if (!(req instanceof bridge.VerifyPendingDispatchRequest)) {
+      throw new TypeError(
+        `VerifyPendingDispatch: Expected parameter to be instanceof bridge.VerifyPendingDispatchRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.VerifyPendingDispatchRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("VerifyPendingDispatch", request, (res) => common.Empty.fromObject(res));
+  }
+
+  /**
+   * Call the `EnqueueInbox` RPC with request/response type conversion.
+   * @param { bridge.EnqueueInboxRequest } req - Typed request message.
+   * @returns { Promise<common.Empty> } Typed response message.
+   */
+  async EnqueueInbox(req) {
+    // Type validation
+    if (!(req instanceof bridge.EnqueueInboxRequest)) {
+      throw new TypeError(
+        `EnqueueInbox: Expected parameter to be instanceof bridge.EnqueueInboxRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.EnqueueInboxRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("EnqueueInbox", request, (res) => common.Empty.fromObject(res));
+  }
+
+  /**
+   * Call the `DrainInbox` RPC with request/response type conversion.
+   * @param { bridge.DrainInboxRequest } req - Typed request message.
+   * @returns { Promise<bridge.InboxMessages> } Typed response message.
+   */
+  async DrainInbox(req) {
+    // Type validation
+    if (!(req instanceof bridge.DrainInboxRequest)) {
+      throw new TypeError(
+        `DrainInbox: Expected parameter to be instanceof bridge.DrainInboxRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = bridge.DrainInboxRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("DrainInbox", request, (res) => bridge.InboxMessages.fromObject(res));
+  }
+}