@reminix/sdk 0.12.0 → 0.14.0

package/src/resources/knowledge/collections/documents.ts

@@ -0,0 +1,200 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { Cursor, type CursorParams, PagePromise } from '../../../core/pagination';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+export class Documents extends APIResource {
+  /**
+   * Get details of a document.
+   */
+  retrieve(
+    documentID: string,
+    params: DocumentRetrieveParams,
+    options?: RequestOptions,
+  ): APIPromise<KnowledgeDocument> {
+    const { collectionId } = params;
+    return this._client.get(path`/knowledge/collections/${collectionId}/documents/${documentID}`, options);
+  }
+
+  /**
+   * List all documents in a knowledge collection.
+   */
+  list(
+    id: string,
+    query: DocumentListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<KnowledgeDocumentsCursor, KnowledgeDocument> {
+    return this._client.getAPIList(path`/knowledge/collections/${id}/documents`, Cursor<KnowledgeDocument>, {
+      query,
+      ...options,
+    });
+  }
+
+  /**
+   * Delete a document and its associated data.
+   */
+  delete(documentID: string, params: DocumentDeleteParams, options?: RequestOptions): APIPromise<void> {
+    const { collectionId } = params;
+    return this._client.delete(path`/knowledge/collections/${collectionId}/documents/${documentID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Trigger processing for a document after upload.
+   *
+   * This extracts text from the document, splits it into chunks, generates
+   * embeddings, and stores them for search.
+   *
+   * The document status will transition: pending → processing → ready (or failed).
+   */
+  process(
+    documentID: string,
+    params: DocumentProcessParams,
+    options?: RequestOptions,
+  ): APIPromise<DocumentProcessResponse> {
+    const { collectionId, ...body } = params;
+    return this._client.post(path`/knowledge/collections/${collectionId}/documents/${documentID}/process`, {
+      body,
+      ...options,
+    });
+  }
+
+  /**
+   * Create a document record and get a presigned URL for upload.
+   *
+   * After receiving the response, upload the file to the presigned URL using a PUT
+   * request. The document will be processed automatically after upload.
+   */
+  upload(
+    id: string,
+    body: DocumentUploadParams,
+    options?: RequestOptions,
+  ): APIPromise<DocumentUploadResponse> {
+    return this._client.post(path`/knowledge/collections/${id}/documents`, { body, ...options });
+  }
+}
+
+export type KnowledgeDocumentsCursor = Cursor<KnowledgeDocument>;
+
+export interface KnowledgeDocument {
+  /**
+   * Unique document ID
+   */
+  id: string;
+
+  /**
+   * Collection ID
+   */
+  collectionId: string;
+
+  /**
+   * When the document was created
+   */
+  createdAt: string;
+
+  /**
+   * MIME type
+   */
+  mimeType: string;
+
+  /**
+   * Document name
+   */
+  name: string;
+
+  /**
+   * S3 URL of the document
+   */
+  sourceUrl: string;
+
+  /**
+   * Processing status
+   */
+  status: 'pending' | 'processing' | 'ready' | 'failed';
+
+  /**
+   * When the document was last updated
+   */
+  updatedAt: string;
+
+  /**
+   * Document metadata
+   */
+  metadata?: unknown;
+}
+
+export interface DocumentProcessResponse {
+  document: KnowledgeDocument;
+
+  message: string;
+}
+
+export interface DocumentUploadResponse {
+  document: KnowledgeDocument;
+
+  /**
+   * Presigned URL for uploading the file
+   */
+  uploadUrl: string;
+}
+
+export interface DocumentRetrieveParams {
+  collectionId: string;
+}
+
+export interface DocumentListParams extends CursorParams {
+  status?: 'pending' | 'processing' | 'ready' | 'failed';
+}
+
+export interface DocumentDeleteParams {
+  collectionId: string;
+}
+
+export interface DocumentProcessParams {
+  /**
+   * Path param
+   */
+  collectionId: string;
+
+  /**
+   * Body param: Use Unstructured.io for extraction if available
+   */
+  preferUnstructured?: boolean;
+}
+
+export interface DocumentUploadParams {
+  /**
+   * MIME type of the document
+   */
+  mimeType: string;
+
+  /**
+   * Document name (filename)
+   */
+  name: string;
+
+  /**
+   * File size in bytes
+   */
+  size?: number;
+}
+
+export declare namespace Documents {
+  export {
+    type KnowledgeDocument as KnowledgeDocument,
+    type DocumentProcessResponse as DocumentProcessResponse,
+    type DocumentUploadResponse as DocumentUploadResponse,
+    type KnowledgeDocumentsCursor as KnowledgeDocumentsCursor,
+    type DocumentRetrieveParams as DocumentRetrieveParams,
+    type DocumentListParams as DocumentListParams,
+    type DocumentDeleteParams as DocumentDeleteParams,
+    type DocumentProcessParams as DocumentProcessParams,
+    type DocumentUploadParams as DocumentUploadParams,
+  };
+}

package/src/resources/knowledge/collections/index.ts

@@ -0,0 +1,22 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Collections,
+  type KnowledgeCollection,
+  type CollectionCreateParams,
+  type CollectionUpdateParams,
+  type CollectionListParams,
+  type KnowledgeCollectionsCursor,
+} from './collections';
+export {
+  Documents,
+  type KnowledgeDocument,
+  type DocumentProcessResponse,
+  type DocumentUploadResponse,
+  type DocumentRetrieveParams,
+  type DocumentListParams,
+  type DocumentDeleteParams,
+  type DocumentProcessParams,
+  type DocumentUploadParams,
+  type KnowledgeDocumentsCursor,
+} from './documents';

package/src/resources/knowledge/collections.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './collections/index';

package/src/resources/knowledge/index.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Collections,
+  type KnowledgeCollection,
+  type CollectionCreateParams,
+  type CollectionUpdateParams,
+  type CollectionListParams,
+  type KnowledgeCollectionsCursor,
+} from './collections/index';
+export { Knowledge, type KnowledgeSearchResponse, type KnowledgeSearchParams } from './knowledge';

package/src/resources/knowledge/knowledge.ts

@@ -0,0 +1,101 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as CollectionsAPI from './collections/collections';
+import {
+  CollectionCreateParams,
+  CollectionListParams,
+  CollectionUpdateParams,
+  Collections,
+  KnowledgeCollection,
+  KnowledgeCollectionsCursor,
+} from './collections/collections';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+
+export class Knowledge extends APIResource {
+  collections: CollectionsAPI.Collections = new CollectionsAPI.Collections(this._client);
+
+  /**
+   * Search across one or more knowledge collections using semantic similarity.
+   *
+   * The search uses vector embeddings to find the most relevant content. Results are
+   * ordered by relevance score (0-1, higher is more similar).
+   */
+  search(body: KnowledgeSearchParams, options?: RequestOptions): APIPromise<KnowledgeSearchResponse> {
+    return this._client.post('/knowledge/search', { body, ...options });
+  }
+}
+
+export interface KnowledgeSearchResponse {
+  chunks: Array<KnowledgeSearchResponse.Chunk>;
+
+  /**
+   * Number of results found
+   */
+  count: number;
+}
+
+export namespace KnowledgeSearchResponse {
+  export interface Chunk {
+    /**
+     * Position in document
+     */
+    chunkIndex: number;
+
+    /**
+     * Chunk text content
+     */
+    content: string;
+
+    /**
+     * Source document ID
+     */
+    documentId: string;
+
+    /**
+     * Similarity score (0-1)
+     */
+    score: number;
+  }
+}
+
+export interface KnowledgeSearchParams {
+  /**
+   * Collection IDs to search
+   */
+  collectionIds: Array<string>;
+
+  /**
+   * Natural language search query
+   */
+  query: string;
+
+  /**
+   * Maximum number of results
+   */
+  limit?: number;
+
+  /**
+   * Minimum similarity score (0-1)
+   */
+  threshold?: number;
+}
+
+Knowledge.Collections = Collections;
+
+export declare namespace Knowledge {
+  export {
+    type KnowledgeSearchResponse as KnowledgeSearchResponse,
+    type KnowledgeSearchParams as KnowledgeSearchParams,
+  };
+
+  export {
+    Collections as Collections,
+    type KnowledgeCollection as KnowledgeCollection,
+    type KnowledgeCollectionsCursor as KnowledgeCollectionsCursor,
+    type CollectionCreateParams as CollectionCreateParams,
+    type CollectionUpdateParams as CollectionUpdateParams,
+    type CollectionListParams as CollectionListParams,
+  };
+}

package/src/resources/knowledge.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './knowledge/index';

package/src/resources/memory.ts

@@ -0,0 +1,188 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { buildHeaders } from '../internal/headers';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class MemoryResource extends APIResource {
+  /**
+   * Get a memory value by key for a specific identity.
+   *
+   * Identity is specified via query parameters with the `identity.` prefix.
+   *
+   * @example
+   * ```ts
+   * const memory = await client.memory.retrieve('x');
+   * ```
+   */
+  retrieve(key: string, options?: RequestOptions): APIPromise<Memory> {
+    return this._client.get(path`/memory/${key}`, options);
+  }
+
+  /**
+   * List all memory keys for a specific identity.
+   *
+   * Identity is specified via query parameters with the `identity.` prefix. For
+   * example: `?identity.user_id=user_123&identity.tenant_id=acme`
+   *
+   * Returns memory keys and metadata (not full values for efficiency).
+   *
+   * @example
+   * ```ts
+   * const memories = await client.memory.list();
+   * ```
+   */
+  list(options?: RequestOptions): APIPromise<MemoryListResponse> {
+    return this._client.get('/memory', options);
+  }
+
+  /**
+   * Delete a memory by key for a specific identity.
+   *
+   * @example
+   * ```ts
+   * await client.memory.delete('x');
+   * ```
+   */
+  delete(key: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/memory/${key}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Delete all memories for a specific identity.
+   *
+   * @example
+   * ```ts
+   * const response = await client.memory.deleteAll();
+   * ```
+   */
+  deleteAll(options?: RequestOptions): APIPromise<MemoryDeleteAllResponse> {
+    return this._client.delete('/memory', options);
+  }
+
+  /**
+   * Store a key-value memory for a specific identity.
+   *
+   * If a memory with the same key already exists, it will be updated.
+   *
+   * @example
+   * ```ts
+   * const memory = await client.memory.store({
+   *   identity: { user_id: 'user_123' },
+   *   key: 'preferred_language',
+   *   value: 'en',
+   * });
+   * ```
+   */
+  store(body: MemoryStoreParams, options?: RequestOptions): APIPromise<Memory> {
+    return this._client.post('/memory', { body, ...options });
+  }
+}
+
+export interface Memory {
+  /**
+   * Unique memory ID
+   */
+  id: string;
+
+  /**
+   * When the memory was created
+   */
+  createdAt: string;
+
+  /**
+   * When the memory expires
+   */
+  expiresAt: string | null;
+
+  /**
+   * Identity fields for memory scoping (e.g., user_id, tenant_id)
+   */
+  identity: { [key: string]: unknown };
+
+  /**
+   * Memory key
+   */
+  key: string;
+
+  /**
+   * Project ID
+   */
+  projectId: string;
+
+  /**
+   * When the memory was last updated
+   */
+  updatedAt: string;
+
+  /**
+   * Memory value
+   */
+  value?: unknown;
+}
+
+export interface MemoryListResponse {
+  data: Array<MemoryListResponse.Data>;
+}
+
+export namespace MemoryListResponse {
+  export interface Data {
+    /**
+     * When the memory expires (if set)
+     */
+    expiresAt: string | null;
+
+    /**
+     * Memory key
+     */
+    key: string;
+
+    /**
+     * When the memory was last updated
+     */
+    updatedAt: string;
+  }
+}
+
+export interface MemoryDeleteAllResponse {
+  /**
+   * Number of memories deleted
+   */
+  deleted: number;
+}
+
+export interface MemoryStoreParams {
+  /**
+   * Identity fields for memory scoping (e.g., user_id, tenant_id)
+   */
+  identity: { [key: string]: unknown };
+
+  /**
+   * Memory key
+   */
+  key: string;
+
+  /**
+   * Optional expiration time (ISO 8601)
+   */
+  expiresAt?: string;
+
+  /**
+   * Value to store
+   */
+  value?: unknown;
+}
+
+export declare namespace MemoryResource {
+  export {
+    type Memory as Memory,
+    type MemoryListResponse as MemoryListResponse,
+    type MemoryDeleteAllResponse as MemoryDeleteAllResponse,
+    type MemoryStoreParams as MemoryStoreParams,
+  };
+}

package/src/resources/tools.ts

@@ -91,19 +91,19 @@ export interface Tool {
   discoveredAt: string | null;
 
   /**
-   * Tool name
+   * JSON Schema for agent input
    */
-  name: string;
+  input: Tool.Input | null;
 
   /**
-   * JSON Schema for agent input parameters
+   * Tool name
    */
-  output: Tool.Output | null;
+  name: string;
 
   /**
-   * JSON Schema for agent input parameters
+   * JSON Schema for agent input
    */
-  parameters: Tool.Parameters | null;
+  output: Tool.Output | null;
 
   /**
    * Project ID
@@ -129,28 +129,96 @@ export interface Tool {
 
 export namespace Tool {
   /**
-   * JSON Schema for agent input parameters
+   * JSON Schema for agent input
    */
-  export interface Output {
-    type: string;
+  export interface Input {
+    /**
+     * Default value for the property
+     */
+    default?: unknown;
+
+    /**
+     * Description of the schema
+     */
+    description?: string;
+
+    /**
+     * Enumeration of allowed values
+     */
+    enum?: Array<unknown>;
 
+    /**
+     * Schema for array items
+     */
+    items?: unknown;
+
+    /**
+     * Property definitions for object types
+     */
     properties?: { [key: string]: unknown };
 
+    /**
+     * List of required property names
+     */
     required?: Array<string>;
 
+    /**
+     * Human-readable title
+     */
+    title?: string;
+
+    /**
+     * JSON Schema type (e.g., "object", "string", "array")
+     */
+    type?: string;
+
     [k: string]: unknown;
   }
 
   /**
-   * JSON Schema for agent input parameters
+   * JSON Schema for agent input
    */
-  export interface Parameters {
-    type: string;
+  export interface Output {
+    /**
+     * Default value for the property
+     */
+    default?: unknown;
+
+    /**
+     * Description of the schema
+     */
+    description?: string;
 
+    /**
+     * Enumeration of allowed values
+     */
+    enum?: Array<unknown>;
+
+    /**
+     * Schema for array items
+     */
+    items?: unknown;
+
+    /**
+     * Property definitions for object types
+     */
     properties?: { [key: string]: unknown };
 
+    /**
+     * List of required property names
+     */
     required?: Array<string>;
 
+    /**
+     * Human-readable title
+     */
+    title?: string;
+
+    /**
+     * JSON Schema type (e.g., "object", "string", "array")
+     */
+    type?: string;
+
     [k: string]: unknown;
   }
 }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.12.0'; // x-release-please-version
+export const VERSION = '0.14.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.12.0";
+export declare const VERSION = "0.14.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.12.0";
+export declare const VERSION = "0.14.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.12.0'; // x-release-please-version
+exports.VERSION = '0.14.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.12.0'; // x-release-please-version
+export const VERSION = '0.14.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map