@segmentstream/agent 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+SegmentStream Agent SDK
+Copyright 2026 SegmentStream

package/README.md

@@ -1,3 +1,179 @@
-# Temporary Holding Version
+# @segmentstream/agent
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The SegmentStream extension for a workspace's agent on [eve](https://www.npmjs.com/package/eve).
+It gives the agent the workspace's ontology as tools, acting as the member who is talking to it,
+and puts it behind the workspace's Telegram bot without a bot token in the deployment: Telegram
+calls go through the workspace's connection, unknown senders pair with a member first, voice
+messages become text, and group chats are answered only when the agent is addressed or asked for
+something it does.
+
+The package is built against one eve version, `0.76.3`, and the workspace's `agent/` pins the same
+one. eve and the package move together.
+
+## Install
+
+```sh
+npm install @segmentstream/agent eve@0.76.3
+```
+
+## Set up
+
+The workspace's `agent/` directory is an eve app in eve's flat layout, a package of its own like
+`ontology/`:
+
+```text
+agent/
+├── package.json            # eve and @segmentstream/agent, both pinned; "build": "eve build"
+├── segmentstream.json      # what the extension mounts, and what the platform reads at deploy
+├── agent.ts                # model, reasoning, limits
+├── instructions.md         # who the company is, how the agent behaves
+└── extensions/
+    └── segmentstream.ts    # mounts this package with segmentstream.json
+```
+
+**`extensions/segmentstream.ts`** mounts the extension. The file name is the mount's namespace, so
+every contribution is named `segmentstream__…`:
+
+```ts
+import { segmentstream } from "@segmentstream/agent/extension";
+
+import config from "../segmentstream.json";
+
+export default segmentstream(config);
+```
+
+**`agent.ts`** chooses the model once per session:
+
+```ts
+import { defineAgent } from "eve";
+import { segmentstream } from "@segmentstream/agent";
+
+export default defineAgent({
+  defaultTools: false,
+  model: segmentstream.model({
+    default: "spacexai/grok-4.7",
+    byRole: { finance: "anthropic/claude-opus-5.5" },
+    preview: "google/gemini-flash",
+  }),
+  reasoning: "medium",
+  limits: { maxTokenCostUsdPerSession: 2 },
+});
+```
+
+`segmentstream.model()` resolves on `session.started`. On a preview deployment it returns `preview`
+when set. Otherwise it returns the model of the first `byRole` entry whose role the member holds, in
+the order written, and `default` when none matches. The roles come from the member's pairing, not
+from the message. The model is never switched mid-session, which keeps the provider's prompt cache.
+A group shares one session, so its model follows the member who started it; each member's rights
+are still their own, because the ontology connection acts as the member of the current turn.
+
+Both entry points export the same handle: `@segmentstream/agent` and
+`@segmentstream/agent/extension`.
+
+## `segmentstream.json`
+
+```json
+{
+  "channels": {
+    "telegram": { "connection": "telegram", "policy": "smart" }
+  }
+}
+```
+
+| Field                          | Default               | Meaning                                                                                         |
+| ------------------------------ | --------------------- | ----------------------------------------------------------------------------------------------- |
+| `channels.telegram.connection` | none                  | The Connect key whose credential is the bot token. Without `channels.telegram`, no Telegram.    |
+| `channels.telegram.policy`     | `"smart"`             | Group messages that do not address the bot: `smart` asks the decision model, `mention` observes |
+| `models.stt`                   | `"spacexai/grok-stt"` | The AI Gateway transcription model for voice messages; `false` leaves them untranscribed        |
+| `models.decision`              | `"typesafe-ai/jev"`   | The AI Gateway decision model of the inbound router                                             |
+| `ontology.connection`          | `true`                | Whether the agent reaches the ontology over MCP                                                 |
+
+An unknown field or an invalid value fails the mount with `SegmentStreamAgentConfigError`, naming
+each path. `manifestOf(config)` returns the normalized configuration, defaults applied, for the
+platform's deployment manifest.
+
+## What the extension contributes
+
+| Name                      | Slot           | What it does                                                                                                    |
+| ------------------------- | -------------- | --------------------------------------------------------------------------------------------------------------- |
+| `segmentstream__ontology` | `connections`  | The app's `/mcp`, resolved per turn for the turn's member. No member, no connection.                            |
+| `segmentstream__telegram` | `channels`     | `POST /eve/v1/telegram`: Telegram through the connection, with pairing, routing and voice.                      |
+| platform rules            | `instructions` | Changes go through actions; `describe` gives the catalog; tools are already narrowed; when to answer `[SILENT]` |
+
+### The ontology
+
+The connection calls `{origin}/mcp` with the deployment's Vercel OIDC token as the bearer and the
+member's id in `X-SegmentStream-Act-As`. The ontology service verifies the token, refuses a member
+who is inactive or has no live pairing, lists only the tools the member may run and records the
+member in history. A turn whose principal carries no `memberId`, such as an unpaired caller,
+gets no ontology connection at all. Each member gets their own connection instance, so members who
+share a group chat's session never share a client.
+
+### Telegram
+
+- **Credentials.** eve's Telegram channel puts the bot token in the URL path. The adapter gives it a
+  placeholder token and an origin that does not resolve, and its `fetch` sends each method call to
+  the connection's `bot` API and each download to its `file` API through SegmentStream's connection
+  proxy. The token stays in SegmentStream.
+- **Webhook.** A webhook is accepted only with `X-Telegram-Bot-Api-Secret-Token` equal to
+  `SEGMENTSTREAM_AGENT_WEBHOOK_SECRET`, compared in constant time. The platform generates the
+  secret and registers the webhook after each production deployment.
+- **Production only.** Outside `VERCEL_ENV=production` the route answers 200 and does nothing, so a
+  preview never answers a real chat. Without `channels.telegram` it answers 404.
+- **Pairing.** Messages from bots and channel posts are dropped. The sender's Telegram account is
+  looked up with the ontology service on every message, so a revocation stops at once. An unknown
+  sender who writes privately gets a link to `/agent/connect?code=…`, valid for ten minutes. In a
+  group, the agent only asks an unknown sender to message it privately, because anyone in the group
+  could open a link posted there. A revoked pairing or an inactive member gets a short refusal.
+- **Who the agent is.** A paired sender's turn runs with the principal id `telegram:<user>`
+  (`telegram:<chat>:<user>` in groups) and the attributes `memberId`, `memberName`, `roles`,
+  `chatId`, `chatType` and `username`.
+- **Routing.** A private chat, a mention of the bot, a reply to it and a command are always
+  answered. Under `smart`, any other group message is put to one `decide` question on the decision
+  model, with the agent's description and the chat's recent observed messages. A message that is not
+  answered joins a ring of the chat's last 30 observed messages. The next answered message carries
+  the ring into its turn as context. A failed decision observes.
+- **Voice.** Voice messages, audio files and video notes are downloaded through the connection and
+  transcribed with `models.stt` through AI Gateway. The transcript becomes the message, with a note
+  such as `[voice message, 12 s]` in context. A file over the proxy's 2 MiB limit, or a failed
+  transcription, reaches the agent as a note saying so. Photos and documents up to 2 MiB reach the
+  agent as eve's file parts.
+- **Silence.** When the model answers a routed message with exactly `[SILENT]` (or `NO_REPLY`), in
+  any case, nothing is sent to the chat. The turn stays in the session.
+
+The observed ring lives in process memory, per chat and forum topic, because eve's durable
+`defineState` is session state and an observed message has no session. A new function instance
+starts with an empty ring.
+
+## Local development
+
+`eve dev` in `agent/` runs the agent locally. The Telegram channel stays silent outside production.
+To reach a local ontology service, set `SEGMENTSTREAM_AGENT_ONTOLOGY_URL=http://localhost:3000`.
+`vercel env pull` writes a `VERCEL_OIDC_TOKEN` for the token. The ontology service admits only
+production tokens of the workspace's project, though, so a local run gets the ontology only from a
+local ontology service configured to accept that token.
+
+Building the package needs Node.js 24, as eve does: `npm run build` runs `eve extension build`,
+which writes the agent-shaped `dist/extension` tree, its declarations and eve's compatibility
+manifest.
+
+## Environment
+
+The platform sets every variable on the workspace's Vercel project. None of them is a model key or
+a provider token.
+
+| Variable                             | Used for                                                                        |
+| ------------------------------------ | ------------------------------------------------------------------------------- |
+| `VERCEL_PROJECT_PRODUCTION_URL`      | The app's origin: `/mcp`, `/api/ontology/agent/*` and the `/agent/connect` link |
+| `SEGMENTSTREAM_AGENT_ONTOLOGY_URL`   | Overrides that origin in local development                                      |
+| `SEGMENTSTREAM_URL`                  | backend-next, where the connection proxy answers                                |
+| `SEGMENTSTREAM_WORKSPACE_ID`         | The workspace in the proxy's path                                               |
+| `SEGMENTSTREAM_ORGANIZATION_ID`      | The tenant the proxy selects                                                    |
+| `SEGMENTSTREAM_AGENT_WEBHOOK_SECRET` | The Telegram webhook secret; the only secret                                    |
+| `VERCEL_ENV`                         | Channels run only in `production`; `preview` selects the preview model          |
+| `VERCEL_OIDC_TOKEN`                  | The runtime token outside a request; Vercel sends it on each request otherwise  |
+| `AI_GATEWAY_API_KEY`                 | Optional. AI Gateway uses the OIDC token when it is unset                       |
+
+## License
+
+Apache-2.0

