@cavi-ai/api-client 0.1.0

package/dist/providers/hermes/agent-config.js

@@ -0,0 +1,242 @@
+import { GatewayAgentConfigApiClient, GatewayAgentConfigApiError, assertAgentProfileId, buildAgentConfigFromConfigSnapshot, findAgentProfile, isMissingAgentConfigRouteError, normalizeAgentProfiles, setAgentConfigPathValue, } from "../../core/gateway/agent/config.js";
+import { isSensitiveKey } from "../../core/http/redaction.js";
+import { HERMES_AGENT_CONFIG_API_ENDPOINTS } from "../../contracts/paths.js";
+/** Cookie the Hermes host-config plugin reads to select the active profile. */
+export const HERMES_PROFILE_COOKIE_NAME = "hermes_profile";
+const REASONING_EFFORT_OPTIONS = [
+    { value: "", label: "Default" },
+    { value: "none", label: "None" },
+    { value: "minimal", label: "Minimal" },
+    { value: "low", label: "Low" },
+    { value: "medium", label: "Medium" },
+    { value: "high", label: "High" },
+    { value: "xhigh", label: "Extra high" },
+];
+function cleanString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : null;
+}
+export function hermesAgentProfileConfigYamlPath(agentId) {
+    const id = assertAgentProfileId(agentId);
+    return id === "default"
+        ? "~/.hermes/config.yaml"
+        : `~/.hermes/profiles/${id}/config.yaml`;
+}
+export function hermesProfileCookieHeader(agentId) {
+    return `${HERMES_PROFILE_COOKIE_NAME}=${assertAgentProfileId(agentId)}`;
+}
+function modelOptionsFromHermesWebuiSnapshot(modelsPayload) {
+    const options = [];
+    for (const groupValue of asArray(asRecord(modelsPayload).groups)) {
+        const group = asRecord(groupValue);
+        for (const modelValue of asArray(group.models)) {
+            const model = asRecord(modelValue);
+            const value = cleanString(model.id) || cleanString(model.value) || cleanString(model.name);
+            if (!value)
+                continue;
+            options.push({
+                value,
+                label: cleanString(model.label) || cleanString(model.name) || value,
+            });
+        }
+    }
+    return options;
+}
+function mcpServerNamesFromHermesWebuiSnapshot(mcpServersPayload) {
+    return asArray(asRecord(mcpServersPayload).servers)
+        .map((value) => {
+        if (typeof value === "string")
+            return cleanString(value);
+        const server = asRecord(value);
+        return cleanString(server.name) || cleanString(server.id);
+    })
+        .filter(Boolean);
+}
+function buildHermesWebuiSnapshotConfig(input) {
+    const config = asRecord(input.config);
+    if (Object.keys(config).length > 0)
+        return config;
+    let synthetic = {};
+    const models = asRecord(input.models);
+    const defaultModel = cleanString(models.default_model);
+    if (defaultModel) {
+        synthetic = setAgentConfigPathValue(synthetic, "model.default", defaultModel);
+    }
+    const activeProvider = cleanString(models.active_provider);
+    if (activeProvider) {
+        synthetic = setAgentConfigPathValue(synthetic, "model.provider", activeProvider);
+    }
+    const reasoning = asRecord(input.reasoning);
+    const reasoningEffort = cleanString(reasoning.reasoning_effort);
+    if (reasoningEffort) {
+        synthetic = setAgentConfigPathValue(synthetic, "agent.reasoning_effort", reasoningEffort);
+    }
+    const showReasoning = asBoolean(reasoning.show_reasoning);
+    if (showReasoning !== null) {
+        synthetic = setAgentConfigPathValue(synthetic, "display.show_reasoning", showReasoning);
+    }
+    const mcpServers = mcpServerNamesFromHermesWebuiSnapshot(input.mcpServers);
+    if (mcpServers.length > 0) {
+        synthetic = setAgentConfigPathValue(synthetic, "mcp_servers.enabled", mcpServers);
+    }
+    return synthetic;
+}
+function buildHermesWebuiSnapshotSchema(input) {
+    const schema = asRecord(input.schema);
+    if (Object.keys(schema).length > 0)
+        return schema;
+    const fields = {};
+    const modelOptions = modelOptionsFromHermesWebuiSnapshot(input.models);
+    if (cleanString(asRecord(input.models).default_model)) {
+        fields["model.default"] = {
+            type: modelOptions.length > 0 ? "select" : "string",
+            category: "model",
+            description: "Default model",
+            ...(modelOptions.length > 0 ? { options: modelOptions } : {}),
+        };
+    }
+    if (cleanString(asRecord(input.models).active_provider)) {
+        fields["model.provider"] = {
+            type: "string",
+            category: "model",
+            description: "Active provider",
+        };
+    }
+    if (cleanString(asRecord(input.reasoning).reasoning_effort)) {
+        fields["agent.reasoning_effort"] = {
+            type: "select",
+            category: "agent",
+            description: "Reasoning effort",
+            options: REASONING_EFFORT_OPTIONS,
+        };
+    }
+    if (asBoolean(asRecord(input.reasoning).show_reasoning) !== null) {
+        fields["display.show_reasoning"] = {
+            type: "boolean",
+            category: "display",
+            description: "Show reasoning",
+        };
+    }
+    if (mcpServerNamesFromHermesWebuiSnapshot(input.mcpServers).length > 0) {
+        fields["mcp_servers.enabled"] = {
+            type: "list",
+            category: "mcp_servers",
+            description: "Enabled MCP servers",
+        };
+    }
+    return Object.keys(fields).length > 0
+        ? { fields, category_order: ["model", "agent", "mcp_servers", "display"] }
+        : {};
+}
+export function buildAgentConfigFromHermesConfigSnapshot(input) {
+    return buildAgentConfigFromConfigSnapshot({
+        ...input,
+        defaultSourcePath: hermesAgentProfileConfigYamlPath,
+    });
+}
+export function buildAgentConfigFromHermesWebuiSnapshot(input) {
+    const agentId = assertAgentProfileId(input.agentId);
+    const profile = input.profile ??
+        findAgentProfile(normalizeAgentProfiles(input.profiles), agentId) ??
+        null;
+    return buildAgentConfigFromHermesConfigSnapshot({
+        agentId,
+        profile,
+        config: buildHermesWebuiSnapshotConfig(input),
+        schema: buildHermesWebuiSnapshotSchema(input),
+        defaults: input.defaults,
+        fetchedAt: input.fetchedAt,
+        etag: input.etag,
+    });
+}
+function unsupportedHermesWebuiPatchKeys(diff) {
+    return Object.keys(diff).filter((key) => {
+        return key.startsWith("profile.") || isSensitiveKey(key);
+    });
+}
+export class HermesAgentConfigApiClient extends GatewayAgentConfigApiClient {
+    constructor(options) {
+        super(options, {
+            endpoints: HERMES_AGENT_CONFIG_API_ENDPOINTS,
+            surface: "hermes-agent-config-api",
+            defaultSourcePath: hermesAgentProfileConfigYamlPath,
+        });
+    }
+    async getProfileConfig(agentId) {
+        const id = assertAgentProfileId(agentId);
+        try {
+            return await super.getProfileConfig(id);
+        }
+        catch (error) {
+            if (!isMissingAgentConfigRouteError(error))
+                throw error;
+            return this.getProfileConfigViaHermesWebui(id);
+        }
+    }
+    async getProfileConfigViaHermesWebui(agentId) {
+        const id = assertAgentProfileId(agentId);
+        const profiles = normalizeAgentProfiles(await this.requestJson(this.endpoints.profiles));
+        const profile = findAgentProfile(profiles, id);
+        if (!profile && id !== "default") {
+            throw new GatewayAgentConfigApiError(`Agent profile "${id}" was not found.`, {
+                path: this.endpoints.profiles,
+                status: 404,
+            });
+        }
+        const headers = { Cookie: hermesProfileCookieHeader(id) };
+        const [config, schema, defaults] = await Promise.all([
+            this.requestJson(this.endpoints.config, { headers }),
+            this.requestJson(this.endpoints.configSchema, { headers }),
+            this.requestJson(this.endpoints.configDefaults, { headers }),
+        ]);
+        return buildAgentConfigFromHermesWebuiSnapshot({
+            agentId: id,
+            profile,
+            config,
+            schema,
+            defaults,
+            fetchedAt: Date.now(),
+        });
+    }
+    async patchProfileConfig(agentId, diff, options = {}) {
+        const id = assertAgentProfileId(agentId);
+        try {
+            return await super.patchProfileConfig(id, diff, options);
+        }
+        catch (error) {
+            if (!isMissingAgentConfigRouteError(error))
+                throw error;
+            return this.patchProfileConfigViaHermesWebui(id, diff);
+        }
+    }
+    async patchProfileConfigViaHermesWebui(agentId, diff) {
+        const id = assertAgentProfileId(agentId);
+        const unsupported = unsupportedHermesWebuiPatchKeys(diff);
+        if (unsupported.length > 0) {
+            throw new GatewayAgentConfigApiError(`These config keys are not editable through the mobile editor: ${unsupported.join(", ")}.`);
+        }
+        const headers = { Cookie: hermesProfileCookieHeader(id) };
+        let nextConfig = asRecord(await this.requestJson(this.endpoints.config, { headers }));
+        for (const [key, value] of Object.entries(diff)) {
+            if (value === undefined)
+                continue;
+            nextConfig = setAgentConfigPathValue(nextConfig, key, value);
+        }
+        await this.requestJson(this.endpoints.config, {
+            method: "PUT",
+            headers,
+            body: { config: nextConfig },
+        });
+        return this.getProfileConfigViaHermesWebui(id);
+    }
+}

