@otonoma/paranet-client 2.11.0-rc.18

package/src/schema/paranet.ts

@@ -0,0 +1,257 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+
+/**
+ * `PncpPacket` wraps all core PNCP message variants.
+ */
+export type PncpPacket =
+  | {
+      type: "request";
+      body: PncpRequest;
+      [k: string]: any;
+    }
+  | {
+      type: "message";
+      body: PncpMessage;
+      [k: string]: any;
+    };
+export type ConversationId = string;
+export type EntityId = string;
+/**
+ * Determines the match strategy used by the paranet.
+ */
+export type SkillMatchStrategy = "BEST" | "FIRST" | "STRICT";
+export type EntityReq = string;
+export type PncpMessageBody =
+  | {
+      type: "response";
+      body: PncpDataMessage;
+      [k: string]: any;
+    }
+  | {
+      type: "status";
+      body: PncpDataMessage;
+      [k: string]: any;
+    }
+  | {
+      type: "cancel";
+      body: PncpDataMessage;
+      [k: string]: any;
+    }
+  | {
+      type: "question";
+      body: PncpQuestionMessage;
+      [k: string]: any;
+    }
+  | {
+      type: "answer";
+      body: PncpAnswerMessage;
+      [k: string]: any;
+    }
+  | {
+      type: "error";
+      body: PncpDataMessage;
+      [k: string]: any;
+    };
+export type Id = string;
+/**
+ * Represents all message types that can be sent from the paranet to an actor.
+ */
+export type PncpCallback =
+  | {
+      type: "skill";
+      body: PncpRequestCallback;
+      [k: string]: any;
+    }
+  | {
+      type: "message";
+      body: PncpMessageCallback;
+      [k: string]: any;
+    };
+/**
+ * Used to track the current state of the conversation.
+ */
+export type ConversationState = "IN_PROGRESS" | "COMPLETED" | "ERRORED" | "CANCELED";
+
+/**
+ * A common root type. This type is itself not used, but it will allow schema resolution to properly find all of the types in one place.
+ */
+export interface ParanetTypes {
+  pncp: PncpPacket;
+  callback: PncpCallback;
+  [k: string]: any;
+}
+/**
+ * Represents a "skill message" request. All conversations are initiated via a skill request.
+ */
+export interface PncpRequest {
+  /**
+   * The core body to the request.
+   */
+  body: PncpSkillMessage;
+  /**
+   * Information provided on callback to the actor when a response is received.
+   */
+  callback?: {
+    [k: string]: any;
+  };
+  /**
+   * The parent conversation ID, if one exists.
+   */
+  parentId?: ConversationId | null;
+  /**
+   * Identifying information about who is making the call.
+   */
+  author: EntityId;
+  /**
+   * Specifies the match strategy.
+   */
+  matchStrategy?: SkillMatchStrategy & string;
+  /**
+   * Version request spec for the (subject, action) pair.
+   */
+  versionReq?: string | null;
+  /**
+   * When specified, the particular actor is called if the skill matches.
+   */
+  targetActorId?: EntityReq | null;
+  /**
+   * An arbitrary key that is allowed to be set and provided on further messages from mediums.
+   */
+  key?: {
+    [k: string]: any;
+  };
+  /**
+   * ID of the medium that made the request.
+   */
+  mediumInfo?: PncpRequestMediumInfo | null;
+  [k: string]: any;
+}
+export interface PncpSkillMessage {
+  /**
+   * Subject of the request.
+   */
+  subject: string;
+  /**
+   * Action of the request.
+   */
+  action: string;
+  body: any;
+  [k: string]: any;
+}
+export interface PncpRequestMediumInfo {
+  id: EntityId;
+  userInfo: any;
+  [k: string]: any;
+}
+/**
+ * PNCP Message. Messages are a variety of types of data sent within a conversation.
+ */
+export interface PncpMessage {
+  id: ConversationId;
+  message: PncpMessageBody;
+  [k: string]: any;
+}
+/**
+ * A simple data packet.
+ */
+export interface PncpDataMessage {
+  data: any;
+  [k: string]: any;
+}
+/**
+ * A PNCP packet for question messages.
+ */
+export interface PncpQuestionMessage {
+  /**
+   * The id of the question.
+   */
+  id: string;
+  data: any;
+  callback?: {
+    [k: string]: any;
+  };
+  [k: string]: any;
+}
+/**
+ * A PNCP packet for answer messages.
+ */
+export interface PncpAnswerMessage {
+  /**
+   * The ID of the question message being replied to.
+   */
+  replyTo: Id;
+  data: any;
+  [k: string]: any;
+}
+/**
+ * Skill request sent to an actor from the paranet.
+ */
+export interface PncpRequestCallback {
+  id: ConversationId;
+  messageId: Id;
+  body: PncpSkillMessage;
+  /**
+   * The parent conversation ID, if one exists.
+   */
+  parentId?: ConversationId | null;
+  timeCreated: string;
+  authorId: EntityId;
+  /**
+   * The actor ID of the receiving actor. This is optional as some skill matches have no targets in the case of a broadcast skill message type.
+   */
+  targetActorId?: EntityId | null;
+  /**
+   * Additional parameters included with the request. These come from actor/skill templates.
+   */
+  parameters?: ParameterData;
+  [k: string]: any;
+}
+export interface ParameterData {
+  /**
+   * Default to empty values.
+   */
+  provider?: {
+    [k: string]: any;
+  };
+  skill?: {
+    [k: string]: any;
+  };
+  medium?: any;
+  [k: string]: any;
+}
+/**
+ * In the flow of paranet messages, this is logically a "response" message. The `data` field comes from the targeted actor whereas others are contextual from the paranet.
+ */
+export interface PncpMessageCallback {
+  /**
+   * The identifier for the target actor (initiator of the original conversation, typically).
+   */
+  id: ConversationId;
+  messageId: Id;
+  timeCreated: string;
+  /**
+   * Key provided from response to initial call.
+   */
+  key?: {
+    [k: string]: any;
+  };
+  message: PncpMessage;
+  params?: any;
+  /**
+   * Callback information if any was provided in the conversation.
+   */
+  callback?: {
+    [k: string]: any;
+  };
+  medium?: any;
+  /**
+   * Any change to the conversation state will be present here.
+   */
+  conversationState: ConversationState;
+  [k: string]: any;
+}

