@redplanethq/sdk 0.1.10 → 0.1.12

package/dist/index.mjs

@@ -1,4 +1,6 @@
 import { Command } from 'commander';
+import { z } from 'zod';
+import { randomUUID } from 'crypto';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -83,6 +85,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,
@@ -101,18 +104,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 = `{
@@ -126,10 +133,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"
+];
 var EpisodeTypeEnum;
 (function(EpisodeTypeEnum2) {
   EpisodeTypeEnum2["CONVERSATION"] = "CONVERSATION";
@@ -166,11 +200,6 @@ var OAuth2Params = class {
     __name(this, "OAuth2Params");
   }
 };
-var APIKeyParams = class {
-  static {
-    __name(this, "APIKeyParams");
-  }
-};
 
 // ../types/dist/integration.js
 var IntegrationEventType;
@@ -397,7 +426,377 @@ var IntegrationCLI = class {
     return this.program;
   }
 };
+var IngestInputSchema = z.object({
+  episodeBody: z.string(),
+  referenceTime: z.string(),
+  metadata: z.record(z.union([
+    z.string(),
+    z.number(),
+    z.boolean()
+  ])).optional(),
+  source: z.string(),
+  labelIds: z.array(z.string()).optional(),
+  sessionId: z.string().optional(),
+  type: z.enum([
+    "CONVERSATION",
+    "DOCUMENT"
+  ]).default("CONVERSATION"),
+  title: z.string().optional()
+});
+var IngestResponseSchema = z.object({
+  success: z.boolean(),
+  id: z.string()
+});
+var SearchInputSchema = z.object({
+  query: z.string(),
+  startTime: z.string().optional(),
+  endTime: z.string().optional(),
+  labelIds: z.array(z.string()).optional(),
+  limit: z.number().optional(),
+  structured: z.boolean().optional(),
+  sortBy: z.enum([
+    "relevance",
+    "recency"
+  ]).optional()
+});
+var SearchResponseSchema = z.record(z.unknown());
+var MeResponseSchema = z.object({
+  id: z.string(),
+  name: z.string().nullable().optional(),
+  persona: z.string().nullable().optional(),
+  workspaceId: z.string().nullable().optional(),
+  phoneNumber: z.string().nullable().optional(),
+  email: z.string().nullable().optional(),
+  timezone: z.string().nullable().optional(),
+  metadata: z.record(z.unknown()).nullable().optional()
+});
+var IntegrationAccountSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  slug: z.string().optional()
+}).passthrough();
+var GetIntegrationsConnectedResponseSchema = z.object({
+  accounts: z.array(IntegrationAccountSchema)
+});
+var GetIntegrationActionsInputSchema = z.object({
+  accountId: z.string(),
+  query: z.string().optional()
+});
+var GetIntegrationActionsResponseSchema = z.object({
+  actions: z.array(z.unknown())
+});
+var ExecuteIntegrationActionInputSchema = z.object({
+  accountId: z.string(),
+  action: z.string(),
+  parameters: z.record(z.unknown()).optional()
+});
+var ExecuteIntegrationActionResponseSchema = z.object({
+  result: z.unknown()
+});
+var GetDocumentsInputSchema = z.object({
+  page: z.number().optional(),
+  limit: z.number().optional(),
+  source: z.string().optional(),
+  status: z.string().optional(),
+  type: z.string().optional(),
+  sessionId: z.string().optional(),
+  label: z.string().optional(),
+  cursor: z.string().optional()
+});
+var DocumentSchema = z.object({
+  id: z.string(),
+  title: z.string().nullable().optional(),
+  createdAt: z.string().optional(),
+  sessionId: z.string().nullable().optional(),
+  source: z.string().nullable().optional()
+}).passthrough();
+var GetDocumentsResponseSchema = z.object({
+  documents: z.array(DocumentSchema),
+  page: z.number(),
+  limit: z.number(),
+  hasMore: z.boolean(),
+  nextCursor: z.string().nullable(),
+  availableSources: z.array(z.object({
+    name: z.string(),
+    slug: z.string()
+  })),
+  totalCount: z.number()
+});
+var GetDocumentInputSchema = z.object({
+  documentId: z.string()
+});
+var GetDocumentResponseSchema = z.object({
+  document: DocumentSchema.nullable()
+});
+var GatewayAgentInfoSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  tools: z.array(z.string()),
+  platform: z.string().nullable(),
+  hostname: z.string().nullable(),
+  status: z.enum([
+    "CONNECTED",
+    "DISCONNECTED"
+  ])
+});
+var GetGatewaysResponseSchema = z.object({
+  gateways: z.array(GatewayAgentInfoSchema)
+});
+var ExecuteGatewayInputSchema = z.object({
+  gatewayId: z.string(),
+  intent: z.string()
+});
+var ExecuteGatewayToolInputSchema = z.object({
+  gatewayId: z.string(),
+  toolName: z.string(),
+  params: z.record(z.unknown())
+});
+var ExecuteGatewayResponseSchema = z.object({
+  result: z.unknown()
+});
+var AuthorizationCodeResponseSchema = z.object({
+  authorizationCode: z.string(),
+  url: z.string()
+});
+var TokenExchangeInputSchema = z.object({
+  authorizationCode: z.string()
+});
+var TokenExchangeResponseSchema = z.object({
+  token: z.object({
+    token: z.string(),
+    obfuscatedToken: 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 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();
+  }
+};
 
-export { APIKeyParams, ActionStatus, ActionStatusEnum, COMPACTED_SESSION_NODE_PROPERTIES, ClaudeModels, ENTITY_NODE_PROPERTIES, EPISODIC_NODE_PROPERTIES, EXPLICIT_PATTERN_TYPES, EpisodeType, EpisodeTypeEnum, GeminiModels, IMPLICIT_PATTERN_TYPES, IntegrationCLI, IntegrationEventType, LLMMappings, LLMModelEnum, LLMModelType, OAuth2Params, OpenAIModels, PATTERN_TYPES, QUALITY_THRESHOLDS, STATEMENT_NODE_PROPERTIES, Spec, UserTypeEnum };
+export { ActionStatus, ActionStatusEnum, AuthorizationCodeResponseSchema, COMPACTED_SESSION_NODE_PROPERTIES, ClaudeModels, CoreClient, CoreClientError, DocumentSchema, ENTITY_NODE_PROPERTIES, EPISODIC_NODE_PROPERTIES, EXPLICIT_PATTERN_TYPES, EntityTypes, EpisodeType, EpisodeTypeEnum, ExecuteGatewayInputSchema, ExecuteGatewayResponseSchema, ExecuteGatewayToolInputSchema, ExecuteIntegrationActionInputSchema, ExecuteIntegrationActionResponseSchema, GatewayAgentInfoSchema, GeminiModels, GetDocumentInputSchema, GetDocumentResponseSchema, GetDocumentsInputSchema, GetDocumentsResponseSchema, GetGatewaysResponseSchema, GetIntegrationActionsInputSchema, GetIntegrationActionsResponseSchema, GetIntegrationsConnectedResponseSchema, IMPLICIT_PATTERN_TYPES, IngestInputSchema, IngestResponseSchema, IntegrationAccountSchema, IntegrationCLI, IntegrationEventType, LLMMappings, LLMModelEnum, LLMModelType, MeResponseSchema, OAuth2Params, OpenAIModels, PATTERN_TYPES, QUALITY_THRESHOLDS, STATEMENT_NODE_PROPERTIES, SearchInputSchema, SearchResponseSchema, Spec, StatementAspects, TokenExchangeInputSchema, TokenExchangeResponseSchema, UserTypeEnum };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map