eric-sdk 0.0.5 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+All notable changes to the Eric SDK are documented here.
+
+This project follows semantic versioning.
+Pre-1.0 releases may introduce intentional breaking changes as the API surface hardens.
+
+---
+
+## [0.1.1] – 2026-01-30
+
+### Changed
+- Removed explicit `flow: "decisionRouter"` from SDK requests.
+
+### Rationale
+The Eric API no longer accepts direct flow invocation.
+All requests are treated as intent submissions and are routed through
+the internal decision router by default.
+
+This change simplifies the SDK payload and prevents accidental coupling
+to internal execution details.
+
+## [0.1.0] – 2026-01-27
+
+### Changed
+- Removed `client.call()` to prevent direct flow invocation.
+- All executions must now be routed through `decide()`.
+
+### Rationale
+Direct flow execution allowed applications to bypass policy enforcement.
+Eric is designed as a governance and control layer; all execution must pass through
+policy evaluation to ensure deterministic, auditable outcomes.
+
+This release intentionally narrows the public API to reflect Eric’s execution model.
+
+---
+
+## [0.0.5] – 2025-12-14
+
+### Added
+- Initial public SDK release.
+- `decide()` with policy-based routing and optional execution bounds.

package/README.md

@@ -1,27 +1,15 @@
-# 📘 Eric SDK (JavaScript + TypeScript)
+# Eric SDK (JavaScript / TypeScript)
 
-**Official SDK for interacting with Eric AI — a governed, deterministic routing layer for AI systems.**
+Official SDK for interacting with **Eric AI**, a policy-governed execution layer for AI systems.
 
-Eric evaluates incoming requests, applies routing constraints, selects the appropriate AI flow, and returns **structured, auditable outputs**.
-Used in **Ingomu**, **EventInterface**, and early enterprise pilots.
+Eric is designed for environments where AI behavior must be **controlled, deterministic, and auditable**.  
+All requests are evaluated against configured policy before any capability is executed.
 
----
-
-## 🚀 Features
-
-* 🔁 **Governed routing** via `eric.decide()`
-* 🧭 Deterministic flow selection using the **decisionRouter**
-* 🎯 Restricted auto-routing with `allowedFlows`
-* 🔧 Direct flow execution with `eric.call()`
-* 🔒 Public vs Private API key security model
-* 🧠 Domain-aware tone and behavior (events, wellness, business)
-* 🛡️ Domain whitelisting + rate limiting (public keys)
-* 🧱 Strong TypeScript typing
-* 🧰 Production-ready SDK backed by Firebase Cloud Functions
+This SDK exposes a single, safe interaction model that enforces those guarantees by default.
 
 ---
 
-## 📦 Installation
+## Installation
 
 ```bash
 npm install eric-sdk
@@ -29,273 +17,109 @@ npm install eric-sdk
 
 ---
 
-## 🔑 API Keys (Important)
-
-Eric supports **two types of API keys**, similar to Stripe or OpenAI.
-
-### 🔓 Public Key (`pub_xxx`)
+## Authentication
 
-Safe for browser usage (Vue, React, etc.)
+You will need an Eric-issued API key.
 
-* Rate-limited
-* Domain-whitelisted
-* Restricted to **safe flows only**
-
-Allowed flows with a public key:
+```ts
+import { EricSDK } from "eric-sdk";
 
-* `decisionRouter`
-* `shortTextSummary`
-* `announcementRewriter`
+const eric = new EricSDK({
+  apiKey: process.env.ERIC_API_KEY!,
+  client: "your-app-id",
+});
+```
 
-Public keys **cannot** execute admin or sensitive flows.
+API keys are scoped and governed server-side.
+Keys should be treated as secrets and stored securely.
 
 ---
 
-### 🔐 Private Key (`priv_xxx`)
-
-Server-to-server only.
+## Security Notice
 
-* Full access to all flows
-* No domain restriction
-* Higher rate limits
-* Intended for trusted backend workloads
+This SDK enforces server-side policy and execution controls.
 
-⚠️ If a private key leaks, anyone can trigger billable flows — **the owning client is billed**.
-This is the same model used by Stripe, OpenAI, Twilio, and AWS.
+API keys must be stored securely and never embedded in public repositories.
 
 ---
 
-## 🔧 Quick Start — Governed Auto-Routing
-
-```ts
-import { EricSDK } from "eric-sdk";
+## Usage
 
