@frost1994/agentic-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,605 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const client = require("./index-DHqclwK8.cjs");
+class AiHttpError extends Error {
+  constructor(code, message, traceId) {
+    super(message);
+    this.name = "AiHttpError";
+    this.code = code;
+    this.traceId = traceId;
+  }
+}
+class AiHttpClient {
+  constructor(baseUrl, headersProvider) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.headersProvider = headersProvider;
+  }
+  async getPluginConfig(systemCode) {
+    const raw = await this.request(
+      "GET",
+      `/plugin/config?systemCode=${encodeURIComponent(systemCode)}`
+    ).catch(() => null);
+    if (!raw) {
+      return null;
+    }
+    return {
+      systemCode: raw.systemCode ?? systemCode,
+      defaultMode: raw.defaultMode ?? "floating",
+      themeStrategy: raw.themeStrategy ?? "system",
+      themePreset: raw.themePreset ?? "light",
+      primaryColor: raw.primaryColor ?? "#409EFF",
+      defaultModelCode: raw.defaultModelCode ?? "default",
+      enableFullscreen: Boolean(raw.enableFullscreen ?? true),
+      enableDrawer: Boolean(raw.enableDrawer ?? true),
+      enableKnowledge: Boolean(raw.enableKnowledge ?? false),
+      enableText2Sql: Boolean(raw.enableText2Sql ?? true),
+      rateLimitPerHour: Number(raw.rateLimitPerHour ?? 100)
+    };
+  }
+  async listModels() {
+    const raw = await this.request("GET", "/models");
+    return raw.map((item) => ({
+      code: item.code ?? item.modelCode ?? "",
+      name: item.name ?? item.modelName ?? "",
+      supportStream: Boolean(item.supportStream ?? true),
+      supportToolCall: Boolean(item.supportToolCall ?? false),
+      bestFor: (item.bestFor ?? []).filter(Boolean),
+      maxTokens: typeof item.maxTokens === "number" ? item.maxTokens : void 0
+    })).filter((item) => item.code && item.name);
+  }
+  async createConversation(systemCode, title, modelCode) {
+    return this.request("POST", "/conversations", {
+      systemCode,
+      title: title ?? "New conversation",
+      modelCode: modelCode ?? "default"
+    });
+  }
+  async listConversations(systemCode, page = 1, size = 20) {
+    return this.request(
+      "GET",
+      `/conversations?systemCode=${encodeURIComponent(systemCode)}&page=${page}&size=${size}`
+    );
+  }
+  async getMessages(conversationId) {
+    return this.request(
+      "GET",
+      `/conversations/${encodeURIComponent(conversationId)}/messages`
+    );
+  }
+  async deleteConversation(conversationId) {
+    await this.request(
+      "DELETE",
+      `/conversations/${encodeURIComponent(conversationId)}`
+    );
+  }
+  async getSuggestions(systemCode, sceneCode) {
+    let path = `/suggestions?systemCode=${encodeURIComponent(systemCode)}`;
+    if (sceneCode) {
+      path += `&sceneCode=${encodeURIComponent(sceneCode)}`;
+    }
+    return this.request("GET", path);
+  }
+  async confirmAction(actionId, confirm) {
+    await this.request("POST", "/actions/confirm", {
+      actionId,
+      confirm
+    });
+  }
+  async listDataSources() {
+    const raw = await this.request("GET", "/data-sources");
+    return raw.map((item) => ({
+      code: item.code ?? item.sourceCode ?? "",
+      name: item.name ?? item.sourceName ?? "",
+      type: item.type ?? item.dbType ?? "",
+      description: item.description
+    })).filter((item) => item.code && item.name);
+  }
+  async listTables(dataSourceCode) {
+    const raw = await this.request(
+      "GET",
+      `/data-sources/${encodeURIComponent(dataSourceCode)}/tables`
+    );
+    return raw.map((item) => ({
+      tableName: item.tableName ?? "",
+      tableComment: item.tableComment ?? item.tableAlias ?? item.description ?? void 0,
+      columns: Array.isArray(item.columns) ? item.columns : void 0
+    })).filter((item) => item.tableName);
+  }
+  async submitFeedback(messageId, rating, comment) {
+    await this.request("POST", "/feedback", {
+      messageId,
+      rating,
+      comment
+    });
+  }
+  async health() {
+    const healthUrl = this.baseUrl.endsWith("/api/ai") ? `${this.baseUrl.slice(0, -"/api/ai".length)}/actuator/health` : `${this.baseUrl}/health`;
+    const res = await fetch(healthUrl, {
+      method: "GET",
+      headers: this.headersProvider()
+    });
+    if (!res.ok) {
+      throw new AiHttpError(res.status, `HTTP ${res.status}: ${res.statusText}`);
+    }
+    const json = await res.json();
+    if ("code" in json) {
+      if (json.code !== 200) {
+        throw new AiHttpError(json.code, json.message ?? "Unknown API error", json.traceId);
+      }
+      return json.data;
+    }
+    return {
+      status: json.status,
+      service: "ai-gateway"
+    };
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.headersProvider()
+    };
+    const init = {
+      method,
+      headers
+    };
+    if (body !== void 0 && (method === "POST" || method === "PUT" || method === "PATCH")) {
+      init.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, init);
+    if (!res.ok) {
+      throw new AiHttpError(res.status, `HTTP ${res.status}: ${res.statusText}`);
+    }
+    if (res.status === 204 || method === "DELETE") {
+      return void 0;
+    }
+    const json = await res.json();
+    if (json.code !== void 0 && json.code !== 200) {
+      throw new AiHttpError(
+        json.code,
+        json.message ?? "Unknown API error",
+        json.traceId
+      );
+    }
+    return json.data;
+  }
+}
+function createInitialState(overrides) {
+  return {
+    visible: false,
+    mode: "floating",
+    previousMode: null,
+    position: { x: 0, y: 0 },
+    size: { width: 420, height: 600 },
+    systemCode: "",
+    modelCode: "",
+    currentConversationId: null,
+    conversations: [],
+    messagesByConversation: {},
+    toolStepsByMessage: {},
+    streamStatus: "idle",
+    lastSeq: 0,
+    lastHeartbeatAt: 0,
+    reconnectAttempt: 0,
+    themeMode: "system",
+    primaryColor: "#1677ff",
+    hasError: false,
+    lastError: null,
+    ...overrides
+  };
+}
+function reducer(state, action) {
+  switch (action.type) {
+    case "OPEN":
+      return {
+        ...state,
+        visible: true,
+        mode: action.mode ?? state.mode
+      };
+    case "CLOSE":
+      return { ...state, visible: false };
+    case "TOGGLE":
+      return { ...state, visible: !state.visible };
+    case "SWITCH_MODE": {
+      return {
+        ...state,
+        previousMode: state.mode,
+        mode: action.mode
+      };
+    }
+    case "SET_POSITION":
+      return {
+        ...state,
+        position: { x: action.x, y: action.y }
+      };
+    case "SET_SIZE":
+      return {
+        ...state,
+        size: { width: action.width, height: action.height }
+      };
+    case "SET_SYSTEM_CODE":
+      return { ...state, systemCode: action.systemCode };
+    case "SET_MODEL_CODE":
+      return { ...state, modelCode: action.modelCode };
+    case "SET_CONVERSATION":
+      return { ...state, currentConversationId: action.id };
+    case "ADD_CONVERSATION": {
+      const next = [action.conversation, ...state.conversations];
+      return { ...state, conversations: next };
+    }
+    case "SET_CONVERSATIONS":
+      return { ...state, conversations: action.conversations };
+    case "APPEND_MESSAGE": {
+      const list = state.messagesByConversation[action.conversationId] ?? [];
+      return {
+        ...state,
+        messagesByConversation: {
+          ...state.messagesByConversation,
+          [action.conversationId]: [...list, action.message]
+        }
+      };
+    }
+    case "APPEND_DELTA": {
+      const list = state.messagesByConversation[action.conversationId];
+      if (!list) return state;
+      const idx = list.findIndex((m) => m.id === action.messageId);
+      if (idx === -1) return state;
+      const next = list.slice();
+      next[idx] = { ...next[idx], content: next[idx].content + action.delta };
+      return {
+        ...state,
+        messagesByConversation: {
+          ...state.messagesByConversation,
+          [action.conversationId]: next
+        }
+      };
+    }
+    case "UPDATE_MESSAGE_STATUS": {
+      const list = state.messagesByConversation[action.conversationId];
+      if (!list) return state;
+      const idx = list.findIndex((m) => m.id === action.messageId);
+      if (idx === -1) return state;
+      const next = list.slice();
+      const msg = next[idx];
+      next[idx] = {
+        ...msg,
+        status: action.status,
+        finishedAt: action.status === "success" || action.status === "failed" ? (/* @__PURE__ */ new Date()).toISOString() : msg.finishedAt
+      };
+      return {
+        ...state,
+        messagesByConversation: {
+          ...state.messagesByConversation,
+          [action.conversationId]: next
+        }
+      };
+    }
+    case "SET_MESSAGES":
+      return {
+        ...state,
+        messagesByConversation: {
+          ...state.messagesByConversation,
+          [action.conversationId]: action.messages
+        }
+      };
+    case "APPEND_TOOL_STEP": {
+      const steps = state.toolStepsByMessage[action.messageId] ?? [];
+      return {
+        ...state,
+        toolStepsByMessage: {
+          ...state.toolStepsByMessage,
+          [action.messageId]: [...steps, action.step]
+        }
+      };
+    }
+    case "UPDATE_TOOL_STEP": {
+      const steps = state.toolStepsByMessage[action.messageId];
+      if (!steps) return state;
+      const idx = steps.findIndex((s) => s.stepId === action.stepId);
+      if (idx === -1) return state;
+      const next = steps.slice();
+      next[idx] = { ...next[idx], ...action.patch };
+      return {
+        ...state,
+        toolStepsByMessage: {
+          ...state.toolStepsByMessage,
+          [action.messageId]: next
+        }
+      };
+    }
+    case "SET_STREAM_STATUS":
+      return { ...state, streamStatus: action.status };
+    case "SET_LAST_SEQ":
+      return { ...state, lastSeq: action.seq };
+    case "SET_HEARTBEAT":
+      return { ...state, lastHeartbeatAt: action.ts };
+    case "INCREMENT_RECONNECT":
+      return { ...state, reconnectAttempt: state.reconnectAttempt + 1 };
+    case "RESET_RECONNECT":
+      return { ...state, reconnectAttempt: 0 };
+    case "SET_THEME":
+      return { ...state, themeMode: action.mode };
+    case "SET_PRIMARY_COLOR":
+      return { ...state, primaryColor: action.color };
+    case "SET_ERROR":
+      return {
+        ...state,
+        hasError: action.error !== null,
+        lastError: action.error
+      };
+    case "HYDRATE":
+      return { ...state, ...action.state };
+    default:
+      return state;
+  }
+}
+const SERIAL_VERSION = 1;
+function serialize(state) {
+  const {
+    streamStatus,
+    lastSeq,
+    lastHeartbeatAt,
+    reconnectAttempt,
+    hasError,
+    lastError,
+    ...persistable
+  } = state;
+  return { version: SERIAL_VERSION, state: persistable };
+}
+function deserialize(data) {
+  if (!data || typeof data !== "object") return null;
+  const parsed = data;
+  if (parsed.version !== SERIAL_VERSION) return null;
+  return createInitialState(parsed.state);
+}
+function serializeToString(state) {
+  return JSON.stringify(serialize(state));
+}
+function deserializeFromString(json) {
+  try {
+    return deserialize(JSON.parse(json));
+  } catch {
+    return null;
+  }
+}
+class ToolRegistry {
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+  }
+  /** Register a tool with its definition and executor. */
+  register(definition, executor) {
+    this.tools.set(definition.name, { definition, executor });
+  }
+  /** Unregister a tool by name. */
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  /** Look up a registered tool. */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /** Check whether a tool is registered. */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /** List all registered tool names. */
+  list() {
+    return Array.from(this.tools.keys());
+  }
+  /** Get all definitions (for sending to LLM). */
+  getDefinitions() {
+    return Array.from(this.tools.values()).map((t) => t.definition);
+  }
+  /** Clear all registrations. */
+  clear() {
+    this.tools.clear();
+  }
+}
+class ToolOrchestrator {
+  constructor(options) {
+    this.registry = options.registry;
+    this.onStepStart = options.onStepStart;
+    this.onStepComplete = options.onStepComplete;
+    this.onStepError = options.onStepError;
+  }
+  /**
+   * Execute a plan of tool steps.
+   *
+   * - `serial`:  steps run one after another; if one fails, abort the rest.
+   * - `parallel`: steps run concurrently; all results collected regardless of individual failures.
+   */
+  async execute(plan) {
+    if (plan.mode === "serial") {
+      return this.executeSerial(plan.steps);
+    }
+    return this.executeParallel(plan.steps);
+  }
+  /** Execute a single tool step. */
+  async executeSingle(toolName, args, title) {
+    var _a, _b, _c, _d;
+    const registered = this.registry.get(toolName);
+    if (!registered) {
+      const step2 = {
+        stepId: client.generateId("step_"),
+        toolName,
+        title: title ?? toolName,
+        status: "error",
+        args,
+        message: `Tool "${toolName}" is not registered`
+      };
+      (_a = this.onStepError) == null ? void 0 : _a.call(this, step2, new Error(step2.message));
+      return step2;
+    }
+    const step = {
+      stepId: client.generateId("step_"),
+      toolName,
+      title: title ?? registered.definition.description ?? toolName,
+      status: "running",
+      args
+    };
+    (_b = this.onStepStart) == null ? void 0 : _b.call(this, step);
+    const startTime = Date.now();
+    try {
+      const result = await registered.executor(args);
+      step.status = "success";
+      step.result = result;
+      step.durationMs = Date.now() - startTime;
+      (_c = this.onStepComplete) == null ? void 0 : _c.call(this, step);
+      return step;
+    } catch (err) {
+      step.status = "error";
+      step.result = err instanceof Error ? err.message : String(err);
+      step.durationMs = Date.now() - startTime;
+      (_d = this.onStepError) == null ? void 0 : _d.call(this, step, err instanceof Error ? err : new Error(String(err)));
+      return step;
+    }
+  }
+  async executeSerial(steps) {
+    const results = [];
+    for (const s of steps) {
+      const result = await this.executeSingle(s.toolName, s.args, s.title);
+      results.push(result);
+      if (result.status === "error") {
+        break;
+      }
+    }
+    return results;
+  }
+  async executeParallel(steps) {
+    return Promise.all(
+      steps.map((s) => this.executeSingle(s.toolName, s.args, s.title))
+    );
+  }
+}
+const _CitationParser = class _CitationParser {
+  /**
+   * Extract all citation markers from a text block.
+   *
+   * @param text — source text containing [1], [2], … markers
+   * @returns ordered list of citations with positions
+   */
+  parse(text) {
+    const citations = [];
+    let match;
+    _CitationParser.MARKER_RE.lastIndex = 0;
+    while ((match = _CitationParser.MARKER_RE.exec(text)) !== null) {
+      citations.push({
+        marker: match[0],
+        index: parseInt(match[1], 10),
+        start: match.index,
+        end: match.index + match[0].length
+      });
+    }
+    return citations;
+  }
+  /**
+   * Strip citation markers from text, returning clean text and a mapping.
+   *
+   * @returns `{ text: string, citations: Citation[] }`
+   */
+  strip(text) {
+    const citations = this.parse(text);
+    if (citations.length === 0) {
+      return { text, citations: [] };
+    }
+    let cleaned = "";
+    let lastEnd = 0;
+    for (const c of citations) {
+      cleaned += text.slice(lastEnd, c.start);
+      lastEnd = c.end;
+    }
+    cleaned += text.slice(lastEnd);
+    return { text: cleaned.trim(), citations };
+  }
+  /**
+   * Replace citation markers with custom formatter output.
+   *
+   * @param text    — source text
+   * @param format  — callback receiving citation index, returns replacement string
+   */
+  replace(text, format) {
+    return text.replace(_CitationParser.MARKER_RE, (_match, num) => format(parseInt(num, 10)));
+  }
+};
+_CitationParser.MARKER_RE = /\[(\d+)\]/g;
+let CitationParser = _CitationParser;
+class ChunkMatcher {
+  /**
+   * Match parsed citations to a list of knowledge chunks.
+   *
+   * @param citations — output from `CitationParser.parse()`
+   * @param chunks    — chunks returned by backend (should be 1-based indexed)
+   * @returns chunks that were cited, with `citedBy` populated
+   */
+  match(citations, chunks) {
+    const citedIndices = new Set(citations.map((c) => c.index));
+    const indexToCitations = /* @__PURE__ */ new Map();
+    for (const c of citations) {
+      const arr = indexToCitations.get(c.index) ?? [];
+      arr.push(c.index);
+      indexToCitations.set(c.index, arr);
+    }
+    const matched = [];
+    for (const chunk of chunks) {
+      if (citedIndices.has(chunk.index)) {
+        matched.push({
+          ...chunk,
+          citedBy: indexToCitations.get(chunk.index) ?? [chunk.index]
+        });
+      }
+    }
+    matched.sort((a, b) => a.index - b.index);
+    return matched;
+  }
+  /**
+   * Build a flat map: citation index → chunk.
+   *
+   * @returns Map where key is citation number and value is the matching chunk
+   */
+  buildIndexMap(chunks) {
+    const map = /* @__PURE__ */ new Map();
+    for (const chunk of chunks) {
+      map.set(chunk.index, chunk);
+    }
+    return map;
+  }
+  /**
+   * Find chunks that are NOT cited in the text (orphans).
+   */
+  findOrphans(citations, chunks) {
+    const cited = new Set(citations.map((c) => c.index));
+    return chunks.filter((c) => !cited.has(c.index));
+  }
+}
+exports.ErrorCodes = client.ErrorCodes;
+exports.SqlGuard = client.SqlGuard;
+exports.SseClient = client.SseClient;
+exports.clamp = client.clamp;
+exports.createError = client.createError;
+exports.debounce = client.debounce;
+exports.deepClone = client.deepClone;
+exports.delay = client.delay;
+exports.formatDate = client.formatDate;
+exports.formatDuration = client.formatDuration;
+exports.generateId = client.generateId;
+exports.isAborted = client.isAborted;
+exports.isArray = client.isArray;
+exports.isFunction = client.isFunction;
+exports.isNumber = client.isNumber;
+exports.isObject = client.isObject;
+exports.isRetriable = client.isRetriable;
+exports.isString = client.isString;
+exports.throttle = client.throttle;
+exports.AiHttpClient = AiHttpClient;
+exports.AiHttpError = AiHttpError;
+exports.ChunkMatcher = ChunkMatcher;
+exports.CitationParser = CitationParser;
+exports.ToolOrchestrator = ToolOrchestrator;
+exports.ToolRegistry = ToolRegistry;
+exports.createInitialState = createInitialState;
+exports.deserialize = deserialize;
+exports.deserializeFromString = deserializeFromString;
+exports.reducer = reducer;
+exports.serialize = serialize;
+exports.serializeToString = serializeToString;
+//# sourceMappingURL=index.cjs.map