package/dist/providers/hermes/chat-run.d.ts

@@ -0,0 +1,106 @@
+import { type RunStreamApprovalChoice, type RunStreamEvent } from "../../core/gateway/run/contracts.js";
+import { type RunPreviewSnapshotFetcher } from "../../core/gateway/run/event-stream.js";
+/**
+ * Provider-neutral metadata bag attached to a Hermes chat run. Free-form by
+ * design — the gateway forwards untyped fields to route handlers. Use
+ * {@link sanitizeHermesRouteMetadata} before sending to strip dict-valued
+ * route binding keys some routers reject as malformed.
+ */
+export type HermesRouteMetadata = Record<string, unknown>;
+export type GatewayRouteMetadata = HermesRouteMetadata;
+/**
+ * Gateway route bindings are scalar fields (`targetProfile`, `targetAgent`,
+ * `sessionKey`, `action`). Some routers validate dict-valued `binding` /
+ * `routeBinding` keys and reject the whole chat turn — strip those before
+ * forwarding metadata.
+ */
+export declare function sanitizeHermesRouteMetadata(metadata: HermesRouteMetadata | undefined): HermesRouteMetadata | undefined;
+export declare const sanitizeGatewayRouteMetadata: typeof sanitizeHermesRouteMetadata;
+/**
+ * A file sent with a chat turn. Base64 keeps it on the HTTP run path (gateway
+ * field names are sent in snake AND camel case so the server can read whichever
+ * casing it accepts).
+ */
+export type HermesChatRunAttachment = {
+    name: string;
+    mimeType: string;
+    size: number;
+    /** Base64-encoded file bytes (no data: prefix). */
+    dataBase64: string;
+};
+export type GatewayChatRunAttachment = HermesChatRunAttachment;
+export type StartHermesChatRunParams = {
+    httpBase: string;
+    authToken: string;
+    clientId: string;
+    input: string;
+    sessionId: string;
+    /** Defaults to {@link sessionId} when omitted. */
+    sessionKey?: string;
+    targetProfile?: string;
+    targetAgent?: string;
+    action?: string;
+    metadata?: HermesRouteMetadata;
+    attachments?: readonly HermesChatRunAttachment[];
+    signal?: AbortSignal;
+};
+export type StartGatewayChatRunParams = StartHermesChatRunParams;
+/**
+ * Starts a Hermes chat run through the configured run endpoint. Sends route binding fields in
+ * both snake AND camel case for cross-version gateway compatibility. Sanitizes
+ * metadata via {@link sanitizeHermesRouteMetadata} before forwarding.
+ *
+ * Returns the new `run_id`. Pair with {@link HermesSseRunEventProvider} or
+ * {@link streamHermesChatRun} to consume the event stream.
+ */
+export declare function startHermesChatRun(params: StartHermesChatRunParams): Promise<{
+    runId: string;
+}>;
+export declare const startGatewayChatRun: typeof startHermesChatRun;
+export type ResolveHermesChatRunApprovalParams = {
+    httpBase: string;
+    authToken: string;
+    clientId: string;
+    runId: string;
+    choice: RunStreamApprovalChoice;
+    sessionKey?: string;
+    signal?: AbortSignal;
+};
+export type ResolveGatewayChatRunApprovalParams = ResolveHermesChatRunApprovalParams;
+/**
+ * Resolves a pending approval gate through the configured run approval endpoint with
+ * one of the canonical {@link RunStreamApprovalChoice} options.
+ */
+export declare function resolveHermesChatRunApproval(params: ResolveHermesChatRunApprovalParams): Promise<void>;
+export declare const resolveGatewayChatRunApproval: typeof resolveHermesChatRunApproval;
+export type StreamHermesChatRunResult = {
+    /**
+     * True when at least one terminal lifecycle event was observed (delta /
+     * completed / failed / cancelled). Callers use this to detect a silent
+     * stream (no response) and trigger a fallback transport.
+     */
+    sawAssistantResponseEvent: boolean;
+};
+export type StreamGatewayChatRunResult = StreamHermesChatRunResult;
+export type StreamHermesChatRunParams = StartHermesChatRunParams & {
+    onEvent: (event: RunStreamEvent) => void;
+    /**
+     * Optional snapshot fetcher — when present, composes a tool-event fallback
+     * via {@link RunPreviewPollProvider} so tool calls land in the stream even
+     * when the Hermes SSE doesn't surface them. Once Hermes SSE catches up on
+     * tool events, the fallback becomes a no-op automatically.
+     */
+    fetchToolEventSnapshot?: RunPreviewSnapshotFetcher;
+};
+export type StreamGatewayChatRunParams = StreamHermesChatRunParams;
+/**
+ * Canonical orchestrator: starts a Hermes chat run, subscribes to its event
+ * stream via {@link HermesSseRunEventProvider}, and optionally stitches in
+ * tool events from the post-hoc run preview via
+ * {@link createRunStreamWithToolFallback}. Consumers receive canonical
+ * {@link RunStreamEvent}s on `onEvent` — switch on `event.event` against
+ * {@link RUN_STREAM_EVENT_NAMES}, never inline strings.
+ */
+export declare function streamHermesChatRun(params: StreamHermesChatRunParams): Promise<StreamHermesChatRunResult>;
+export declare const streamGatewayChatRun: typeof streamHermesChatRun;
+//# sourceMappingURL=chat-run.d.ts.map

