@pellux/goodvibes-sdk 0.33.5 → 0.33.7

package/README.md

@@ -32,6 +32,8 @@ Entry points:
 - `@pellux/goodvibes-sdk/peer`
 - `@pellux/goodvibes-sdk/contracts`
 - `@pellux/goodvibes-sdk/browser`
+- `@pellux/goodvibes-sdk/browser/knowledge`
+- `@pellux/goodvibes-sdk/browser/homeassistant`
 - `@pellux/goodvibes-sdk/web`
 - `@pellux/goodvibes-sdk/workers`
 - `@pellux/goodvibes-sdk/react-native`

package/dist/browser-homeassistant.d.ts

@@ -0,0 +1,118 @@
+import type { OperatorMethodInput, OperatorMethodOutput, OperatorTypedMethodId } from '@pellux/goodvibes-contracts/generated/foundation-client-types';
+import { forScopedBrowserSession, type ScopedBrowserSdk, type ScopedBrowserSdkOptions, type SharedBrowserMethodId } from './browser-scoped.js';
+declare const HOME_ASSISTANT_BROWSER_ROUTES: {
+    readonly 'homeassistant.homeGraph.askHomeGraph': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/ask";
+    };
+    readonly 'homeassistant.homeGraph.browse': {
+        readonly method: "GET";
+        readonly path: "/api/homeassistant/home-graph/browse";
+    };
+    readonly 'homeassistant.homeGraph.export': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/export";
+    };
+    readonly 'homeassistant.homeGraph.generateHomeGraphPacket': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/packet";
+    };
+    readonly 'homeassistant.homeGraph.generateRoomPage': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/room-page";
+    };
+    readonly 'homeassistant.homeGraph.import': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/import";
+    };
+    readonly 'homeassistant.homeGraph.ingestHomeGraphArtifact': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/ingest/artifact";
+    };
+    readonly 'homeassistant.homeGraph.ingestHomeGraphNote': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/ingest/note";
+    };
+    readonly 'homeassistant.homeGraph.ingestHomeGraphUrl': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/ingest/url";
+    };
+    readonly 'homeassistant.homeGraph.linkHomeGraphKnowledge': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/link";
+    };
+    readonly 'homeassistant.homeGraph.listHomeGraphIssues': {
+        readonly method: "GET";
+        readonly path: "/api/homeassistant/home-graph/issues";
+    };
+    readonly 'homeassistant.homeGraph.map': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/map";
+    };
+    readonly 'homeassistant.homeGraph.pages.list': {
+        readonly method: "GET";
+        readonly path: "/api/homeassistant/home-graph/pages";
+    };
+    readonly 'homeassistant.homeGraph.refinement.run': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/refinement/run";
+    };
+    readonly 'homeassistant.homeGraph.refinement.task.cancel': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/refinement/tasks/{id}/cancel";
+    };
+    readonly 'homeassistant.homeGraph.refinement.task.get': {
+        readonly method: "GET";
+        readonly path: "/api/homeassistant/home-graph/refinement/tasks/{id}";
+    };
+    readonly 'homeassistant.homeGraph.refinement.tasks.list': {
+        readonly method: "GET";
+        readonly path: "/api/homeassistant/home-graph/refinement/tasks";
+    };
+    readonly 'homeassistant.homeGraph.refreshDevicePassport': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/device-passport";
+    };
+    readonly 'homeassistant.homeGraph.reindex': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/reindex";
+    };
+    readonly 'homeassistant.homeGraph.reset': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/reset";
+    };
+    readonly 'homeassistant.homeGraph.reviewHomeGraphFact': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/facts/review";
+    };
+    readonly 'homeassistant.homeGraph.sources.list': {
+        readonly method: "GET";
+        readonly path: "/api/homeassistant/home-graph/sources";
+    };
+    readonly 'homeassistant.homeGraph.status': {
+        readonly method: "GET";
+        readonly path: "/api/homeassistant/home-graph/status";
+    };
+    readonly 'homeassistant.homeGraph.syncHomeGraph': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/sync";
+    };
+    readonly 'homeassistant.homeGraph.unlinkHomeGraphKnowledge': {
+        readonly method: "POST";
+        readonly path: "/api/homeassistant/home-graph/unlink";
+    };
+};
+declare const HOME_ASSISTANT_BROWSER_DOMAINS: readonly ["session", "turn", "tasks", "providers", "surfaces", "routes", "knowledge", "control-plane"];
+export type BrowserHomeAssistantMethodId = SharedBrowserMethodId | Extract<keyof typeof HOME_ASSISTANT_BROWSER_ROUTES, OperatorTypedMethodId>;
+export type BrowserHomeAssistantDomain = typeof HOME_ASSISTANT_BROWSER_DOMAINS[number];
+export interface BrowserHomeAssistantSdk extends ScopedBrowserSdk<BrowserHomeAssistantMethodId, BrowserHomeAssistantDomain> {
+    readonly homeGraph: {
+        status(input?: OperatorMethodInput<'homeassistant.homeGraph.status'>): Promise<OperatorMethodOutput<'homeassistant.homeGraph.status'>>;
+        ask(input: OperatorMethodInput<'homeassistant.homeGraph.askHomeGraph'>): Promise<OperatorMethodOutput<'homeassistant.homeGraph.askHomeGraph'>>;
+        map(input?: OperatorMethodInput<'homeassistant.homeGraph.map'>): Promise<OperatorMethodOutput<'homeassistant.homeGraph.map'>>;
+        pages(input?: OperatorMethodInput<'homeassistant.homeGraph.pages.list'>): Promise<OperatorMethodOutput<'homeassistant.homeGraph.pages.list'>>;
+    };
+}
+export declare function createBrowserHomeAssistantSdk(options?: ScopedBrowserSdkOptions): BrowserHomeAssistantSdk;
+export { forScopedBrowserSession as forSession };
+//# sourceMappingURL=browser-homeassistant.d.ts.map

