@kloddy/kloddy-js 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,195 @@
+import React from 'react';
+
+interface KloddyOptions {
+    apiKey?: string;
+    apiSecret?: string;
+    token?: string;
+    personalApiKey?: string;
+    projectApiKey?: string;
+    applicationId?: string;
+    secretKey?: string;
+    host?: string;
+    cacheTtlSeconds?: number;
+    defaultOrgId?: string;
+    defaultFeatureId?: string;
+}
+interface User {
+    id: string;
+    email: string;
+    name: string;
+    [key: string]: any;
+}
+interface Organization {
+    id: string;
+    name: string;
+    [key: string]: any;
+}
+interface Feature {
+    id: string;
+    name: string;
+    org_id: string;
+    [key: string]: any;
+}
+interface PromptListOptions {
+    page?: number;
+    pageSize?: number;
+    name?: string;
+    org_id?: string;
+    feature_id?: string;
+}
+interface PromptOptions {
+    version?: number | string;
+    fallback?: string;
+    cacheTtlSeconds?: number;
+    resolve?: boolean;
+}
+interface PromptTemplate {
+    id: string;
+    name: string;
+    content: string;
+    version: number;
+    variables?: string[];
+    [key: string]: any;
+}
+interface ExecuteOptions {
+    variables?: Record<string, any>;
+    model?: string;
+    version?: string | number;
+    resolve?: boolean;
+}
+interface ExecuteResult {
+    result: string;
+    model: string;
+    version: string | number;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+interface EvaluationOptions {
+    name: string;
+    models?: string[];
+    judge?: string;
+    version?: (string | number)[];
+    variables?: Record<string, any>;
+    evaluate_id?: string;
+    temperature?: number;
+}
+interface EvaluationResult {
+    result: string;
+    winner?: string;
+    answers: {
+        model: string;
+        answer: string;
+        score?: number;
+    }[];
+}
+interface AuthResponse {
+    token: string;
+    expiresAt?: string;
+}
+
+declare class KloddyClient {
+    private apiKey;
+    private apiSecret;
+    private host;
+    defaultOrgId: string | null;
+    defaultFeatureId: string | null;
+    private token;
+    private tokenExpires;
+    constructor(apiKeyOrOptions: string | KloddyOptions, options?: KloddyOptions);
+    login(): Promise<string>;
+    getToken(): Promise<string>;
+    request<T>(path: string, options?: RequestInit): Promise<T>;
+    /**
+     * Get current user information.
+     */
+    whoAmI(): Promise<User>;
+    /**
+     * List organizations for the current user.
+     */
+    listOrganizations(): Promise<Organization[]>;
+    /**
+     * List features, optionally filtered by organization.
+     */
+    listFeatures(orgId?: string): Promise<Feature[]>;
+}
+
+declare class Prompts {
+    private client;
+    constructor(options: {
+        posthog?: KloddyClient;
+    } | KloddyOptions);
+    /**
+     * List prompts with filters.
+     */
+    list(options?: PromptListOptions): Promise<PromptTemplate[]>;
+    /**
+     * Fetch a prompt template.
+     */
+    get(name: string, options?: PromptOptions): Promise<PromptTemplate>;
+    /**
+     * Execute a prompt via the Kloddy API.
+     */
+    execute(name: string, options?: ExecuteOptions): Promise<ExecuteResult>;
+    /**
+     * Play: Direct execution for a single model/version.
+     * Same as execute but follows specific naming/body requirements.
+     */
+    play(name: string, options?: Omit<ExecuteOptions, 'judge' | 'evaluate_id'>): Promise<ExecuteResult>;
+    /**
+     * Update: Download all prompts for the user/organization.
+     */
+    update(options?: PromptListOptions): Promise<PromptTemplate[]>;
+    /**
+     * Local compilation of a template string with variables.
+     */
+    compile(template: string | PromptTemplate, variables: Record<string, any>): string;
+}
+
+declare class Evaluations {
+    private client;
+    constructor(options: {
+        posthog?: KloddyClient;
+    } | KloddyOptions);
+    /**
+     * Run or retrieve an evaluation.
+     */
+    run(options: EvaluationOptions): Promise<EvaluationResult>;
+    /**
+     * Alias for run() as requested.
+     */
+    evaluate(options: EvaluationOptions): Promise<EvaluationResult>;
+    /**
+     * Legacy alias for run(name) as requested in the hook example.
+     */
+    get(name: string, variables?: Record<string, any>): Promise<EvaluationResult>;
+}
+
+interface KloddyProviderProps {
+    children: React.ReactNode;
+    client?: KloddyClient;
+    options?: KloddyOptions;
+    apiKey?: string;
+    token?: string;
+}
+declare const KloddyProvider: React.FC<KloddyProviderProps>;
+declare const usePrompt: () => {
+    getPrompt: (id: string, options?: {}) => Promise<PromptTemplate>;
+    getAwnser: (id: string, options?: {}) => Promise<ExecuteResult>;
+    getEvaluation: (id: string, variables?: {}) => Promise<EvaluationResult>;
+    compile: (template: any, variables: any) => string;
+};
+
+declare class Kloddy {
+    client: KloddyClient;
+    prompts: Prompts;
+    evaluations: Evaluations;
+    constructor(apiKeyOrOptions: string | KloddyOptions, options?: KloddyOptions);
+    whoAmI(): Promise<User>;
+    listOrganizations(): Promise<Organization[]>;
+    listFeatures(orgId?: string): Promise<Feature[]>;
+}
+
+export { type AuthResponse, type EvaluationOptions, type EvaluationResult, Evaluations, type ExecuteOptions, type ExecuteResult, type Feature, Kloddy, KloddyClient, type KloddyOptions, KloddyProvider, type KloddyProviderProps, type Organization, type PromptListOptions, type PromptOptions, type PromptTemplate, Prompts, type User, Kloddy as default, usePrompt };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AAEnC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,qBAAa,MAAM;IACV,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;gBAEpB,eAAe,EAAE,MAAM,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,aAAa;IAMtE,MAAM;IAIN,iBAAiB;IAIjB,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM;CAGlC;AAED,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -0,0 +1,327 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Evaluations: () => Evaluations,
+  Kloddy: () => Kloddy,
+  KloddyClient: () => KloddyClient,
+  KloddyProvider: () => KloddyProvider,
+  Prompts: () => Prompts,
+  default: () => index_default,
+  usePrompt: () => usePrompt
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_cross_fetch = __toESM(require("cross-fetch"));
+var KloddyClient = class {
+  apiKey;
+  apiSecret;
+  host;
+  defaultOrgId = null;
+  defaultFeatureId = null;
+  token = null;
+  tokenExpires = null;
+  constructor(apiKeyOrOptions, options) {
+    if (typeof apiKeyOrOptions === "string") {
+      this.apiKey = apiKeyOrOptions;
+      this.apiSecret = options?.apiSecret || options?.personalApiKey || options?.secretKey || "";
+      this.token = options?.token || null;
+      this.host = options?.host || "https://api.kloddy.com";
+      this.defaultOrgId = options?.defaultOrgId || null;
+      this.defaultFeatureId = options?.defaultFeatureId || null;
+    } else {
+      this.apiKey = apiKeyOrOptions.apiKey || apiKeyOrOptions.projectApiKey || apiKeyOrOptions.applicationId || "";
+      this.apiSecret = apiKeyOrOptions.apiSecret || apiKeyOrOptions.personalApiKey || apiKeyOrOptions.secretKey || "";
+      this.token = apiKeyOrOptions.token || null;
+      this.host = apiKeyOrOptions.host || "https://api.kloddy.com";
+      this.defaultOrgId = apiKeyOrOptions.defaultOrgId || null;
+      this.defaultFeatureId = apiKeyOrOptions.defaultFeatureId || null;
+    }
+    if (!this.token && (!this.apiKey || !this.apiSecret)) {
+      console.warn("KloddyClient: token or credentials missing. API calls will fail.");
+    }
+  }
+  async login() {
+    if (!this.apiKey || !this.apiSecret) {
+      throw new Error("KloddyClient: Cannot login without apiKey and apiSecret.");
+    }
+    const response = await (0, import_cross_fetch.default)(`${this.host}/api/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        applicationId: this.apiKey,
+        secretKey: this.apiSecret
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Kloddy Auth failed: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    this.token = data.token;
+    this.tokenExpires = Date.now() + (data.expiresAt ? new Date(data.expiresAt).getTime() - Date.now() : 36e5);
+    return this.token;
+  }
+  async getToken() {
+    if (this.token && !this.apiSecret) {
+      return this.token;
+    }
+    if (!this.token || this.tokenExpires && Date.now() >= this.tokenExpires - 6e4) {
+      return this.login();
+    }
+    return this.token;
+  }
+  async request(path, options = {}) {
+    const token = await this.getToken();
+    const url = path.startsWith("http") ? path : `${this.host}${path}`;
+    const response = await (0, import_cross_fetch.default)(url, {
+      ...options,
+      headers: {
+        ...options.headers,
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Kloddy API error: ${response.status} ${error}`);
+    }
+    return await response.json();
+  }
+  /**
+   * Get current user information.
+   */
+  async whoAmI() {
+    return this.request("/api/whoiam");
+  }
+  /**
+   * List organizations for the current user.
+   */
+  async listOrganizations() {
+    return this.request("/api/organizations");
+  }
+  /**
+   * List features, optionally filtered by organization.
+   */
+  async listFeatures(orgId) {
+    const path = orgId ? `/api/features?org_id=${orgId}` : "/api/features";
+    return this.request(path);
+  }
+};
+
+// src/prompts.ts
+var Prompts = class {
+  client;
+  constructor(options) {
+    if ("posthog" in options && options.posthog) {
+      this.client = options.posthog;
+    } else {
+      this.client = new KloddyClient(options);
+    }
+  }
+  /**
+   * List prompts with filters.
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.page) params.append("page", options.page.toString());
+    if (options.pageSize) params.append("pageSize", options.pageSize.toString());
+    if (options.name) params.append("name", options.name);
+    const orgId = options.org_id || this.client.defaultOrgId;
+    if (orgId) params.append("org_id", orgId);
+    const featureId = options.feature_id || this.client.defaultFeatureId;
+    if (featureId) params.append("feature_id", featureId);
+    const queryString = params.toString() ? `?${params.toString()}` : "";
+    return this.client.request(`/api/prompts${queryString}`);
+  }
+  /**
+   * Fetch a prompt template.
+   */
+  async get(name, options = {}) {
+    const params = new URLSearchParams();
+    if (options.version) params.append("version", options.version.toString());
+    const resolve = options.resolve !== void 0 ? options.resolve : true;
+    params.append("resolve", resolve.toString());
+    const queryString = params.toString() ? `?${params.toString()}` : "";
+    try {
+      return await this.client.request(`/api/prompt/${name}${queryString}`, {
+        method: "GET"
+      });
+    } catch (error) {
+      if (options.fallback) {
+        return {
+          id: "fallback",
+          name,
+          content: options.fallback,
+          version: 0
+        };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Execute a prompt via the Kloddy API.
+   */
+  async execute(name, options = {}) {
+    return this.client.request(`/api/prompt/${name}`, {
+      method: "POST",
+      body: JSON.stringify({
+        ...options,
+        resolve: options.resolve !== void 0 ? options.resolve : true
+      })
+    });
+  }
+  /**
+   * Play: Direct execution for a single model/version.
+   * Same as execute but follows specific naming/body requirements.
+   */
+  async play(name, options = {}) {
+    return this.client.request("/api/play", {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        ...options,
+        resolve: options.resolve !== void 0 ? options.resolve : true
+      })
+    });
+  }
+  /**
+   * Update: Download all prompts for the user/organization.
+   */
+  async update(options = {}) {
+    return this.list(options);
+  }
+  /**
+   * Local compilation of a template string with variables.
+   */
+  compile(template, variables) {
+    let content = typeof template === "string" ? template : template.content;
+    for (const [key, value] of Object.entries(variables)) {
+      const regex = new RegExp(`{{${key}}}|{${key}}`, "g");
+      content = content.replace(regex, String(value));
+    }
+    return content;
+  }
+};
+
+// src/evaluations.ts
+var Evaluations = class {
+  client;
+  constructor(options) {
+    if ("posthog" in options && options.posthog) {
+      this.client = options.posthog;
+    } else {
+      this.client = new KloddyClient(options);
+    }
+  }
+  /**
+   * Run or retrieve an evaluation.
+   */
+  async run(options) {
+    return this.client.request("/api/evaluate", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /**
+   * Alias for run() as requested.
+   */
+  async evaluate(options) {
+    return this.run(options);
+  }
+  /**
+   * Legacy alias for run(name) as requested in the hook example.
+   */
+  async get(name, variables = {}) {
+    return this.run({ name, variables });
+  }
+};
+
+// src/hooks/use-prompt.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var KloddyContext = (0, import_react.createContext)(null);
+var KloddyProvider = ({ children, client, options, apiKey, token }) => {
+  const value = (0, import_react.useMemo)(() => {
+    const activeClient = client || new KloddyClient({ ...options, apiKey, token });
+    return {
+      prompts: new Prompts({ posthog: activeClient }),
+      evaluations: new Evaluations({ posthog: activeClient })
+    };
+  }, [client, options, token]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(KloddyContext.Provider, { value, children });
+};
+var usePrompt = () => {
+  const context = (0, import_react.useContext)(KloddyContext);
+  if (!context) {
+    throw new Error("usePrompt must be used within a KloddyProvider");
+  }
+  const { prompts, evaluations } = context;
+  return {
+    getPrompt: (id, options = {}) => prompts.get(id, options),
+    getAwnser: (id, options = {}) => prompts.execute(id, options),
+    // Use user's spelling "getAwnser"
+    getEvaluation: (id, variables = {}) => evaluations.get(id, variables),
+    compile: (template, variables) => prompts.compile(template, variables)
+  };
+};
+
+// src/index.ts
+var Kloddy = class {
+  client;
+  prompts;
+  evaluations;
+  constructor(apiKeyOrOptions, options) {
+    this.client = new KloddyClient(apiKeyOrOptions, options);
+    this.prompts = new Prompts({ posthog: this.client });
+    this.evaluations = new Evaluations({ posthog: this.client });
+  }
+  async whoAmI() {
+    return this.client.whoAmI();
+  }
+  async listOrganizations() {
+    return this.client.listOrganizations();
+  }
+  async listFeatures(orgId) {
+    return this.client.listFeatures(orgId);
+  }
+};
+var index_default = Kloddy;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Evaluations,
+  Kloddy,
+  KloddyClient,
+  KloddyProvider,
+  Prompts,
+  usePrompt
+});

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,2CAAyB;AACzB,4CAA0B;AAC1B,gDAA8B;AAC9B,qDAAmC;AAEnC,qCAAwC;AACxC,uCAAoC;AACpC,+CAA4C;AAG5C,MAAa,MAAM;IACV,MAAM,CAAe;IACrB,OAAO,CAAU;IACjB,WAAW,CAAc;IAEhC,YAAY,eAAuC,EAAE,OAAuB;QAC1E,IAAI,CAAC,MAAM,GAAG,IAAI,qBAAY,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,GAAG,IAAI,iBAAO,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QACrD,IAAI,CAAC,WAAW,GAAG,IAAI,yBAAW,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED,KAAK,CAAC,MAAM;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,iBAAiB;QACrB,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,KAAc;QAC/B,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;CACF;AAtBD,wBAsBC;AAED,kBAAe,MAAM,CAAC"}