package/dist/providers/hermes/chat-run.d.ts.map

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

package/dist/providers/hermes/chat-run.js

@@ -0,0 +1,221 @@
+import { RUN_STREAM_EVENT_NAMES, } from "../../core/gateway/run/contracts.js";
+import { HERMES_API_ENDPOINTS } from "../../contracts/paths.js";
+import { HermesSseRunEventProvider } from "./sse-run-event-provider.js";
+import { RunPreviewPollProvider, createRunStreamWithToolFallback, } from "../../core/gateway/run/event-stream.js";
+const DICT_REJECTING_ROUTE_METADATA_KEYS = new Set(["binding", "routeBinding"]);
+function isDict(value) {
+    return Boolean(value) && typeof value === "object";
+}
+/**
+ * Gateway route bindings are scalar fields (`targetProfile`, `targetAgent`,
+ * `sessionKey`, `action`). Some routers validate dict-valued `binding` /
+ * `routeBinding` keys and reject the whole chat turn — strip those before
+ * forwarding metadata.
+ */
+export function sanitizeHermesRouteMetadata(metadata) {
+    if (!metadata || Object.keys(metadata).length === 0) {
+        return undefined;
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(metadata)) {
+        if (DICT_REJECTING_ROUTE_METADATA_KEYS.has(key) && isDict(value)) {
+            continue;
+        }
+        out[key] = value;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export const sanitizeGatewayRouteMetadata = sanitizeHermesRouteMetadata;
+function serializeAttachments(attachments) {
+    return attachments.map((a) => ({
+        name: a.name,
+        mime_type: a.mimeType,
+        mimeType: a.mimeType,
+        size: a.size,
+        data_base64: a.dataBase64,
+        dataBase64: a.dataBase64,
+    }));
+}
+function addOptionalRunField(body, key, value) {
+    const trimmed = value?.trim();
+    if (trimmed)
+        body[key] = trimmed;
+}
+/**
+ * Starts a Hermes chat run through the configured run endpoint. Sends route binding fields in
+ * both snake AND camel case for cross-version gateway compatibility. Sanitizes
+ * metadata via {@link sanitizeHermesRouteMetadata} before forwarding.
+ *
+ * Returns the new `run_id`. Pair with {@link HermesSseRunEventProvider} or
+ * {@link streamHermesChatRun} to consume the event stream.
+ */
+export async function startHermesChatRun(params) {
+    const sessionKey = params.sessionKey?.trim() || params.sessionId;
+    const headers = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "X-Portal-Client-Id": params.clientId,
+        "X-Hermes-Session-Key": sessionKey,
+    };
+    if (params.authToken.trim()) {
+        headers.Authorization = `Bearer ${params.authToken.trim()}`;
+    }
+    const body = {
+        input: params.input,
+        session_id: params.sessionId,
+    };
+    addOptionalRunField(body, "targetProfile", params.targetProfile);
+    addOptionalRunField(body, "target_profile", params.targetProfile);
+    addOptionalRunField(body, "targetAgent", params.targetAgent);
+    addOptionalRunField(body, "target_agent", params.targetAgent);
+    addOptionalRunField(body, "action", params.action);
+    if (params.metadata && Object.keys(params.metadata).length > 0) {
+        const sanitized = sanitizeHermesRouteMetadata(params.metadata);
+        if (sanitized)
+            body.metadata = sanitized;
+    }
+    if (params.attachments && params.attachments.length > 0) {
+        body.attachments = serializeAttachments(params.attachments);
+    }
+    const response = await fetch(`${params.httpBase}${HERMES_API_ENDPOINTS.runs}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        cache: "no-store",
+        signal: params.signal,
+    });
+    if (!response.ok) {
+        throw new Error(`run start failed with HTTP ${response.status}`);
+    }
+    const payload = (await response.json());
+    const runId = typeof payload.run_id === "string" ? payload.run_id : "";
+    if (!runId) {
+        throw new Error("run start missing run_id");
+    }
+    return { runId };
+}
+export const startGatewayChatRun = startHermesChatRun;
+/**
+ * Resolves a pending approval gate through the configured run approval endpoint with
+ * one of the canonical {@link RunStreamApprovalChoice} options.
+ */
+export async function resolveHermesChatRunApproval(params) {
+    const headers = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "X-Portal-Client-Id": params.clientId,
+    };
+    if (params.authToken.trim()) {
+        headers.Authorization = `Bearer ${params.authToken.trim()}`;
+    }
+    if (params.sessionKey?.trim()) {
+        headers["X-Hermes-Session-Key"] = params.sessionKey.trim();
+    }
+    const response = await fetch(`${params.httpBase}${HERMES_API_ENDPOINTS.runApproval(params.runId)}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ choice: params.choice }),
+        cache: "no-store",
+        signal: params.signal,
+    });
+    if (!response.ok) {
+        throw new Error(`approval resolve failed with HTTP ${response.status}`);
+    }
+}
+export const resolveGatewayChatRunApproval = resolveHermesChatRunApproval;
+/**
+ * Canonical orchestrator: starts a Hermes chat run, subscribes to its event
+ * stream via {@link HermesSseRunEventProvider}, and optionally stitches in
+ * tool events from the post-hoc run preview via
+ * {@link createRunStreamWithToolFallback}. Consumers receive canonical
+ * {@link RunStreamEvent}s on `onEvent` — switch on `event.event` against
+ * {@link RUN_STREAM_EVENT_NAMES}, never inline strings.
+ */
+export async function streamHermesChatRun(params) {
+    const sessionKey = params.sessionKey?.trim() || params.sessionId;
+    const { runId } = await startHermesChatRun({
+        httpBase: params.httpBase,
+        authToken: params.authToken,
+        clientId: params.clientId,
+        input: params.input,
+        sessionId: params.sessionId,
+        sessionKey,
+        targetProfile: params.targetProfile,
+        targetAgent: params.targetAgent,
+        action: params.action,
+        metadata: params.metadata,
+        attachments: params.attachments,
+        signal: params.signal,
+    });
+    const sseProvider = new HermesSseRunEventProvider({
+        httpBase: params.httpBase,
+        authToken: params.authToken,
+        clientId: params.clientId,
+        sessionKey,
+    });
+    const composed = params.fetchToolEventSnapshot
+        ? createRunStreamWithToolFallback({
+            primary: sseProvider,
+            toolEventFallback: new RunPreviewPollProvider({
+                fetchSnapshot: params.fetchToolEventSnapshot,
+            }),
+        })
+        : sseProvider;
+    let sawAssistantResponseEvent = false;
+    return await new Promise((resolve, reject) => {
+        let subscription = null;
+        let settled = false;
+        const settleResolve = () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ sawAssistantResponseEvent });
+        };
+        const settleReject = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error instanceof Error ? error : new Error(String(error)));
+        };
+        composed
+            .subscribe({ runId, signal: params.signal }, {
+            onEvent: (event) => {
+                if (event.event === RUN_STREAM_EVENT_NAMES.MESSAGE_DELTA ||
+                    event.event === RUN_STREAM_EVENT_NAMES.RUN_COMPLETED ||
+                    event.event === RUN_STREAM_EVENT_NAMES.RUN_FAILED ||
+                    event.event === RUN_STREAM_EVENT_NAMES.RUN_CANCELLED) {
+                    sawAssistantResponseEvent = true;
+                }
+                try {
+                    params.onEvent(event);
+                }
+                catch (handlerError) {
+                    settleReject(handlerError);
+                }
+            },
+            onError: settleReject,
+            onComplete: settleResolve,
+        })
+            .then((sub) => {
+            subscription = sub;
+            if (settled) {
+                void Promise.resolve(sub.dispose());
+            }
+        })
+            .catch(settleReject);
+        if (params.signal) {
+            const onAbort = () => {
+                if (subscription)
+                    void Promise.resolve(subscription.dispose());
+                settleReject(new Error("aborted"));
+            };
+            if (params.signal.aborted) {
+                onAbort();
+            }
+            else {
+                params.signal.addEventListener("abort", onAbort, { once: true });
+            }
+        }
+    });
+}
+export const streamGatewayChatRun = streamHermesChatRun;

