@layerinfinite/sdk 0.1.1

package/README.md

@@ -0,0 +1,121 @@
+# Layerinfinite TypeScript SDK (`@layerinfinite/sdk`)
+
+Layerinfinite is a decision intelligence middleware for AI agents — it records action outcomes, computes composite trust scores, and recommends the highest-performing next action so your agents learn from every decision. Drop it into any TypeScript or JavaScript project with zero runtime dependencies.
+
+## Installation
+
+```bash
+npm install @layerinfinite/sdk
+# or
+yarn add @layerinfinite/sdk
+# or
+pnpm add @layerinfinite/sdk
+```
+
+## Quick Start
+
+```typescript
+import { LayerinfiniteClient } from '@layerinfinite/sdk';
+
+const client = new LayerinfiniteClient({ apiKey: 'layerinfinite_your_key' });
+
+// Ask Layerinfinite which action to take
+const scores = await client.getScores({
+  agentId: 'my-agent',
+  issueType: 'billing_dispute',
+});
+console.log(scores.top_action?.action_name);  // e.g. "escalate_to_senior"
+console.log(`Policy: ${scores.policy}`);      // exploit | explore | escalate
+
+// Log the outcome after the action runs
+await client.logOutcome({
+  agent_id: 'my-agent',
+  action_id: scores.top_action!.action_id,
+  context_id: scores.context_id,
+  issue_type: 'billing_dispute',
+  success: true,
+  outcome_score: 0.9,
+  business_outcome: 'resolved',
+});
+```
+
+## LangChain Integration
+
+```typescript
+import { LayerinfiniteClient } from '@layerinfinite/sdk';
+import { tool } from '@langchain/core/tools';
+
+const layerinfinite = new LayerinfiniteClient({ apiKey: process.env.LAYERINFINITE_API_KEY! });
+
+const resolveTicket = tool(
+  async ({ agentId, issueType }: { agentId: string; issueType: string }) => {
+    const scores = await layerinfinite.getScores({ agentId, issueType });
+    const action = scores.top_action!;
+    // ... run the action ...
+    await layerinfinite.logOutcome({
+      agent_id: agentId, action_id: action.action_id,
+      context_id: scores.context_id, issue_type: issueType,
+      success: true, outcome_score: 0.85, business_outcome: 'resolved',
+    });
+    return action.action_name;
+  },
+  { name: 'resolve_ticket', description: 'Resolve a support ticket guided by Layerinfinite' }
+);
+```
+
+## CrewAI-style Integration
+
+```typescript
+import { LayerinfiniteClient } from '@layerinfinite/sdk';
+
+const layerinfinite = new LayerinfiniteClient({ apiKey: process.env.LAYERINFINITE_API_KEY! });
+
+export async function agentDecide(agentId: string, issue: string) {
+  const { top_action, context_id, policy } = await layerinfinite.getScores({
+    agentId, issueType: issue,
+  });
+  console.log(`[Layerinfinite] Policy: ${policy}, Action: ${top_action?.action_name}`);
+  return { action: top_action, contextId: context_id };
+}
+```
+
+## Error Handling
+
+```typescript
+import {
+  LayerinfiniteClient,
+  LayerinfiniteAuthError,
+  LayerinfiniteRateLimitError,
+  LayerinfiniteServerError,
+} from '@layerinfinite/sdk';
+
+const client = new LayerinfiniteClient({ apiKey: 'layerinfinite_key' });
+
+try {
+  const scores = await client.getScores({ agentId: 'agent-1', issueType: 'billing' });
+} catch (err) {
+  if (err instanceof LayerinfiniteAuthError) {
+    console.error('Invalid API key');
+  } else if (err instanceof LayerinfiniteRateLimitError) {
+    console.error(`Rate limited — retry after ${err.retryAfter}s`);
+    await new Promise(r => setTimeout(r, err.retryAfter * 1000));
+  } else if (err instanceof LayerinfiniteServerError) {
+    console.error(`Server error: ${err.statusCode}`);
+  }
+}
+```
+
+## Configuration
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `apiKey` | required | Your Layerinfinite API key |
+| `baseUrl` | `https://your-app.railway.app` | API base URL |
+| `timeout` | `10000` | Request timeout in ms |
+| `maxRetries` | `3` | Max retries on 429/5xx |
+
+## Links
+
+- **npm**: [@layerinfinite/sdk](https://www.npmjs.com/package/@layerinfinite/sdk)
+- **Docs**: [docs.layerinfinite.ai](https://docs.layerinfinite.ai)
+- **GitHub**: [github.com/hari08varma/Outcome](https://github.com/hari08varma/Outcome)

package/dist/index.d.mts

@@ -0,0 +1,115 @@
+interface ScoredAction {
+    action_id: string;
+    action_name: string;
+    action_category: string;
+    composite_score: number;
+    confidence: number;
+    total_attempts: number;
+    policy_reason?: string;
+    is_cold_start?: boolean;
+    is_low_sample?: boolean;
+}
+interface GetScoresResponse {
+    ranked_actions: ScoredAction[];
+    top_action: ScoredAction | null;
+    policy: 'exploit' | 'explore' | 'escalate';
+    cold_start: boolean;
+    context_id: string;
+    agent_id: string;
+    served_from_cache?: boolean;
+}
+interface LogOutcomeRequest {
+    agent_id: string;
+    action_id: string;
+    context_id: string;
+    issue_type: string;
+    success: boolean;
+    /** Must be between 0.0 and 1.0 */
+    outcome_score: number;
+    business_outcome: 'resolved' | 'failed' | 'pending';
+    episode_id?: string;
+    response_ms?: number;
+    feedback_signal?: 'immediate' | 'delayed' | 'none';
+}
+interface LogOutcomeResponse {
+    logged: boolean;
+    outcome_id: string;
+    agent_trust_score: number;
+    trust_status: string;
+    policy: string;
+}
+interface LayerinfiniteConfig {
+    apiKey: string;
+    /** Default: https://your-app.railway.app */
+    baseUrl?: string;
+    /** Request timeout in ms. Default: 10000 */
+    timeout?: number;
+    /** Max retries on 429/5xx. Default: 3 */
+    maxRetries?: number;
+}
+
+declare class LayerinfiniteClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    constructor(config: LayerinfiniteConfig);
+    private raiseForStatus;
+    private fetchWithRetry;
+    /**
+     * Fetch ranked action scores for the given agent and context.
+     *
+     * @throws {LayerinfiniteAuthError} on 401
+     * @throws {LayerinfiniteRateLimitError} on 429
+     * @throws {LayerinfiniteServerError} on 5xx
+     */
+    getScores(params: {
+        agentId: string;
+        issueType: string;
+        environment?: string;
+    }): Promise<GetScoresResponse>;
+    /**
+     * Log the outcome of an action taken by the agent.
+     *
+     * @throws {LayerinfiniteAuthError} on 401
+     * @throws {LayerinfiniteRateLimitError} on 429
+     * @throws {LayerinfiniteServerError} on 5xx
+     */
+    logOutcome(request: LogOutcomeRequest): Promise<LogOutcomeResponse>;
+    /**
+     * Check API health (no auth required).
+     */
+    health(): Promise<{
+        status: string;
+        version: string;
+    }>;
+}
+
+declare class LayerinfiniteError extends Error {
+    readonly statusCode?: number;
+    readonly responseBody?: unknown;
+    constructor(message: string, statusCode?: number, responseBody?: unknown);
+}
+/** Raised on HTTP 401 — invalid or missing API key. */
+declare class LayerinfiniteAuthError extends LayerinfiniteError {
+    name: string;
+    constructor(message: string, responseBody?: unknown);
+}
+/** Raised on HTTP 429 — rate limit exceeded. */
+declare class LayerinfiniteRateLimitError extends LayerinfiniteError {
+    name: string;
+    readonly retryAfter: number;
+    constructor(message: string, retryAfter: number);
+}
+/** Raised on HTTP 404 — resource not found. */
+declare class LayerinfiniteNotFoundError extends LayerinfiniteError {
+    name: string;
+    constructor(message: string, responseBody?: unknown);
+}
+/** Raised on HTTP 5xx — server-side error. */
+declare class LayerinfiniteServerError extends LayerinfiniteError {
+    name: string;
+    constructor(message: string, statusCode: number, responseBody?: unknown);
+}
+
+export { type GetScoresResponse, LayerinfiniteAuthError, LayerinfiniteClient, type LayerinfiniteConfig, LayerinfiniteError, LayerinfiniteNotFoundError, LayerinfiniteRateLimitError, LayerinfiniteServerError, type LogOutcomeRequest, type LogOutcomeResponse, type ScoredAction };

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+interface ScoredAction {
+    action_id: string;
+    action_name: string;
+    action_category: string;
+    composite_score: number;
+    confidence: number;
+    total_attempts: number;
+    policy_reason?: string;
+    is_cold_start?: boolean;
+    is_low_sample?: boolean;
+}
+interface GetScoresResponse {
+    ranked_actions: ScoredAction[];
+    top_action: ScoredAction | null;
+    policy: 'exploit' | 'explore' | 'escalate';
+    cold_start: boolean;
+    context_id: string;
+    agent_id: string;
+    served_from_cache?: boolean;
+}
+interface LogOutcomeRequest {
+    agent_id: string;
+    action_id: string;
+    context_id: string;
+    issue_type: string;
+    success: boolean;
+    /** Must be between 0.0 and 1.0 */
+    outcome_score: number;
+    business_outcome: 'resolved' | 'failed' | 'pending';
+    episode_id?: string;
+    response_ms?: number;
+    feedback_signal?: 'immediate' | 'delayed' | 'none';
+}
+interface LogOutcomeResponse {
+    logged: boolean;
+    outcome_id: string;
+    agent_trust_score: number;
+    trust_status: string;
+    policy: string;
+}
+interface LayerinfiniteConfig {
+    apiKey: string;
+    /** Default: https://your-app.railway.app */
+    baseUrl?: string;
+    /** Request timeout in ms. Default: 10000 */
+    timeout?: number;
+    /** Max retries on 429/5xx. Default: 3 */
+    maxRetries?: number;
+}
+
+declare class LayerinfiniteClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly maxRetries;
+    constructor(config: LayerinfiniteConfig);
+    private raiseForStatus;
+    private fetchWithRetry;
+    /**
+     * Fetch ranked action scores for the given agent and context.
+     *
+     * @throws {LayerinfiniteAuthError} on 401
+     * @throws {LayerinfiniteRateLimitError} on 429
+     * @throws {LayerinfiniteServerError} on 5xx
+     */
+    getScores(params: {
+        agentId: string;
+        issueType: string;
+        environment?: string;
+    }): Promise<GetScoresResponse>;
+    /**
+     * Log the outcome of an action taken by the agent.
+     *
+     * @throws {LayerinfiniteAuthError} on 401
+     * @throws {LayerinfiniteRateLimitError} on 429
+     * @throws {LayerinfiniteServerError} on 5xx
+     */
+    logOutcome(request: LogOutcomeRequest): Promise<LogOutcomeResponse>;
+    /**
+     * Check API health (no auth required).
+     */
+    health(): Promise<{
+        status: string;
+        version: string;
+    }>;
+}
+
+declare class LayerinfiniteError extends Error {
+    readonly statusCode?: number;
+    readonly responseBody?: unknown;
+    constructor(message: string, statusCode?: number, responseBody?: unknown);
+}
+/** Raised on HTTP 401 — invalid or missing API key. */
+declare class LayerinfiniteAuthError extends LayerinfiniteError {
+    name: string;
+    constructor(message: string, responseBody?: unknown);
+}
+/** Raised on HTTP 429 — rate limit exceeded. */
+declare class LayerinfiniteRateLimitError extends LayerinfiniteError {
+    name: string;
+    readonly retryAfter: number;
+    constructor(message: string, retryAfter: number);
+}
+/** Raised on HTTP 404 — resource not found. */
+declare class LayerinfiniteNotFoundError extends LayerinfiniteError {
+    name: string;
+    constructor(message: string, responseBody?: unknown);
+}
+/** Raised on HTTP 5xx — server-side error. */
+declare class LayerinfiniteServerError extends LayerinfiniteError {
+    name: string;
+    constructor(message: string, statusCode: number, responseBody?: unknown);
+}
+
+export { type GetScoresResponse, LayerinfiniteAuthError, LayerinfiniteClient, type LayerinfiniteConfig, LayerinfiniteError, LayerinfiniteNotFoundError, LayerinfiniteRateLimitError, LayerinfiniteServerError, type LogOutcomeRequest, type LogOutcomeResponse, type ScoredAction };

package/dist/index.js

@@ -0,0 +1,230 @@
+"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, {
+  LayerinfiniteAuthError: () => LayerinfiniteAuthError,
+  LayerinfiniteClient: () => LayerinfiniteClient,
+  LayerinfiniteError: () => LayerinfiniteError,
+  LayerinfiniteNotFoundError: () => LayerinfiniteNotFoundError,
+  LayerinfiniteRateLimitError: () => LayerinfiniteRateLimitError,
+  LayerinfiniteServerError: () => LayerinfiniteServerError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var LayerinfiniteError = class extends Error {
+  constructor(message, statusCode, responseBody) {
+    super(message);
+    this.name = "LayerinfiniteError";
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LayerinfiniteAuthError = class extends LayerinfiniteError {
+  constructor(message, responseBody) {
+    super(message, 401, responseBody);
+    this.name = "LayerinfiniteAuthError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LayerinfiniteRateLimitError = class extends LayerinfiniteError {
+  constructor(message, retryAfter) {
+    super(message, 429);
+    this.name = "LayerinfiniteRateLimitError";
+    this.retryAfter = retryAfter;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LayerinfiniteNotFoundError = class extends LayerinfiniteError {
+  constructor(message, responseBody) {
+    super(message, 404, responseBody);
+    this.name = "LayerinfiniteNotFoundError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LayerinfiniteServerError = class extends LayerinfiniteError {
+  constructor(message, statusCode, responseBody) {
+    super(message, statusCode, responseBody);
+    this.name = "LayerinfiniteServerError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://your-app.railway.app";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_RETRIES = 3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var LayerinfiniteClient = class {
+  constructor(config) {
+    if (!config.apiKey) throw new LayerinfiniteError("apiKey is required");
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+  }
+  // ── Internal: parse and raise typed errors ─────────────────
+  async raiseForStatus(response) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    const code = response.status;
+    if (code === 401) throw new LayerinfiniteAuthError(
+      "Invalid or missing API key. Verify your X-API-Key.",
+      body
+    );
+    if (code === 404) throw new LayerinfiniteNotFoundError("Resource not found.", body);
+    if (code === 429) {
+      const retryAfter = parseInt(response.headers.get("Retry-After") ?? "60", 10);
+      throw new LayerinfiniteRateLimitError(
+        `Rate limit exceeded. Retry after ${retryAfter}s.`,
+        retryAfter
+      );
+    }
+    if (code >= 500) {
+      const msg = body?.error ?? "unknown server error";
+      throw new LayerinfiniteServerError(`Layerinfinite server error [${code}]: ${msg}`, code, body);
+    }
+    throw new LayerinfiniteError(`Request error [${code}]`, code, body);
+  }
+  // ── Internal: fetch with timeout + retry ───────────────────
+  async fetchWithRetry(url, init, isRetryableStatus) {
+    let lastErr;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const response = await fetch(url, { ...init, signal: controller.signal });
+        if (response.status === 429 && attempt < this.maxRetries) {
+          const retryAfter = parseInt(response.headers.get("Retry-After") ?? "60", 10);
+          await sleep(retryAfter * 1e3);
+          continue;
+        }
+        if (response.status >= 500 && attempt < this.maxRetries) {
+          await sleep(1e3 * Math.pow(2, attempt));
+          continue;
+        }
+        if (!response.ok) await this.raiseForStatus(response);
+        return response;
+      } catch (err) {
+        if (err instanceof LayerinfiniteError) throw err;
+        if (err instanceof Error && err.name === "AbortError") {
+          lastErr = new LayerinfiniteError(`Request timed out after ${this.timeout}ms`);
+        } else {
+          lastErr = new LayerinfiniteError(`Network error: ${String(err)}`);
+        }
+        if (attempt >= this.maxRetries) throw lastErr;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw lastErr ?? new LayerinfiniteError("Max retries exceeded");
+  }
+  // ── Public API ──────────────────────────────────────────────
+  /**
+   * Fetch ranked action scores for the given agent and context.
+   *
+   * @throws {LayerinfiniteAuthError} on 401
+   * @throws {LayerinfiniteRateLimitError} on 429
+   * @throws {LayerinfiniteServerError} on 5xx
+   */
+  async getScores(params) {
+    const qs = new URLSearchParams({
+      agent_id: params.agentId,
+      issue_type: params.issueType,
+      environment: params.environment ?? "production"
+    });
+    const url = `${this.baseUrl}/v1/get-scores?${qs.toString()}`;
+    const response = await this.fetchWithRetry(
+      url,
+      {
+        method: "GET",
+        headers: {
+          "X-API-Key": this.apiKey,
+          "Accept": "application/json"
+        }
+      },
+      (code) => code === 429 || code >= 500
+    );
+    const data = await response.json();
+    if (!data.agent_id) data.agent_id = params.agentId;
+    return data;
+  }
+  /**
+   * Log the outcome of an action taken by the agent.
+   *
+   * @throws {LayerinfiniteAuthError} on 401
+   * @throws {LayerinfiniteRateLimitError} on 429
+   * @throws {LayerinfiniteServerError} on 5xx
+   */
+  async logOutcome(request) {
+    const url = `${this.baseUrl}/v1/log-outcome`;
+    const response = await this.fetchWithRetry(
+      url,
+      {
+        method: "POST",
+        headers: {
+          "X-API-Key": this.apiKey,
+          "Content-Type": "application/json",
+          "Accept": "application/json"
+        },
+        body: JSON.stringify(request)
+      },
+      (code) => code === 429 || code >= 500
+    );
+    return response.json();
+  }
+  /**
+   * Check API health (no auth required).
+   */
+  async health() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5e3);
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/health`, {
+        method: "GET",
+        headers: { "Accept": "application/json" },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new LayerinfiniteError(`Health check failed [${response.status}]`);
+      }
+      return response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LayerinfiniteAuthError,
+  LayerinfiniteClient,
+  LayerinfiniteError,
+  LayerinfiniteNotFoundError,
+  LayerinfiniteRateLimitError,
+  LayerinfiniteServerError
+});

package/dist/index.mjs

@@ -0,0 +1,198 @@
+// src/errors.ts
+var LayerinfiniteError = class extends Error {
+  constructor(message, statusCode, responseBody) {
+    super(message);
+    this.name = "LayerinfiniteError";
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LayerinfiniteAuthError = class extends LayerinfiniteError {
+  constructor(message, responseBody) {
+    super(message, 401, responseBody);
+    this.name = "LayerinfiniteAuthError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LayerinfiniteRateLimitError = class extends LayerinfiniteError {
+  constructor(message, retryAfter) {
+    super(message, 429);
+    this.name = "LayerinfiniteRateLimitError";
+    this.retryAfter = retryAfter;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LayerinfiniteNotFoundError = class extends LayerinfiniteError {
+  constructor(message, responseBody) {
+    super(message, 404, responseBody);
+    this.name = "LayerinfiniteNotFoundError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var LayerinfiniteServerError = class extends LayerinfiniteError {
+  constructor(message, statusCode, responseBody) {
+    super(message, statusCode, responseBody);
+    this.name = "LayerinfiniteServerError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://your-app.railway.app";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_RETRIES = 3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var LayerinfiniteClient = class {
+  constructor(config) {
+    if (!config.apiKey) throw new LayerinfiniteError("apiKey is required");
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+  }
+  // ── Internal: parse and raise typed errors ─────────────────
+  async raiseForStatus(response) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = {};
+    }
+    const code = response.status;
+    if (code === 401) throw new LayerinfiniteAuthError(
+      "Invalid or missing API key. Verify your X-API-Key.",
+      body
+    );
+    if (code === 404) throw new LayerinfiniteNotFoundError("Resource not found.", body);
+    if (code === 429) {
+      const retryAfter = parseInt(response.headers.get("Retry-After") ?? "60", 10);
+      throw new LayerinfiniteRateLimitError(
+        `Rate limit exceeded. Retry after ${retryAfter}s.`,
+        retryAfter
+      );
+    }
+    if (code >= 500) {
+      const msg = body?.error ?? "unknown server error";
+      throw new LayerinfiniteServerError(`Layerinfinite server error [${code}]: ${msg}`, code, body);
+    }
+    throw new LayerinfiniteError(`Request error [${code}]`, code, body);
+  }
+  // ── Internal: fetch with timeout + retry ───────────────────
+  async fetchWithRetry(url, init, isRetryableStatus) {
+    let lastErr;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const response = await fetch(url, { ...init, signal: controller.signal });
+        if (response.status === 429 && attempt < this.maxRetries) {
+          const retryAfter = parseInt(response.headers.get("Retry-After") ?? "60", 10);
+          await sleep(retryAfter * 1e3);
+          continue;
+        }
+        if (response.status >= 500 && attempt < this.maxRetries) {
+          await sleep(1e3 * Math.pow(2, attempt));
+          continue;
+        }
+        if (!response.ok) await this.raiseForStatus(response);
+        return response;
+      } catch (err) {
+        if (err instanceof LayerinfiniteError) throw err;
+        if (err instanceof Error && err.name === "AbortError") {
+          lastErr = new LayerinfiniteError(`Request timed out after ${this.timeout}ms`);
+        } else {
+          lastErr = new LayerinfiniteError(`Network error: ${String(err)}`);
+        }
+        if (attempt >= this.maxRetries) throw lastErr;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw lastErr ?? new LayerinfiniteError("Max retries exceeded");
+  }
+  // ── Public API ──────────────────────────────────────────────
+  /**
+   * Fetch ranked action scores for the given agent and context.
+   *
+   * @throws {LayerinfiniteAuthError} on 401
+   * @throws {LayerinfiniteRateLimitError} on 429
+   * @throws {LayerinfiniteServerError} on 5xx
+   */
+  async getScores(params) {
+    const qs = new URLSearchParams({
+      agent_id: params.agentId,
+      issue_type: params.issueType,
+      environment: params.environment ?? "production"
+    });
+    const url = `${this.baseUrl}/v1/get-scores?${qs.toString()}`;
+    const response = await this.fetchWithRetry(
+      url,
+      {
+        method: "GET",
+        headers: {
+          "X-API-Key": this.apiKey,
+          "Accept": "application/json"
+        }
+      },
+      (code) => code === 429 || code >= 500
+    );
+    const data = await response.json();
+    if (!data.agent_id) data.agent_id = params.agentId;
+    return data;
+  }
+  /**
+   * Log the outcome of an action taken by the agent.
+   *
+   * @throws {LayerinfiniteAuthError} on 401
+   * @throws {LayerinfiniteRateLimitError} on 429
+   * @throws {LayerinfiniteServerError} on 5xx
+   */
+  async logOutcome(request) {
+    const url = `${this.baseUrl}/v1/log-outcome`;
+    const response = await this.fetchWithRetry(
+      url,
+      {
+        method: "POST",
+        headers: {
+          "X-API-Key": this.apiKey,
+          "Content-Type": "application/json",
+          "Accept": "application/json"
+        },
+        body: JSON.stringify(request)
+      },
+      (code) => code === 429 || code >= 500
+    );
+    return response.json();
+  }
+  /**
+   * Check API health (no auth required).
+   */
+  async health() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5e3);
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/health`, {
+        method: "GET",
+        headers: { "Accept": "application/json" },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new LayerinfiniteError(`Health check failed [${response.status}]`);
+      }
+      return response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+export {
+  LayerinfiniteAuthError,
+  LayerinfiniteClient,
+  LayerinfiniteError,
+  LayerinfiniteNotFoundError,
+  LayerinfiniteRateLimitError,
+  LayerinfiniteServerError
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@layerinfinite/sdk",
+    "version": "0.1.1",
+    "description": "Decision intelligence layer for AI agents",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.js"
+        }
+    },
+    "scripts": {
+        "build": "tsup src/index.ts --format cjs,esm --dts",
+        "test": "vitest run",
+        "typecheck": "tsc --noEmit",
+        "prepublishOnly": "npm run build && npm run typecheck"
+    },
+    "keywords": [
+        "ai",
+        "agents",
+        "llm",
+        "decision-intelligence",
+        "layerinfinite",
+        "mlops"
+    ],
+    "author": "Layerinfinite",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/hari08varma/Outcome"
+    },
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "dependencies": {},
+    "devDependencies": {
+        "tsup": "^8.0.0",
+        "typescript": "^5.4.0",
+        "vitest": "^1.4.0",
+        "@vitest/coverage-v8": "^1.4.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}