@tablestore/tablestore-agent-cli 0.1.8 → 0.2.0

package/dist/dashboard-runtime/dashboard/src/services/instances.ts

@@ -0,0 +1,71 @@
+import type {
+  ConnectInstancePayload,
+  ImportInstancePayload,
+  InstanceActionResult,
+  InstanceDetail,
+  InstanceSummary,
+  UpdateInstancePayload,
+} from "@/types/instance";
+import { apiDelete, apiGet, apiPost, apiPut } from "./api-client";
+
+export interface InstancesOverview {
+  activeInstance: string | null;
+  hasDefault: boolean;
+  instances: InstanceSummary[];
+}
+
+export async function listInstances(): Promise<InstancesOverview> {
+  return apiGet<InstancesOverview>("/api/v1/instances");
+}
+
+export async function getInstance(name: string): Promise<InstanceDetail> {
+  return apiGet<InstanceDetail>(
+    `/api/v1/instances/${encodeURIComponent(name)}`,
+  );
+}
+
+export async function connectInstance(
+  payload: ConnectInstancePayload,
+): Promise<InstanceActionResult> {
+  return apiPost<InstanceActionResult>("/api/v1/instances", payload);
+}
+
+export async function importInstance(
+  payload: ImportInstancePayload,
+): Promise<InstanceActionResult> {
+  return apiPost<InstanceActionResult>("/api/v1/instances", payload);
+}
+
+export async function updateInstance(
+  name: string,
+  payload: UpdateInstancePayload,
+): Promise<InstanceActionResult> {
+  return apiPut<InstanceActionResult>(
+    `/api/v1/instances/${encodeURIComponent(name)}`,
+    payload,
+  );
+}
+
+export async function deleteInstance(
+  name: string,
+): Promise<{ activeInstance: string | null }> {
+  return apiDelete<{ activeInstance: string | null }>(
+    `/api/v1/instances/${encodeURIComponent(name)}`,
+  );
+}
+
+export async function switchInstance(
+  name: string,
+): Promise<{ activeInstance: string }> {
+  return apiPost<{ activeInstance: string }>(
+    `/api/v1/instances/${encodeURIComponent(name)}/use`,
+  );
+}
+
+export async function exportInstanceToken(
+  name: string,
+): Promise<{ token: string; name: string }> {
+  return apiGet<{ token: string; name: string }>(
+    `/api/v1/instances/${encodeURIComponent(name)}/token`,
+  );
+}

package/dist/dashboard-runtime/dashboard/src/services/memory.ts