package/dist/browser-homeassistant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-homeassistant.d.ts","sourceRoot":"","sources":["../src/browser-homeassistant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,+DAA+D,CAAC;AACvE,OAAO,EAEL,uBAAuB,EAGvB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,QAAA,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BsD,CAAC;AAE1F,QAAA,MAAM,8BAA8B,wGAS1B,CAAC;AAEX,MAAM,MAAM,4BAA4B,GACpC,qBAAqB,GACrB,OAAO,CAAC,MAAM,OAAO,6BAA6B,EAAE,qBAAqB,CAAC,CAAC;AAE/E,MAAM,MAAM,0BAA0B,GAAG,OAAO,8BAA8B,CAAC,MAAM,CAAC,CAAC;AAEvF,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB,CAAC,4BAA4B,EAAE,0BAA0B,CAAC;IACzH,QAAQ,CAAC,SAAS,EAAE;QAClB,MAAM,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAC,gCAAgC,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,gCAAgC,CAAC,CAAC,CAAC;QACvI,GAAG,CAAC,KAAK,EAAE,mBAAmB,CAAC,sCAAsC,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,sCAAsC,CAAC,CAAC,CAAC;QAC/I,GAAG,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAC,6BAA6B,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,6BAA6B,CAAC,CAAC,CAAC;QAC9H,KAAK,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAC,oCAAoC,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,oCAAoC,CAAC,CAAC,CAAC;KAC/I,CAAC;CACH;AAED,wBAAgB,6BAA6B,CAAC,OAAO,GAAE,uBAA4B,GAAG,uBAAuB,CAkB5G;AAED,OAAO,EAAE,uBAAuB,IAAI,UAAU,EAAE,CAAC"}

package/dist/browser-homeassistant.js

@@ -0,0 +1,54 @@
+import { createScopedBrowserSdk, forScopedBrowserSession, SHARED_BROWSER_ROUTES, } from './browser-scoped.js';
+const HOME_ASSISTANT_BROWSER_ROUTES = {
+    'homeassistant.homeGraph.askHomeGraph': { method: 'POST', path: '/api/homeassistant/home-graph/ask' },
+    'homeassistant.homeGraph.browse': { method: 'GET', path: '/api/homeassistant/home-graph/browse' },
+    'homeassistant.homeGraph.export': { method: 'POST', path: '/api/homeassistant/home-graph/export' },
+    'homeassistant.homeGraph.generateHomeGraphPacket': { method: 'POST', path: '/api/homeassistant/home-graph/packet' },
+    'homeassistant.homeGraph.generateRoomPage': { method: 'POST', path: '/api/homeassistant/home-graph/room-page' },
+    'homeassistant.homeGraph.import': { method: 'POST', path: '/api/homeassistant/home-graph/import' },
+    'homeassistant.homeGraph.ingestHomeGraphArtifact': { method: 'POST', path: '/api/homeassistant/home-graph/ingest/artifact' },
+    'homeassistant.homeGraph.ingestHomeGraphNote': { method: 'POST', path: '/api/homeassistant/home-graph/ingest/note' },
+    'homeassistant.homeGraph.ingestHomeGraphUrl': { method: 'POST', path: '/api/homeassistant/home-graph/ingest/url' },
+    'homeassistant.homeGraph.linkHomeGraphKnowledge': { method: 'POST', path: '/api/homeassistant/home-graph/link' },
+    'homeassistant.homeGraph.listHomeGraphIssues': { method: 'GET', path: '/api/homeassistant/home-graph/issues' },
+    'homeassistant.homeGraph.map': { method: 'POST', path: '/api/homeassistant/home-graph/map' },
+    'homeassistant.homeGraph.pages.list': { method: 'GET', path: '/api/homeassistant/home-graph/pages' },
+    'homeassistant.homeGraph.refinement.run': { method: 'POST', path: '/api/homeassistant/home-graph/refinement/run' },
+    'homeassistant.homeGraph.refinement.task.cancel': { method: 'POST', path: '/api/homeassistant/home-graph/refinement/tasks/{id}/cancel' },
+    'homeassistant.homeGraph.refinement.task.get': { method: 'GET', path: '/api/homeassistant/home-graph/refinement/tasks/{id}' },
+    'homeassistant.homeGraph.refinement.tasks.list': { method: 'GET', path: '/api/homeassistant/home-graph/refinement/tasks' },
+    'homeassistant.homeGraph.refreshDevicePassport': { method: 'POST', path: '/api/homeassistant/home-graph/device-passport' },
+    'homeassistant.homeGraph.reindex': { method: 'POST', path: '/api/homeassistant/home-graph/reindex' },
+    'homeassistant.homeGraph.reset': { method: 'POST', path: '/api/homeassistant/home-graph/reset' },
+    'homeassistant.homeGraph.reviewHomeGraphFact': { method: 'POST', path: '/api/homeassistant/home-graph/facts/review' },
+    'homeassistant.homeGraph.sources.list': { method: 'GET', path: '/api/homeassistant/home-graph/sources' },
+    'homeassistant.homeGraph.status': { method: 'GET', path: '/api/homeassistant/home-graph/status' },
+    'homeassistant.homeGraph.syncHomeGraph': { method: 'POST', path: '/api/homeassistant/home-graph/sync' },
+    'homeassistant.homeGraph.unlinkHomeGraphKnowledge': { method: 'POST', path: '/api/homeassistant/home-graph/unlink' },
+};
+const HOME_ASSISTANT_BROWSER_DOMAINS = [
+    'session',
+    'turn',
+    'tasks',
+    'providers',
+    'surfaces',
+    'routes',
+    'knowledge',
+    'control-plane',
+];
+export function createBrowserHomeAssistantSdk(options = {}) {
+    const sdk = createScopedBrowserSdk({
+        ...SHARED_BROWSER_ROUTES,
+        ...HOME_ASSISTANT_BROWSER_ROUTES,
+    }, HOME_ASSISTANT_BROWSER_DOMAINS, options);
+    return {
+        ...sdk,
+        homeGraph: {
+            status: (input = {}) => sdk.operator.invoke('homeassistant.homeGraph.status', input),
+            ask: (input) => sdk.operator.invoke('homeassistant.homeGraph.askHomeGraph', input),
+            map: (input = {}) => sdk.operator.invoke('homeassistant.homeGraph.map', input),
+            pages: (input = {}) => sdk.operator.invoke('homeassistant.homeGraph.pages.list', input),
+        },
+    };
+}
+export { forScopedBrowserSession as forSession };

package/dist/browser-knowledge.d.ts