package/dist/providers/hermes/client.d.ts

@@ -0,0 +1,13 @@
+import { GatewayApiClient, type GatewayCapabilities, type GatewayRunStatus } from "../../core/gateway/client/client.js";
+import type { HttpApiClientOptions } from "../../core/http/types.js";
+export type HermesCapabilities = GatewayCapabilities & {
+    object?: "hermes.api_server.capabilities" | string;
+    platform?: "hermes-agent" | string;
+};
+export type HermesRunStatus = GatewayRunStatus & {
+    object?: "hermes.run" | string;
+};
+export declare class HermesApiClient extends GatewayApiClient {
+    constructor(options: HttpApiClientOptions);
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/providers/hermes/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/providers/hermes/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACtB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,GAAG;IACrD,MAAM,CAAC,EAAE,gCAAgC,GAAG,MAAM,CAAC;IACnD,QAAQ,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG;IAC/C,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC;CAChC,CAAC;AAEF,qBAAa,eAAgB,SAAQ,gBAAgB;gBACvC,OAAO,EAAE,oBAAoB;CAG1C"}

package/dist/providers/hermes/client.js

@@ -0,0 +1,6 @@
+import { GatewayApiClient, } from "../../core/gateway/client/client.js";
+export class HermesApiClient extends GatewayApiClient {
+    constructor(options) {
+        super(options, "hermes-api-server");
+    }
+}

package/dist/providers/hermes/env-config.d.ts

@@ -0,0 +1,18 @@
+import { type HttpApiEnvSource, type HttpApiSurfaceConfig } from "../../core/env/config.js";
+export declare const HERMES_HTTP_API_ENV_KEYS: {
+    readonly baseUrl: "HERMES_API_BASE_URL";
+    readonly authToken: "HERMES_API_AUTH_TOKEN";
+    readonly clientId: "HERMES_API_CLIENT_ID";
+};
+export declare const HERMES_HTTP_API_ENV_ALIASES: {
+    readonly baseUrl: readonly ["EXPO_PUBLIC_HERMES_API_BASE_URL", "VITE_HERMES_API_BASE_URL", "GATEWAY_API_BASE_URL", "EXPO_PUBLIC_GATEWAY_API_BASE_URL", "VITE_GATEWAY_API_BASE_URL"];
+    readonly authToken: readonly ["EXPO_PUBLIC_HERMES_API_AUTH_TOKEN", "VITE_HERMES_API_AUTH_TOKEN", "GATEWAY_API_AUTH_TOKEN", "EXPO_PUBLIC_GATEWAY_TOKEN", "EXPO_PUBLIC_GATEWAY_API_AUTH_TOKEN", "VITE_GATEWAY_API_AUTH_TOKEN"];
+    readonly clientId: readonly ["EXPO_PUBLIC_HERMES_API_CLIENT_ID", "VITE_HERMES_API_CLIENT_ID", "GATEWAY_API_CLIENT_ID", "EXPO_PUBLIC_GATEWAY_CLIENT_ID", "EXPO_PUBLIC_GATEWAY_API_CLIENT_ID", "VITE_GATEWAY_API_CLIENT_ID"];
+};
+export type ResolveHermesHttpApiConfigOptions = {
+    defaults?: Partial<HttpApiSurfaceConfig>;
+    trimValues?: boolean;
+    includeAliases?: boolean;
+};
+export declare function resolveHermesHttpApiConfigFromEnv(env: HttpApiEnvSource, options?: ResolveHermesHttpApiConfigOptions): HttpApiSurfaceConfig;
+//# sourceMappingURL=env-config.d.ts.map

package/dist/providers/hermes/env-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-config.d.ts","sourceRoot":"","sources":["../../../src/providers/hermes/env-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAElC,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;CAwB9B,CAAC;AAEX,MAAM,MAAM,iCAAiC,GAAG;IAC9C,QAAQ,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACzC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,gBAAgB,EACrB,OAAO,GAAE,iCAAsC,GAC9C,oBAAoB,CAUtB"}

package/dist/providers/hermes/env-config.js

@@ -0,0 +1,38 @@
+import { resolveHttpSurfaceConfigFromEnv, } from "../../core/env/config.js";
+export const HERMES_HTTP_API_ENV_KEYS = {
+    baseUrl: "HERMES_API_BASE_URL",
+    authToken: "HERMES_API_AUTH_TOKEN",
+    clientId: "HERMES_API_CLIENT_ID",
+};
+export const HERMES_HTTP_API_ENV_ALIASES = {
+    baseUrl: [
+        "EXPO_PUBLIC_HERMES_API_BASE_URL",
+        "VITE_HERMES_API_BASE_URL",
+        "GATEWAY_API_BASE_URL",
+        "EXPO_PUBLIC_GATEWAY_API_BASE_URL",
+        "VITE_GATEWAY_API_BASE_URL",
+    ],
+    authToken: [
+        "EXPO_PUBLIC_HERMES_API_AUTH_TOKEN",
+        "VITE_HERMES_API_AUTH_TOKEN",
+        "GATEWAY_API_AUTH_TOKEN",
+        "EXPO_PUBLIC_GATEWAY_TOKEN",
+        "EXPO_PUBLIC_GATEWAY_API_AUTH_TOKEN",
+        "VITE_GATEWAY_API_AUTH_TOKEN",
+    ],
+    clientId: [
+        "EXPO_PUBLIC_HERMES_API_CLIENT_ID",
+        "VITE_HERMES_API_CLIENT_ID",
+        "GATEWAY_API_CLIENT_ID",
+        "EXPO_PUBLIC_GATEWAY_CLIENT_ID",
+        "EXPO_PUBLIC_GATEWAY_API_CLIENT_ID",
+        "VITE_GATEWAY_API_CLIENT_ID",
+    ],
+};
+export function resolveHermesHttpApiConfigFromEnv(env, options = {}) {
+    return resolveHttpSurfaceConfigFromEnv(env, {
+        keys: HERMES_HTTP_API_ENV_KEYS,
+        aliases: HERMES_HTTP_API_ENV_ALIASES,
+        fallback: { baseUrl: "http://127.0.0.1:8787", clientId: "cavi-api-client" },
+    }, options);
+}

package/dist/providers/hermes/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./client.js";
+export * from "./agent-config.js";
+export * from "./chat-run.js";
+export * from "./env-config.js";
+export * from "./media.js";
+export * from "./provider-module.js";
+export * from "./sse-run-event-provider.js";
+export * from "./team-registry.js";
+export * from "./team-registry-config.js";
+export * from "./websocket.js";
+export * from "./wiki.js";
+//# sourceMappingURL=index.d.ts.map