@@ -0,0 +1,158 @@
+import type { PaginatedData } from "@/types/api";
+import type {
+  AddMemoryRequest,
+  CreateMemoryStoreRequest,
+  DeleteMemoryUnitRequest,
+  MemoryRequestLog,
+  MemoryScope,
+  MemorySearchHit,
+  MemoryStore,
+  MemoryUnit,
+  SearchMemoryRequest,
+  SessionMessage,
+  UpdateMemoryStoreRequest,
+  UpdateMemoryUnitRequest,
+} from "@/types/memory";
+import { apiDelete, apiGet, apiPost, apiPut } from "./api-client";
+
+export type ScopedPaginatedData<T> = PaginatedData<T> & {
+  scope: MemoryScope;
+  memoryStoreName?: string;
+};
+
+function buildScopeQuery(
+  scope: MemoryScope,
+  extra?: Record<string, number | string | undefined>
+): string {
+  const params = new URLSearchParams();
+  params.set("appId", scope.appId);
+  if (scope.tenantId) params.set("tenantId", scope.tenantId);
+  if (scope.agentId) params.set("agentId", scope.agentId);
+  if (scope.runId) params.set("runId", scope.runId);
+
+  Object.entries(extra ?? {}).forEach(([key, value]) => {
+    if (value !== undefined && value !== "") {
+      params.set(key, String(value));
+    }
+  });
+
+  return params.toString();
+}
+
+export async function listMemoryStores(): Promise<PaginatedData<MemoryStore>> {
+  return apiGet<PaginatedData<MemoryStore>>("/api/v1/memory/stores");
+}
+
+export async function describeMemoryStore(
+  memoryStoreName: string
+): Promise<MemoryStore> {
+  return apiGet<MemoryStore>(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}`
+  );
+}
+
+export async function createMemoryStore(
+  request: CreateMemoryStoreRequest
+): Promise<void> {
+  await apiPost<Record<string, never>>("/api/v1/memory/stores", request);
+}
+
+export async function updateMemoryStore(
+  request: UpdateMemoryStoreRequest
+): Promise<void> {
+  const { memoryStoreName, ...body } = request;
+  await apiPut<Record<string, never>>(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}`,
+    body
+  );
+}
+
+export async function deleteMemoryStore(memoryStoreName: string): Promise<void> {
+  await apiDelete<Record<string, never>>(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}`
+  );
+}
+
+export async function listMemoryUnits(
+  memoryStoreName: string,
+  scope: MemoryScope,
+  options?: { limit?: number; nextToken?: string }
+): Promise<ScopedPaginatedData<MemoryUnit>> {
+  const query = buildScopeQuery(scope, options);
+  return apiGet<ScopedPaginatedData<MemoryUnit>>(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/units?${query}`
+  );
+}
+
+export async function addMemory(request: AddMemoryRequest): Promise<unknown> {
+  const { memoryStoreName, ...body } = request;
+  return apiPost(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/units`,
+    body
+  );
+}
+
+export async function getMemoryUnit(
+  request: DeleteMemoryUnitRequest
+): Promise<{ memory: MemoryUnit; memoryStoreName: string }> {
+  const query = buildScopeQuery(request.scope);
+  return apiGet(
+    `/api/v1/memory/stores/${encodeURIComponent(request.memoryStoreName)}/units/${encodeURIComponent(request.memoryId)}?${query}`
+  );
+}
+
+export async function updateMemoryUnit(
+  request: UpdateMemoryUnitRequest
+): Promise<{ memory: MemoryUnit; updated: boolean; memoryStoreName: string }> {
+  const { memoryStoreName, memoryId, ...body } = request;
+  return apiPut(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/units/${encodeURIComponent(memoryId)}`,
+    body
+  );
+}
+
+export async function deleteMemoryUnit(
+  request: DeleteMemoryUnitRequest
+): Promise<void> {
+  const { memoryStoreName, memoryId, ...body } = request;
+  await apiDelete<Record<string, never>>(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/units/${encodeURIComponent(memoryId)}`,
+    body
+  );
+}
+
+export async function searchMemory(
+  request: SearchMemoryRequest
+): Promise<{
+  results: MemorySearchHit[];
+  scope: MemoryScope;
+  memoryStoreName: string;
+}> {
+  const { memoryStoreName, ...body } = request;
+  return apiPost(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/search`,
+    body
+  );
+}
+
+export async function listMemoryMessages(
+  memoryStoreName: string,
+  scope: MemoryScope,
+  options?: { limit?: number; nextToken?: string; minTimestamp?: string; maxTimestamp?: string }
+): Promise<ScopedPaginatedData<SessionMessage>> {
+  const query = buildScopeQuery(scope, options);
+  return apiGet<ScopedPaginatedData<SessionMessage>>(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/messages?${query}`
+  );
+}
+
+export async function listMemoryRequests(
+  memoryStoreName: string,
+  scope: MemoryScope,
+  options?: { limit?: number; nextToken?: string; operation?: string; minTimestamp?: string; maxTimestamp?: string }
+): Promise<ScopedPaginatedData<MemoryRequestLog>> {
+  const query = buildScopeQuery(scope, options);
+  return apiGet<ScopedPaginatedData<MemoryRequestLog>>(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/requests?${query}`
+  );
+}

package/dist/dashboard-runtime/dashboard/src/services/retrieval.ts

@@ -0,0 +1,16 @@
+import type { RetrievalRequest, RetrievalResult } from "@/types/retrieval";
+import { apiPost } from "./api-client";
+
+export interface RetrieveResponse {
+  retrievalResults: RetrievalResult[];
+}
+
+export async function retrieve(
+  request: RetrievalRequest
+): Promise<RetrieveResponse> {
+  const { knowledgeBaseName, ...body } = request;
+  return apiPost<RetrieveResponse>(
+    `/api/v1/knowledge-bases/${encodeURIComponent(knowledgeBaseName)}/retrieve`,
+    body
+  );
+}

package/dist/dashboard-runtime/dashboard/src/services/runtime-context.ts

