@kmlckj/licos-platform-sdk 0.6.5 → 0.6.8

package/dist/index.d.ts

@@ -0,0 +1,531 @@
+export class PlatformSdkError extends Error {
+  status?: number;
+  code?: number;
+  details?: unknown;
+}
+
+export class ConfigurationError extends PlatformSdkError {}
+export class ApiError extends PlatformSdkError {}
+
+export const DataSourceType: {
+  TEXT: 0;
+  URL: 1;
+  URI: 2;
+};
+
+export type KnowledgeDataSourceType = 0 | 1 | 2 | 'text' | 'url' | 'uri' | 'raw' | 'content' | 'web' | 'file' | 'source_file_id';
+
+export interface KnowledgeChunkConfig {
+  separator?: string;
+  maxTokens?: number;
+  max_tokens?: number;
+  removeExtraSpaces?: boolean;
+  remove_extra_spaces?: boolean;
+  removeUrlsEmails?: boolean;
+  remove_urls_emails?: boolean;
+}
+
+export class ChunkConfig {
+  separator: string;
+  max_tokens: number;
+  remove_extra_spaces: boolean;
+  remove_urls_emails: boolean;
+  constructor(options?: KnowledgeChunkConfig);
+}
+
+export interface KnowledgeDocumentOptions {
+  source?: KnowledgeDataSourceType;
+  source_type?: KnowledgeDataSourceType;
+  raw_data?: string;
+  content?: string;
+  text?: string;
+  url?: string;
+  web_url?: string;
+  uri?: string;
+  source_file_id?: string;
+  name?: string;
+  file_type?: string;
+  update_rule?: Record<string, unknown>;
+}
+
+export class KnowledgeDocument {
+  constructor(options?: KnowledgeDocumentOptions);
+}
+
+export interface KnowledgeDataset {
+  name?: string;
+  description?: string;
+  status?: number;
+  dataset_id?: string;
+  space_id?: string;
+  doc_count?: number;
+  slice_count?: number;
+  search_method?: string;
+  supported_search_methods?: string[];
+  [key: string]: unknown;
+}
+
+export interface ListDatasetsOptions {
+  name?: string;
+  spaceId?: string;
+  space_id?: string;
+  formatType?: number;
+  format_type?: number;
+  pageSize?: number;
+  page_size?: number;
+  pageNum?: number;
+  page_num?: number;
+}
+
+export interface CreateDatasetOptions {
+  description?: string;
+  spaceId?: string;
+  space_id?: string;
+  config?: Record<string, unknown>;
+  formatType?: number;
+  format_type?: number;
+  sourceType?: string;
+  source_type?: string;
+  engineType?: string;
+  engine_type?: string;
+  accessScope?: string;
+  access_scope?: string;
+  multimodalEnabled?: boolean;
+  multimodal_enabled?: boolean;
+  graphEnabled?: boolean;
+  graph_enabled?: boolean;
+  embeddingModel?: string;
+  embedding_model?: string;
+  embeddingDim?: number;
+  embedding_dim?: number;
+  chunkingStrategy?: Record<string, unknown>;
+  chunking_strategy?: Record<string, unknown>;
+  processingProfile?: Record<string, unknown>;
+  processing_profile?: Record<string, unknown>;
+}
+
+export interface AddDocumentsOptions {
+  datasetId?: string;
+  dataset_id?: string;
+  datasetName?: string;
+  dataset_name?: string;
+  chunkConfig?: KnowledgeChunkConfig | ChunkConfig | Record<string, unknown>;
+  chunk_config?: KnowledgeChunkConfig | ChunkConfig | Record<string, unknown>;
+  formatType?: number;
+  format_type?: number;
+  batchId?: string;
+  batch_id?: string;
+  batchName?: string;
+  batch_name?: string;
+  processingProfile?: Record<string, unknown>;
+  processing_profile?: Record<string, unknown>;
+  chunkingStrategy?: Record<string, unknown>;
+  chunking_strategy?: Record<string, unknown>;
+  name?: string;
+}
+
+export interface SearchKnowledgeOptions {
+  datasetId?: string;
+  dataset_id?: string;
+  datasetIds?: string[];
+  dataset_ids?: string[];
+  datasetName?: string;
+  dataset_name?: string;
+  datasetNames?: string[];
+  dataset_names?: string[];
+  topK?: number;
+  top_k?: number;
+  minScore?: number;
+  min_score?: number;
+  candidateTopK?: number;
+  candidate_top_k?: number;
+  searchMethod?: string;
+  search_method?: string;
+  enableRerank?: boolean;
+  enable_rerank?: boolean;
+  needCitation?: boolean;
+  need_citation?: boolean;
+  needTrace?: boolean;
+  need_trace?: boolean;
+}
+
+export interface KnowledgeDocumentInfo {
+  id?: string;
+  sourceId?: string;
+  name?: string;
+  contentType?: string;
+  fileSize?: number;
+  status?: string;
+  errorMessage?: string;
+  chunkCount?: number;
+  createdAt?: string;
+  [key: string]: unknown;
+}
+
+export interface KnowledgeSearchResult {
+  segment_infos?: Array<{
+    content?: string;
+    score?: number;
+    metadata?: Record<string, unknown>;
+    segment_id?: string;
+    dataset_id?: string;
+    document_id?: string;
+    document_name?: string;
+    [key: string]: unknown;
+  }>;
+  citations?: unknown[];
+  request_id?: string;
+  dataset_ids?: string[];
+  route_trace?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export function runtime(): Promise<Record<string, unknown>>;
+export function modelCatalog(): Promise<Record<string, unknown>>;
+export function listDatasets(options?: ListDatasetsOptions): Promise<{ total_count?: number; dataset_list?: KnowledgeDataset[]; [key: string]: unknown }>;
+export function getDataset(datasetId: string): Promise<KnowledgeDataset>;
+export function createDataset(name: string, options?: CreateDatasetOptions): Promise<KnowledgeDataset>;
+export function deleteDataset(datasetId: string): Promise<void>;
+export function findDatasetByName(name: string): Promise<KnowledgeDataset | null>;
+export function ensureDataset(name: string, options?: CreateDatasetOptions): Promise<KnowledgeDataset>;
+export function addDocuments(documents: KnowledgeDocumentOptions[], options?: AddDocumentsOptions): Promise<{ document_infos?: KnowledgeDocumentInfo[]; [key: string]: unknown }>;
+export function addText(content: string, options?: AddDocumentsOptions): Promise<{ document_infos?: KnowledgeDocumentInfo[]; [key: string]: unknown }>;
+export function addUrl(url: string, options?: AddDocumentsOptions): Promise<{ document_infos?: KnowledgeDocumentInfo[]; [key: string]: unknown }>;
+export function listDocuments(datasetId: string, options?: { page?: number; size?: number }): Promise<{ total?: number; document_infos?: KnowledgeDocumentInfo[]; [key: string]: unknown }>;
+export function deleteDocuments(datasetId: string, documentIds: string[]): Promise<void>;
+export function search(query: string, options?: SearchKnowledgeOptions): Promise<KnowledgeSearchResult>;
+
+export const knowledge: {
+  DataSourceType: typeof DataSourceType;
+  ChunkConfig: typeof ChunkConfig;
+  KnowledgeDocument: typeof KnowledgeDocument;
+  runtime: typeof runtime;
+  modelCatalog: typeof modelCatalog;
+  listDatasets: typeof listDatasets;
+  getDataset: typeof getDataset;
+  createDataset: typeof createDataset;
+  deleteDataset: typeof deleteDataset;
+  findDatasetByName: typeof findDatasetByName;
+  ensureDataset: typeof ensureDataset;
+  addDocuments: typeof addDocuments;
+  addText: typeof addText;
+  addUrl: typeof addUrl;
+  listDocuments: typeof listDocuments;
+  deleteDocuments: typeof deleteDocuments;
+  search: typeof search;
+};
+
+export interface DatabaseFilter {
+  field: string;
+  op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'not_in' | 'is_null' | 'is_not_null' | 'like' | 'ilike' | string;
+  value?: unknown;
+}
+
+export interface DatabaseOrderBy {
+  field: string;
+  direction?: 'asc' | 'desc';
+}
+
+export interface DatabaseRange {
+  from: number;
+  to: number;
+}
+
+export interface DatabaseResponse {
+  data?: Record<string, unknown>[];
+  count?: number;
+  affectedRows?: number;
+  message?: string;
+  [key: string]: unknown;
+}
+
+export interface DatabaseQueryOptions {
+  select?: string | string[];
+  filters?: DatabaseFilter[];
+  orderBy?: DatabaseOrderBy[];
+  range?: DatabaseRange;
+  limit?: number;
+  offset?: number;
+  count?: boolean;
+  head?: boolean;
+}
+
+export interface DatabaseMutationOptions {
+  row?: Record<string, unknown>;
+  rows?: Record<string, unknown>[];
+  values?: Record<string, unknown>;
+  filters?: DatabaseFilter[];
+  updates?: Array<{ filters?: DatabaseFilter[]; values?: Record<string, unknown> }>;
+  deletes?: Array<{ filters?: DatabaseFilter[] }>;
+  conflictKeys?: string[];
+  returning?: boolean;
+}
+
+export interface DatabaseOperation {
+  type: 'query' | 'insert' | 'update' | 'delete' | 'upsert' | string;
+  request: Record<string, unknown>;
+}
+
+export interface DatabaseSchemaColumn {
+  name: string;
+  type?: string;
+  nullable?: boolean;
+  primaryKey?: boolean;
+  defaultValue?: string | null;
+  [key: string]: unknown;
+}
+
+export interface DatabaseSchemaTable {
+  schema?: string;
+  name: string;
+  description?: string | null;
+  columns?: DatabaseSchemaColumn[];
+  indexes?: unknown[];
+  foreignKeys?: unknown[];
+  constraints?: unknown[];
+  [key: string]: unknown;
+}
+
+export interface DatabaseSchema {
+  databaseId?: string;
+  environment?: 'dev' | 'prod' | string;
+  tables?: DatabaseSchemaTable[];
+  views?: unknown[];
+  functions?: unknown[];
+  enums?: unknown[];
+  [key: string]: unknown;
+}
+
+export interface GenerateOrmOptions {
+  language: 'typescript' | 'python' | 'ts' | 'py' | string;
+  orm?: 'drizzle' | 'sqlalchemy' | string;
+}
+
+export interface TableQuery {
+  select(...fields: string[]): TableQuery;
+  filter(field: string, op: string, value?: unknown): TableQuery;
+  eq(field: string, value: unknown): TableQuery;
+  neq(field: string, value: unknown): TableQuery;
+  gt(field: string, value: unknown): TableQuery;
+  gte(field: string, value: unknown): TableQuery;
+  lt(field: string, value: unknown): TableQuery;
+  lte(field: string, value: unknown): TableQuery;
+  in(field: string, value: unknown[]): TableQuery;
+  notIn(field: string, value: unknown[]): TableQuery;
+  isNull(field: string): TableQuery;
+  isNotNull(field: string): TableQuery;
+  like(field: string, value: string): TableQuery;
+  ilike(field: string, value: string): TableQuery;
+  order(field: string, options?: { desc?: boolean }): TableQuery;
+  range(from: number, to: number): TableQuery;
+  limit(value: number): TableQuery;
+  offset(value: number): TableQuery;
+  withCount(options?: { head?: boolean }): TableQuery;
+  execute(): Promise<DatabaseResponse>;
+  single(): Promise<DatabaseResponse>;
+  maybeSingle(): Promise<DatabaseResponse>;
+}
+
+export function query(table: string, options?: DatabaseQueryOptions): Promise<DatabaseResponse>;
+export function single(table: string, options?: DatabaseQueryOptions & { maybe?: boolean }): Promise<DatabaseResponse>;
+export function maybeSingle(table: string, options?: DatabaseQueryOptions): Promise<DatabaseResponse>;
+export function aggregate(table: string, aggregateName: string, options?: { field?: string; groupBy?: string[]; filters?: DatabaseFilter[] }): Promise<DatabaseResponse>;
+export function insert(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
+export function updateRows(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
+export function deleteRows(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
+export function upsert(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
+export function transaction(operations: DatabaseOperation[]): Promise<DatabaseResponse[]>;
+export function rpc(functionName: string, args?: Record<string, unknown>): Promise<DatabaseResponse>;
+export function getSchema(): Promise<DatabaseSchema>;
+export function defaultOrm(language: string): string;
+export function generateOrm(schemaPayload: DatabaseSchema, options: GenerateOrmOptions): string;
+export function exportOrm(options: GenerateOrmOptions): Promise<string>;
+export function table(name: string): TableQuery;
+
+export const database: {
+  query: typeof query;
+  single: typeof single;
+  maybeSingle: typeof maybeSingle;
+  aggregate: typeof aggregate;
+  insert: typeof insert;
+  updateRows: typeof updateRows;
+  deleteRows: typeof deleteRows;
+  upsert: typeof upsert;
+  transaction: typeof transaction;
+  rpc: typeof rpc;
+  getSchema: typeof getSchema;
+  defaultOrm: typeof defaultOrm;
+  generateOrm: typeof generateOrm;
+  exportOrm: typeof exportOrm;
+  table: typeof table;
+};
+
+export interface StudioDatabaseColumn {
+  originalName?: string;
+  name?: string;
+  type?: string;
+  defaultValue?: string | null;
+  primaryKey?: boolean;
+  nullable?: boolean;
+  unique?: boolean;
+  array?: boolean;
+  checkExpression?: string;
+  [key: string]: unknown;
+}
+
+export interface StudioDatabaseTableOptions {
+  envScope?: 'dev' | 'prod' | string;
+  schema?: string;
+  description?: string;
+  columns?: StudioDatabaseColumn[];
+}
+
+export interface StudioDatabaseRowOptions {
+  envScope?: 'dev' | 'prod' | string;
+  schema?: string;
+  rowId?: string;
+  rowIndex?: number;
+  rowIds?: string[];
+  rowIndexes?: number[];
+}
+
+export interface StudioDatabaseSyncOptions {
+  sourceScope?: 'dev' | 'prod' | string;
+  targetScope?: 'dev' | 'prod' | string;
+  tables?: string[];
+  sourceProjectId?: string;
+  targetProjectId?: string;
+}
+
+export interface StudioDatabaseControlOptions {
+  environment?: 'dev' | 'prod' | string;
+}
+
+export const studioDatabase: {
+  getDatabase(options?: { envScope?: string }): Promise<Record<string, unknown>>;
+  createDefaultDatabase(options?: { envScope?: string }): Promise<Record<string, unknown>>;
+  deleteDatabase(options?: { envScope?: string }): Promise<void>;
+  listTables(options?: { envScope?: string; keyword?: string }): Promise<Record<string, unknown>[]>;
+  createTable(tableName: string, options?: StudioDatabaseTableOptions): Promise<Record<string, unknown>>;
+  updateTable(tableName: string, options?: StudioDatabaseTableOptions & { newTableName?: string }): Promise<Record<string, unknown>>;
+  deleteTable(tableName: string, options?: Pick<StudioDatabaseTableOptions, 'envScope' | 'schema'>): Promise<void>;
+  addColumn(tableName: string, options: StudioDatabaseTableOptions & { name: string; type: string; defaultValue?: string | null; array?: boolean; primaryKey?: boolean; nullable?: boolean; unique?: boolean; checkExpression?: string }): Promise<Record<string, unknown>>;
+  getTableData(tableName: string, options?: Pick<StudioDatabaseTableOptions, 'envScope' | 'schema'>): Promise<Record<string, unknown>>;
+  insertRow(tableName: string, values: Record<string, unknown>, options?: Pick<StudioDatabaseTableOptions, 'envScope' | 'schema'>): Promise<Record<string, unknown>>;
+  updateRow(tableName: string, values: Record<string, unknown>, options?: StudioDatabaseRowOptions): Promise<Record<string, unknown>>;
+  deleteRows(tableName: string, options?: StudioDatabaseRowOptions): Promise<Record<string, unknown>>;
+  executeSql(sqlText: string, options?: { envScope?: string }): Promise<Record<string, unknown>>;
+  sqlHistory(options?: { envScope?: string }): Promise<Record<string, unknown>[]>;
+  exportBackup(options?: { envScope?: string }): Promise<Record<string, unknown>>;
+  importBackup(backup: Record<string, unknown>, options?: { envScope?: string }): Promise<Record<string, unknown>>;
+  sync(options?: StudioDatabaseSyncOptions): Promise<Record<string, unknown>>;
+  syncProject(sourceProjectId: string, targetProjectId: string, options?: StudioDatabaseSyncOptions): Promise<Record<string, unknown>>;
+  ensureDatabase(options?: StudioDatabaseControlOptions): Promise<Record<string, unknown>>;
+  getSchema(options?: StudioDatabaseControlOptions): Promise<DatabaseSchema>;
+  getConfig(options?: StudioDatabaseControlOptions): Promise<Record<string, unknown>>;
+  controlSql(sqlText: string, options?: StudioDatabaseControlOptions): Promise<Record<string, unknown>>;
+  explainSql(sqlText: string, options?: StudioDatabaseControlOptions): Promise<Record<string, unknown>>;
+  validateSchema(schema: DatabaseSchema, options?: StudioDatabaseControlOptions): Promise<Record<string, unknown>>;
+  diffSchema(schema: DatabaseSchema, options?: StudioDatabaseControlOptions): Promise<Record<string, unknown>>;
+  listMigrations(options?: StudioDatabaseControlOptions): Promise<Record<string, unknown>[]>;
+  createMigration(options: StudioDatabaseControlOptions & { title: string; statements?: string[]; schema?: DatabaseSchema; dryRun?: boolean }): Promise<Record<string, unknown>>;
+  getMigration(migrationId: string): Promise<Record<string, unknown>>;
+};
+
+export interface StorageSummary {
+  workspaceId?: string;
+  projectId?: string;
+  scope?: string;
+  bucketName?: string;
+  usedSizeBytes?: number;
+  fileCount?: number;
+  folderCount?: number;
+  serviceEnabled?: boolean;
+  [key: string]: unknown;
+}
+
+export interface StorageFolder {
+  id?: string;
+  workspaceId?: string;
+  projectId?: string;
+  scope?: string;
+  parentId?: string | null;
+  folderName?: string;
+  folderPath?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  [key: string]: unknown;
+}
+
+export interface StorageFile {
+  id?: string;
+  workspaceId?: string;
+  projectId?: string;
+  scope?: string;
+  folderId?: string | null;
+  folderPath?: string;
+  fileName?: string;
+  contentType?: string;
+  sizeBytes?: number;
+  storageBucket?: string;
+  storageKey?: string;
+  downloadUrl?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  [key: string]: unknown;
+}
+
+export interface StorageEntries {
+  currentFolderId?: string | null;
+  currentFolderName?: string;
+  currentFolderPath?: string;
+  breadcrumbs?: unknown[];
+  folders?: StorageFolder[];
+  files?: StorageFile[];
+  [key: string]: unknown;
+}
+
+export interface UploadFileOptions {
+  folderId?: string;
+  fileName?: string;
+  contentType?: string;
+}
+
+export const MAX_UPLOAD_FILE_BYTES: number;
+
+export interface ShareUrlOptions {
+  expirySeconds?: number;
+}
+
+export function summary(): Promise<StorageSummary>;
+export function listFolders(): Promise<StorageFolder[]>;
+export function listEntries(options?: { folderId?: string }): Promise<StorageEntries>;
+export function listFiles(): Promise<StorageFile[]>;
+export function createFolder(folderName: string, options?: { parentId?: string }): Promise<StorageFolder>;
+export function renameFolder(folderId: string, folderName: string): Promise<StorageFolder>;
+export function deleteFolder(folderId: string): Promise<void>;
+export function uploadFile(
+  input: string | Blob | Buffer | Uint8Array,
+  options?: UploadFileOptions,
+): Promise<StorageFile>;
+export function renameFile(fileId: string, fileName: string): Promise<StorageFile>;
+export function moveFile(fileId: string, options?: { folderId?: string }): Promise<StorageFile>;
+export function shareUrl(fileId: string, options?: ShareUrlOptions): Promise<{ url?: string; expiresAt?: string; [key: string]: unknown }>;
+export function objectExists(options?: { fileId?: string; objectKey?: string }): Promise<{ fileId?: string; bucketName?: string; objectKey?: string; exists?: boolean; [key: string]: unknown }>;
+export function deleteFile(fileId: string): Promise<void>;
+
+export const storage: {
+  summary: typeof summary;
+  listFolders: typeof listFolders;
+  listEntries: typeof listEntries;
+  listFiles: typeof listFiles;
+  createFolder: typeof createFolder;
+  renameFolder: typeof renameFolder;
+  deleteFolder: typeof deleteFolder;
+  uploadFile: typeof uploadFile;
+  renameFile: typeof renameFile;
+  moveFile: typeof moveFile;
+  shareUrl: typeof shareUrl;
+  objectExists: typeof objectExists;
+  deleteFile: typeof deleteFile;
+};

package/dist/index.js

@@ -0,0 +1 @@
+export{PlatformSdkError,ConfigurationError,ApiError}from"./shared.js";export*from"./database.js";export*from"./knowledge.js";export*from"./storage.js";export{studioDatabase}from"./studio-database.js";

package/dist/knowledge.js

@@ -0,0 +1 @@
+import{Buffer as e}from"node:buffer";import{ApiError as t,ConfigurationError as a}from"./shared.js";import{authHeaders as n,refreshRuntimeConfig as r,runtimeConfig as o,shouldRefreshUserToken as s}from"./runtime.js";export const DataSourceType=Object.freeze({TEXT:0,URL:1,URI:2});export class ChunkConfig{constructor({separator:e="\n",maxTokens:t=2e3,max_tokens:a,removeExtraSpaces:n=!1,remove_extra_spaces:r,removeUrlsEmails:o=!1,remove_urls_emails:s}={}){this.separator=e,this.max_tokens=a??t,this.remove_extra_spaces=r??n,this.remove_urls_emails=s??o}}export class KnowledgeDocument{constructor(e={}){Object.assign(this,e)}}async function i(){return o()}function c(e){return Object.fromEntries(Object.entries(e).filter(([,e])=>null!=e))}function d(e,t,a={}){const n=new URL(`${e.baseUrl}/api/v1/knowledge${t}`);for(const[e,t]of Object.entries(a))Array.isArray(t)?t.forEach(t=>n.searchParams.append(e,String(t))):null!=t&&n.searchParams.set(e,String(t));return n}async function u(e){const a=await e.text(),n=a?JSON.parse(a):null;if(!e.ok)throw new t(a||`platform knowledge API returned ${e.status}`,{status:e.status,details:n});if(!n||"object"!=typeof n)return n;if(void 0!==n.code&&0!==n.code||!1===n.success)throw new t(n.message||"platform knowledge API failed",{status:e.status,code:"number"==typeof n.code?n.code:void 0,details:n});return n.data}async function p(e,a,{params:o,body:p,config:m}={}){let l=m||await i();for(let t=0;t<2;t+=1)try{const t=await fetch(d(l,a,o),{method:e,headers:n(l,void 0===p?void 0:"application/json"),body:void 0===p?void 0:JSON.stringify(c(p))});return await u(t)}catch(e){if(0===t&&s(e)){l=await r(l);continue}throw e}throw new t("platform knowledge API failed")}export async function runtime(){return p("GET","/runtime")}export async function modelCatalog(){return p("GET","/runtime/model-catalog")}export async function listDatasets(e={}){const t=await i();return p("GET","/openapi/v1/datasets",{config:t,params:{space_id:e.spaceId??e.space_id??t.workspaceId,name:e.name,format_type:e.formatType??e.format_type,page_size:e.pageSize??e.page_size,page_num:e.pageNum??e.page_num}})}export async function getDataset(e){return p("GET",`/openapi/v1/datasets/${encodeURIComponent(e)}`)}export async function createDataset(e,t={}){const a=await i();return p("POST","/openapi/v1/datasets",{config:a,body:{name:e,description:t.description,config:t.config,space_id:t.spaceId??t.space_id??a.workspaceId,format_type:t.formatType??t.format_type,source_type:t.sourceType??t.source_type,engine_type:t.engineType??t.engine_type,access_scope:t.accessScope??t.access_scope,multimodal_enabled:t.multimodalEnabled??t.multimodal_enabled,graph_enabled:t.graphEnabled??t.graph_enabled,embedding_model:t.embeddingModel??t.embedding_model,embedding_dim:t.embeddingDim??t.embedding_dim,chunking_strategy:t.chunkingStrategy??t.chunking_strategy,processing_profile:t.processingProfile??t.processing_profile}})}export async function deleteDataset(e){await p("DELETE",`/openapi/v1/datasets/${encodeURIComponent(e)}`)}export async function findDatasetByName(e){const t=await listDatasets({name:e,pageSize:50,pageNum:1}),a=Array.isArray(t?.dataset_list)?t.dataset_list:[];return a.find(t=>t?.name===e)||a[0]||null}export async function ensureDataset(e,t={}){return await findDatasetByName(e)||createDataset(e,t)}async function m(e,{create:t=!1}={}){const n=t?await ensureDataset(e):await findDatasetByName(e),r=n?.dataset_id;if(!r)throw new a(`knowledge dataset not found: ${e}`);return String(r)}function l(e){if(e)return{...e}}export async function addDocuments(t,a={}){const n=a.datasetId||a.dataset_id||(a.datasetName||a.dataset_name?await m(a.datasetName||a.dataset_name,{create:!0}):void 0);if(!n)throw new TypeError("datasetId or datasetName is required");return p("POST","/openapi/open_api/knowledge/document/create",{body:{dataset_id:n,document_bases:t.map(t=>function(t){const a={...t},n=function(e){if("number"==typeof e)return e;const t=String(e).trim().toLowerCase();if(["text","raw","content","0"].includes(t))return DataSourceType.TEXT;if(["url","web","1"].includes(t))return DataSourceType.URL;if(["uri","file","source_file_id","source-file-id","2"].includes(t))return DataSourceType.URI;throw new TypeError(`unsupported knowledge document source: ${e}`)}(a.source??a.source_type??function(e){return e.url||e.web_url?DataSourceType.URL:e.uri||e.source_file_id?DataSourceType.URI:DataSourceType.TEXT}(a)),r=String(a.name||function(e,t){return e===DataSourceType.URL?String(t.url||t.web_url||"web-url"):e===DataSourceType.URI?String(t.uri||t.source_file_id||"object"):"document.txt"}(n,a)),o=String(a.file_type||(n===DataSourceType.TEXT?"txt":"")),s={document_source:n};if(n===DataSourceType.TEXT){const t=a.raw_data??a.content??a.text;if(null==t)throw new TypeError("TEXT knowledge document requires raw_data/content/text");s.file_base64=e.from(String(t),"utf8").toString("base64"),s.file_type=o||"txt"}else if(n===DataSourceType.URL){const e=a.url||a.web_url;if(!e)throw new TypeError("URL knowledge document requires url");s.web_url=String(e)}else{const e=a.source_file_id||a.uri;if(!e)throw new TypeError("URI knowledge document requires uri/source_file_id");s.source_file_id=String(e),o&&(s.file_type=o)}return c({name:r,source_info:c(s),update_rule:a.update_rule})}(t)),chunk_strategy:l(a.chunkConfig||a.chunk_config),format_type:a.formatType??a.format_type,batch_id:a.batchId??a.batch_id,batch_name:a.batchName??a.batch_name,processing_profile:a.processingProfile??a.processing_profile,chunking_strategy:a.chunkingStrategy??a.chunking_strategy}})}export async function addText(e,t={}){return addDocuments([new KnowledgeDocument({source:DataSourceType.TEXT,raw_data:e,name:t.name||"document.txt"})],t)}export async function addUrl(e,t={}){return addDocuments([new KnowledgeDocument({source:DataSourceType.URL,url:e,name:t.name})],t)}export async function listDocuments(e,t={}){return p("GET",`/openapi/v1/datasets/${encodeURIComponent(e)}/documents`,{params:{page:t.page,size:t.size}})}export async function deleteDocuments(e,t){if(!Array.isArray(t)||0===t.length)throw new TypeError("documentIds is required");await p("POST","/openapi/open_api/knowledge/document/delete",{body:{dataset_id:e,document_ids:t}})}export async function search(e,t={}){const a=await async function(e={}){const t=[];if((e.datasetId||e.dataset_id)&&t.push(e.datasetId||e.dataset_id),Array.isArray(e.datasetIds||e.dataset_ids)&&t.push(...e.datasetIds||e.dataset_ids),(e.datasetName||e.dataset_name)&&t.push(await m(e.datasetName||e.dataset_name)),Array.isArray(e.datasetNames||e.dataset_names))for(const a of e.datasetNames||e.dataset_names)t.push(await m(a));return Array.from(new Set(t.filter(Boolean).map(String)))}(t),n={query:e,dataset_id:1===a.length?a[0]:void 0,dataset_ids:a.length?a:void 0,top_k:t.topK??t.top_k??5,min_score:t.minScore??t.min_score??0,candidate_top_k:t.candidateTopK??t.candidate_top_k,search_method:t.searchMethod??t.search_method,enable_rerank:t.enableRerank??t.enable_rerank,need_citation:t.needCitation??t.need_citation??!0,need_trace:t.needTrace??t.need_trace??!0};return p("POST",1===a.length?`/openapi/v1/datasets/${encodeURIComponent(a[0])}/retrieve`:"/openapi/v1/datasets/retrieve",{body:n})}export const knowledge={DataSourceType:DataSourceType,ChunkConfig:ChunkConfig,KnowledgeDocument:KnowledgeDocument,runtime:runtime,modelCatalog:modelCatalog,listDatasets:listDatasets,getDataset:getDataset,createDataset:createDataset,deleteDataset:deleteDataset,findDatasetByName:findDatasetByName,ensureDataset:ensureDataset,addDocuments:addDocuments,addText:addText,addUrl:addUrl,listDocuments:listDocuments,deleteDocuments:deleteDocuments,search:search};

package/dist/runtime.js

@@ -0,0 +1 @@
+import{ConfigurationError as e}from"./shared.js";const t=new Map;export function env(e){const t=process.env[e];if("string"!=typeof t)return;return t.trim()||void 0}function n(e,t,n){const r=env(e);if(r)return`http://${r}:${env(t)||n}`}export function platformBaseUrl(){const t=env("LICOS_PLATFORM_API_BASE_URL")||n("AIOS_PLATFORM_SERVICE_HOST","AIOS_PLATFORM_SERVICE_PORT","9100")||n("LICOS_PLATFORM_SERVICE_HOST","LICOS_PLATFORM_SERVICE_PORT","9100")||n("PLATFORM_SERVICE_HOST","PLATFORM_SERVICE_PORT","9100");if(!t)throw new e("LICOS_PLATFORM_API_BASE_URL is not configured");return function(e){let t=e.trim().replace(/\/+$/,"");return t.endsWith("/api/v1")&&(t=t.slice(0,-7)),t.replace(/\/+$/,"")}(t)}export function projectEnvironment(e){const t=((e?env(e):void 0)||"").toLowerCase();if("dev"===t||"prod"===t)return t;const n=(env("LICOS_PROJECT_ENV")||env("AGENT_ENV")||"").toLowerCase();return["prod","production","release"].includes(n)?"prod":"dev"}async function r(n,r,{forceRefresh:o=!1}={}){const s=String(r||"").trim();if(!s)throw new e("project owner user ID is not configured");const i=env("LICOS_AI_AGENT_TOKEN");if(!i)throw new e("platform runtime identity is unavailable");const c=`${n}\n${s}\n${i}`;if(t.has(c)){const e=t.get(c);if(!o)return e;if(e&&"function"==typeof e.then)return e}const a=fetch(`${n}/api/v1/internal/auth/ai-user-token`,{method:"POST",headers:{Authorization:`Bearer ${i}`,"Content-Type":"application/json"},body:JSON.stringify({userId:s})}).then(async n=>{const r=await n.text();let o=null;try{o=r?JSON.parse(r):null}catch(t){const o=new e("parse AI user token exchange response failed");throw o.status=n.status,o.details=r,o}if(!n.ok){const t=o?.message||r||`AI user token exchange returned ${n.status}`,s=new e(t);throw s.status=n.status,s.details=o,s}const s=function(t){if(!t||"object"!=typeof t)throw new e("AI user token exchange response is not an object");if(void 0!==t.code&&0!==t.code||!1===t.success){const n=new e(t.message||"AI user token exchange failed");throw n.code="number"==typeof t.code?t.code:void 0,n.details=t,n}const n=t.data,r="string"==typeof n?n.trim():String(n?.accessToken||n?.access_token||n?.token||"").trim();if(!r){const n=new e("AI user token exchange response missing accessToken");throw n.details=t,n}return r}(o);return t.set(c,s),s});t.set(c,a);try{return await a}catch(e){throw t.delete(c),e}}export function clearTokenCacheForTests(){t.clear()}export function shouldRefreshUserToken(e){return 401===e?.status||10002===e?.code}export async function refreshRuntimeConfig(e){return{...e,token:await r(e.baseUrl,e.userId,{forceRefresh:!0})}}export async function runtimeConfig({environmentOverrideEnv:t}={}){const n=env("LICOS_PROJECT_ID")||env("AGENT_PROJECT_ID");if(!n)throw new e("LICOS_PROJECT_ID or AGENT_PROJECT_ID is not configured");const o=platformBaseUrl(),s=env("LICOS_USER_ID")||env("AGENT_USER_ID"),i=await r(o,s);return{baseUrl:o,projectId:n,environment:projectEnvironment(t),token:i,workspaceId:env("LICOS_WORKSPACE_ID")||env("AGENT_WORKSPACE_ID"),userId:s}}export function authHeaders(e,t="application/json"){const n={Authorization:`Bearer ${e.token}`};return t&&(n["Content-Type"]=t),e.workspaceId&&(n["X-Workspace-Id"]=e.workspaceId),e.userId&&(n["X-User-Id"]=e.userId),n}

package/dist/shared.js

@@ -0,0 +1 @@
+export class PlatformSdkError extends Error{constructor(r,t={}){super(r),this.name=new.target.name,this.status=t.status,this.code=t.code,this.details=t.details}}export class ConfigurationError extends PlatformSdkError{}export class ApiError extends PlatformSdkError{}

package/dist/storage.js

@@ -0,0 +1 @@
+import{readFile as e,stat as t}from"node:fs/promises";import o from"node:path";import{ApiError as r}from"./shared.js";import{authHeaders as n,refreshRuntimeConfig as i,runtimeConfig as a,shouldRefreshUserToken as s}from"./runtime.js";export const MAX_UPLOAD_FILE_BYTES=20971520;async function l(){return a({environmentOverrideEnv:"LICOS_STORAGE_SCOPE"})}function d(e,t,o){return`${e.baseUrl}/api/v1/studio/storage${t}?${function(e,t={}){const o=new URLSearchParams;o.set("projectId",e.projectId),o.set("scope",e.environment);for(const[e,r]of Object.entries(t))null!=r&&o.set(e,String(r));return o.toString()}(e,o)}`}async function c(e){const t=await e.text(),o=t?JSON.parse(t):null;if(!e.ok)throw new r(t||`platform storage API returned ${e.status}`,{status:e.status,details:o});if(!o||"object"!=typeof o)return o;if(void 0!==o.code&&0!==o.code||!1===o.success)throw new r(o.message||"platform storage API failed",{status:e.status,code:"number"==typeof o.code?o.code:void 0,details:o});return o.data}async function f(e,t,{params:o,body:a}={}){let f=await l();for(let r=0;r<2;r+=1)try{const r=await fetch(d(f,t,o),{method:e,headers:n(f),body:void 0===a?void 0:JSON.stringify(a)});return await c(r)}catch(e){if(0===r&&s(e)){f=await i(f);continue}throw e}throw new r("platform storage API failed")}function u(e){if(e>20971520)throw new RangeError("uploadFile input exceeds max size of 20971520 bytes")}export async function summary(){return f("GET","/summary")}export async function listFolders(){return await f("GET","/folders")||[]}export async function listEntries({folderId:e}={}){return f("GET","/entries",{params:{folderId:e}})}export async function listFiles(){return await f("GET","/files")||[]}export async function createFolder(e,{parentId:t}={}){return f("POST","/folders",{body:{folderName:e,parentId:t}})}export async function renameFolder(e,t){return f("PUT",`/folders/${encodeURIComponent(e)}`,{body:{folderName:t}})}export async function deleteFolder(e){await f("DELETE",`/folders/${encodeURIComponent(e)}`)}export async function uploadFile(a,d={}){const{blob:f,fileName:p}=await async function(r,n={}){if("string"==typeof r){u((await t(r)).size);const i=await e(r);return{blob:new Blob([i],{type:n.contentType||"application/octet-stream"}),fileName:n.fileName||o.basename(r)}}if(r instanceof Blob)return u(r.size),{blob:r,fileName:n.fileName||"file"};if(r instanceof Uint8Array||Buffer.isBuffer(r))return u(r.byteLength),{blob:new Blob([r],{type:n.contentType||"application/octet-stream"}),fileName:n.fileName||"file"};throw new TypeError("uploadFile input must be a file path, Blob, Buffer, or Uint8Array")}(a,d);let m=await l();for(let e=0;e<2;e+=1){const t=new FormData;t.set("projectId",m.projectId),t.set("scope",m.environment),d.folderId&&t.set("folderId",d.folderId),t.set("file",f,p);try{const e=await fetch(`${m.baseUrl}/api/v1/studio/storage/files/upload`,{method:"POST",headers:n(m,void 0),body:t});return await c(e)}catch(t){if(0===e&&s(t)){m=await i(m);continue}throw t}}throw new r("platform storage upload failed")}export async function renameFile(e,t){return f("PUT",`/files/${encodeURIComponent(e)}/rename`,{body:{fileName:t}})}export async function moveFile(e,{folderId:t}={}){return f("PUT",`/files/${encodeURIComponent(e)}/move`,{body:{folderId:t}})}export async function shareUrl(e,{expirySeconds:t}={}){return f("POST",`/files/${encodeURIComponent(e)}/share-url`,{body:{expirySeconds:t}})}export async function objectExists({fileId:e,objectKey:t}={}){return f("POST","/objects/exists",{body:{fileId:e,objectKey:t}})}export async function deleteFile(e){await f("DELETE",`/files/${encodeURIComponent(e)}`)}export const storage={summary:summary,listFolders:listFolders,listEntries:listEntries,listFiles:listFiles,createFolder:createFolder,renameFolder:renameFolder,deleteFolder:deleteFolder,uploadFile:uploadFile,renameFile:renameFile,moveFile:moveFile,shareUrl:shareUrl,objectExists:objectExists,deleteFile:deleteFile};

package/dist/studio-database.js

@@ -0,0 +1 @@
+import{ApiError as e}from"./shared.js";import{authHeaders as t,refreshRuntimeConfig as a,runtimeConfig as n,shouldRefreshUserToken as r}from"./runtime.js";async function o(){return n({environmentOverrideEnv:"LICOS_STUDIO_DATABASE_SCOPE"})}function s(e,t){const a=String(t||e.environment||"dev").toLowerCase();return["prod","production","release"].includes(a)?"prod":"dev"}function c(e){return Object.fromEntries(Object.entries(e).filter(([,e])=>null!=e))}async function i(t){const a=await t.text(),n=a?JSON.parse(a):null;if(!t.ok)throw new e(a||`platform Studio database API returned ${t.status}`,{status:t.status,details:n});if(!n||"object"!=typeof n)return n;if(void 0!==n.code&&0!==n.code||!1===n.success)throw new e(n.message||"platform Studio database API failed",{status:t.status,code:"number"==typeof n.code?n.code:void 0,details:n});return n.data}async function u(n,s,{body:u}={}){let p=await o();for(let e=0;e<2;e+=1)try{const e=void 0!==u,a=await fetch(s(p),{method:n,headers:t(p,e?"application/json":void 0),body:e?JSON.stringify(c(u)):void 0});return await i(a)}catch(t){if(0===e&&r(t)){p=await a(p);continue}throw t}throw new e("platform Studio database API failed")}async function p(e,t={}){return{envScope:s(await o(),e),...t}}function d(e,t,{params:a,body:n}={}){return u(e,e=>function(e,t,a={}){const n=function(e,t={}){const a=new URLSearchParams;a.set("projectId",e.projectId);for(const[e,n]of Object.entries(c(t)))if(Array.isArray(n))for(const t of n)a.append(e,String(t));else a.set(e,String(n));return a.toString()}(e,a);return`${e.baseUrl}/api/v1/studio/databases${t}${n?`?${n}`:""}`}(e,t,a),{body:n})}function l(e,t,{params:a,body:n}={}){return u(e,e=>function(e,t,a={}){const n=new URLSearchParams;for(const[e,t]of Object.entries(c(a)))n.set(e,String(t));const r=n.toString();return`${e.baseUrl}/api/v1/studio/control/database/projects/${encodeURIComponent(e.projectId)}${t}${r?`?${r}`:""}`}(e,t,a),{body:n})}export async function getDatabase(e={}){return d("GET","/dev",{params:await p(e.envScope)})}export async function createDefaultDatabase(e={}){return d("POST","/dev/default",{params:await p(e.envScope)})}export async function deleteDatabase(e={}){await d("DELETE","/dev",{params:await p(e.envScope)})}export async function listTables(e={}){return await d("GET","/dev/tables",{params:await p(e.envScope,{keyword:e.keyword})})||[]}export async function createTable(e,t={}){return d("POST","/dev/tables",{params:await p(t.envScope),body:{tableName:e,description:t.description,columns:t.columns||[]}})}export async function updateTable(e,t={}){return d("PUT","/dev/tables",{params:await p(t.envScope,{tableName:e,schema:t.schema}),body:{tableName:t.newTableName,description:t.description,columns:t.columns}})}export async function deleteTable(e,t={}){await d("POST","/dev/tables/delete",{params:await p(t.envScope,{tableName:e,schema:t.schema})})}export async function addColumn(e,t={}){return d("POST","/dev/tables/columns",{params:await p(t.envScope,{tableName:e,schema:t.schema}),body:{name:t.name,type:t.type,description:t.description,defaultValue:t.defaultValue,array:t.array,primaryKey:t.primaryKey,nullable:t.nullable,unique:t.unique,checkExpression:t.checkExpression}})}export async function getTableData(e,t={}){return d("GET","/dev/tables/data",{params:await p(t.envScope,{tableName:e,schema:t.schema})})}export async function insertRow(e,t,a={}){return d("POST","/dev/tables/rows",{params:await p(a.envScope,{tableName:e,schema:a.schema}),body:{values:t}})}export async function updateRow(e,t,a={}){return d("POST","/dev/tables/rows/update",{params:await p(a.envScope,{tableName:e,schema:a.schema}),body:{rowId:a.rowId,rowIndex:a.rowIndex,values:t}})}export async function deleteRows(e,t={}){return d("POST","/dev/tables/rows/delete",{params:await p(t.envScope,{tableName:e,schema:t.schema}),body:{rowIds:t.rowIds,rowIndexes:t.rowIndexes}})}export async function executeSql(e,t={}){return d("POST","/dev/sql/execute",{params:await p(t.envScope),body:{sqlText:e}})}export async function sqlHistory(e={}){return await d("GET","/dev/sql/history",{params:await p(e.envScope)})||[]}export async function exportBackup(e={}){return d("GET","/backup/export",{params:await p(e.envScope||"prod")})}export async function importBackup(e,t={}){return d("POST","/backup/import",{params:await p(t.envScope||"prod"),body:e})}export async function sync(e={}){return d("POST","/sync",{body:{sourceScope:e.sourceScope||"dev",targetScope:e.targetScope||"prod",tables:e.tables||[],source_project_id:e.sourceProjectId,target_project_id:e.targetProjectId}})}export async function syncProject(e,t,a={}){return d("POST","/sync_project",{body:{sourceScope:a.sourceScope||"dev",targetScope:a.targetScope||"prod",tables:a.tables||[],source_project_id:e,target_project_id:t}})}export async function ensureDatabase(e={}){return l("POST","/ensure",{params:{environment:e.environment}})}export async function getSchema(e={}){return l("GET","/schema",{params:{environment:e.environment}})}export async function getConfig(e={}){return l("GET","/config",{params:{environment:e.environment}})}export async function controlSql(e,t={}){return l("POST","/sql",{params:{environment:t.environment},body:{sqlText:e}})}export async function explainSql(e,t={}){return l("POST","/sql/explain",{params:{environment:t.environment},body:{sqlText:e}})}export async function validateSchema(e,t={}){return l("POST","/schema/validate",{body:{environment:t.environment,schema:e}})}export async function diffSchema(e,t={}){return l("POST","/schema/diff",{body:{environment:t.environment,schema:e}})}export async function listMigrations(e={}){return await l("GET","/migrations",{params:{environment:e.environment}})||[]}export async function createMigration(e={}){return l("POST","/migrations",{body:{environment:e.environment,dryRun:e.dryRun??!0,title:e.title,statements:e.statements||[],schema:e.schema}})}export async function getMigration(e){return l("GET",`/migrations/${encodeURIComponent(e)}`)}export const studioDatabase={getDatabase:getDatabase,createDefaultDatabase:createDefaultDatabase,deleteDatabase:deleteDatabase,listTables:listTables,createTable:createTable,updateTable:updateTable,deleteTable:deleteTable,addColumn:addColumn,getTableData:getTableData,insertRow:insertRow,updateRow:updateRow,deleteRows:deleteRows,executeSql:executeSql,sqlHistory:sqlHistory,exportBackup:exportBackup,importBackup:importBackup,sync:sync,syncProject:syncProject,ensureDatabase:ensureDatabase,getSchema:getSchema,getConfig:getConfig,controlSql:controlSql,explainSql:explainSql,validateSchema:validateSchema,diffSchema:diffSchema,listMigrations:listMigrations,createMigration:createMigration,getMigration:getMigration};

package/package.json

@@ -1,42 +1,47 @@
 {
   "name": "@kmlckj/licos-platform-sdk",
-  "version": "0.6.5",
+  "version": "0.6.8",
   "description": "LICOS platform SDK package shell for browser and Node runtimes",
   "author": "kmlckj",
   "type": "module",
-  "main": "./src/index.js",
-  "browser": "./src/browser.js",
-  "types": "./src/index.d.ts",
+  "main": "./dist/index.js",
+  "browser": "./dist/browser.js",
+  "types": "./dist/index.d.ts",
   "typesVersions": {
     "*": {
       "browser": [
-        "src/browser.d.ts"
+        "dist/browser.d.ts"
       ]
     }
   },
   "exports": {
     ".": {
       "browser": {
-        "types": "./src/browser.d.ts",
-        "default": "./src/browser.js"
+        "types": "./dist/browser.d.ts",
+        "default": "./dist/browser.js"
       },
-      "types": "./src/index.d.ts",
-      "import": "./src/index.js",
-      "default": "./src/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./browser": {
-      "types": "./src/browser.d.ts",
-      "import": "./src/browser.js",
-      "default": "./src/browser.js"
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js",
+      "default": "./dist/browser.js"
     }
   },
   "files": [
-    "src",
+    "dist",
     "README.md"
   ],
   "scripts": {
+    "build": "node build.mjs",
+    "prepack": "npm run build",
     "test": "node --test"
   },
+  "devDependencies": {
+    "terser": "5.48.0"
+  },
   "license": "MIT",
   "publishConfig": {
     "access": "public",

package/src/browser.js

@@ -1 +0,0 @@
-export { PlatformSdkError, ConfigurationError, ApiError } from './shared.js';