@@ -0,0 +1,210 @@
+import type { OperatorMethodInput, OperatorMethodOutput, OperatorTypedMethodId } from '@pellux/goodvibes-contracts/generated/foundation-client-types';
+import { forScopedBrowserSession, type ScopedBrowserSdk, type ScopedBrowserSdkOptions, type SharedBrowserMethodId } from './browser-scoped.js';
+declare const KNOWLEDGE_BROWSER_ROUTES: {
+    readonly 'knowledge.ask': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/ask";
+    };
+    readonly 'knowledge.candidate.decide': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/candidates/{id}/decide";
+    };
+    readonly 'knowledge.candidate.get': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/candidates/{id}";
+    };
+    readonly 'knowledge.candidates.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/candidates";
+    };
+    readonly 'knowledge.connector.doctor': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/connectors/{id}/doctor";
+    };
+    readonly 'knowledge.connector.get': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/connectors/{id}";
+    };
+    readonly 'knowledge.connectors.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/connectors";
+    };
+    readonly 'knowledge.extraction.get': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/extractions/{id}";
+    };
+    readonly 'knowledge.extractions.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/extractions";
+    };
+    readonly 'knowledge.graphql.execute': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/graphql";
+    };
+    readonly 'knowledge.graphql.schema': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/graphql/schema";
+    };
+    readonly 'knowledge.ingest.artifact': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/ingest/artifact";
+    };
+    readonly 'knowledge.ingest.bookmarks': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/ingest/bookmarks";
+    };
+    readonly 'knowledge.ingest.browserHistory': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/ingest/browser-history";
+    };
+    readonly 'knowledge.ingest.connector': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/ingest/connector";
+    };
+    readonly 'knowledge.ingest.url': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/ingest/url";
+    };
+    readonly 'knowledge.ingest.urls': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/ingest/urls";
+    };
+    readonly 'knowledge.issue.review': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/issues/{id}/review";
+    };
+    readonly 'knowledge.issues.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/issues";
+    };
+    readonly 'knowledge.item.get': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/items/{id}";
+    };
+    readonly 'knowledge.job-runs.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/job-runs";
+    };
+    readonly 'knowledge.job.get': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/jobs/{jobId}";
+    };
+    readonly 'knowledge.job.run': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/jobs/{jobId}/run";
+    };
+    readonly 'knowledge.jobs.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/jobs";
+    };
+    readonly 'knowledge.lint': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/lint";
+    };
+    readonly 'knowledge.map': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/map";
+    };
+    readonly 'knowledge.nodes.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/nodes";
+    };
+    readonly 'knowledge.packet': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/packet";
+    };
+    readonly 'knowledge.projection.materialize': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/projections/materialize";
+    };
+    readonly 'knowledge.projection.render': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/projections/render";
+    };
+    readonly 'knowledge.projections.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/projections";
+    };
+    readonly 'knowledge.refinement.run': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/refinement/run";
+    };
+    readonly 'knowledge.refinement.task.cancel': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/refinement/tasks/{id}/cancel";
+    };
+    readonly 'knowledge.refinement.task.get': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/refinement/tasks/{id}";
+    };
+    readonly 'knowledge.refinement.tasks.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/refinement/tasks";
+    };
+    readonly 'knowledge.reindex': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/reindex";
+    };
+    readonly 'knowledge.report.get': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/reports/{id}";
+    };
+    readonly 'knowledge.reports.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/reports";
+    };
+    readonly 'knowledge.schedule.delete': {
+        readonly method: "DELETE";
+        readonly path: "/api/knowledge/schedules/{id}";
+    };
+    readonly 'knowledge.schedule.enable': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/schedules/{id}/enabled";
+    };
+    readonly 'knowledge.schedule.get': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/schedules/{id}";
+    };
+    readonly 'knowledge.schedule.save': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/schedules";
+    };
+    readonly 'knowledge.schedules.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/schedules";
+    };
+    readonly 'knowledge.search': {
+        readonly method: "POST";
+        readonly path: "/api/knowledge/search";
+    };
+    readonly 'knowledge.source.extraction.get': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/sources/{id}/extraction";
+    };
+    readonly 'knowledge.sources.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/sources";
+    };
+    readonly 'knowledge.status': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/status";
+    };
+    readonly 'knowledge.usage.list': {
+        readonly method: "GET";
+        readonly path: "/api/knowledge/usage";
+    };
+};
+declare const KNOWLEDGE_BROWSER_DOMAINS: readonly ["session", "turn", "tasks", "providers", "knowledge", "control-plane"];
+export type BrowserKnowledgeMethodId = SharedBrowserMethodId | Extract<keyof typeof KNOWLEDGE_BROWSER_ROUTES, OperatorTypedMethodId>;
+export type BrowserKnowledgeDomain = typeof KNOWLEDGE_BROWSER_DOMAINS[number];
+export interface BrowserKnowledgeSdk extends ScopedBrowserSdk<BrowserKnowledgeMethodId, BrowserKnowledgeDomain> {
+    readonly knowledge: {
+        ask(input: OperatorMethodInput<'knowledge.ask'>): Promise<OperatorMethodOutput<'knowledge.ask'>>;
+        search(input: OperatorMethodInput<'knowledge.search'>): Promise<OperatorMethodOutput<'knowledge.search'>>;
+        status(): Promise<OperatorMethodOutput<'knowledge.status'>>;
+        map(input?: OperatorMethodInput<'knowledge.map'>): Promise<OperatorMethodOutput<'knowledge.map'>>;
+    };
+}
+export declare function createBrowserKnowledgeSdk(options?: ScopedBrowserSdkOptions): BrowserKnowledgeSdk;
+export { forScopedBrowserSession as forSession };
+//# sourceMappingURL=browser-knowledge.d.ts.map

package/dist/browser-knowledge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-knowledge.d.ts","sourceRoot":"","sources":["../src/browser-knowledge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,+DAA+D,CAAC;AACvE,OAAO,EAEL,uBAAuB,EAGvB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiD2D,CAAC;AAE1F,QAAA,MAAM,yBAAyB,kFAOrB,CAAC;AAEX,MAAM,MAAM,wBAAwB,GAChC,qBAAqB,GACrB,OAAO,CAAC,MAAM,OAAO,wBAAwB,EAAE,qBAAqB,CAAC,CAAC;AAE1E,MAAM,MAAM,sBAAsB,GAAG,OAAO,yBAAyB,CAAC,MAAM,CAAC,CAAC;AAE9E,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB,CAAC,wBAAwB,EAAE,sBAAsB,CAAC;IAC7G,QAAQ,CAAC,SAAS,EAAE;QAClB,GAAG,CAAC,KAAK,EAAE,mBAAmB,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,eAAe,CAAC,CAAC,CAAC;QACjG,MAAM,CAAC,KAAK,EAAE,mBAAmB,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,CAAC,CAAC;QAC1G,MAAM,IAAI,OAAO,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,CAAC,CAAC;QAC5D,GAAG,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,eAAe,CAAC,CAAC,CAAC;KACnG,CAAC;CACH;AAED,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,uBAA4B,GAAG,mBAAmB,CAkBpG;AAED,OAAO,EAAE,uBAAuB,IAAI,UAAU,EAAE,CAAC"}