@@ -0,0 +1,8 @@
+import type { RuntimeContext } from "@/types/runtime-context";
+import { apiGet } from "./api-client";
+
+export async function fetchRuntimeContext(): Promise<RuntimeContext> {
+  return apiGet<RuntimeContext>("/api/v1/runtime/context", {
+    cache: "no-store",
+  });
+}

package/dist/dashboard-runtime/dashboard/src/types/api.ts

@@ -0,0 +1,18 @@
+export interface ApiResponse<T> {
+  code: string;
+  data: T;
+  message: string;
+  requestId?: string;
+}
+
+export interface PaginatedData<T> {
+  items: T[];
+  totalCount: number;
+  nextToken?: string;
+}
+
+export interface ApiError {
+  code: string;
+  message: string;
+  status?: number;
+}

package/dist/dashboard-runtime/dashboard/src/types/instance.ts

@@ -0,0 +1,68 @@
+/**
+ * Shared DTOs for multi-instance management endpoints under
+ * /api/v1/instances/*. Values returned to the browser are either
+ * non-sensitive metadata or masked secrets; raw AK/SK never cross this layer.
+ */
+
+export interface InstanceSummary {
+  name: string;
+  active: boolean;
+  otsInstanceName?: string;
+  region?: string;
+  hasOss: boolean;
+  /**
+   * True when this row represents the legacy top-level [default] section
+   * rather than a named [instances.<name>] entry.
+   */
+  isDefaultFallback?: boolean;
+}
+
+export interface InstanceDetail extends InstanceSummary {
+  otsEndpoint?: string;
+  ossEndpoint?: string;
+  ossBucketName?: string;
+  /** Masked AK (first4****last4), safe for UI display. */
+  accessKeyIdMasked?: string;
+  /** Masked SK (first4****last4), safe for UI display. */
+  accessKeySecretMasked?: string;
+  memoryDefaults?: {
+    storeName?: string;
+    appId?: string;
+    tenantId?: string;
+    agentId?: string;
+    runId?: string;
+  };
+}
+
+export interface ConnectInstancePayload {
+  name: string;
+  accessKeyId: string;
+  accessKeySecret: string;
+  otsEndpoint: string;
+  otsInstanceName: string;
+  ossEndpoint?: string;
+  ossBucketName?: string;
+  region?: string;
+  /** When true, also set this instance as the active one. */
+  activate?: boolean;
+}
+
+/**
+ * Partial patch for an existing instance. The `name` is taken from the URL
+ * path and cannot be renamed here.
+ */
+export type UpdateInstancePayload = Partial<
+  Omit<ConnectInstancePayload, "name">
+>;
+
+export interface ImportInstancePayload {
+  token: string;
+  /** Optional instance name; server picks a default when omitted. */
+  name?: string;
+  activate?: boolean;
+}
+
+export interface InstanceActionResult {
+  activeInstance: string | null;
+  instance: InstanceSummary;
+}

package/dist/dashboard-runtime/dashboard/src/types/llm-chat.ts