-const eric = new EricSDK({
-  apiKey: process.env.ERIC_API_KEY!, // pub_ or priv_
-  client: "eventinterface",
-});
+### Policy-Governed Execution
 
-const result = await eric.decide({
-  text: "I'm overwhelmed today.",
-});
-```
+All interactions with Eric are routed through `decide()`.
 
-### Example response
-
-```json
-{
-  "flow": "dailyNudgeGenerator",
-  "type": "structured",
-  "data": {
-    "nudge": "You're building momentum — take a breath and trust your progress."
-  },
-  "meta": {
-    "routingMode": "llm",
-    "reason": "Detected emotional distress language"
-  }
-}
-```
-
-The `meta` field explains **why** a particular flow was chosen.
-
----
-
-## 🎯 Auto-Routing with Restrictions
+Eric evaluates each request against policy, routing constraints, and execution bounds before selecting and invoking an approved capability.
 
 ```ts
 const result = await eric.decide({
-  text: this.form.body,
-  allowedFlows: ["announcementRewriter"],
-  userState: {
-    tone: "energetic",
-    length: 150,
-  },
+  text: "summarize the provided content",
+  requestType: "summary",
 });
 ```
 
-### Guarantees
-
-* Eric **must** choose `announcementRewriter`
-* No unrelated flows can be selected
-* Predictable, safe behavior for admin tools
-
 ---
 
-## 🔧 Manual Flow Execution (Private Key Only)
+### Optional Execution Bounds
+
+You may optionally restrict which capabilities are eligible for execution.
 
 ```ts