package/dist/browser-knowledge.js

@@ -0,0 +1,75 @@
+import { createScopedBrowserSdk, forScopedBrowserSession, SHARED_BROWSER_ROUTES, } from './browser-scoped.js';
+const KNOWLEDGE_BROWSER_ROUTES = {
+    'knowledge.ask': { method: 'POST', path: '/api/knowledge/ask' },
+    'knowledge.candidate.decide': { method: 'POST', path: '/api/knowledge/candidates/{id}/decide' },
+    'knowledge.candidate.get': { method: 'GET', path: '/api/knowledge/candidates/{id}' },
+    'knowledge.candidates.list': { method: 'GET', path: '/api/knowledge/candidates' },
+    'knowledge.connector.doctor': { method: 'GET', path: '/api/knowledge/connectors/{id}/doctor' },
+    'knowledge.connector.get': { method: 'GET', path: '/api/knowledge/connectors/{id}' },
+    'knowledge.connectors.list': { method: 'GET', path: '/api/knowledge/connectors' },
+    'knowledge.extraction.get': { method: 'GET', path: '/api/knowledge/extractions/{id}' },
+    'knowledge.extractions.list': { method: 'GET', path: '/api/knowledge/extractions' },
+    'knowledge.graphql.execute': { method: 'POST', path: '/api/knowledge/graphql' },
+    'knowledge.graphql.schema': { method: 'GET', path: '/api/knowledge/graphql/schema' },
+    'knowledge.ingest.artifact': { method: 'POST', path: '/api/knowledge/ingest/artifact' },
+    'knowledge.ingest.bookmarks': { method: 'POST', path: '/api/knowledge/ingest/bookmarks' },
+    'knowledge.ingest.browserHistory': { method: 'POST', path: '/api/knowledge/ingest/browser-history' },
+    'knowledge.ingest.connector': { method: 'POST', path: '/api/knowledge/ingest/connector' },
+    'knowledge.ingest.url': { method: 'POST', path: '/api/knowledge/ingest/url' },
+    'knowledge.ingest.urls': { method: 'POST', path: '/api/knowledge/ingest/urls' },
+    'knowledge.issue.review': { method: 'POST', path: '/api/knowledge/issues/{id}/review' },
+    'knowledge.issues.list': { method: 'GET', path: '/api/knowledge/issues' },
+    'knowledge.item.get': { method: 'GET', path: '/api/knowledge/items/{id}' },
+    'knowledge.job-runs.list': { method: 'GET', path: '/api/knowledge/job-runs' },
+    'knowledge.job.get': { method: 'GET', path: '/api/knowledge/jobs/{jobId}' },
+    'knowledge.job.run': { method: 'POST', path: '/api/knowledge/jobs/{jobId}/run' },
+    'knowledge.jobs.list': { method: 'GET', path: '/api/knowledge/jobs' },
+    'knowledge.lint': { method: 'POST', path: '/api/knowledge/lint' },
+    'knowledge.map': { method: 'GET', path: '/api/knowledge/map' },
+    'knowledge.nodes.list': { method: 'GET', path: '/api/knowledge/nodes' },
+    'knowledge.packet': { method: 'POST', path: '/api/knowledge/packet' },
+    'knowledge.projection.materialize': { method: 'POST', path: '/api/knowledge/projections/materialize' },
+    'knowledge.projection.render': { method: 'POST', path: '/api/knowledge/projections/render' },
+    'knowledge.projections.list': { method: 'GET', path: '/api/knowledge/projections' },
+    'knowledge.refinement.run': { method: 'POST', path: '/api/knowledge/refinement/run' },
+    'knowledge.refinement.task.cancel': { method: 'POST', path: '/api/knowledge/refinement/tasks/{id}/cancel' },
+    'knowledge.refinement.task.get': { method: 'GET', path: '/api/knowledge/refinement/tasks/{id}' },
+    'knowledge.refinement.tasks.list': { method: 'GET', path: '/api/knowledge/refinement/tasks' },
+    'knowledge.reindex': { method: 'POST', path: '/api/knowledge/reindex' },
+    'knowledge.report.get': { method: 'GET', path: '/api/knowledge/reports/{id}' },
+    'knowledge.reports.list': { method: 'GET', path: '/api/knowledge/reports' },
+    'knowledge.schedule.delete': { method: 'DELETE', path: '/api/knowledge/schedules/{id}' },
+    'knowledge.schedule.enable': { method: 'POST', path: '/api/knowledge/schedules/{id}/enabled' },
+    'knowledge.schedule.get': { method: 'GET', path: '/api/knowledge/schedules/{id}' },
+    'knowledge.schedule.save': { method: 'POST', path: '/api/knowledge/schedules' },
+    'knowledge.schedules.list': { method: 'GET', path: '/api/knowledge/schedules' },
+    'knowledge.search': { method: 'POST', path: '/api/knowledge/search' },
+    'knowledge.source.extraction.get': { method: 'GET', path: '/api/knowledge/sources/{id}/extraction' },
+    'knowledge.sources.list': { method: 'GET', path: '/api/knowledge/sources' },
+    'knowledge.status': { method: 'GET', path: '/api/knowledge/status' },
+    'knowledge.usage.list': { method: 'GET', path: '/api/knowledge/usage' },
+};
+const KNOWLEDGE_BROWSER_DOMAINS = [
+    'session',
+    'turn',
+    'tasks',
+    'providers',
+    'knowledge',
+    'control-plane',
+];
+export function createBrowserKnowledgeSdk(options = {}) {
+    const sdk = createScopedBrowserSdk({
+        ...SHARED_BROWSER_ROUTES,
+        ...KNOWLEDGE_BROWSER_ROUTES,
+    }, KNOWLEDGE_BROWSER_DOMAINS, options);
+    return {
+        ...sdk,
+        knowledge: {
+            ask: (input) => sdk.operator.invoke('knowledge.ask', input),
+            search: (input) => sdk.operator.invoke('knowledge.search', input),
+            status: () => sdk.operator.invoke('knowledge.status', {}),
+            map: (input = {}) => sdk.operator.invoke('knowledge.map', input),
+        },
+    };
+}
+export { forScopedBrowserSession as forSession };

package/dist/browser-scoped.d.ts