package/src/util.ts

@@ -0,0 +1,129 @@
+// Utility wrappers for protobuf.
+
+import { JsonValue, JsonObject, typeofJsonValue, isJsonObject, JsonReadOptions } from "@protobuf-ts/runtime";
+import { jsonReadOptions } from "@protobuf-ts/runtime";
+import { Value, NullValue, ListValue, Struct } from "./proto/otonoma/common/value";
+
+
+// Hijack the fromJson function, provide our own implementation that is the sensible choice.
+Value.fromJson = (json: JsonValue, options) => fromJsonValueInner(json, jsonReadOptions(options));
+export function fromJsonValue(json: JsonValue): Value {
+  return fromJsonValueInner(json, { ignoreUnknownFields: false });
+}
+
+// Converts a json value to a otonoma common Value.
+function fromJsonValueInner(json: JsonValue, options: JsonReadOptions, target?: Value): Value {
+  if (!target)
+    target = Value.create();
+  switch (typeof json) {
+    case "undefined":
+      // NOTE: We coalesce undefined to null, which is fine for our purposes.
+      target.kind = { oneofKind: "nullValue", nullValue: NullValue.NULL_VALUE };
+      break;
+    case "bigint":
+      if (json < 0) {
+        target.kind = { oneofKind: "negIntValue", negIntValue: json };
+      } else {
+        target.kind = { oneofKind: "posIntValue", posIntValue: json };
+      }
+      break;
+    case "number":
+      // Check the number further.
+      if (Number.isNaN(json) || !Number.isFinite(json)) {
+        // TODO: We could special case NaN and Inf.
+        throw "PNCP cannot handle NaN or infinite values yet.";
+      }
+      if (Number.isInteger(json)) {
+        if (json < 0) {
+          target.kind = { oneofKind: "negIntValue", negIntValue: BigInt(json) };
+        } else {
+          target.kind = { oneofKind: "posIntValue", posIntValue: BigInt(json) };
+        }
+      } else {
+        target.kind = { oneofKind: "numberValue", numberValue: json };
+      }
+      break;
+    case "string":
+      target.kind = { oneofKind: "stringValue", stringValue: json };
+      break;
+    case "boolean":
+      target.kind = { oneofKind: "boolValue", boolValue: json };
+      break;
+    case "object":
+      if (json === null) {
+        target.kind = { oneofKind: "nullValue", nullValue: NullValue.NULL_VALUE };
+      }
+      else if (globalThis.Array.isArray(json)) {
+        target.kind = { oneofKind: "listValue", listValue: ListValue.fromJson(json) };
+      }
+      else {
+        target.kind = { oneofKind: "structValue", structValue: Struct.fromJson(json) };
+      }
+      break;
+    default: throw new globalThis.Error("Unable to parse " + Value.typeName + " from JSON " + typeofJsonValue(json));
+  }
+  return target;
+}
+
+ListValue.fromJson = (json: Array<JsonValue>) => {
+  if (!globalThis.Array.isArray(json))
+    throw new globalThis.Error("Unable to parse " + ListValue.typeName + " from JSON " + typeofJsonValue(json));
+  let target = ListValue.create();
+  let values = json.map(v => Value.fromJson(v));
+  target.values.push(...values);
+  return target;
+};
+
+Struct.fromJson = (json: JsonObject) => {
+
+  if (!isJsonObject(json))
+    throw new globalThis.Error("Unable to parse message " + Struct.typeName + " from JSON " + typeofJsonValue(json) + ".");
+  let target = Struct.create();
+  for (let [k, v] of globalThis.Object.entries(json)) {
+    target.fields[k] = Value.fromJson(v);
+  }
+  return target;
+};
+
+Value.toJson = (message: Value, options) => fromValueToJson(message);
+
+export function fromValueToJson(message: Value): JsonValue {
+  if (message.kind.oneofKind === undefined)
+    throw new globalThis.Error();
+  switch (message.kind.oneofKind) {
+    case undefined: throw new globalThis.Error();
+    case "boolValue": return message.kind.boolValue;
+    case "nullValue": return null;
+    case "negIntValue": return Number(message.kind.negIntValue);
+    case "posIntValue": return Number(message.kind.posIntValue);
+    case "numberValue":
+      let numberValue = message.kind.numberValue;
+      if (typeof numberValue == "number" && !Number.isFinite(numberValue))
+        throw new globalThis.Error();
+      return numberValue;
+    case "stringValue": return message.kind.stringValue;
+    case "listValue":
+      let listValueField = Value.fields.find(f => f.no === 8);
+      if (listValueField?.kind !== "message")
+        throw new globalThis.Error();
+      return listValueField.T().toJson(message.kind.listValue);
+    case "structValue":
+      let structValueField = Value.fields.find(f => f.no === 7);
+      if (structValueField?.kind !== "message")
+        throw new globalThis.Error();
+      return structValueField.T().toJson(message.kind.structValue);
+  }
+
+}
+
+Struct.toJson = (message: Struct) => {
+  let json: JsonObject = {};
+  for (let [k, v] of Object.entries(message.fields)) {
+    json[k] = Value.toJson(v);
+  }
+  return json;
+};
+
+ListValue.toJson = (message: ListValue) => {
+  return message.values.map(v => Value.toJson(v));
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    // "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}