-const result = await eric.call("speakerPerformanceAnalyzer", {
-  speakerName: "Jane Doe",
-  feedbackComments: ["Loved the energy!", "Slides were unclear"],
+await eric.decide({
+  text: "Generate a structured daily summary for the provided input",
+  allowedFlows: ["dailySummary"],
 });
 ```
 
-Use `eric.call()` when:
-
-* You already know the exact flow
-* Running batch jobs or scheduled tasks
-* Executing admin or restricted operations
-* Using private server keys
-
----
-
-## 🧠 When to Use `decide()` vs `call()`
+When bounds are provided:
 
-| Method                          | Use Case                                       |
-| ------------------------------- | ---------------------------------------------- |
-| `eric.decide()`                 | Let Eric select the correct flow automatically |
-| `eric.decide({ allowedFlows })` | Auto-routing restricted to a safe list         |
-| `eric.call()`                   | Direct execution when flow is already known    |
+* Only approved capabilities may execute
+* No out-of-scope behavior is permitted
+* Results remain deterministic and auditable
 
 ---
 
-## 🧱 Full SDK API
-
-### `eric.decide(options)`
-
-```ts
-{
-  text?: string;
-  userState?: Record<string, any>;
-  topic?: string;
-  allowedFlows?: string[];
-}
-```
-
-Returns:
+## Response Shape
 
 ```ts
 {
   flow: string;
-  type: "structured" | "text";
-  data: any;
-  meta?: {
-    routingMode: "direct" | "requestType" | "signature" | "llm" | "forced";
-    reason: string;
-  };
+  type: string;
+  data: unknown;
 }
 ```
 
----
-
-### `eric.call(flow, data)`
+All responses conform to pre-approved output contracts.
 
-Direct execution of a known flow.
+All fields are guaranteed to be present according to the executed capability’s contract.
 
 ---
 
-## 🧩 Supported Flows
-
-### Common
-
-* `decisionRouter`
-* `shortTextSummary`
-* `questionAnswerHelper`
-* `dailyNudgeGenerator`
-
-### Wellness
-
-* `aiCoachFeedback`
-* `personalizedSessionRecommender`
-* `wellnessProgressReporter`
-* `trendInsightReporter`
-
-### Events
+## Design Principles
 
-* `eventSummaryDigest`
-* `speakerPerformanceAnalyzer`
-* `networkingMatchmaker`
-* `attendeeEngagementReporter`
-* `eventPulseReport`
-* `sessionRecapGenerator`
-* `sponsorValueSummary`
-* `announcementRewriter`
-
-### Business
-
-* `leadershipInsight`
-* `feedbackInsightAnalyzer`
-* `performanceReviewAssistant`
-* `teamDynamicsAnalyzer`
-* `productivityCoach`
+* **Policy-first execution** — no direct or bypassed calls
+* **Deterministic behavior** — predictable outputs by design
+* **Auditability** — every decision and execution is logged
+* **Infrastructure-grade** — built for production systems, not chatbots
+* **Intend-base API** — clients describe what they want, not what to run
 
 ---
 
-## 🌐 Public Key Security Model
-
-Eric’s backend enforces:
-
-### ✔ Allowed Flows
-
-Public keys may only call:
+## Versioning
 
-* `decisionRouter`
-* `shortTextSummary`
-* `announcementRewriter`
+The Eric SDK follows semantic versioning.
 
----
-
-### ✔ Domain Whitelisting
+Breaking changes reflect deliberate enforcement of governance and safety guarantees.
 
-Only approved origins can access public keys:
+Pre-1.0 versions were experimental and are not supported.
 
-```json
-[
-  "http://localhost:5173",
-  "https://eventinterface.com",
-  "https://www.eventinterface.com",
-  "https://ingomu.com",
-  "https://www.ingomu.com"
-]
-```
+See `CHANGELOG.md` for details.
 
 ---
 
-### ✔ Rate Limiting
+## Support
 
-* Default: **60 requests per minute per IP**
-* Applies only to public keys
-* Enforced automatically by the backend
-
----
-
-## 🛡️ Private Key Rules
-
-Private keys:
-
-* Must be used server-side only
-* Are not domain-restricted
-* Can execute all flows
-* Should be stored in environment variables
-* Are billed per usage
-
----
-
-## ⚙️ Configuration
-
-```ts
-new EricSDK({
-  apiKey: "pub_xxx" | "priv_xxx",
-  client: "eventinterface",
-  baseUrl: "https://us-central1-eric-ai-prod.cloudfunctions.net/runFlow",
-});
-```
-
-> **Note:**
-> Domain context (events, wellness, business) is derived server-side from the client identity and is not required in the SDK configuration.
-
----
-
-## 🧪 Local Development
-
-```bash
-npm link
-# then in consuming project:
-npm link eric-sdk
-```
-
----
+For access, onboarding, or documentation:
+[https://ericaicontrol.dev](https://ericaicontrol.dev)
 
-## 📄 License
 
-MIT © 2025

package/dist/index.cjs

@@ -63,32 +63,11 @@ var EricSDK = class {
     this.baseUrl = options.baseUrl ?? "https://us-central1-eric-ai-prod.cloudfunctions.net/runFlow";
   }
   /* -------------------------------------------------------------
-   * 1) DIRECT CALL — developer explicitly chooses the flow
+   * DECIDE — policy-governed execution
    * ------------------------------------------------------------- */
-  async call(flowName, data) {
+  async decide(input) {
+    const { allowedFlows, requestType, ...rest } = input;
     const payload = {
-      flow: flowName,
-      data: {
-        ...data,
-        client: this.client
-      }
-    };
-    const res = await import_axios.default.post(this.baseUrl, payload, {
-      headers: {
-        "x-api-key": this.apiKey,
-        "x-api-client": this.client,
-        "Content-Type": "application/json"
-      }
-    });
-    return res.data.output;
-  }
-  /* -------------------------------------------------------------
-   * 2) DECIDE — agentic routing with optional allowedFlows
-   * ------------------------------------------------------------- */
-  async decide(data) {
-    const { allowedFlows, requestType, ...rest } = data;
-    const payload = {
-      flow: "decisionRouter",
       data: {
         ...rest,
         client: this.client,

package/dist/index.d.cts

@@ -8,19 +8,19 @@ interface EricResponse {
     type: string;
     data: any;
 }
+interface DecideInput {
+    text?: string;
+    topic?: string;
+    requestType?: string;
+    userState?: any;
+    allowedFlows?: string[];
+}
 declare class EricSDK {
     private apiKey;
     private client;
     private baseUrl;
     constructor(options: EricClientOptions);
-    call(flowName: string, data: any): Promise<EricResponse>;
-    decide(data: {
-        text?: string;
-        topic?: string;
-        requestType?: string;
-        userState?: any;
-        allowedFlows?: string[];
-    }): Promise<EricResponse>;
+    decide(input: DecideInput): Promise<EricResponse>;
 }
 
 interface ShortTextSummary {
@@ -195,4 +195,4 @@ declare function isPerformanceReview(result: any): result is {
     data: PerformanceReview;
 };
 
-export { type AICoachFeedback, type AnnouncementRewrite, type AttendeeEngagement, type DailyNudge, type EricClientOptions, type EricResponse, EricSDK, type EventPulse, type EventSummaryDigest, type FeedbackInsight, type LeadershipInsight, type NetworkingMatches, type PerformanceReview, type ProductivityInsight, type QAItem, type QuestionAnswerSummary, type RecommendationItem, type SessionRecap, type SessionRecommendation, type ShortTextSummary, type SpeakerPerformance, type SponsorValueSummary, type TeamDynamics, type TrendInsight, type WellnessProgress, isAICoachFeedback, isAnnouncementRewrite, isAttendeeEngagement, isEventPulse, isEventSummary, isFeedbackInsight, isLeadershipInsight, isNetworkingMatches, isNudge, isPerformanceReview, isProductivityInsight, isQA, isRecommendation, isSessionRecap, isSpeakerPerformance, isSponsorSummary, isSummary, isTeamDynamics, isTrendInsight, isWellnessProgress };
+export { type AICoachFeedback, type AnnouncementRewrite, type AttendeeEngagement, type DailyNudge, type DecideInput, type EricClientOptions, type EricResponse, EricSDK, type EventPulse, type EventSummaryDigest, type FeedbackInsight, type LeadershipInsight, type NetworkingMatches, type PerformanceReview, type ProductivityInsight, type QAItem, type QuestionAnswerSummary, type RecommendationItem, type SessionRecap, type SessionRecommendation, type ShortTextSummary, type SpeakerPerformance, type SponsorValueSummary, type TeamDynamics, type TrendInsight, type WellnessProgress, isAICoachFeedback, isAnnouncementRewrite, isAttendeeEngagement, isEventPulse, isEventSummary, isFeedbackInsight, isLeadershipInsight, isNetworkingMatches, isNudge, isPerformanceReview, isProductivityInsight, isQA, isRecommendation, isSessionRecap, isSpeakerPerformance, isSponsorSummary, isSummary, isTeamDynamics, isTrendInsight, isWellnessProgress };

package/dist/index.d.ts

@@ -8,19 +8,19 @@ interface EricResponse {
     type: string;
     data: any;
 }
+interface DecideInput {
+    text?: string;
+    topic?: string;
+    requestType?: string;
+    userState?: any;
+    allowedFlows?: string[];
+}
 declare class EricSDK {
     private apiKey;
     private client;
     private baseUrl;
     constructor(options: EricClientOptions);
-    call(flowName: string, data: any): Promise<EricResponse>;
-    decide(data: {
-        text?: string;
-        topic?: string;
-        requestType?: string;
-        userState?: any;
-        allowedFlows?: string[];
-    }): Promise<EricResponse>;
+    decide(input: DecideInput): Promise<EricResponse>;
 }
 
 interface ShortTextSummary {
@@ -195,4 +195,4 @@ declare function isPerformanceReview(result: any): result is {
     data: PerformanceReview;
 };
 
-export { type AICoachFeedback, type AnnouncementRewrite, type AttendeeEngagement, type DailyNudge, type EricClientOptions, type EricResponse, EricSDK, type EventPulse, type EventSummaryDigest, type FeedbackInsight, type LeadershipInsight, type NetworkingMatches, type PerformanceReview, type ProductivityInsight, type QAItem, type QuestionAnswerSummary, type RecommendationItem, type SessionRecap, type SessionRecommendation, type ShortTextSummary, type SpeakerPerformance, type SponsorValueSummary, type TeamDynamics, type TrendInsight, type WellnessProgress, isAICoachFeedback, isAnnouncementRewrite, isAttendeeEngagement, isEventPulse, isEventSummary, isFeedbackInsight, isLeadershipInsight, isNetworkingMatches, isNudge, isPerformanceReview, isProductivityInsight, isQA, isRecommendation, isSessionRecap, isSpeakerPerformance, isSponsorSummary, isSummary, isTeamDynamics, isTrendInsight, isWellnessProgress };
+export { type AICoachFeedback, type AnnouncementRewrite, type AttendeeEngagement, type DailyNudge, type DecideInput, type EricClientOptions, type EricResponse, EricSDK, type EventPulse, type EventSummaryDigest, type FeedbackInsight, type LeadershipInsight, type NetworkingMatches, type PerformanceReview, type ProductivityInsight, type QAItem, type QuestionAnswerSummary, type RecommendationItem, type SessionRecap, type SessionRecommendation, type ShortTextSummary, type SpeakerPerformance, type SponsorValueSummary, type TeamDynamics, type TrendInsight, type WellnessProgress, isAICoachFeedback, isAnnouncementRewrite, isAttendeeEngagement, isEventPulse, isEventSummary, isFeedbackInsight, isLeadershipInsight, isNetworkingMatches, isNudge, isPerformanceReview, isProductivityInsight, isQA, isRecommendation, isSessionRecap, isSpeakerPerformance, isSponsorSummary, isSummary, isTeamDynamics, isTrendInsight, isWellnessProgress };

package/dist/index.js

@@ -7,32 +7,11 @@ var EricSDK = class {
     this.baseUrl = options.baseUrl ?? "https://us-central1-eric-ai-prod.cloudfunctions.net/runFlow";
   }
   /* -------------------------------------------------------------
-   * 1) DIRECT CALL — developer explicitly chooses the flow
+   * DECIDE — policy-governed execution
    * ------------------------------------------------------------- */
-  async call(flowName, data) {
+  async decide(input) {
+    const { allowedFlows, requestType, ...rest } = input;
     const payload = {
-      flow: flowName,
-      data: {
-        ...data,
-        client: this.client
-      }
-    };
-    const res = await axios.post(this.baseUrl, payload, {
-      headers: {
-        "x-api-key": this.apiKey,
-        "x-api-client": this.client,
-        "Content-Type": "application/json"
-      }
-    });
-    return res.data.output;
-  }
-  /* -------------------------------------------------------------
-   * 2) DECIDE — agentic routing with optional allowedFlows
-   * ------------------------------------------------------------- */
-  async decide(data) {
-    const { allowedFlows, requestType, ...rest } = data;
-    const payload = {
-      flow: "decisionRouter",
       data: {
         ...rest,
         client: this.client,

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "eric-sdk",
-  "version": "0.0.5",
-  "description": "Official SDK for interacting with the Eric AI Policy Engine",
+  "version": "0.1.1",
+  "description": "Official SDK for enforcing policy-governed AI execution using the Eric AI governance layer",
   "author": "Rod Bridges",
   "license": "MIT",
-
   "type": "module",
-
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-
   "exports": {
     ".": {
       "require": "./dist/index.cjs",
@@ -18,20 +15,18 @@
       "types": "./dist/index.d.ts"
     }
   },
-
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",
     "prepare": "npm run build",
     "test": "echo \"No tests yet\""
   },
-
   "dependencies": {
     "axios": "^1.13.2",
     "zod": "^4.1.13"
   },
-
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
-  }
-}
+  },
+  "homepage": "https://ericaicontrol.dev"
+}

package/src/client.ts

@@ -12,6 +12,14 @@ export interface EricResponse {
   data: any;
 }
 
+export interface DecideInput {
+  text?: string;
+  topic?: string;
+  requestType?: string;
+  userState?: any;
+  allowedFlows?: string[];
+}
+
 export class EricSDK {
   private apiKey: string;
   private client: string;
@@ -26,47 +34,17 @@ export class EricSDK {
   }
 
   /* -------------------------------------------------------------
-   * 1) DIRECT CALL — developer explicitly chooses the flow
-   * ------------------------------------------------------------- */
-  async call(flowName: string, data: any): Promise<EricResponse> {
-    const payload = {
-      flow: flowName,
-      data: {
-        ...data,
-        client: this.client,
-      }
-    };
-
-    const res = await axios.post(this.baseUrl, payload, {
-      headers: {
-        "x-api-key": this.apiKey,
-        "x-api-client": this.client,
-        "Content-Type": "application/json",
-      }
-    });
-
-    return res.data.output;
-  }
-
-  /* -------------------------------------------------------------
-   * 2) DECIDE — agentic routing with optional allowedFlows
+   * DECIDE — policy-governed execution
    * ------------------------------------------------------------- */
-  async decide(data: {
-    text?: string;
-    topic?: string;
-    requestType?: string;
-    userState?: any;
-    allowedFlows?: string[];
-  }): Promise<EricResponse> {
-    const { allowedFlows, requestType, ...rest } = data;
+  async decide(input: DecideInput): Promise<EricResponse> {
+    const { allowedFlows, requestType, ...rest } = input;
 
     const payload: any = {
-      flow: "decisionRouter",
       data: {
         ...rest,
         client: this.client,
         text: rest.text ?? "implicit_intent",
-      }
+      },
     };
 
     if (requestType) {
@@ -82,7 +60,7 @@ export class EricSDK {
         "x-api-key": this.apiKey,
         "x-api-client": this.client,
         "Content-Type": "application/json",
-      }
+      },
     });
 
     return res.data.output;