@@ -0,0 +1,148 @@
+import type { OperatorMethodInput, OperatorMethodOutput, OperatorTypedMethodId } from '@pellux/goodvibes-contracts/generated/foundation-client-types';
+import type { AuthTokenResolver, HttpRetryPolicy, StreamReconnectPolicy, TransportMiddleware } from './transport-http.js';
+import type { GoodVibesAuthClient, GoodVibesTokenStore } from './auth.js';
+import type { SDKObserver } from './observer/index.js';
+export type BrowserScopedRouteDefinition = {
+    readonly method: string;
+    readonly path: string;
+};
+export interface ScopedBrowserSdkOptions {
+    readonly baseUrl?: string | undefined;
+    readonly authToken?: string | null | undefined;
+    readonly getAuthToken?: AuthTokenResolver | undefined;
+    readonly tokenStore?: GoodVibesTokenStore | undefined;
+    readonly fetch?: typeof fetch | undefined;
+    readonly WebSocketImpl?: typeof WebSocket | undefined;
+    readonly headers?: HeadersInit | undefined;
+    readonly getHeaders?: (() => HeadersInit | undefined | Promise<HeadersInit | undefined>) | undefined;
+    readonly retry?: HttpRetryPolicy | undefined;
+    readonly middleware?: readonly TransportMiddleware[] | undefined;
+    readonly realtime?: {
+        readonly sseReconnect?: StreamReconnectPolicy | undefined;
+        readonly onError?: ((error: unknown) => void) | undefined;
+    } | undefined;
+    readonly observer?: SDKObserver | undefined;
+}
+export interface ScopedInvokeOptions {
+    readonly signal?: AbortSignal | undefined;
+    readonly headers?: HeadersInit | undefined;
+}
+type ScopedInput<TMethodId extends OperatorTypedMethodId> = OperatorMethodInput<TMethodId>;
+type ScopedOutput<TMethodId extends OperatorTypedMethodId> = OperatorMethodOutput<TMethodId>;
+export interface ScopedOperatorClient<TMethodId extends OperatorTypedMethodId> {
+    invoke<TSelectedMethodId extends TMethodId>(methodId: TSelectedMethodId, input?: ScopedInput<TSelectedMethodId>, options?: ScopedInvokeOptions): Promise<ScopedOutput<TSelectedMethodId>>;
+}
+export interface ScopedRuntimeEventEnvelope<TPayload extends {
+    readonly type: string;
+} = {
+    readonly type: string;
+}> {
+    readonly type: string;
+    readonly ts: number;
+    readonly traceId?: string | undefined;
+    readonly sessionId?: string | undefined;
+    readonly source?: string | undefined;
+    readonly payload: TPayload;
+}
+export interface ScopedRuntimeEventFeed<TPayload extends {
+    readonly type: string;
+} = {
+    readonly type: string;
+}> {
+    on<TType extends string>(type: TType, listener: (payload: TPayload & {
+        readonly type: TType;
+    }) => void): () => void;
+    onEnvelope<TType extends string>(type: TType, listener: (envelope: ScopedRuntimeEventEnvelope<TPayload & {
+        readonly type: TType;
+    }>) => void): () => void;
+}
+export type ScopedRuntimeEvents<TDomain extends string> = {
+    readonly domains: readonly TDomain[];
+    domain(domain: TDomain): ScopedRuntimeEventFeed;
+} & {
+    readonly [K in TDomain]: ScopedRuntimeEventFeed;
+};
+export interface ScopedBrowserSdk<TMethodId extends OperatorTypedMethodId, TDomain extends string> {
+    readonly operator: ScopedOperatorClient<TMethodId>;
+    readonly auth: GoodVibesAuthClient;
+    readonly realtime: {
+        viaSse(): ScopedRuntimeEvents<TDomain>;
+    };
+    use(middleware: TransportMiddleware): void;
+}
+declare const SHARED_BROWSER_ROUTES: {
+    readonly 'accounts.snapshot': {
+        readonly method: "GET";
+        readonly path: "/api/accounts";
+    };
+    readonly 'control.auth.current': {
+        readonly method: "GET";
+        readonly path: "/api/control-plane/auth";
+    };
+    readonly 'control.auth.login': {
+        readonly method: "POST";
+        readonly path: "/login";
+    };
+    readonly 'control.snapshot': {
+        readonly method: "GET";
+        readonly path: "/api/control-plane";
+    };
+    readonly 'control.status': {
+        readonly method: "GET";
+        readonly path: "/status";
+    };
+    readonly 'providers.get': {
+        readonly method: "GET";
+        readonly path: "/api/providers/{providerId}";
+    };
+    readonly 'providers.list': {
+        readonly method: "GET";
+        readonly path: "/api/providers";
+    };
+    readonly 'providers.usage.get': {
+        readonly method: "GET";
+        readonly path: "/api/providers/{providerId}/usage";
+    };
+    readonly 'sessions.create': {
+        readonly method: "POST";
+        readonly path: "/api/sessions";
+    };
+    readonly 'sessions.followUp': {
+        readonly method: "POST";
+        readonly path: "/api/sessions/{sessionId}/follow-up";
+    };
+    readonly 'sessions.get': {
+        readonly method: "GET";
+        readonly path: "/api/sessions/{sessionId}";
+    };
+    readonly 'sessions.inputs.cancel': {
+        readonly method: "POST";
+        readonly path: "/api/sessions/{sessionId}/inputs/{inputId}/cancel";
+    };
+    readonly 'sessions.inputs.list': {
+        readonly method: "GET";
+        readonly path: "/api/sessions/{sessionId}/inputs";
+    };
+    readonly 'sessions.list': {
+        readonly method: "GET";
+        readonly path: "/api/sessions";
+    };
+    readonly 'sessions.messages.create': {
+        readonly method: "POST";
+        readonly path: "/api/sessions/{sessionId}/messages";
+    };
+    readonly 'sessions.messages.list': {
+        readonly method: "GET";
+        readonly path: "/api/sessions/{sessionId}/messages";
+    };
+    readonly 'sessions.steer': {
+        readonly method: "POST";
+        readonly path: "/api/sessions/{sessionId}/steer";
+    };
+};
+export type SharedBrowserMethodId = Extract<keyof typeof SHARED_BROWSER_ROUTES, OperatorTypedMethodId>;
+export declare function resolveBrowserBaseUrl(baseUrl?: string): string;
+export declare function forScopedBrowserSession<TDomain extends string>(events: ScopedRuntimeEvents<TDomain>, sessionId: string): ScopedRuntimeEvents<TDomain>;
+export declare function createScopedBrowserSdk<TMethodId extends OperatorTypedMethodId, TDomain extends string>(routes: Record<TMethodId, BrowserScopedRouteDefinition>, domains: readonly TDomain[], options?: ScopedBrowserSdkOptions): ScopedBrowserSdk<TMethodId, TDomain>;
+export { SHARED_BROWSER_ROUTES };
+//# sourceMappingURL=browser-scoped.d.ts.map

