@tablestore/tablestore-agent-cli 0.3.1 → 0.4.1

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/models/memory.js

@@ -0,0 +1,684 @@
+import { assignIfPresent, toJsonValue } from './base.js';
+export class Scope {
+    appId;
+    tenantId;
+    agentId;
+    runId;
+    constructor(options) {
+        Object.assign(this, options);
+    }
+    toJSONRequest() {
+        const result = {};
+        if (this.appId !== undefined) {
+            result.appId = this.appId;
+        }
+        if (this.tenantId !== undefined) {
+            result.tenantId = this.tenantId;
+        }
+        if (this.agentId !== undefined) {
+            result.agentId = this.agentId;
+        }
+        if (this.runId !== undefined) {
+            result.runId = this.runId;
+        }
+        return result;
+    }
+}
+export class MessagePayload {
+    role;
+    content;
+    messageId;
+    timestamp;
+    metadata;
+    constructor(options) {
+        Object.assign(this, options);
+        this.role = options.role;
+        this.content = options.content;
+    }
+    toJSONRequest() {
+        const result = {
+            role: this.role,
+            content: this.content,
+        };
+        if (this.messageId !== undefined) {
+            result.messageId = this.messageId;
+        }
+        if (this.timestamp !== undefined) {
+            result.timestamp = this.timestamp;
+        }
+        if (this.metadata !== undefined) {
+            result.metadata = this.metadata;
+        }
+        return result;
+    }
+}
+export class CreateMemoryStoreRequest {
+    /** Required. At most 32 characters matching `^[a-zA-Z0-9_]+$`. */
+    memoryStoreName;
+    /**
+     * Free-form description. Limit is **1024 bytes** (UTF-8 byte length, not
+     * characters) - note this differs from `extractInstructions`, which is
+     * measured in code points.
+     */
+    description;
+    /**
+     * Custom extraction instructions. Limit is **4096 code points (runes)**, not
+     * bytes - use `[...text].length` if you pre-validate on the client.
+     */
+    extractInstructions;
+    /**
+     * Storage mode; defaults to `ots` when omitted. **Immutable after creation** -
+     * UpdateMemoryStore cannot change it.
+     */
+    storageMode;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+    }
+    toJSONRequest() {
+        const result = { memoryStoreName: this.memoryStoreName };
+        assignIfPresent(result, 'description', this.description);
+        assignIfPresent(result, 'extractInstructions', this.extractInstructions);
+        assignIfPresent(result, 'storageMode', this.storageMode);
+        return result;
+    }
+}
+export class GetMemoryStoreRequest {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    toJSONRequest() {
+        return { memoryStoreName: this.options.memoryStoreName };
+    }
+}
+export class ListMemoryStoresRequest {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    toJSONRequest() {
+        const result = {};
+        assignIfPresent(result, 'limit', this.options.limit);
+        assignIfPresent(result, 'nextToken', this.options.nextToken);
+        return result;
+    }
+}
+/**
+ * UpdateMemoryStore is a strict PATCH and accepts **only** `description` and
+ * `extractInstructions`. Everything else (including `storageMode`) is immutable.
+ *
+ * Per-field semantics:
+ *
+ * - omitted / `undefined` / {@link UNSET} / `null` - leave the field unchanged
+ * - `''` (empty string) - **clear** the stored value
+ *
+ * Sending neither field is a no-op: the service simply echoes the current
+ * store info back.
+ */
+export class UpdateMemoryStoreRequest {
+    memoryStoreName;
+    /**
+     * `''` clears the description; omitting it leaves it unchanged.
+     * Limit is 1024 **bytes**.
+     */
+    description;
+    /**
+     * `''` clears the instructions; omitting it leaves them unchanged.
+     * Limit is 4096 **code points (runes)**.
+     */
+    extractInstructions;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+    }
+    toJSONRequest() {
+        const result = { memoryStoreName: this.memoryStoreName };
+        assignIfPresent(result, 'description', this.description);
+        assignIfPresent(result, 'extractInstructions', this.extractInstructions);
+        return result;
+    }
+}
+export class DeleteMemoryStoreRequest {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    toJSONRequest() {
+        return { memoryStoreName: this.options.memoryStoreName };
+    }
+}
+export class AddMemoriesRequest {
+    memoryStoreName;
+    scope;
+    messages;
+    text;
+    metadata;
+    sync;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+    }
+    toJSONRequest() {
+        const result = { memoryStoreName: this.memoryStoreName };
+        assignIfPresent(result, 'scope', toJsonValue(this.scope));
+        assignIfPresent(result, 'messages', this.messages?.map((item) => toJsonValue(item)));
+        assignIfPresent(result, 'text', this.text);
+        assignIfPresent(result, 'metadata', this.metadata);
+        assignIfPresent(result, 'sync', this.sync);
+        return result;
+    }
+}
+export class SearchMemoriesRequest {
+    memoryStoreName;
+    /** `appId` and `tenantId` are required; `agentId`/`runId` accept `*`. */
+    scope;
+    query;
+    /**
+     * Exact key/value equality filters, AND-ed together. The memory search API
+     * supports **only** equality matching - the `MetadataFilter` tree
+     * (AND/OR/NOT/range) applies to knowledge-base `retrieve`, not here.
+     */
+    metadata;
+    /** Defaults to 10; maximum 50. Values above 50 are rejected with 400. */
+    topK;
+    /** Defaults to `true` when omitted. */
+    enableRerank;
+    /**
+     * Optional session context. Must be a **fully specified four-part scope**
+     * (no `*` wildcards) and must be contained by `scope`. Enables the
+     * session-affinity ranking policy, which populates `rankingScore` /
+     * `rankingSignals` on each hit when the policy is enabled server-side.
+     */
+    contextScope;
+    /**
+     * Minimum relevance in `[0, 1]`. Defaults to `0`, meaning no filtering;
+     * out-of-range values are rejected with 400.
+     *
+     * It filters on `results[].score` - the canonical relevance, which **is
+     * affected by `enableRerank`** (reranker score when on, normalized cosine
+     * similarity when off). It does *not* filter on `results[].similarity`,
+     * which is always the raw cosine similarity.
+     */
+    minSimilarity;
+    /**
+     * Include supporting evidence on each hit. At most 8 evidence entries per
+     * hit, each truncated to 1200 characters.
+     */
+    includeEvidence;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.query = options.query;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+            query: this.query,
+        };
+        assignIfPresent(result, 'scope', toJsonValue(this.scope));
+        assignIfPresent(result, 'contextScope', toJsonValue(this.contextScope));
+        assignIfPresent(result, 'metadata', this.metadata);
+        assignIfPresent(result, 'topK', this.topK);
+        assignIfPresent(result, 'enableRerank', this.enableRerank);
+        assignIfPresent(result, 'minSimilarity', this.minSimilarity);
+        assignIfPresent(result, 'includeEvidence', this.includeEvidence);
+        return result;
+    }
+}
+export class ListMemoriesRequest {
+    memoryStoreName;
+    scope;
+    limit;
+    nextToken;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+    }
+    toJSONRequest() {
+        const result = { memoryStoreName: this.memoryStoreName };
+        assignIfPresent(result, 'scope', toJsonValue(this.scope));
+        assignIfPresent(result, 'limit', this.limit);
+        assignIfPresent(result, 'nextToken', this.nextToken);
+        return result;
+    }
+}
+export class GetMemoryRequest {
+    memoryStoreName;
+    memoryId;
+    scope;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.memoryId = options.memoryId;
+        this.scope = options.scope;
+    }
+    toJSONRequest() {
+        return {
+            memoryStoreName: this.memoryStoreName,
+            memoryId: this.memoryId,
+            scope: toJsonValue(this.scope),
+        };
+    }
+}
+export class UpdateMemoryRequest {
+    memoryStoreName;
+    memoryId;
+    scope;
+    text;
+    metadata;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.memoryId = options.memoryId;
+        this.scope = options.scope;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+            memoryId: this.memoryId,
+            scope: toJsonValue(this.scope),
+        };
+        assignIfPresent(result, 'text', this.text);
+        assignIfPresent(result, 'metadata', this.metadata);
+        return result;
+    }
+}
+export class DeleteMemoryRequest {
+    memoryStoreName;
+    memoryId;
+    scope;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.memoryId = options.memoryId;
+        this.scope = options.scope;
+    }
+    toJSONRequest() {
+        return {
+            memoryStoreName: this.memoryStoreName,
+            memoryId: this.memoryId,
+            scope: toJsonValue(this.scope),
+        };
+    }
+}
+/**
+ * Unlike the dream APIs, the message and request-audit listings accept **both**
+ * Unix-millisecond values (number or numeric string) and RFC3339 timestamps.
+ */
+export class ListMemoryStoreMessagesRequest {
+    memoryStoreName;
+    scope;
+    /** Defaults to 200; maximum 500. */
+    limit;
+    nextToken;
+    /** Unix milliseconds (number or numeric string) or an RFC3339 timestamp. */
+    minTimestamp;
+    /** Unix milliseconds (number or numeric string) or an RFC3339 timestamp. */
+    maxTimestamp;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.scope = options.scope;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+            scope: toJsonValue(this.scope),
+        };
+        assignIfPresent(result, 'limit', this.limit);
+        assignIfPresent(result, 'nextToken', this.nextToken);
+        assignIfPresent(result, 'minTimestamp', this.minTimestamp);
+        assignIfPresent(result, 'maxTimestamp', this.maxTimestamp);
+        return result;
+    }
+}
+/**
+ * Unlike the dream APIs, the message and request-audit listings accept **both**
+ * Unix-millisecond values (number or numeric string) and RFC3339 timestamps.
+ */
+export class ListMemoryStoreRequestsRequest {
+    memoryStoreName;
+    scope;
+    /** Defaults to 50; maximum 100. */
+    limit;
+    nextToken;
+    operation;
+    /** Unix milliseconds (number or numeric string) or an RFC3339 timestamp. */
+    minTimestamp;
+    /** Unix milliseconds (number or numeric string) or an RFC3339 timestamp. */
+    maxTimestamp;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+    }
+    toJSONRequest() {
+        const result = { memoryStoreName: this.memoryStoreName };
+        assignIfPresent(result, 'scope', toJsonValue(this.scope));
+        assignIfPresent(result, 'limit', this.limit);
+        assignIfPresent(result, 'nextToken', this.nextToken);
+        assignIfPresent(result, 'operation', this.operation);
+        assignIfPresent(result, 'minTimestamp', this.minTimestamp);
+        assignIfPresent(result, 'maxTimestamp', this.maxTimestamp);
+        return result;
+    }
+}
+export class GetMemoryTaskRequest {
+    memoryStoreName;
+    requestId;
+    /**
+     * Optional. When omitted no ownership check is performed. When supplied it is
+     * compared against the task's own scope and a mismatch is rejected with 400.
+     * Hierarchical `*` wildcards are allowed.
+     */
+    scope;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.requestId = options.requestId;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+            requestId: this.requestId,
+        };
+        assignIfPresent(result, 'scope', toJsonValue(this.scope));
+        return result;
+    }
+}
+export class ListMemoryTasksRequest {
+    memoryStoreName;
+    /**
+     * **Careful:** this scope is a value, not an optional filter. Any segment you
+     * leave empty is filled in with the literal `__default__`, so an empty scope
+     * means "the `__default__/__default__/__default__/__default__` scope", **not**
+     * "all scopes". Use `*` explicitly to match a whole level.
+     */
+    scope;
+    status;
+    /** Defaults to 50; maximum 100. */
+    limit;
+    nextToken;
+    /** Unix **milliseconds** only (number or numeric string). RFC3339 is rejected. */
+    minTimestamp;
+    /** Unix **milliseconds** only (number or numeric string). RFC3339 is rejected. */
+    maxTimestamp;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.scope = options.scope;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+            scope: toJsonValue(this.scope),
+        };
+        assignIfPresent(result, 'status', this.status);
+        assignIfPresent(result, 'limit', this.limit);
+        assignIfPresent(result, 'nextToken', this.nextToken);
+        assignIfPresent(result, 'minTimestamp', this.minTimestamp);
+        assignIfPresent(result, 'maxTimestamp', this.maxTimestamp);
+        return result;
+    }
+}
+export class ListMemoryStoreScopesRequest {
+    memoryStoreName;
+    scope;
+    limit;
+    nextToken;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.scope = options.scope;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+            scope: toJsonValue(this.scope),
+        };
+        assignIfPresent(result, 'limit', this.limit);
+        assignIfPresent(result, 'nextToken', this.nextToken);
+        return result;
+    }
+}
+export class CreateMemoryDreamTaskRequest {
+    memoryStoreName;
+    /** Required, 1..20 entries. Hierarchical `*` wildcards are allowed. */
+    scopes;
+    /**
+     * Unix **milliseconds** only (number or numeric string). The dream APIs do
+     * **not** accept RFC3339 - unlike `ListMemoryStoreMessages` /
+     * `ListMemoryStoreRequests`. Negative values and `min > max` are rejected
+     * with 400.
+     */
+    minTimestamp;
+    /** Unix **milliseconds** only. See {@link minTimestamp}. */
+    maxTimestamp;
+    /** `0..100`; defaults to 100. */
+    maxSessions;
+    /** `0..20000`; defaults to 5000. */
+    maxMessages;
+    /** `0..5000`; defaults to 1000. */
+    maxMemories;
+    /**
+     * Cap on how many concrete scopes a wildcard in `scopes` may expand to.
+     * `0..1000`; defaults to 200.
+     */
+    expandedScopeLimit;
+    /** Defaults to `preserve_scope`. */
+    scopeOutputMode;
+    /**
+     * Defaults to `proposal`. **Only valid when `taskType` is `memory`** -
+     * sending it with `skill` or `profile` is rejected with 400.
+     */
+    applyMode;
+    /** Defaults to `low`; `plan` implies `high` when omitted. */
+    effort;
+    /** Defaults to `memory`. See {@link DreamTaskType}. */
+    taskType;
+    /** See {@link DreamConfidenceThresholds}; `delete` is rejected with 400. */
+    confidenceThresholds;
+    /** At most **4000 bytes** (UTF-8 byte length, not characters). */
+    instructions;
+    /**
+     * Idempotency key with a **7 day** window: within that window the same token
+     * resolves to the same `dreamId` instead of starting a new run.
+     */
+    clientToken;
+    /**
+     * Resume from the previous successful run's `processedThroughMs` watermark
+     * for the same `(scope, taskType)`. Defaults to `false` (full reprocess) for
+     * manually triggered runs. An explicit `minTimestamp` always wins.
+     */
+    incremental;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.scopes = options.scopes;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+            scopes: this.scopes.map((item) => toJsonValue(item)),
+        };
+        assignIfPresent(result, 'minTimestamp', this.minTimestamp);
+        assignIfPresent(result, 'maxTimestamp', this.maxTimestamp);
+        assignIfPresent(result, 'maxSessions', this.maxSessions);
+        assignIfPresent(result, 'maxMessages', this.maxMessages);
+        assignIfPresent(result, 'maxMemories', this.maxMemories);
+        assignIfPresent(result, 'expandedScopeLimit', this.expandedScopeLimit);
+        assignIfPresent(result, 'scopeOutputMode', this.scopeOutputMode);
+        assignIfPresent(result, 'applyMode', this.applyMode);
+        assignIfPresent(result, 'effort', this.effort);
+        assignIfPresent(result, 'taskType', this.taskType);
+        assignIfPresent(result, 'confidenceThresholds', this.confidenceThresholds);
+        assignIfPresent(result, 'instructions', this.instructions);
+        assignIfPresent(result, 'clientToken', this.clientToken);
+        assignIfPresent(result, 'incremental', this.incremental);
+        return result;
+    }
+}
+export class GetMemoryDreamTaskRequest {
+    memoryStoreName;
+    dreamId;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.dreamId = options.dreamId;
+    }
+    toJSONRequest() {
+        return {
+            memoryStoreName: this.memoryStoreName,
+            dreamId: this.dreamId,
+        };
+    }
+}
+export class ListMemoryDreamTasksRequest {
+    memoryStoreName;
+    scope;
+    status;
+    /** Unix **milliseconds** only (number or numeric string). RFC3339 is rejected. */
+    minTimestamp;
+    /** Unix **milliseconds** only (number or numeric string). RFC3339 is rejected. */
+    maxTimestamp;
+    /** Defaults to 50; maximum 100. */
+    limit;
+    nextToken;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.scope = options.scope;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+            scope: toJsonValue(this.scope),
+        };
+        assignIfPresent(result, 'status', this.status);
+        assignIfPresent(result, 'minTimestamp', this.minTimestamp);
+        assignIfPresent(result, 'maxTimestamp', this.maxTimestamp);
+        assignIfPresent(result, 'limit', this.limit);
+        assignIfPresent(result, 'nextToken', this.nextToken);
+        return result;
+    }
+}
+export class CancelMemoryDreamTaskRequest {
+    memoryStoreName;
+    dreamId;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.dreamId = options.dreamId;
+    }
+    toJSONRequest() {
+        return {
+            memoryStoreName: this.memoryStoreName,
+            dreamId: this.dreamId,
+        };
+    }
+}
+/**
+ * ListMemoryDreamActions has **two mutually exclusive query modes**. Exactly
+ * one of `dreamId` and `scope` must be supplied; sending both, or neither, is
+ * rejected with 400.
+ *
+ * **1. `dreamId` mode** - list the actions of one dream run. All filters
+ * (`status`, `action`, `targetScope`, `sourceMemoryId`, `minConfidence`,
+ * `maxConfidence`, `orderBy`) apply, and the response echoes `dreamId`.
+ *
+ * **2. `scope` + `actionType` mode** - list emitted extracts across dream runs.
+ * `actionType` is required here and may only be `EMIT_SKILL` or `EMIT_PROFILE`.
+ * Caveats:
+ *
+ * - `action`, `targetScope`, `sourceMemoryId`, `minConfidence`, `maxConfidence`
+ *   and `orderBy` are **validated but silently ignored**; ordering is fixed.
+ * - `status`, `limit` and `nextToken` still apply.
+ * - The response **omits the `dreamId` key**.
+ * - `scope` matches each action's `targetScope` and accepts `*` wildcards.
+ *
+ * The fields stay individually optional (rather than a discriminated union) so
+ * that existing `dreamId`-mode callers keep compiling unchanged; the mode is
+ * enforced by the service, not by the type system.
+ */
+export class ListMemoryDreamActionsRequest {
+    memoryStoreName;
+    /** Required in `dreamId` mode; must be omitted in `scope` mode. */
+    dreamId;
+    /** Required in `scope` mode; must be omitted in `dreamId` mode. */
+    scope;
+    /**
+     * Required in `scope` mode and only valid there. Only `EMIT_SKILL` and
+     * `EMIT_PROFILE` are supported; anything else is rejected with 400.
+     */
+    actionType;
+    status;
+    /** Accepts all seven action types. Ignored in `scope` mode. */
+    action;
+    /** Ignored in `scope` mode. */
+    targetScope;
+    /** Ignored in `scope` mode. */
+    sourceMemoryId;
+    /** `0..1` and `<= maxConfidence`. Ignored in `scope` mode. */
+    minConfidence;
+    /** `0..1` and `>= minConfidence`. Ignored in `scope` mode. */
+    maxConfidence;
+    /** Defaults to `created_at_asc`. Ignored in `scope` mode. */
+    orderBy;
+    /** Defaults to 100; maximum 100. */
+    limit;
+    nextToken;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+        };
+        assignIfPresent(result, 'dreamId', this.dreamId);
+        assignIfPresent(result, 'scope', toJsonValue(this.scope));
+        assignIfPresent(result, 'actionType', this.actionType);
+        assignIfPresent(result, 'status', this.status);
+        assignIfPresent(result, 'action', this.action);
+        assignIfPresent(result, 'targetScope', toJsonValue(this.targetScope));
+        assignIfPresent(result, 'sourceMemoryId', this.sourceMemoryId);
+        assignIfPresent(result, 'minConfidence', this.minConfidence);
+        assignIfPresent(result, 'maxConfidence', this.maxConfidence);
+        assignIfPresent(result, 'orderBy', this.orderBy);
+        assignIfPresent(result, 'limit', this.limit);
+        assignIfPresent(result, 'nextToken', this.nextToken);
+        return result;
+    }
+}
+/**
+ * Applies proposed dream actions. `EMIT_SKILL` and `EMIT_PROFILE` actions
+ * cannot be applied: including even one of their IDs rejects the **whole**
+ * request with 400 before any action is applied, so there is no partial write.
+ */
+export class ApplyMemoryDreamActionsRequest {
+    memoryStoreName;
+    dreamId;
+    /** Required and non-empty; at most **100** IDs per call. */
+    actionIds;
+    /**
+     * Free-form audit label recorded on each action actually applied by this
+     * call. The service neither validates nor generates it, and it is not
+     * rewritten on actions that were already applied.
+     */
+    applier;
+    constructor(options) {
+        Object.assign(this, options);
+        this.memoryStoreName = options.memoryStoreName;
+        this.dreamId = options.dreamId;
+        this.actionIds = options.actionIds;
+    }
+    toJSONRequest() {
+        const result = {
+            memoryStoreName: this.memoryStoreName,
+            dreamId: this.dreamId,
+            actionIds: this.actionIds,
+        };
+        assignIfPresent(result, 'applier', this.applier);
+        return result;
+    }
+}