package/dist/extension/_manifest.json

@@ -0,0 +1,13 @@
+{
+  "kind": "eve-extension",
+  "formatVersion": 2,
+  "builtWithEve": "0.76.3",
+  "requires": {
+    "extension": 1,
+    "tool": 85,
+    "channel": 58,
+    "connection": 46,
+    "instructions": 2,
+    "config": 1
+  }
+}

package/dist/extension/channels/telegram.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `segmentstream__telegram` at `POST /eve/v1/telegram`: the workspace's Telegram bot, reached
+ * through the connection named in `channels.telegram`. Without that setting the route answers 404.
+ */
+declare const _default: import("eve/channels/telegram").TelegramChannel;
+export default _default;

package/dist/extension/channels/telegram.mjs

@@ -0,0 +1,15 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import segmentstream from "../extension.mjs";
+import { segmentstreamTelegram } from "../lib/telegram/adapter.mjs";
+import { decide } from "eve/ai";
+var telegram_default = segmentstreamTelegram({
+	settings: () => segmentstream.config.channels.telegram,
+	models: () => segmentstream.config.models,
+	decide: (options) => decide(options)
+});
+export { telegram_default as default };

package/dist/extension/config.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The extension's configuration: `agent/segmentstream.json`, mounted by
+ * `agent/extensions/segmentstream.ts` and read by the platform at deploy.
+ *
+ * eve validates a mount's configuration with a Standard Schema. The schema below is written by
+ * hand, so the package adds no second schema library next to the Effect Schema the rest of the
+ * repository uses.
+ */
+export declare const TELEGRAM_POLICIES: readonly ["mention", "smart"];
+/**
+ * How the Telegram channel treats group messages that do not address the bot: `smart` asks the
+ * decision model whether to answer, `mention` only observes them.
+ */
+export type TelegramPolicy = (typeof TELEGRAM_POLICIES)[number];
+/** The speech-to-text model voice messages are transcribed with, in the AI Gateway catalog. */
+export declare const DEFAULT_STT_MODEL = "spacexai/grok-stt";
+/** The decision model the inbound router asks; eve's `decide` default. */
+export declare const DEFAULT_DECISION_MODEL = "typesafe-ai/jev";
+/**
+ * `agent/segmentstream.json` as authored. A JSON import widens string literals to `string` and
+ * `false` to `boolean`, so the accepted types are wider than the values validation allows.
+ */
+export interface SegmentStreamAgentConfigInput {
+    readonly channels?: {
+        readonly telegram?: {
+            /** The Connect key whose credential is the bot token, such as `telegram`. */
+            readonly connection: string;
+            /** `smart` (default) or `mention`. */
+            readonly policy?: string;
+        };
+    };
+    readonly models?: {
+        /** A Gateway transcription model, or `false` to leave voice messages untranscribed. */
+        readonly stt?: string | boolean;
+        /** The Gateway decision model of the inbound router. */
+        readonly decision?: string;
+    };
+    readonly ontology?: {
+        /** Whether the agent reaches the ontology over MCP. On by default. */
+        readonly connection?: boolean;
+    };
+}
+export interface TelegramSettings {
+    readonly connection: string;
+    readonly policy: TelegramPolicy;
+}
+/** The validated configuration with defaults applied. It stays JSON-serializable. */
+export interface SegmentStreamAgentConfig {
+    readonly channels: {
+        readonly telegram: TelegramSettings | null;
+    };
+    readonly models: {
+        readonly stt: string | false;
+        readonly decision: string;
+    };
+    readonly ontology: {
+        readonly connection: boolean;
+    };
+}
+/** One validation failure, in Standard Schema's issue shape. */
+export interface ConfigIssue {
+    readonly message: string;
+    readonly path: ReadonlyArray<string>;
+}
+type Validation = {
+    readonly value: SegmentStreamAgentConfig;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<ConfigIssue>;
+};
+/** `agent/segmentstream.json` is invalid. The message lists every issue with its path. */
+export declare class SegmentStreamAgentConfigError extends Error {
+    readonly issues: ReadonlyArray<ConfigIssue>;
+    readonly name = "SegmentStreamAgentConfigError";
+    constructor(issues: ReadonlyArray<ConfigIssue>);
+}
+/** Validates the authored configuration and applies the defaults. */
+export declare function validateConfig(input: unknown): Validation;
+/**
+ * The Standard Schema eve validates the mount with. `types` exists only for type inference, as the
+ * Standard Schema specification allows.
+ */
+export declare const configSchema: {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: "segmentstream";
+        readonly validate: typeof validateConfig;
+        readonly types: {
+            readonly input: SegmentStreamAgentConfigInput;
+            readonly output: SegmentStreamAgentConfig;
+        };
+    };
+};
+/**
+ * The normalized configuration a mount declares, for the deployment manifest of later phases.
+ * Throws {@link SegmentStreamAgentConfigError} when the configuration is invalid.
+ */
+export declare function manifestOf(config: SegmentStreamAgentConfigInput): SegmentStreamAgentConfig;
+export {};

