@synapseone/sdk 0.0.0-stage → 0.7.0-dev.41

package/dist/iam.d.ts

@@ -0,0 +1,88 @@
+import { HttpClient } from './_http';
+export declare class IamService {
+    private readonly http;
+    constructor(http: HttpClient);
+    login(email: string, orgSlug?: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+        user: any;
+    }>;
+    refresh(refreshToken: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    logout(refreshToken: string): Promise<unknown>;
+    logoutAll(refreshToken: string): Promise<{
+        ok: boolean;
+        revoked: number;
+    }>;
+    verify(): Promise<unknown>;
+    me(): Promise<unknown>;
+    oidcConfig(): Promise<unknown>;
+    oidcStart(org?: string): Promise<unknown>;
+    oidcCallback(code: string, state: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+        user: any;
+    }>;
+    listOrgs(): Promise<any[]>;
+    createOrg(slug: string, displayName: string): Promise<unknown>;
+    listAccounts(orgId: string): Promise<unknown>;
+    listUsers(orgId: string): Promise<unknown>;
+    createUser(orgId: string, email: string, displayName?: string): Promise<unknown>;
+    createAccount(orgId: string, slug: string, displayName: string): Promise<unknown>;
+    userPolicies(userId: string): Promise<unknown>;
+    createRole(accountId: string, slug: string, description?: string): Promise<unknown>;
+    listRoles(accountId: string): Promise<unknown>;
+    deleteRole(roleId: string): Promise<unknown>;
+    listPolicies(accountId: string): Promise<unknown>;
+    deletePolicy(policyId: string): Promise<unknown>;
+    createPolicy(accountId: string, slug: string, document: any, description?: string): Promise<unknown>;
+    authorize(userId: string, action: string, resource: string, context?: Record<string, unknown>): Promise<{
+        allowed: boolean;
+    }>;
+    attachPolicy(roleId: string, policyId: string): Promise<unknown>;
+    detachPolicy(roleId: string, policyId: string): Promise<unknown>;
+    rolePolicies(roleId: string): Promise<unknown>;
+    assignRole(userId: string, roleId: string): Promise<unknown>;
+    unassignRole(userId: string, roleId: string): Promise<unknown>;
+    userRoles(userId: string): Promise<unknown>;
+    simulate(documents: any[], action: string, resource: string, context?: Record<string, unknown>): Promise<{
+        allowed: boolean;
+    }>;
+    listAudit(limit?: number, actor?: string): Promise<unknown>;
+    createApiKey(accountId: string, name?: string, scopes?: string[]): Promise<{
+        apiKey: string;
+    }>;
+    revokeApiKey(keyId: string): Promise<unknown>;
+    listApiKeys(accountId: string): Promise<unknown>;
+    verifyApiKey(apiKey: string): Promise<unknown>;
+    createServiceAccount(accountId: string, slug: string, description?: string): Promise<unknown>;
+    listServiceAccounts(accountId: string): Promise<unknown>;
+    serviceAccountToken(saId: string, scopes?: string[]): Promise<{
+        accessToken: string;
+    }>;
+    usageSummary(filter?: {
+        from?: string | Date;
+        to?: string | Date;
+        feature?: string;
+        accountId?: string;
+        actor?: string;
+        method?: string;
+        status?: number;
+        statusClass?: string;
+    }): Promise<any>;
+    usageEvents(filter?: {
+        from?: string | Date;
+        to?: string | Date;
+        feature?: string;
+        accountId?: string;
+        actor?: string;
+        method?: string;
+        status?: number;
+        statusClass?: string;
+        q?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<any>;
+}

package/dist/iam.js

@@ -0,0 +1,149 @@
+"use strict";
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * Synapse IAM client: auth/OIDC, orgs/accounts/users, roles/policies,
+ * API keys, service accounts and usage analytics.
+ *
+ * Access it through `new SynapseOneClient(...).iam` or build it with an
+ * HttpClient directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IamService = void 0;
+class IamService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    // ---- auth ----
+    login(email, orgSlug = 'acme') {
+        return this.http.req('/v1/auth/login', {
+            method: 'POST', body: JSON.stringify({ email, orgSlug }),
+        });
+    }
+    refresh(refreshToken) {
+        return this.http.req('/v1/auth/refresh', {
+            method: 'POST', body: JSON.stringify({ refreshToken }),
+        });
+    }
+    logout(refreshToken) {
+        return this.http.req('/v1/auth/logout', { method: 'POST', body: JSON.stringify({ refreshToken }) });
+    }
+    logoutAll(refreshToken) {
+        return this.http.req('/v1/auth/logout-all', { method: 'POST', body: JSON.stringify({ refreshToken }) });
+    }
+    verify() { return this.http.req('/v1/auth/verify'); }
+    me() { return this.http.req('/v1/auth/me'); }
+    oidcConfig() { return this.http.req('/v1/auth/oidc/config'); }
+    oidcStart(org = 'acme') { return this.http.req(`/v1/auth/oidc/start?org=${encodeURIComponent(org)}`); }
+    oidcCallback(code, state) {
+        return this.http.req('/v1/auth/oidc/callback', {
+            method: 'POST', body: JSON.stringify({ code, state }),
+        });
+    }
+    // ---- orgs/accounts/users ----
+    listOrgs() { return this.http.req('/v1/orgs'); }
+    createOrg(slug, displayName) {
+        return this.http.req('/v1/orgs', { method: 'POST', body: JSON.stringify({ slug, displayName }) });
+    }
+    listAccounts(orgId) { return this.http.req(`/v1/orgs/${encodeURIComponent(orgId)}/accounts`); }
+    listUsers(orgId) { return this.http.req(`/v1/orgs/${encodeURIComponent(orgId)}/users`); }
+    createUser(orgId, email, displayName) {
+        return this.http.req(`/v1/orgs/${encodeURIComponent(orgId)}/users`, { method: 'POST', body: JSON.stringify({ email, displayName }) });
+    }
+    createAccount(orgId, slug, displayName) {
+        return this.http.req(`/v1/orgs/${encodeURIComponent(orgId)}/accounts`, { method: 'POST', body: JSON.stringify({ slug, displayName }) });
+    }
+    userPolicies(userId) { return this.http.req(`/v1/users/${encodeURIComponent(userId)}/policies`); }
+    // ---- roles / policies ----
+    createRole(accountId, slug, description = '') {
+        return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/roles`, { method: 'POST', body: JSON.stringify({ slug, description }) });
+    }
+    listRoles(accountId) { return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/roles`); }
+    deleteRole(roleId) { return this.http.req(`/v1/roles/${encodeURIComponent(roleId)}`, { method: 'DELETE' }); }
+    listPolicies(accountId) { return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/policies`); }
+    deletePolicy(policyId) { return this.http.req(`/v1/policies/${encodeURIComponent(policyId)}`, { method: 'DELETE' }); }
+    createPolicy(accountId, slug, document, description = '') {
+        return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/policies`, { method: 'POST', body: JSON.stringify({ slug, document, description }) });
+    }
+    authorize(userId, action, resource, context) {
+        return this.http.req('/v1/authorize', { method: 'POST', body: JSON.stringify({ userId, action, resource, context }) });
+    }
+    attachPolicy(roleId, policyId) {
+        return this.http.req(`/v1/roles/${encodeURIComponent(roleId)}/attach`, { method: 'POST', body: JSON.stringify({ policyId }) });
+    }
+    detachPolicy(roleId, policyId) {
+        return this.http.req(`/v1/roles/${encodeURIComponent(roleId)}/policies/${encodeURIComponent(policyId)}`, { method: 'DELETE' });
+    }
+    rolePolicies(roleId) {
+        return this.http.req(`/v1/roles/${encodeURIComponent(roleId)}/policies`);
+    }
+    assignRole(userId, roleId) {
+        return this.http.req(`/v1/users/${encodeURIComponent(userId)}/assign`, { method: 'POST', body: JSON.stringify({ roleId }) });
+    }
+    unassignRole(userId, roleId) {
+        return this.http.req(`/v1/users/${encodeURIComponent(userId)}/roles/${encodeURIComponent(roleId)}`, { method: 'DELETE' });
+    }
+    userRoles(userId) {
+        return this.http.req(`/v1/users/${encodeURIComponent(userId)}/roles`);
+    }
+    simulate(documents, action, resource, context) {
+        return this.http.req('/v1/authorize/dry-run', { method: 'POST', body: JSON.stringify({ documents, action, resource, context }) });
+    }
+    listAudit(limit = 50, actor) {
+        const qs = `?limit=${limit}${actor ? `&actor=${encodeURIComponent(actor)}` : ''}`;
+        return this.http.req(`/v1/audit${qs}`);
+    }
+    // ---- API keys ----
+    createApiKey(accountId, name = 'default', scopes = ['*']) {
+        return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/keys`, { method: 'POST', body: JSON.stringify({ name, scopes }) });
+    }
+    revokeApiKey(keyId) {
+        return this.http.req(`/v1/keys/${encodeURIComponent(keyId)}`, { method: 'DELETE' });
+    }
+    listApiKeys(accountId) {
+        return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/keys`);
+    }
+    verifyApiKey(apiKey) {
+        return this.http.req(`/v1/keys/verify`, { method: 'POST', body: JSON.stringify({ apiKey }) });
+    }
+    // ---- service accounts ----
+    createServiceAccount(accountId, slug, description = '') {
+        return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/service-accounts`, { method: 'POST', body: JSON.stringify({ slug, description }) });
+    }
+    listServiceAccounts(accountId) { return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/service-accounts`); }
+    // scopes omitted -> the server delegates the caller's own scopes (never
+    // widens to '*'). Pass an explicit list to narrow the minted token.
+    serviceAccountToken(saId, scopes) {
+        return this.http.req(`/v1/service-accounts/${encodeURIComponent(saId)}/token`, {
+            method: 'POST',
+            body: JSON.stringify(scopes === undefined ? {} : { scopes }),
+        });
+    }
+    // ---- usage & telemetry ----
+    usageSummary(filter) {
+        const qs = new URLSearchParams();
+        if (filter) {
+            for (const [k, v] of Object.entries(filter)) {
+                if (v !== undefined && v !== null && String(v) !== '') {
+                    qs.set(k, v instanceof Date ? v.toISOString() : String(v));
+                }
+            }
+        }
+        const s = qs.toString();
+        return this.http.req(`/v1/usage/summary${s ? `?${s}` : ''}`);
+    }
+    usageEvents(filter) {
+        const qs = new URLSearchParams();
+        if (filter) {
+            for (const [k, v] of Object.entries(filter)) {
+                if (v !== undefined && v !== null && String(v) !== '') {
+                    qs.set(k, v instanceof Date ? v.toISOString() : String(v));
+                }
+            }
+        }
+        const s = qs.toString();
+        return this.http.req(`/v1/usage/events${s ? `?${s}` : ''}`);
+    }
+}
+exports.IamService = IamService;

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+import { HttpClient, SynapseOneClientOptions } from './_http';
+import { IamService } from './iam';
+import { WorkflowService } from './workflow';
+import { LdsAttributeInput, LdsDatasourceInput, LdsEntitiesQuery, LdsIngestResult, LdsService } from './lds';
+import { BaseService } from './base';
+import { FaststoreService } from './faststore';
+import { QueueService } from './queue';
+import { StreamService } from './stream';
+import { InferenceService } from './inference';
+import { AiService } from './ai';
+export * from './_http';
+export * from './iam';
+export * from './workflow';
+export * from './ai';
+export * from './lds';
+export * from './base';
+export * from './faststore';
+export * from './queue';
+export * from './stream';
+export * from './inference';
+/** Legacy flat LDS signatures (the namespaced service drops the `lds` prefix). */
+export interface LdsLegacyMethods {
+    ldsLicenses(): Promise<any[]>;
+    ldsDatasources(query?: {
+        orgId?: string;
+        accountId?: string;
+    }): Promise<any[]>;
+    ldsCreateDatasource(input: LdsDatasourceInput): Promise<any>;
+    ldsDatasource(id: string): Promise<any>;
+    ldsUpdateDatasource(id: string, patch: Partial<LdsDatasourceInput>): Promise<any>;
+    ldsDeleteDatasource(id: string): Promise<{
+        ok: boolean;
+    }>;
+    ldsAttributes(id: string): Promise<any[]>;
+    ldsSetAttributes(id: string, attributes: LdsAttributeInput[]): Promise<any[]>;
+    ldsIngest(id: string, records: Record<string, unknown> | Record<string, unknown>[]): Promise<LdsIngestResult>;
+    ldsEntities(id: string, query?: LdsEntitiesQuery): Promise<any[]>;
+    ldsEntity(id: string, entityId: string): Promise<any>;
+    ldsStats(id: string): Promise<any>;
+}
+export declare class SynapseOneClient {
+    readonly http: HttpClient;
+    readonly iam: IamService;
+    readonly workflow: WorkflowService;
+    readonly ai: AiService;
+    readonly lds: LdsService;
+    readonly base: BaseService;
+    readonly faststore: FaststoreService;
+    readonly queue: QueueService;
+    readonly stream: StreamService;
+    readonly inference: InferenceService;
+    constructor(opts: SynapseOneClientOptions);
+    get baseUrl(): string;
+    setToken(t: string): void;
+    setApiKey(k: string): void;
+    setTenant(t: string | undefined): void;
+    /** Generic escape hatch (forward-compat with endpoints added after this SDK). */
+    call(method: string, path: string, body?: unknown): Promise<unknown>;
+}
+export interface SynapseOneClient extends Pick<IamService, keyof IamService>, Pick<WorkflowService, keyof WorkflowService>, LdsLegacyMethods {
+}
+/**
+ * @deprecated Use {@link SynapseOneClient}. Kept for the SynapseDX -> SynapseOne
+ * rebrand window; this is the same class, not a subclass.
+ */
+export { SynapseOneClient as SynapseDXClient };