package/dist/browser-scoped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-scoped.d.ts","sourceRoot":"","sources":["../src/browser-scoped.ts"],"names":[],"mappings":"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"}

package/dist/browser-scoped.js

@@ -0,0 +1,243 @@
+import { ConfigurationError, ContractError } from '@pellux/goodvibes-errors';
+import { createHttpTransport, openRawServerSentEventStream, } from './transport-http.js';
+import { createGoodVibesAuthClient, } from './auth.js';
+const SHARED_BROWSER_ROUTES = {
+    'accounts.snapshot': { method: 'GET', path: '/api/accounts' },
+    'control.auth.current': { method: 'GET', path: '/api/control-plane/auth' },
+    'control.auth.login': { method: 'POST', path: '/login' },
+    'control.snapshot': { method: 'GET', path: '/api/control-plane' },
+    'control.status': { method: 'GET', path: '/status' },
+    'providers.get': { method: 'GET', path: '/api/providers/{providerId}' },
+    'providers.list': { method: 'GET', path: '/api/providers' },
+    'providers.usage.get': { method: 'GET', path: '/api/providers/{providerId}/usage' },
+    'sessions.create': { method: 'POST', path: '/api/sessions' },
+    'sessions.followUp': { method: 'POST', path: '/api/sessions/{sessionId}/follow-up' },
+    'sessions.get': { method: 'GET', path: '/api/sessions/{sessionId}' },
+    'sessions.inputs.cancel': { method: 'POST', path: '/api/sessions/{sessionId}/inputs/{inputId}/cancel' },
+    'sessions.inputs.list': { method: 'GET', path: '/api/sessions/{sessionId}/inputs' },
+    'sessions.list': { method: 'GET', path: '/api/sessions' },
+    'sessions.messages.create': { method: 'POST', path: '/api/sessions/{sessionId}/messages' },
+    'sessions.messages.list': { method: 'GET', path: '/api/sessions/{sessionId}/messages' },
+    'sessions.steer': { method: 'POST', path: '/api/sessions/{sessionId}/steer' },
+};
+export function resolveBrowserBaseUrl(baseUrl) {
+    const explicit = baseUrl?.trim();
+    if (explicit)
+        return explicit;
+    if (typeof globalThis.location?.origin === 'string' && globalThis.location.origin.trim()) {
+        return globalThis.location.origin.trim();
+    }
+    throw new ConfigurationError('Browser baseUrl is required when location.origin is unavailable.');
+}
+function resolveFetch(fetchImpl) {
+    const resolved = fetchImpl ?? globalThis.fetch;
+    if (typeof resolved !== 'function') {
+        throw new ConfigurationError('Fetch implementation is required. Pass options.fetch or use a browser/runtime that provides global fetch.');
+    }
+    return resolved;
+}
+function buildRouteError(methodId) {
+    return new ContractError(`Operator method "${methodId}" is not available from this scoped browser SDK entrypoint. Import the matching scoped entrypoint instead of the full browser client.`);
+}
+function createScopedOperatorClient(routes, options) {
+    const transport = createHttpTransport({
+        baseUrl: resolveBrowserBaseUrl(options.baseUrl),
+        authToken: options.authToken ?? null,
+        getAuthToken: options.tokenStore
+            ? () => options.tokenStore.getToken()
+            : options.getAuthToken,
+        fetch: resolveFetch(options.fetch),
+        headers: options.headers,
+        getHeaders: options.getHeaders,
+        retry: options.retry,
+        middleware: options.middleware,
+        observer: options.observer,
+    });
+    const operator = {
+        async invoke(methodId, input, invokeOptions = {}) {
+            const route = routes[methodId];
+            if (!route)
+                throw buildRouteError(methodId);
+            const resolved = transport.resolveContractRequest(route.method, route.path, input && typeof input === 'object' && !Array.isArray(input)
+                ? input
+                : {});
+            return await transport.requestJson(resolved.url, {
+                method: resolved.method,
+                body: resolved.body,
+                headers: invokeOptions.headers,
+                signal: invokeOptions.signal,
+                methodId,
+                idempotent: false,
+            });
+        },
+    };
+    return {
+        operator,
+        requestJson: (pathOrUrl, requestOptions) => transport.requestJson(pathOrUrl, requestOptions),
+        getAuthToken: () => transport.getAuthToken(),
+        use: (middleware) => transport.use(middleware),
+    };
+}
+function createAuthOperatorShim(operator) {
+    return {
+        control: {
+            auth: {
+                current: () => operator.invoke('control.auth.current', {}),
+                login: (input) => operator.invoke('control.auth.login', input),
+            },
+        },
+    };
+}
+function createFeed(subscribe) {
+    return {
+        on(type, listener) {
+            return subscribe(type, (envelope) => {
+                listener(envelope.payload);
+            });
+        },
+        onEnvelope(type, listener) {
+            return subscribe(type, listener);
+        },
+    };
+}
+function normalizeEnvelope(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const envelope = value;
+    const payload = envelope.payload;
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const payloadType = payload.type;
+    if (typeof payloadType !== 'string')
+        return null;
+    return {
+        type: typeof envelope.type === 'string' ? envelope.type : payloadType,
+        ts: typeof envelope.ts === 'number'
+            ? envelope.ts
+            : typeof envelope.timestamp === 'number'
+                ? envelope.timestamp
+                : Date.now(),
+        traceId: typeof envelope.traceId === 'string' ? envelope.traceId : undefined,
+        sessionId: typeof envelope.sessionId === 'string' ? envelope.sessionId : undefined,
+        source: typeof envelope.source === 'string' ? envelope.source : undefined,
+        payload: payload,
+    };
+}
+function buildEventUrl(baseUrl, domain) {
+    const url = new URL('/api/control-plane/events', baseUrl);
+    url.searchParams.set('domains', domain);
+    return url.toString();
+}
+function createScopedRealtime(domains, options, getAuthToken) {
+    return {
+        viaSse() {
+            const baseUrl = resolveBrowserBaseUrl(options.baseUrl);
+            const fetchImpl = resolveFetch(options.fetch);
+            const feeds = new Map();
+            const activeByDomain = new Map();
+            const ensureDomain = (domain) => {
+                let active = activeByDomain.get(domain);
+                if (active)
+                    return active;
+                active = { listenersByType: new Map(), closed: false };
+                activeByDomain.set(domain, active);
+                void openRawServerSentEventStream(fetchImpl, buildEventUrl(baseUrl, domain), {
+                    onEvent: (eventName, payload) => {
+                        if (eventName !== domain)
+                            return;
+                        const envelope = normalizeEnvelope(payload);
+                        if (!envelope)
+                            return;
+                        for (const listener of [...(active.listenersByType.get(envelope.payload.type) ?? [])]) {
+                            listener(envelope);
+                        }
+                    },
+                    onError: (error) => options.realtime?.onError?.(error),
+                }, {
+                    reconnect: options.realtime?.sseReconnect,
+                    getAuthToken,
+                }).then((disconnect) => {
+                    if (active.closed || activeByDomain.get(domain) !== active) {
+                        disconnect();
+                        return;
+                    }
+                    active.disconnect = disconnect;
+                }).catch((error) => {
+                    options.realtime?.onError?.(error);
+                });
+                return active;
+            };
+            const getFeed = (domain) => {
+                let feed = feeds.get(domain);
+                if (feed)
+                    return feed;
+                feed = createFeed((type, listener) => {
+                    const active = ensureDomain(domain);
+                    const listeners = active.listenersByType.get(type) ?? new Set();
+                    listeners.add(listener);
+                    active.listenersByType.set(type, listeners);
+                    return () => {
+                        listeners.delete(listener);
+                        if (listeners.size === 0)
+                            active.listenersByType.delete(type);
+                        if (active.listenersByType.size === 0) {
+                            active.closed = true;
+                            active.disconnect?.();
+                            activeByDomain.delete(domain);
+                        }
+                    };
+                });
+                feeds.set(domain, feed);
+                return feed;
+            };
+            return Object.freeze({
+                domains,
+                domain: getFeed,
+                ...Object.fromEntries(domains.map((domain) => [domain, getFeed(domain)])),
+            });
+        },
+    };
+}
+export function forScopedBrowserSession(events, sessionId) {
+    const feeds = new Map();
+    const getFeed = (domain) => {
+        let feed = feeds.get(domain);
+        if (feed)
+            return feed;
+        const baseFeed = events.domain(domain);
+        feed = {
+            on(type, listener) {
+                return baseFeed.onEnvelope(type, (envelope) => {
+                    if (envelope.sessionId !== sessionId)
+                        return;
+                    listener(envelope.payload);
+                });
+            },
+            onEnvelope(type, listener) {
+                return baseFeed.onEnvelope(type, (envelope) => {
+                    if (envelope.sessionId !== sessionId)
+                        return;
+                    listener(envelope);
+                });
+            },
+        };
+        feeds.set(domain, feed);
+        return feed;
+    };
+    return Object.freeze({
+        domains: events.domains,
+        domain: getFeed,
+        ...Object.fromEntries(events.domains.map((domain) => [domain, getFeed(domain)])),
+    });
+}
+export function createScopedBrowserSdk(routes, domains, options = {}) {
+    const scoped = createScopedOperatorClient(routes, options);
+    const auth = createGoodVibesAuthClient(createAuthOperatorShim(scoped.operator), options.tokenStore ?? null, options.getAuthToken, options.observer, undefined, null);
+    return {
+        operator: scoped.operator,
+        auth,
+        realtime: createScopedRealtime(domains, options, scoped.getAuthToken),
+        use: scoped.use,
+    };
+}
+export { SHARED_BROWSER_ROUTES };

