@redplanethq/sdk 0.1.10 → 0.1.12

package/dist/index.js

@@ -1,6 +1,8 @@
 'use strict';
 
 var commander = require('commander');
+var zod = require('zod');
+var crypto = require('crypto');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -85,6 +87,7 @@ var EPISODIC_NODE_PROPERTIES = `{
   metadata: e.metadata,
   createdAt: e.createdAt,
   userId: e.userId,
+  workspaceId: e.workspaceId,
   sessionId: e.sessionId,
   queueId: e.queueId,
   labelIds: e.labelIds,
@@ -103,18 +106,22 @@ var STATEMENT_NODE_PROPERTIES = `{
   fact: s.fact,
   createdAt: s.createdAt,
   userId: s.userId,
+  workspaceId: s.workspaceId,
   validAt: s.validAt,
   invalidAt: s.invalidAt,
   invalidatedBy: s.invalidatedBy,
   attributes: s.attributes,
+  aspect: s.aspect,
   recallCount: s.recallCount,
   provenanceCount: s.provenanceCount
 }`;
 var ENTITY_NODE_PROPERTIES = `{
   uuid: ent.uuid,
   name: ent.name,
+  type: ent.type,
   createdAt: ent.createdAt,
   userId: ent.userId,
+  workspaceId: ent.workspaceId,
   attributes: ent.attributes
 }`;
 var COMPACTED_SESSION_NODE_PROPERTIES = `{
@@ -128,10 +135,37 @@ var COMPACTED_SESSION_NODE_PROPERTIES = `{
   updatedAt: cs.updatedAt,
   confidence: cs.confidence,
   userId: cs.userId,
+  workspaceId: cs.workspaceId,
   source: cs.source,
   compressionRatio: cs.compressionRatio,
   metadata: cs.metadata
 }`;
+var EntityTypes = [
+  "Person",
+  "Organization",
+  "Place",
+  "Event",
+  "Project",
+  "Task",
+  "Technology",
+  "Product",
+  "Standard",
+  "Concept",
+  "Predicate"
+];
+var StatementAspects = [
+  "Identity",
+  "Knowledge",
+  "Belief",
+  "Preference",
+  "Habit",
+  "Goal",
+  "Directive",
+  "Decision",
+  "Event",
+  "Problem",
+  "Relationship"
+];
 exports.EpisodeTypeEnum = void 0;
 (function(EpisodeTypeEnum2) {
   EpisodeTypeEnum2["CONVERSATION"] = "CONVERSATION";
@@ -168,11 +202,6 @@ var OAuth2Params = class {
     __name(this, "OAuth2Params");
   }
 };
-var APIKeyParams = class {
-  static {
-    __name(this, "APIKeyParams");
-  }
-};
 
 // ../types/dist/integration.js
 exports.IntegrationEventType = void 0;
@@ -399,24 +428,421 @@ var IntegrationCLI = class {
     return this.program;
   }
 };
+var IngestInputSchema = zod.z.object({
+  episodeBody: zod.z.string(),
+  referenceTime: zod.z.string(),
+  metadata: zod.z.record(zod.z.union([
+    zod.z.string(),
+    zod.z.number(),
+    zod.z.boolean()
+  ])).optional(),
+  source: zod.z.string(),
+  labelIds: zod.z.array(zod.z.string()).optional(),
+  sessionId: zod.z.string().optional(),
+  type: zod.z.enum([
+    "CONVERSATION",
+    "DOCUMENT"
+  ]).default("CONVERSATION"),
+  title: zod.z.string().optional()
+});
+var IngestResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  id: zod.z.string()
+});
+var SearchInputSchema = zod.z.object({
+  query: zod.z.string(),
+  startTime: zod.z.string().optional(),
+  endTime: zod.z.string().optional(),
+  labelIds: zod.z.array(zod.z.string()).optional(),
+  limit: zod.z.number().optional(),
+  structured: zod.z.boolean().optional(),
+  sortBy: zod.z.enum([
+    "relevance",
+    "recency"
+  ]).optional()
+});
+var SearchResponseSchema = zod.z.record(zod.z.unknown());
+var MeResponseSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string().nullable().optional(),
+  persona: zod.z.string().nullable().optional(),
+  workspaceId: zod.z.string().nullable().optional(),
+  phoneNumber: zod.z.string().nullable().optional(),
+  email: zod.z.string().nullable().optional(),
+  timezone: zod.z.string().nullable().optional(),
+  metadata: zod.z.record(zod.z.unknown()).nullable().optional()
+});
+var IntegrationAccountSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string().optional(),
+  slug: zod.z.string().optional()
+}).passthrough();
+var GetIntegrationsConnectedResponseSchema = zod.z.object({
+  accounts: zod.z.array(IntegrationAccountSchema)
+});
+var GetIntegrationActionsInputSchema = zod.z.object({
+  accountId: zod.z.string(),
+  query: zod.z.string().optional()
+});
+var GetIntegrationActionsResponseSchema = zod.z.object({
+  actions: zod.z.array(zod.z.unknown())
+});
+var ExecuteIntegrationActionInputSchema = zod.z.object({
+  accountId: zod.z.string(),
+  action: zod.z.string(),
+  parameters: zod.z.record(zod.z.unknown()).optional()
+});
+var ExecuteIntegrationActionResponseSchema = zod.z.object({
+  result: zod.z.unknown()
+});
+var GetDocumentsInputSchema = zod.z.object({
+  page: zod.z.number().optional(),
+  limit: zod.z.number().optional(),
+  source: zod.z.string().optional(),
+  status: zod.z.string().optional(),
+  type: zod.z.string().optional(),
+  sessionId: zod.z.string().optional(),
+  label: zod.z.string().optional(),
+  cursor: zod.z.string().optional()
+});
+var DocumentSchema = zod.z.object({
+  id: zod.z.string(),
+  title: zod.z.string().nullable().optional(),
+  createdAt: zod.z.string().optional(),
+  sessionId: zod.z.string().nullable().optional(),
+  source: zod.z.string().nullable().optional()
+}).passthrough();
+var GetDocumentsResponseSchema = zod.z.object({
+  documents: zod.z.array(DocumentSchema),
+  page: zod.z.number(),
+  limit: zod.z.number(),
+  hasMore: zod.z.boolean(),
+  nextCursor: zod.z.string().nullable(),
+  availableSources: zod.z.array(zod.z.object({
+    name: zod.z.string(),
+    slug: zod.z.string()
+  })),
+  totalCount: zod.z.number()
+});
+var GetDocumentInputSchema = zod.z.object({
+  documentId: zod.z.string()
+});
+var GetDocumentResponseSchema = zod.z.object({
+  document: DocumentSchema.nullable()
+});
+var GatewayAgentInfoSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string(),
+  tools: zod.z.array(zod.z.string()),
+  platform: zod.z.string().nullable(),
+  hostname: zod.z.string().nullable(),
+  status: zod.z.enum([
+    "CONNECTED",
+    "DISCONNECTED"
+  ])
+});
+var GetGatewaysResponseSchema = zod.z.object({
+  gateways: zod.z.array(GatewayAgentInfoSchema)
+});
+var ExecuteGatewayInputSchema = zod.z.object({
+  gatewayId: zod.z.string(),
+  intent: zod.z.string()
+});
+var ExecuteGatewayToolInputSchema = zod.z.object({
+  gatewayId: zod.z.string(),
+  toolName: zod.z.string(),
+  params: zod.z.record(zod.z.unknown())
+});
+var ExecuteGatewayResponseSchema = zod.z.object({
+  result: zod.z.unknown()
+});
+var AuthorizationCodeResponseSchema = zod.z.object({
+  authorizationCode: zod.z.string(),
+  url: zod.z.string()
+});
+var TokenExchangeInputSchema = zod.z.object({
+  authorizationCode: zod.z.string()
+});
+var TokenExchangeResponseSchema = zod.z.object({
+  token: zod.z.object({
+    token: zod.z.string(),
+    obfuscatedToken: zod.z.string()
+  }).nullable()
+});
+var CoreClientError = class extends Error {
+  static {
+    __name(this, "CoreClientError");
+  }
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "CoreClientError";
+    this.statusCode = statusCode;
+  }
+};
+var CoreClient = class {
+  static {
+    __name(this, "CoreClient");
+  }
+  baseUrl;
+  token;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+  }
+  async request(method, path, options) {
+    let url = `${this.baseUrl}${path}`;
+    if (options?.searchParams) {
+      const params = new URLSearchParams(options.searchParams);
+      const query = params.toString();
+      if (query) url += `?${query}`;
+    }
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`
+      },
+      ...options?.body ? {
+        body: JSON.stringify(options.body)
+      } : {}
+    });
+    if (!response.ok) {
+      let errorMessage;
+      try {
+        const errorBody = await response.json();
+        errorMessage = errorBody.error || JSON.stringify(errorBody);
+      } catch {
+        errorMessage = await response.text();
+      }
+      throw new CoreClientError(errorMessage, response.status);
+    }
+    return response.json();
+  }
+  /**
+  * Send a request without an Authorization header.
+  * Used for public endpoints like authorization-code and token exchange.
+  */
+  async requestPublic(method, path, options) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      ...options?.body ? {
+        body: JSON.stringify(options.body)
+      } : {}
+    });
+    if (!response.ok) {
+      let errorMessage;
+      try {
+        const errorBody = await response.json();
+        errorMessage = errorBody.error || JSON.stringify(errorBody);
+      } catch {
+        errorMessage = await response.text();
+      }
+      throw new CoreClientError(errorMessage, response.status);
+    }
+    return response.json();
+  }
+  /**
+  * Get the authenticated user's profile info.
+  * GET /api/v1/me
+  */
+  async me() {
+    return this.request("GET", "/api/v1/me");
+  }
+  /**
+  * Store a conversation or document in memory.
+  * POST /api/v1/add
+  */
+  async ingest(body) {
+    return this.request("POST", "/api/v1/add", {
+      body
+    });
+  }
+  /**
+  * Search memory with a query and optional filters.
+  * POST /api/v1/search
+  */
+  async search(body) {
+    return this.request("POST", "/api/v1/search", {
+      body
+    });
+  }
+  /**
+  * List all connected integration accounts for the workspace.
+  * GET /api/v1/integration_account
+  */
+  async getIntegrationsConnected() {
+    return this.request("GET", "/api/v1/integration_account");
+  }
+  /**
+  * Get relevant actions for a specific integration account.
+  * GET /api/v1/integration_account/:accountId/action?query=...
+  */
+  async getIntegrationActions(params) {
+    const searchParams = {};
+    if (params.query) searchParams.query = params.query;
+    return this.request("GET", `/api/v1/integration_account/${params.accountId}/action`, {
+      searchParams: Object.keys(searchParams).length > 0 ? searchParams : void 0
+    });
+  }
+  /**
+  * Execute an action on an integration account.
+  * POST /api/v1/integration_account/:accountId/action
+  */
+  async executeIntegrationAction(params) {
+    const { accountId, ...body } = params;
+    return this.request("POST", `/api/v1/integration_account/${accountId}/action`, {
+      body
+    });
+  }
+  /**
+  * Generate a new session UUID for conversation tracking.
+  * Local operation — no API call.
+  */
+  async getSessionId() {
+    return crypto.randomUUID();
+  }
+  /**
+  * List documents with optional filtering and pagination.
+  * GET /api/v1/documents
+  */
+  async getDocuments(params) {
+    const searchParams = {};
+    if (params) {
+      if (params.page != null) searchParams.page = String(params.page);
+      if (params.limit != null) searchParams.limit = String(params.limit);
+      if (params.source) searchParams.source = params.source;
+      if (params.status) searchParams.status = params.status;
+      if (params.type) searchParams.type = params.type;
+      if (params.sessionId) searchParams.sessionId = params.sessionId;
+      if (params.label) searchParams.label = params.label;
+      if (params.cursor) searchParams.cursor = params.cursor;
+    }
+    return this.request("GET", "/api/v1/documents", {
+      searchParams: Object.keys(searchParams).length > 0 ? searchParams : void 0
+    });
+  }
+  /**
+  * Get a single document by ID.
+  * GET /api/v1/documents/:documentId
+  */
+  async getDocument(params) {
+    return this.request("GET", `/api/v1/documents/${params.documentId}`);
+  }
+  /**
+  * List all connected gateways for the workspace.
+  * GET /api/v1/gateways
+  */
+  async getGateways() {
+    return this.request("GET", "/api/v1/gateways");
+  }
+  /**
+  * Run a gateway sub-agent with an intent and return the final text result.
+  * POST /api/v1/gateways/:gatewayId/execute
+  */
+  async executeGateway(params) {
+    return this.request("POST", `/api/v1/gateways/${params.gatewayId}/execute`, {
+      body: {
+        intent: params.intent
+      }
+    });
+  }
+  /**
+  * Proxy a single tool call to a gateway via server websocket.
+  * POST /api/v1/gateways/:gatewayId/execute  (mode: "tool")
+  */
+  async executeGatewayTool(params) {
+    return this.request("POST", `/api/v1/gateways/${params.gatewayId}/execute`, {
+      body: {
+        mode: "tool",
+        toolName: params.toolName,
+        params: params.params
+      }
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Auth – Device-style login flow (public endpoints, no token required)
+  // -------------------------------------------------------------------------
+  /**
+  * Request a fresh authorization code.
+  * POST /api/v1/authorization-code  (unauthenticated)
+  *
+  * The returned `url` is the page the user must visit to authorize the CLI.
+  */
+  async getAuthorizationCode() {
+    return this.requestPublic("POST", "/api/v1/authorization-code");
+  }
+  /**
+  * Exchange an authorization code for a personal access token.
+  * POST /api/v1/token  (unauthenticated)
+  *
+  * Returns `{ token: null }` while the user has not yet completed
+  * the browser authorization step.  Poll until `token` is non-null.
+  */
+  async exchangeToken(params) {
+    return this.requestPublic("POST", "/api/v1/token", {
+      body: params
+    });
+  }
+  /**
+  * Verify that the current token is valid by calling /api/v1/me.
+  * Returns the user profile on success, or throws CoreClientError on failure.
+  * Useful as a health-check before launching other operations.
+  */
+  async checkAuth() {
+    return this.me();
+  }
+};
 
-exports.APIKeyParams = APIKeyParams;
 exports.ActionStatus = ActionStatus;
+exports.AuthorizationCodeResponseSchema = AuthorizationCodeResponseSchema;
 exports.COMPACTED_SESSION_NODE_PROPERTIES = COMPACTED_SESSION_NODE_PROPERTIES;
 exports.ClaudeModels = ClaudeModels;
+exports.CoreClient = CoreClient;
+exports.CoreClientError = CoreClientError;
+exports.DocumentSchema = DocumentSchema;
 exports.ENTITY_NODE_PROPERTIES = ENTITY_NODE_PROPERTIES;
 exports.EPISODIC_NODE_PROPERTIES = EPISODIC_NODE_PROPERTIES;
 exports.EXPLICIT_PATTERN_TYPES = EXPLICIT_PATTERN_TYPES;
+exports.EntityTypes = EntityTypes;
 exports.EpisodeType = EpisodeType;
+exports.ExecuteGatewayInputSchema = ExecuteGatewayInputSchema;
+exports.ExecuteGatewayResponseSchema = ExecuteGatewayResponseSchema;
+exports.ExecuteGatewayToolInputSchema = ExecuteGatewayToolInputSchema;
+exports.ExecuteIntegrationActionInputSchema = ExecuteIntegrationActionInputSchema;
+exports.ExecuteIntegrationActionResponseSchema = ExecuteIntegrationActionResponseSchema;
+exports.GatewayAgentInfoSchema = GatewayAgentInfoSchema;
 exports.GeminiModels = GeminiModels;
+exports.GetDocumentInputSchema = GetDocumentInputSchema;
+exports.GetDocumentResponseSchema = GetDocumentResponseSchema;
+exports.GetDocumentsInputSchema = GetDocumentsInputSchema;
+exports.GetDocumentsResponseSchema = GetDocumentsResponseSchema;
+exports.GetGatewaysResponseSchema = GetGatewaysResponseSchema;
+exports.GetIntegrationActionsInputSchema = GetIntegrationActionsInputSchema;
+exports.GetIntegrationActionsResponseSchema = GetIntegrationActionsResponseSchema;
+exports.GetIntegrationsConnectedResponseSchema = GetIntegrationsConnectedResponseSchema;
 exports.IMPLICIT_PATTERN_TYPES = IMPLICIT_PATTERN_TYPES;
+exports.IngestInputSchema = IngestInputSchema;
+exports.IngestResponseSchema = IngestResponseSchema;
+exports.IntegrationAccountSchema = IntegrationAccountSchema;
 exports.IntegrationCLI = IntegrationCLI;
 exports.LLMModelType = LLMModelType;
+exports.MeResponseSchema = MeResponseSchema;
 exports.OAuth2Params = OAuth2Params;
 exports.OpenAIModels = OpenAIModels;
 exports.PATTERN_TYPES = PATTERN_TYPES;
 exports.QUALITY_THRESHOLDS = QUALITY_THRESHOLDS;
 exports.STATEMENT_NODE_PROPERTIES = STATEMENT_NODE_PROPERTIES;
+exports.SearchInputSchema = SearchInputSchema;
+exports.SearchResponseSchema = SearchResponseSchema;
 exports.Spec = Spec;
+exports.StatementAspects = StatementAspects;
+exports.TokenExchangeInputSchema = TokenExchangeInputSchema;
+exports.TokenExchangeResponseSchema = TokenExchangeResponseSchema;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map