package/dist/index.js

@@ -0,0 +1,143 @@
+"use strict";
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * synapseone JavaScript SDK — works in Node 18+ and browsers (fetch-based).
+ *
+ * The SDK is split per service:
+ *   client.iam        auth/OIDC, orgs/accounts/users, roles, policies,
+ *                     API keys, service accounts, usage analytics
+ *   client.workflow   templates, workflow CRUD/lifecycle, executions, test runs,
+ *                     credentials, public inbound webhooks
+ *   client.ai         API assistant (natural language -> endpoint + body)
+ *   client.lds        LDS datasources/attributes/records/entities/licenses
+ *   client.base       SynapseBase collections/documents/queries/mapping
+ *   client.faststore  Synapse Faststore cache/KV, collections, locks
+ *   client.queue      SynapseQueue publish/consume/ack, dead letters
+ *   client.inference  LLM proxy, embeddings, decision + semantic routing
+ *
+ * The old flat methods still work but emit a DeprecationWarning pointing at the
+ * namespaced replacement (e.g. `client.listTemplates()` ->
+ * `client.workflow.listTemplates()`).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynapseDXClient = exports.SynapseOneClient = void 0;
+const _http_1 = require("./_http");
+const iam_1 = require("./iam");
+const workflow_1 = require("./workflow");
+const lds_1 = require("./lds");
+const base_1 = require("./base");
+const faststore_1 = require("./faststore");
+const queue_1 = require("./queue");
+const stream_1 = require("./stream");
+const inference_1 = require("./inference");
+const ai_1 = require("./ai");
+__exportStar(require("./_http"), exports);
+__exportStar(require("./iam"), exports);
+__exportStar(require("./workflow"), exports);
+__exportStar(require("./ai"), exports);
+__exportStar(require("./lds"), exports);
+__exportStar(require("./base"), exports);
+__exportStar(require("./faststore"), exports);
+__exportStar(require("./queue"), exports);
+__exportStar(require("./stream"), exports);
+__exportStar(require("./inference"), exports);
+class SynapseOneClient {
+    http;
+    iam;
+    workflow;
+    ai;
+    lds;
+    base;
+    faststore;
+    queue;
+    stream;
+    inference;
+    constructor(opts) {
+        this.http = new _http_1.HttpClient(opts);
+        this.iam = new iam_1.IamService(this.http);
+        this.workflow = new workflow_1.WorkflowService(this.http);
+        this.ai = new ai_1.AiService(this.http);
+        this.lds = new lds_1.LdsService(this.http);
+        this.base = new base_1.BaseService(this.http);
+        this.faststore = new faststore_1.FaststoreService(this.http);
+        this.queue = new queue_1.QueueService(this.http);
+        this.stream = new stream_1.StreamService(this.http);
+        this.inference = new inference_1.InferenceService(this.http);
+    }
+    get baseUrl() { return this.http.baseUrl; }
+    setToken(t) { this.http.setToken(t); }
+    setApiKey(k) { this.http.setApiKey(k); }
+    setTenant(t) { this.http.setTenant(t); }
+    /** Generic escape hatch (forward-compat with endpoints added after this SDK). */
+    call(method, path, body) {
+        return this.http.call(method, path, body);
+    }
+}
+exports.SynapseOneClient = SynapseOneClient;
+exports.SynapseDXClient = SynapseOneClient;
+const IAM_METHODS = [
+    'login', 'refresh', 'logout', 'logoutAll', 'verify', 'me',
+    'oidcConfig', 'oidcStart', 'oidcCallback',
+    'listOrgs', 'createOrg', 'listAccounts', 'listUsers', 'createUser',
+    'createAccount', 'userPolicies',
+    'createRole', 'listRoles', 'deleteRole', 'listPolicies', 'deletePolicy',
+    'createPolicy', 'authorize', 'attachPolicy', 'detachPolicy', 'rolePolicies',
+    'assignRole', 'unassignRole', 'userRoles', 'simulate', 'listAudit',
+    'createApiKey', 'revokeApiKey', 'listApiKeys', 'verifyApiKey',
+    'createServiceAccount', 'listServiceAccounts', 'serviceAccountToken',
+    'usageSummary', 'usageEvents',
+];
+const WORKFLOW_METHODS = [
+    'listTemplates', 'getTemplate',
+    'listWorkflows', 'getWorkflow', 'createWorkflowFromTemplate',
+    'createWorkflow', 'updateWorkflow', 'deleteWorkflow',
+    'activateWorkflow', 'deactivateWorkflow', 'executeWorkflow',
+    'getExecution', 'listExecutions', 'testRun',
+    'createCredential', 'listCredentials', 'getCredential', 'deleteCredential',
+    'rotateCredential', 'triggerWebhook',
+];
+const LDS_METHODS = [
+    ['ldsLicenses', 'licenses'],
+    ['ldsDatasources', 'datasources'],
+    ['ldsCreateDatasource', 'createDatasource'],
+    ['ldsDatasource', 'datasource'],
+    ['ldsUpdateDatasource', 'updateDatasource'],
+    ['ldsDeleteDatasource', 'deleteDatasource'],
+    ['ldsAttributes', 'attributes'],
+    ['ldsSetAttributes', 'setAttributes'],
+    ['ldsIngest', 'ingest'],
+    ['ldsEntities', 'entities'],
+    ['ldsEntity', 'entity'],
+    ['ldsStats', 'stats'],
+];
+function defineLegacy(service, legacy, target) {
+    Object.defineProperty(SynapseOneClient.prototype, legacy, {
+        value: function (...args) {
+            (0, _http_1.warnDeprecated)(`client.${legacy}`, `client.${service}.${target}`);
+            return this[service][target](...args);
+        },
+        configurable: true,
+        writable: true,
+    });
+}
+for (const name of IAM_METHODS)
+    defineLegacy('iam', name, name);
+for (const name of WORKFLOW_METHODS)
+    defineLegacy('workflow', name, name);
+for (const [legacy, target] of LDS_METHODS)
+    defineLegacy('lds', legacy, target);

