@langinsight/ai-sdk 0.0.1

package/README.md

@@ -0,0 +1,69 @@
+# @langinsight/ai-sdk
+
+LangInsight callback handler for Vercel AI SDK.
+
+## Usage
+
+### generateText
+
+```typescript
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { LangInsight } from "@langinsight/ai-sdk";
+
+const { LANGINSIGHT_ENDPOINT, LANGINSIGHT_API_KEY } = process.env;
+
+const handler = new LangInsight.CallbackHandler({
+  apiKey: LANGINSIGHT_API_KEY,
+  endpoint: LANGINSIGHT_ENDPOINT,
+  metadata: { userId: "admin", sessionId: "admin" },
+});
+
+const prompt = "Hello!";
+
+const result = await generateText({
+  model: openai("gpt-4o"),
+  prompt,
+});
+
+// Report the result to LangInsight
+await handler.report(result, { input: prompt });
+```
+
+### streamText
+
+```typescript
+import { streamText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { LangInsight } from "@langinsight/ai-sdk";
+
+const { LANGINSIGHT_ENDPOINT, LANGINSIGHT_API_KEY } = process.env;
+
+const handler = new LangInsight.CallbackHandler({
+  apiKey: LANGINSIGHT_API_KEY,
+  endpoint: LANGINSIGHT_ENDPOINT,
+  metadata: { userId: "admin", sessionId: "admin" },
+});
+
+const prompt = "Hello!";
+
+const result = streamText({
+  model: openai("gpt-4o"),
+  prompt,
+  // Specify callback handler as onFinish
+  onFinish: handler.onFinish({ input: prompt }),
+});
+
+for await (const chunk of result.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+## Options
+
+- `apiKey`: LangInsight API key (required)
+- `endpoint`: LangInsight API endpoint (required)
+- `metadata`: Metadata to attach to trace information (required)
+  - `userId`: User ID
+  - `sessionId`: Session ID
+  - Any other key-value pairs

package/dist/index.cjs

@@ -0,0 +1,423 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LangInsight: () => LangInsight
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../../node_modules/hono/dist/utils/cookie.js
+var _serialize = (name, value, opt = {}) => {
+  let cookie = `${name}=${value}`;
+  if (name.startsWith("__Secure-") && !opt.secure) {
+    throw new Error("__Secure- Cookie must have Secure attributes");
+  }
+  if (name.startsWith("__Host-")) {
+    if (!opt.secure) {
+      throw new Error("__Host- Cookie must have Secure attributes");
+    }
+    if (opt.path !== "/") {
+      throw new Error('__Host- Cookie must have Path attributes with "/"');
+    }
+    if (opt.domain) {
+      throw new Error("__Host- Cookie must not have Domain attributes");
+    }
+  }
+  if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+    if (opt.maxAge > 3456e4) {
+      throw new Error(
+        "Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration."
+      );
+    }
+    cookie += `; Max-Age=${opt.maxAge | 0}`;
+  }
+  if (opt.domain && opt.prefix !== "host") {
+    cookie += `; Domain=${opt.domain}`;
+  }
+  if (opt.path) {
+    cookie += `; Path=${opt.path}`;
+  }
+  if (opt.expires) {
+    if (opt.expires.getTime() - Date.now() > 3456e7) {
+      throw new Error(
+        "Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future."
+      );
+    }
+    cookie += `; Expires=${opt.expires.toUTCString()}`;
+  }
+  if (opt.httpOnly) {
+    cookie += "; HttpOnly";
+  }
+  if (opt.secure) {
+    cookie += "; Secure";
+  }
+  if (opt.sameSite) {
+    cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+  }
+  if (opt.priority) {
+    cookie += `; Priority=${opt.priority.charAt(0).toUpperCase() + opt.priority.slice(1)}`;
+  }
+  if (opt.partitioned) {
+    if (!opt.secure) {
+      throw new Error("Partitioned Cookie must have Secure attributes");
+    }
+    cookie += "; Partitioned";
+  }
+  return cookie;
+};
+var serialize = (name, value, opt) => {
+  value = encodeURIComponent(value);
+  return _serialize(name, value, opt);
+};
+
+// ../../../node_modules/hono/dist/client/utils.js
+var mergePath = (base, path) => {
+  base = base.replace(/\/+$/, "");
+  base = base + "/";
+  path = path.replace(/^\/+/, "");
+  return base + path;
+};
+var replaceUrlParam = (urlString, params) => {
+  for (const [k, v] of Object.entries(params)) {
+    const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??");
+    urlString = urlString.replace(reg, v ? `/${v}` : "");
+  }
+  return urlString;
+};
+var buildSearchParams = (query) => {
+  const searchParams = new URLSearchParams();
+  for (const [k, v] of Object.entries(query)) {
+    if (v === void 0) {
+      continue;
+    }
+    if (Array.isArray(v)) {
+      for (const v2 of v) {
+        searchParams.append(k, v2);
+      }
+    } else {
+      searchParams.set(k, v);
+    }
+  }
+  return searchParams;
+};
+var replaceUrlProtocol = (urlString, protocol) => {
+  switch (protocol) {
+    case "ws":
+      return urlString.replace(/^http/, "ws");
+    case "http":
+      return urlString.replace(/^ws/, "http");
+  }
+};
+var removeIndexString = (urlString) => {
+  if (/^https?:\/\/[^\/]+?\/index(?=\?|$)/.test(urlString)) {
+    return urlString.replace(/\/index(?=\?|$)/, "/");
+  }
+  return urlString.replace(/\/index(?=\?|$)/, "");
+};
+function isObject(item) {
+  return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+  if (!isObject(target) && !isObject(source)) {
+    return source;
+  }
+  const merged = { ...target };
+  for (const key in source) {
+    const value = source[key];
+    if (isObject(merged[key]) && isObject(value)) {
+      merged[key] = deepMerge(merged[key], value);
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+
+// ../../../node_modules/hono/dist/client/client.js
+var createProxy = (callback, path) => {
+  const proxy = new Proxy(() => {
+  }, {
+    get(_obj, key) {
+      if (typeof key !== "string" || key === "then") {
+        return void 0;
+      }
+      return createProxy(callback, [...path, key]);
+    },
+    apply(_1, _2, args) {
+      return callback({
+        path,
+        args
+      });
+    }
+  });
+  return proxy;
+};
+var ClientRequestImpl = class {
+  url;
+  method;
+  buildSearchParams;
+  queryParams = void 0;
+  pathParams = {};
+  rBody;
+  cType = void 0;
+  constructor(url, method, options) {
+    this.url = url;
+    this.method = method;
+    this.buildSearchParams = options.buildSearchParams;
+  }
+  fetch = async (args, opt) => {
+    if (args) {
+      if (args.query) {
+        this.queryParams = this.buildSearchParams(args.query);
+      }
+      if (args.form) {
+        const form = new FormData();
+        for (const [k, v] of Object.entries(args.form)) {
+          if (Array.isArray(v)) {
+            for (const v2 of v) {
+              form.append(k, v2);
+            }
+          } else {
+            form.append(k, v);
+          }
+        }
+        this.rBody = form;
+      }
+      if (args.json) {
+        this.rBody = JSON.stringify(args.json);
+        this.cType = "application/json";
+      }
+      if (args.param) {
+        this.pathParams = args.param;
+      }
+    }
+    let methodUpperCase = this.method.toUpperCase();
+    const headerValues = {
+      ...args?.header,
+      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers
+    };
+    if (args?.cookie) {
+      const cookies = [];
+      for (const [key, value] of Object.entries(args.cookie)) {
+        cookies.push(serialize(key, value, { path: "/" }));
+      }
+      headerValues["Cookie"] = cookies.join(",");
+    }
+    if (this.cType) {
+      headerValues["Content-Type"] = this.cType;
+    }
+    const headers = new Headers(headerValues ?? void 0);
+    let url = this.url;
+    url = removeIndexString(url);
+    url = replaceUrlParam(url, this.pathParams);
+    if (this.queryParams) {
+      url = url + "?" + this.queryParams.toString();
+    }
+    methodUpperCase = this.method.toUpperCase();
+    const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+    return (opt?.fetch || fetch)(url, {
+      body: setBody ? this.rBody : void 0,
+      method: methodUpperCase,
+      headers,
+      ...opt?.init
+    });
+  };
+};
+var hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
+  const buildSearchParamsOption = options?.buildSearchParams ?? buildSearchParams;
+  const parts = [...opts.path];
+  const lastParts = parts.slice(-3).reverse();
+  if (lastParts[0] === "toString") {
+    if (lastParts[1] === "name") {
+      return lastParts[2] || "";
+    }
+    return proxyCallback.toString();
+  }
+  if (lastParts[0] === "valueOf") {
+    if (lastParts[1] === "name") {
+      return lastParts[2] || "";
+    }
+    return proxyCallback;
+  }
+  let method = "";
+  if (/^\$/.test(lastParts[0])) {
+    const last = parts.pop();
+    if (last) {
+      method = last.replace(/^\$/, "");
+    }
+  }
+  const path = parts.join("/");
+  const url = mergePath(baseUrl, path);
+  if (method === "url") {
+    let result = url;
+    if (opts.args[0]) {
+      if (opts.args[0].param) {
+        result = replaceUrlParam(url, opts.args[0].param);
+      }
+      if (opts.args[0].query) {
+        result = result + "?" + buildSearchParamsOption(opts.args[0].query).toString();
+      }
+    }
+    result = removeIndexString(result);
+    return new URL(result);
+  }
+  if (method === "ws") {
+    const webSocketUrl = replaceUrlProtocol(
+      opts.args[0] && opts.args[0].param ? replaceUrlParam(url, opts.args[0].param) : url,
+      "ws"
+    );
+    const targetUrl = new URL(webSocketUrl);
+    const queryParams = opts.args[0]?.query;
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach((item) => targetUrl.searchParams.append(key, item));
+        } else {
+          targetUrl.searchParams.set(key, value);
+        }
+      });
+    }
+    const establishWebSocket = (...args) => {
+      if (options?.webSocket !== void 0 && typeof options.webSocket === "function") {
+        return options.webSocket(...args);
+      }
+      return new WebSocket(...args);
+    };
+    return establishWebSocket(targetUrl.toString());
+  }
+  const req = new ClientRequestImpl(url, method, {
+    buildSearchParams: buildSearchParamsOption
+  });
+  if (method) {
+    options ??= {};
+    const args = deepMerge(options, { ...opts.args[1] });
+    return req.fetch(opts.args[0], args);
+  }
+  return req;
+}, []);
+
+// src/index.ts
+var LangInsight;
+((LangInsight2) => {
+  class CallbackHandler {
+    constructor(options) {
+      this.options = options;
+      this.client = hc(options.endpoint, { fetch });
+    }
+    client;
+    /**
+     * streamText の onFinish コールバックとして使用
+     *
+     * @example
+     * ```ts
+     * const handler = new LangInsight.CallbackHandler(options);
+     *
+     * const result = streamText({
+     *   model: openai("gpt-4o"),
+     *   prompt: "Hello!",
+     *   onFinish: handler.onFinish({ input: "Hello!" }),
+     * });
+     * ```
+     */
+    onFinish(params) {
+      return async (event) => {
+        await this.sendTraces({
+          input: params.input,
+          result: event
+        });
+      };
+    }
+    /**
+     * generateText の結果を送信
+     *
+     * @example
+     * ```ts
+     * const handler = new LangInsight.CallbackHandler(options);
+     *
+     * const result = await generateText({
+     *   model: openai("gpt-4o"),
+     *   prompt: "Hello!",
+     * });
+     *
+     * await handler.report(result, { input: "Hello!" });
+     * ```
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: should accept any output
+    async report(result, params) {
+      await this.sendTraces({
+        input: params.input,
+        result
+      });
+    }
+    async sendTraces(params) {
+      const { input, result } = params;
+      const { userId, sessionId, ...rest } = this.options.metadata;
+      const model = result.response.modelId ?? "unknown";
+      const startedAt = result.response.timestamp;
+      const endedAt = /* @__PURE__ */ new Date();
+      const inputRes = await this.client.traces.external.$post({
+        header: {
+          "x-api-key": this.options.apiKey
+        },
+        json: {
+          userId,
+          sessionId,
+          model,
+          token: result.usage.inputTokens ?? 0,
+          content: input,
+          type: "input",
+          meta: { ...rest },
+          startedAt: startedAt.toISOString(),
+          endedAt: endedAt.toISOString()
+        }
+      });
+      if (!inputRes.ok) {
+        console.error(await inputRes.text());
+        return;
+      }
+      const outputRes = await this.client.traces.external.$post({
+        header: {
+          "x-api-key": this.options.apiKey
+        },
+        json: {
+          userId,
+          sessionId,
+          model,
+          token: result.usage.outputTokens ?? 0,
+          content: result.text,
+          type: "output",
+          meta: { ...rest },
+          startedAt: startedAt.toISOString(),
+          endedAt: endedAt.toISOString()
+        }
+      });
+      if (!outputRes.ok) {
+        console.error(await outputRes.text());
+        return;
+      }
+    }
+  }
+  LangInsight2.CallbackHandler = CallbackHandler;
+})(LangInsight || (LangInsight = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LangInsight
+});

package/dist/index.d.cts

@@ -0,0 +1,59 @@
+import { StepResult, ToolSet, LanguageModelUsage, GenerateTextResult } from 'ai';
+
+declare namespace LangInsight {
+    interface Options {
+        apiKey: string;
+        endpoint: string;
+        metadata: {
+            userId: string;
+            sessionId: string;
+            [key: string]: any;
+        };
+    }
+    class CallbackHandler {
+        private readonly options;
+        private readonly client;
+        constructor(options: Options);
+        /**
+         * streamText の onFinish コールバックとして使用
+         *
+         * @example
+         * ```ts
+         * const handler = new LangInsight.CallbackHandler(options);
+         *
+         * const result = streamText({
+         *   model: openai("gpt-4o"),
+         *   prompt: "Hello!",
+         *   onFinish: handler.onFinish({ input: "Hello!" }),
+         * });
+         * ```
+         */
+        onFinish(params: {
+            input: string;
+        }): (event: StepResult<ToolSet> & {
+            readonly steps: StepResult<ToolSet>[];
+            readonly totalUsage: LanguageModelUsage;
+        }) => Promise<void>;
+        /**
+         * generateText の結果を送信
+         *
+         * @example
+         * ```ts
+         * const handler = new LangInsight.CallbackHandler(options);
+         *
+         * const result = await generateText({
+         *   model: openai("gpt-4o"),
+         *   prompt: "Hello!",
+         * });
+         *
+         * await handler.report(result, { input: "Hello!" });
+         * ```
+         */
+        report(result: GenerateTextResult<ToolSet, any>, params: {
+            input: string;
+        }): Promise<void>;
+        private sendTraces;
+    }
+}
+
+export { LangInsight };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@langinsight/ai-sdk",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "iZ.Inc",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts --dts --out-dir dist"
+  },
+  "dependencies": {
+    "@hono/client": "^0.0.3"
+  },
+  "peerDependencies": {
+    "ai": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.8",
+    "ai": "^6.0.73",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}