package/dist/contracts/artifacts/operator-contract.json

@@ -3,7 +3,7 @@
   "product": {
     "id": "goodvibes",
     "surface": "operator",
-    "version": "0.33.5"
+    "version": "0.33.7"
   },
   "auth": {
     "modes": [

package/dist/platform/node/capabilities.d.ts

@@ -8,7 +8,7 @@ export interface GoodVibesRuntimeCapability {
     readonly requirements: readonly GoodVibesRuntimeRequirement[];
     readonly dependencyFamilies: readonly string[];
 }
-export declare const GOODVIBES_CLIENT_SAFE_ENTRYPOINTS: readonly ["@pellux/goodvibes-sdk", "@pellux/goodvibes-sdk/auth", "@pellux/goodvibes-sdk/browser", "@pellux/goodvibes-sdk/client-auth", "@pellux/goodvibes-sdk/contracts", "@pellux/goodvibes-sdk/errors", "@pellux/goodvibes-sdk/events", "@pellux/goodvibes-sdk/expo", "@pellux/goodvibes-sdk/observer", "@pellux/goodvibes-sdk/operator", "@pellux/goodvibes-sdk/peer", "@pellux/goodvibes-sdk/react-native", "@pellux/goodvibes-sdk/transport-core", "@pellux/goodvibes-sdk/transport-direct", "@pellux/goodvibes-sdk/transport-http", "@pellux/goodvibes-sdk/transport-realtime", "@pellux/goodvibes-sdk/web", "@pellux/goodvibes-sdk/workers"];
+export declare const GOODVIBES_CLIENT_SAFE_ENTRYPOINTS: readonly ["@pellux/goodvibes-sdk", "@pellux/goodvibes-sdk/auth", "@pellux/goodvibes-sdk/browser", "@pellux/goodvibes-sdk/browser/homeassistant", "@pellux/goodvibes-sdk/browser/knowledge", "@pellux/goodvibes-sdk/client-auth", "@pellux/goodvibes-sdk/contracts", "@pellux/goodvibes-sdk/errors", "@pellux/goodvibes-sdk/events", "@pellux/goodvibes-sdk/expo", "@pellux/goodvibes-sdk/observer", "@pellux/goodvibes-sdk/operator", "@pellux/goodvibes-sdk/peer", "@pellux/goodvibes-sdk/react-native", "@pellux/goodvibes-sdk/transport-core", "@pellux/goodvibes-sdk/transport-direct", "@pellux/goodvibes-sdk/transport-http", "@pellux/goodvibes-sdk/transport-realtime", "@pellux/goodvibes-sdk/web", "@pellux/goodvibes-sdk/workers"];
 export declare const GOODVIBES_NODE_RUNTIME_ENTRYPOINTS: readonly ["@pellux/goodvibes-sdk/platform/node", "@pellux/goodvibes-sdk/platform/node/runtime-boundary", "@pellux/goodvibes-sdk/platform/config", "@pellux/goodvibes-sdk/platform/core", "@pellux/goodvibes-sdk/platform/daemon", "@pellux/goodvibes-sdk/platform/git", "@pellux/goodvibes-sdk/platform/intelligence", "@pellux/goodvibes-sdk/platform/integrations", "@pellux/goodvibes-sdk/platform/knowledge", "@pellux/goodvibes-sdk/platform/knowledge/extensions", "@pellux/goodvibes-sdk/platform/knowledge/home-graph", "@pellux/goodvibes-sdk/platform/multimodal", "@pellux/goodvibes-sdk/platform/pairing", "@pellux/goodvibes-sdk/platform/providers", "@pellux/goodvibes-sdk/platform/runtime", "@pellux/goodvibes-sdk/platform/runtime/observability", "@pellux/goodvibes-sdk/platform/runtime/sandbox", "@pellux/goodvibes-sdk/platform/runtime/settings", "@pellux/goodvibes-sdk/platform/runtime/state", "@pellux/goodvibes-sdk/platform/runtime/store", "@pellux/goodvibes-sdk/platform/runtime/ui", "@pellux/goodvibes-sdk/contracts/node", "@pellux/goodvibes-sdk/platform/tools", "@pellux/goodvibes-sdk/platform/utils", "@pellux/goodvibes-sdk/platform/voice"];
 export declare const GOODVIBES_RUNTIME_CAPABILITIES: readonly GoodVibesRuntimeCapability[];
 export declare function isClientSafeGoodVibesEntrypoint(entrypoint: string): boolean;

package/dist/platform/node/capabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../src/platform/node/capabilities.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAC/B,QAAQ,GACR,MAAM,GACN,QAAQ,GACR,cAAc,GACd,eAAe,CAAC;AAEpB,MAAM,MAAM,2BAA2B,GACnC,OAAO,GACP,WAAW,GACX,WAAW,GACX,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,cAAc,GACd,gBAAgB,GAChB,uBAAuB,CAAC;AAE5B,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,SAAS,uBAAuB,EAAE,CAAC;IACtD,QAAQ,CAAC,YAAY,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAC9D,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;CAChD;AAED,eAAO,MAAM,iCAAiC,qnBAmBpC,CAAC;AAEX,eAAO,MAAM,kCAAkC,wnCA0BrC,CAAC;AAEX,eAAO,MAAM,8BAA8B,EAAE,SAAS,0BAA0B,EAgGtE,CAAC;AAEX,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE3E;AAED,wBAAgB,gCAAgC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE5E;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,CAAC,EAAE,uBAAuB,GAChC,SAAS,0BAA0B,EAAE,CAKvC"}
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../src/platform/node/capabilities.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAC/B,QAAQ,GACR,MAAM,GACN,QAAQ,GACR,cAAc,GACd,eAAe,CAAC;AAEpB,MAAM,MAAM,2BAA2B,GACnC,OAAO,GACP,WAAW,GACX,WAAW,GACX,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,eAAe,GACf,cAAc,GACd,gBAAgB,GAChB,uBAAuB,CAAC;AAE5B,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,SAAS,uBAAuB,EAAE,CAAC;IACtD,QAAQ,CAAC,YAAY,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAC9D,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;CAChD;AAED,eAAO,MAAM,iCAAiC,+sBAqBpC,CAAC;AAEX,eAAO,MAAM,kCAAkC,wnCA0BrC,CAAC;AAEX,eAAO,MAAM,8BAA8B,EAAE,SAAS,0BAA0B,EAgGtE,CAAC;AAEX,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE3E;AAED,wBAAgB,gCAAgC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE5E;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,CAAC,EAAE,uBAAuB,GAChC,SAAS,0BAA0B,EAAE,CAKvC"}

package/dist/platform/node/capabilities.js

@@ -2,6 +2,8 @@ export const GOODVIBES_CLIENT_SAFE_ENTRYPOINTS = [
     '@pellux/goodvibes-sdk',
     '@pellux/goodvibes-sdk/auth',
     '@pellux/goodvibes-sdk/browser',
+    '@pellux/goodvibes-sdk/browser/homeassistant',
+    '@pellux/goodvibes-sdk/browser/knowledge',
     '@pellux/goodvibes-sdk/client-auth',
     '@pellux/goodvibes-sdk/contracts',
     '@pellux/goodvibes-sdk/errors',

package/dist/platform/version.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-let version = '0.33.5';
+let version = '0.33.7';
 try {
     const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', '..', 'package.json'), 'utf-8'));
     version = pkg.version ?? version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-sdk",
-  "version": "0.33.5",
+  "version": "0.33.7",
   "description": "TypeScript SDK for building GoodVibes operator, peer, web, mobile, and daemon-connected apps with typed contracts, auth, realtime events, and transport layers.",
   "keywords": [
     "goodvibes",
@@ -34,6 +34,14 @@
       "types": "./dist/browser.d.ts",
       "import": "./dist/browser.js"
     },
+    "./browser/homeassistant": {
+      "types": "./dist/browser-homeassistant.d.ts",
+      "import": "./dist/browser-homeassistant.js"
+    },
+    "./browser/knowledge": {
+      "types": "./dist/browser-knowledge.d.ts",
+      "import": "./dist/browser-knowledge.js"
+    },
     "./client-auth": {
       "types": "./dist/client-auth/index.d.ts",
       "import": "./dist/client-auth/index.js"
@@ -441,14 +449,14 @@
   "sideEffects": false,
   "type": "module",
   "dependencies": {
-    "@pellux/goodvibes-contracts": "0.33.5",
-    "@pellux/goodvibes-daemon-sdk": "0.33.5",
-    "@pellux/goodvibes-errors": "0.33.5",
-    "@pellux/goodvibes-operator-sdk": "0.33.5",
-    "@pellux/goodvibes-peer-sdk": "0.33.5",
-    "@pellux/goodvibes-transport-core": "0.33.5",
-    "@pellux/goodvibes-transport-http": "0.33.5",
-    "@pellux/goodvibes-transport-realtime": "0.33.5"
+    "@pellux/goodvibes-contracts": "0.33.7",
+    "@pellux/goodvibes-daemon-sdk": "0.33.7",
+    "@pellux/goodvibes-errors": "0.33.7",
+    "@pellux/goodvibes-operator-sdk": "0.33.7",
+    "@pellux/goodvibes-peer-sdk": "0.33.7",
+    "@pellux/goodvibes-transport-core": "0.33.7",
+    "@pellux/goodvibes-transport-http": "0.33.7",
+    "@pellux/goodvibes-transport-realtime": "0.33.7"
   },
   "optionalDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",