package/dist/inference.d.ts

@@ -0,0 +1,110 @@
+import { HttpClient } from './_http';
+export interface InferenceHealthResponse {
+    status: string;
+    service: string;
+    version: string;
+    models: {
+        llm: string;
+        embedding: string;
+        decision: string;
+    };
+    components: {
+        llm: {
+            provider: string;
+            configured: boolean;
+            base_url?: string;
+        };
+        embedding: {
+            model: string;
+            dimension: number;
+            loaded: boolean;
+            device: string;
+            mock_mode: boolean;
+            error?: string | null;
+        };
+        decision: {
+            model: string;
+            architecture: string;
+            loaded: boolean;
+            device: string;
+            mock_mode: boolean;
+            error?: string | null;
+        };
+    };
+    time: string;
+}
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | string;
+    content: string;
+    name?: string;
+}
+export interface ChatCompletionOptions {
+    model?: string;
+    temperature?: number;
+    max_tokens?: number;
+    stream?: boolean;
+    top_p?: number;
+}
+export interface ChatCompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: ChatMessage;
+        finish_reason: string;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export interface EmbeddingItem {
+    object: 'embedding';
+    index: number;
+    embedding: number[];
+}
+export interface EmbeddingResponse {
+    object: 'list';
+    data: EmbeddingItem[];
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+}
+export interface DecisionQuestion {
+    type: 'choice' | 'noul' | 'score' | string;
+    instructions: string;
+    criteria?: Record<string, string>;
+}
+export interface DecisionResponse {
+    model: string;
+    results: Record<string, any>;
+    duration_ms: number;
+}
+export interface RouteResponse {
+    best_choice: string;
+    confidence: number;
+    probabilities: Record<string, number>;
+    model: string;
+    duration_ms: number;
+}
+export declare class InferenceService {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Check health and status of inference subsystems (LLM, embedding, decision). */
+    health(): Promise<InferenceHealthResponse>;
+    /** Run chat completions through the OpenRouter-backed LLM proxy. */
+    chat(messages: ChatMessage[], opts?: ChatCompletionOptions): Promise<ChatCompletionResponse>;
+    /** Generate text embeddings using the self-hosted lightweight model. */
+    embeddings(input: string | string[], opts?: {
+        model?: string;
+    }): Promise<EmbeddingResponse>;
+    /** Run structured question evaluation via Decision-2.0-Eos-0.8B (system_one). */
+    decision(state: string, questions: Record<string, DecisionQuestion>): Promise<DecisionResponse>;
+    /** Semantic route an input text between candidate choices for workflow branching. */
+    route(input: string, choices: Record<string, string>, instruction?: string): Promise<RouteResponse>;
+}