package/dist/extension/config.mjs

@@ -0,0 +1,144 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+const CONNECTION_KEY = /^[a-z][a-z0-9_]{0,63}$/;
+const TELEGRAM_POLICIES = ["mention", "smart"];
+const DEFAULT_STT_MODEL = "spacexai/grok-stt";
+const DEFAULT_DECISION_MODEL = "typesafe-ai/jev";
+var SegmentStreamAgentConfigError = class extends Error {
+	issues;
+	name = "SegmentStreamAgentConfigError";
+	constructor(issues) {
+		super(`agent/segmentstream.json is invalid: ${issues.map((issue) => issue.path.length === 0 ? issue.message : `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);
+		this.issues = issues;
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function section(input) {
+	if (input.value === void 0) return;
+	if (!isRecord(input.value)) {
+		input.issues.push({
+			message: "must be an object",
+			path: input.path
+		});
+		return;
+	}
+	for (const key of Object.keys(input.value)) if (!input.allowed.includes(key)) input.issues.push({
+		message: "is not a known setting",
+		path: [...input.path, key]
+	});
+	return input.value;
+}
+function isTelegramPolicy(value) {
+	return TELEGRAM_POLICIES.some((policy) => policy === value);
+}
+function telegramSettings(value, issues) {
+	const path = ["channels", "telegram"];
+	const telegram = section({
+		value,
+		path,
+		allowed: ["connection", "policy"],
+		issues
+	});
+	if (telegram === void 0) return null;
+	const connection = telegram.connection;
+	const policy = telegram.policy ?? "smart";
+	if (typeof connection !== "string" || !CONNECTION_KEY.test(connection)) issues.push({
+		message: "must be a connection key such as telegram",
+		path: [...path, "connection"]
+	});
+	if (!isTelegramPolicy(policy)) issues.push({
+		message: "must be \"smart\" or \"mention\"",
+		path: [...path, "policy"]
+	});
+	return typeof connection === "string" && isTelegramPolicy(policy) ? {
+		connection,
+		policy
+	} : null;
+}
+function modelId(input) {
+	if (input.value === void 0) return input.fallback;
+	if (typeof input.value !== "string" || input.value === "" || input.value !== input.value.trim()) {
+		input.issues.push({
+			message: "must be a Gateway model id such as provider/model",
+			path: input.path
+		});
+		return input.fallback;
+	}
+	return input.value;
+}
+function validateConfig(input) {
+	const issues = [];
+	const root = section({
+		value: input ?? {},
+		path: [],
+		allowed: [
+			"channels",
+			"models",
+			"ontology"
+		],
+		issues
+	});
+	const channels = section({
+		value: root?.channels,
+		path: ["channels"],
+		allowed: ["telegram"],
+		issues
+	});
+	const models = section({
+		value: root?.models,
+		path: ["models"],
+		allowed: ["stt", "decision"],
+		issues
+	});
+	const ontology = section({
+		value: root?.ontology,
+		path: ["ontology"],
+		allowed: ["connection"],
+		issues
+	});
+	const telegram = telegramSettings(channels?.telegram, issues);
+	const stt = models?.stt === false ? false : modelId({
+		value: models?.stt,
+		fallback: DEFAULT_STT_MODEL,
+		path: ["models", "stt"],
+		issues
+	});
+	const decision = modelId({
+		value: models?.decision,
+		fallback: DEFAULT_DECISION_MODEL,
+		path: ["models", "decision"],
+		issues
+	});
+	const connection = ontology?.connection ?? true;
+	if (typeof connection !== "boolean") issues.push({
+		message: "must be true or false",
+		path: ["ontology", "connection"]
+	});
+	if (issues.length > 0) return { issues };
+	return { value: {
+		channels: { telegram },
+		models: {
+			stt,
+			decision
+		},
+		ontology: { connection: connection === true }
+	} };
+}
+const configSchema = { "~standard": {
+	version: 1,
+	vendor: "segmentstream",
+	validate: validateConfig,
+	types: void 0
+} };
+function manifestOf(config) {
+	const validation = validateConfig(config);
+	if (validation.issues !== void 0) throw new SegmentStreamAgentConfigError(validation.issues);
+	return validation.value;
+}
+export { DEFAULT_DECISION_MODEL, DEFAULT_STT_MODEL, SegmentStreamAgentConfigError, TELEGRAM_POLICIES, configSchema, manifestOf, validateConfig };