@@ -73,6 +73,8 @@ export interface ChatRagKnowledgeBase {
  * `rag` is supplied.
  */
 export interface ChatRequestBody {
+  /** Dashboard project scope at send time. `null` means raw-token/env mode. */
+  activeInstance?: string | null;
   providerId: string;
   model: string;
   messages: Array<{ role: ChatRole; content: string }>;

package/dist/dashboard-runtime/dashboard/src/types/memory.ts

@@ -0,0 +1,106 @@
+export interface MemoryStore {
+  memoryStoreName: string;
+  description?: string;
+  createdAt?: number | string;
+  updatedAt?: number | string;
+  lastSeenAt?: number | string;
+  otsInstance?: string;
+}
+
+export interface MemoryScope {
+  appId: string;
+  tenantId?: string;
+  agentId?: string;
+  runId?: string;
+}
+
+export interface MemoryUnit {
+  id?: string;
+  memoryId?: string;
+  conversation_key?: string;
+  scope?: MemoryScope;
+  memcell_id?: string;
+  unit_type?: string;
+  text: string;
+  search_text?: string;
+  metadata?: Record<string, string>;
+  salience?: number;
+  version?: number;
+  deleted?: boolean;
+  created_at?: string;
+  updated_at?: string;
+  score?: number;
+  createdAt?: number | string;
+  updatedAt?: number | string;
+}
+
+export interface MemorySearchHit {
+  unit: MemoryUnit;
+  score?: number;
+  source?: string;
+}
+
+export interface SessionMessage {
+  messageId?: string;
+  role?: string;
+  speaker?: string;
+  content?: string;
+  timestamp?: string;
+  metadata?: Record<string, string>;
+}
+
+export interface MemoryRequestLog {
+  requestId?: string;
+  operation?: string;
+  scope?: MemoryScope;
+  targetId?: string;
+  responseStatus?: number;
+  latencyMs?: number;
+  createdAt?: string;
+  ingestStatus?: string;
+  lastError?: string;
+  requestSummary?: string;
+  responseSummary?: string;
+}
+
+export interface CreateMemoryStoreRequest {
+  memoryStoreName: string;
+  description?: string;
+}
+
+export interface UpdateMemoryStoreRequest {
+  memoryStoreName: string;
+  description?: string;
+}
+
+export interface AddMemoryRequest {
+  memoryStoreName: string;
+  scope: MemoryScope;
+  text?: string;
+  messages?: SessionMessage[];
+  metadata?: Record<string, string>;
+  sync?: boolean;
+}
+
+export interface UpdateMemoryUnitRequest {
+  memoryStoreName: string;
+  memoryId: string;
+  scope: MemoryScope;
+  text?: string;
+  metadata?: Record<string, string>;
+}
+
+export interface DeleteMemoryUnitRequest {
+  memoryStoreName: string;
+  memoryId: string;
+  scope: MemoryScope;
+}
+
+export interface SearchMemoryRequest {
+  memoryStoreName: string;
+  query: string;
+  scope: MemoryScope;
+  topK?: number;
+  enableRerank?: boolean;
+  metadata?: Record<string, string>;
+}

package/dist/dashboard-runtime/dashboard/src/types/retrieval.ts

@@ -0,0 +1,43 @@
+import type { SearchType } from "./knowledge-base";
+
+export interface RetrievalRequest {
+  knowledgeBaseName: string;
+  subspace?: string[];
+  retrievalQuery: {
+    type: "TEXT";
+    text: string;
+  };
+  retrievalConfiguration?: {
+    searchType?: SearchType[];
+    denseVectorSearchConfiguration?: { numberOfResults: number };
+    fullTextSearchConfiguration?: { numberOfResults: number };
+    rerankingConfiguration?: {
+      type?: string;
+      numberOfResults?: number;
+      rrfConfiguration?: {
+        k?: number;
+        denseVectorSearchWeight?: number;
+        fullTextSearchWeight?: number;
+      };
+      weightConfiguration?: {
+        denseVectorSearchWeight?: number;
+        fullTextSearchWeight?: number;
+      };
+      modelConfiguration?: {
+        provider?: string;
+        model?: string;
+      };
+    };
+    filter?: Record<string, unknown>;
+  };
+}
+
+export interface RetrievalResult {
+  docId: string;
+  chunkId: number;
+  ossKey: string;
+  score: number;
+  content: string;
+  subspace?: string;
+  metadata?: Record<string, unknown>;
+}

package/dist/dashboard-runtime/dashboard/src/types/runtime-context.ts

@@ -0,0 +1,12 @@
+export type RuntimeCredentialSource = "cookie" | "instance" | "env" | null;
+
+export interface RuntimeContext {
+  configured: boolean;
+  credentialSource: RuntimeCredentialSource;
+  activeInstance: string | null;
+  instanceName?: string;
+  region?: string;
+  configRevision: string;
+  dataScopeKey: string;
+  hasAnyInstance: boolean;
+}

package/dist/dashboard-runtime/dashboard/tailwind.config.ts

@@ -0,0 +1,127 @@
+import type { Config } from "tailwindcss";
+import tailwindcssAnimate from "tailwindcss-animate";
+
+const config: Config = {
+  darkMode: ["class", ".dark"],
+  content: [
+    "./src/app/**/*.{ts,tsx}",
+    "./src/components/**/*.{ts,tsx}",
+    "./src/lib/**/*.{ts,tsx}",
+    "./node_modules/streamdown/dist/**/*.js",
+  ],
+  theme: {
+    extend: {
+      fontFamily: {
+        sans: [
+          "-apple-system",
+          "BlinkMacSystemFont",
+          "Segoe UI",
+          "PingFang SC",
+          "Hiragino Sans GB",
+          "Microsoft YaHei",
+          "ui-sans-serif",
+          "system-ui",
+          "sans-serif",
+        ],
+        mono: ["JetBrains Mono", "ui-monospace", "monospace"],
+      },
+      colors: {
+        background: "hsl(var(--background))",
+        foreground: "hsl(var(--foreground))",
+        card: {
+          DEFAULT: "hsl(var(--card))",
+          foreground: "hsl(var(--card-foreground))",
+        },
+        popover: {
+          DEFAULT: "hsl(var(--popover))",
+          foreground: "hsl(var(--popover-foreground))",
+        },
+        primary: {
+          DEFAULT: "hsl(var(--primary))",
+          foreground: "hsl(var(--primary-foreground))",
+          soft: "hsl(var(--primary-soft))",
+          50: "hsl(var(--primary-50))",
+          100: "hsl(var(--primary-100))",
+          200: "hsl(var(--primary-200))",
+          300: "hsl(var(--primary-300))",
+          400: "hsl(var(--primary-400))",
+          500: "hsl(var(--primary-500))",
+          600: "hsl(var(--primary-600))",
+          700: "hsl(var(--primary-700))",
+          800: "hsl(var(--primary-800))",
+          900: "hsl(var(--primary-900))",
+        },
+        secondary: {
+          DEFAULT: "hsl(var(--secondary))",
+          foreground: "hsl(var(--secondary-foreground))",
+        },
+        muted: {
+          DEFAULT: "hsl(var(--muted))",
+          foreground: "hsl(var(--muted-foreground))",
+        },
+        accent: {
+          DEFAULT: "hsl(var(--accent))",
+          foreground: "hsl(var(--accent-foreground))",
+        },
+        destructive: {
+          DEFAULT: "hsl(var(--destructive))",
+          foreground: "hsl(var(--destructive-foreground))",
+        },
+        border: "hsl(var(--border))",
+        "border-light": "hsl(var(--border-light))",
+        input: "hsl(var(--input))",
+        ring: "hsl(var(--ring))",
+        surface: {
+          DEFAULT: "hsl(var(--surface))",
+          secondary: "hsl(var(--surface-secondary))",
+          tertiary: "hsl(var(--surface-tertiary))",
+        },
+        subtle: {
+          DEFAULT: "hsl(var(--subtle))",
+          light: "hsl(var(--subtle-light))",
+          dark: "hsl(var(--subtle-dark))",
+        },
+        sidebar: {
+          bg: "hsl(var(--sidebar-bg))",
+          border: "hsl(var(--sidebar-border))",
+          "active-bg": "hsl(var(--sidebar-active-bg))",
+          "active-fg": "hsl(var(--sidebar-active-fg))",
+          text: "hsl(var(--sidebar-text))",
+        },
+        success: {
+          DEFAULT: "hsl(var(--success))",
+          soft: "hsl(var(--success-soft))",
+        },
+        warning: {
+          DEFAULT: "hsl(var(--warning))",
+          soft: "hsl(var(--warning-soft))",
+        },
+        danger: {
+          DEFAULT: "hsl(var(--danger))",
+          soft: "hsl(var(--danger-soft))",
+        },
+        purple: {
+          DEFAULT: "hsl(var(--purple))",
+          soft: "hsl(var(--purple-soft))",
+        },
+      },
+      borderRadius: {
+        sm: "4px",
+        md: "8px",
+        lg: "12px",
+        xl: "16px",
+        pill: "9999px",
+      },
+      boxShadow: {
+        sm: "0 1px 2px 0 rgb(0 0 0 / 0.05)",
+        md: "0 4px 6px -1px rgb(0 0 0 / 0.07), 0 2px 4px -2px rgb(0 0 0 / 0.05)",
+        lg: "0 10px 15px -3px rgb(0 0 0 / 0.08), 0 4px 6px -4px rgb(0 0 0 / 0.05)",
+        border: "0 0 0 1px rgb(0 0 0 / 0.05)",
+        "primary-soft": "0 4px 12px rgba(37, 99, 235, 0.10)",
+      },
+    },
+  },
+  plugins: [tailwindcssAnimate],
+};
+
+export default config;

package/dist/dashboard-runtime/dashboard/tsconfig.json

@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "out/types/**/*.ts",
+    "out/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}