package/dist/inference.js

@@ -0,0 +1,62 @@
+"use strict";
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * Synapse Inference Engine client: OpenRouter LLM proxy, self-hosted lightweight
+ * embeddings, and self-hosted Decision-2.0-Eos-0.8B structured routing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InferenceService = void 0;
+const P = '/v1/inference';
+class InferenceService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Check health and status of inference subsystems (LLM, embedding, decision). */
+    health() {
+        return this.http.req(`${P}/health`);
+    }
+    /** Run chat completions through the OpenRouter-backed LLM proxy. */
+    chat(messages, opts = {}) {
+        return this.http.req(`${P}/chat/completions`, {
+            method: 'POST',
+            body: JSON.stringify({
+                messages,
+                ...opts,
+            }),
+        });
+    }
+    /** Generate text embeddings using the self-hosted lightweight model. */
+    embeddings(input, opts = {}) {
+        return this.http.req(`${P}/embeddings`, {
+            method: 'POST',
+            body: JSON.stringify({
+                input,
+                ...opts,
+            }),
+        });
+    }
+    /** Run structured question evaluation via Decision-2.0-Eos-0.8B (system_one). */
+    decision(state, questions) {
+        return this.http.req(`${P}/decision`, {
+            method: 'POST',
+            body: JSON.stringify({
+                state,
+                questions,
+            }),
+        });
+    }
+    /** Semantic route an input text between candidate choices for workflow branching. */
+    route(input, choices, instruction) {
+        return this.http.req(`${P}/decision/route`, {
+            method: 'POST',
+            body: JSON.stringify({
+                input,
+                choices,
+                ...(instruction ? { instruction } : {}),
+            }),
+        });
+    }
+}
+exports.InferenceService = InferenceService;