@mininglamp-oss/octo-runtime 0.0.0-stage → 1.0.0

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/dispatcher.js

@@ -0,0 +1,133 @@
+/**
+ * 执行请求构造：把本轮 Context、可信发送者和执行配置封装为 InvokeRequest。
+ * IM 默认值属于此发起入口；Context 的统一渲染与 prompt 封装交给共享执行层。
+ */
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { assertContextEnvelope, mergeContext } from "@mininglamp-oss/octo-runtime-protocol";
+import { validateImConfig } from "../lifecycle/configuration.js";
+export function createImInvocation(config, message, context, sessionKey, session, _signal, occurrenceId = message.messageId) {
+    validateImConfig(config);
+    assertContextEnvelope(context);
+    if (!session.id)
+        throw new Error("IM_SESSION_NOT_ALLOCATED");
+    const selectedAdapter = context.items.find((item) => item.namespace === "octo.execution" && item.name === "adapter")
+        ?.payload.type ??
+        config.adapter.adapter_type ??
+        "codex";
+    if (typeof selectedAdapter !== "string")
+        throw new Error("IM_EXECUTION_CONFIG_INVALID");
+    const agentSource = selectedAdapter === "openclaw" ? "preset" : "provisioned";
+    const defaultWorkdir = join(homedir(), "octo-runtime", "channels", config.bot_id);
+    const workdir = config.adapter.workdir ?? (agentSource === "provisioned" ? defaultWorkdir : undefined);
+    const submittedWorkspace = context.items.find((item) => item.namespace === "octo.execution" && item.name === "workspace");
+    if (submittedWorkspace && submittedWorkspace.payload.path !== workdir)
+        throw new Error("IM_AGENT_WORKDIR_FIXED");
+    const defaults = {
+        schema: context.schema,
+        items: [
+            {
+                namespace: "octo.execution",
+                name: "adapter",
+                payload: {
+                    type: config.adapter.adapter_type ?? "codex",
+                    ...(config.adapter.adapter_type === "openclaw"
+                        ? { provider_agent_id: config.adapter.provider_agent_id ?? "main" }
+                        : {})
+                }
+            },
+            {
+                namespace: "octo.security",
+                name: "approval_policy",
+                payload: { mode: config.approval_mode ?? "full_access" }
+            },
+            {
+                namespace: "octo.execution",
+                name: "limits",
+                payload: {
+                    run_timeout_ms: config.run_timeout_ms ?? 86_400_000,
+                    // IM 的长工具可能长时间无输出；业务可通过本轮 limits 显式收紧。
+                    tool_timeout_ms: 86_400_000
+                }
+            },
+            ...(workdir
+                ? [
+                    {
+                        namespace: "octo.execution",
+                        name: "workspace",
+                        payload: { mode: "fixed", path: workdir }
+                    }
+                ]
+                : []),
+            ...(config.adapter.model || config.adapter.effort
+                ? [
+                    {
+                        namespace: "octo.execution",
+                        name: "model",
+                        payload: {
+                            ...(config.adapter.model ? { selection: { id: config.adapter.model } } : {}),
+                            ...(config.adapter.effort ? { reasoning: { effort: config.adapter.effort } } : {})
+                        }
+                    }
+                ]
+                : [])
+        ]
+    };
+    // Channel 只组装公开 InvokeInput；执行解析和指令渲染统一交给 Host，避免再次拒绝业务 Context。
+    let submitted = context;
+    let snapshot;
+    // 执行默认项也占协议预算；只降级本渠道自动追加的辅助材料，不丢弃显式业务项。
+    for (const optional of ["history", "mention-instructions", undefined]) {
+        try {
+            snapshot = mergeContext(defaults, submitted);
+            break;
+        }
+        catch (error) {
+            if (!(error instanceof Error) || error.message !== "CONTEXT_BUDGET_EXCEEDED" || !optional)
+                throw error;
+            submitted = {
+                ...submitted,
+                items: submitted.items.filter((item) => !(item.namespace === "extra.im" &&
+                    item.name === optional &&
+                    item.payload.automatic === true))
+            };
+        }
+    }
+    if (!snapshot)
+        throw new Error("IM_EXECUTION_CONFIG_INVALID");
+    const eventId = `evt_${randomUUID()}`, runId = `run_${randomUUID()}`;
+    const prompt = message.buildInputs ? "[Image]" : message.text.trim();
+    const request = {
+        protocol_mode: "canonical",
+        invocationId: `invoke_${randomUUID()}`,
+        runId,
+        sessionId: session.id,
+        sessionGeneration: session.generation,
+        providerEpoch: session.generation,
+        agentSource,
+        inputs: [{ type: "text", text: prompt }],
+        contexts: snapshot,
+        approvalMode: snapshot.items.find((item) => item.namespace === "octo.security" && item.name === "approval_policy")?.payload.mode,
+        ...(session.providerSession ? { providerSession: session.providerSession } : {}),
+        runMetadata: {
+            ...message.runMetadata,
+            // 可信身份覆盖可选 metadata，正文或自定义字段不能冒充当前发起人和会话。
+            namespace: "im",
+            platform: "octo",
+            eventId,
+            sessionKey,
+            actorId: message.senderId,
+            channelId: message.conversationId,
+            triggerOccurrenceId: occurrenceId
+        }
+    };
+    if (config.adapter.workdir === undefined &&
+        agentSource === "provisioned" &&
+        workdir === defaultWorkdir)
+        mkdirSync(defaultWorkdir, { recursive: true, mode: 0o700 });
+    session.lastEventId = eventId;
+    session.lastRunId = runId;
+    return { request, adapterType: selectedAdapter };
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/task.d.ts

@@ -0,0 +1,34 @@
+import type { ImInvocationInput } from "./dispatcher.js";
+import { type CanonicalEvent, type InvokeEnvironment } from "@mininglamp-oss/octo-runtime-protocol";
+import type { ImBotConfig, ImExecutionPort, ImTaskAttempt } from "../contracts.js";
+export declare const DEFAULT_CODEX_RETRY: Readonly<{
+    enabled: true;
+    max_consecutive_retries: 5;
+    max_total_retries: 20;
+    recovery_timeout_ms: 120000;
+    initial_delay_ms: 2000;
+    max_delay_ms: 30000;
+}>;
+export interface ImTaskClock {
+    now(): number;
+    schedule(callback: () => void, ms: number): () => void;
+    wait(ms: number, signal: AbortSignal): Promise<void>;
+    random(): number;
+}
+/** 预算内最多 101 次尝试；只保留身份和终态，不在此缓存模型历史。 */
+export declare class ImTask {
+    #private;
+    readonly host: ImExecutionPort;
+    readonly request: ImInvocationInput;
+    readonly adapterType: string;
+    readonly environment: InvokeEnvironment;
+    readonly onAttempt: (request: ImInvocationInput) => void;
+    readonly time: ImTaskClock;
+    readonly attempts: ImTaskAttempt[];
+    stopReason?: string;
+    constructor(host: ImExecutionPort, request: ImInvocationInput, adapterType: string, config: ImBotConfig, environment: InvokeEnvironment, onAttempt: (request: ImInvocationInput) => void, time?: ImTaskClock);
+    /** reset 只阻止后续尝试，不把 reset 变成取消当前 Provider 执行。 */
+    stopRetries(): void;
+    cancel(reason?: string): Promise<boolean>;
+    events(): AsyncGenerator<CanonicalEvent>;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/task.js

@@ -0,0 +1,269 @@
+/** IM 业务恢复编排。Host 每次仍只执行一个 invoke，不承担重放决策。 */
+import { randomUUID } from "node:crypto";
+import { performance } from "node:perf_hooks";
+import { setTimeout as delay } from "node:timers/promises";
+export const DEFAULT_CODEX_RETRY = Object.freeze({
+    enabled: true,
+    max_consecutive_retries: 5,
+    max_total_retries: 20,
+    recovery_timeout_ms: 120_000,
+    initial_delay_ms: 2_000,
+    max_delay_ms: 30_000
+});
+const clock = {
+    now: () => performance.now(),
+    schedule(callback, ms) {
+        const timer = setTimeout(callback, ms);
+        timer.unref();
+        return () => clearTimeout(timer);
+    },
+    wait: async (ms, signal) => {
+        await delay(ms, undefined, { signal });
+    },
+    random: Math.random
+};
+/** 预算内最多 101 次尝试；只保留身份和终态，不在此缓存模型历史。 */
+export class ImTask {
+    host;
+    request;
+    adapterType;
+    environment;
+    onAttempt;
+    time;
+    attempts = [];
+    #policy;
+    #abort = new AbortController();
+    #retryStop = new AbortController();
+    #signal;
+    #active;
+    #cancelPending;
+    #total = 0;
+    #consecutive = 0;
+    #recoveryStarted;
+    #recoveryTimer;
+    #replaySafe = true;
+    #started = false;
+    stopReason;
+    constructor(host, request, adapterType, config, environment, onAttempt, time = clock) {
+        this.host = host;
+        this.request = request;
+        this.adapterType = adapterType;
+        this.environment = environment;
+        this.onAttempt = onAttempt;
+        this.time = time;
+        this.#policy = { ...DEFAULT_CODEX_RETRY, ...config.codex_retry };
+        this.#signal = AbortSignal.any([
+            this.#abort.signal,
+            ...(environment.signal ? [environment.signal] : [])
+        ]);
+    }
+    /** reset 只阻止后续尝试，不把 reset 变成取消当前 Provider 执行。 */
+    stopRetries() {
+        this.#retryStop.abort();
+    }
+    async cancel(reason = "IM user stop") {
+        this.#abort.abort(reason);
+        if (!this.#active)
+            return true; // 退避阶段也属于可停止的业务任务。
+        this.#cancelPending ??= this.host.cancel(this.#active, reason);
+        return (await this.#cancelPending).cancelled;
+    }
+    #stop(reason) {
+        this.stopReason ??= reason;
+        void this.cancel(reason).catch(() => undefined);
+    }
+    async #settleCancellation() {
+        await this.#cancelPending?.catch(() => undefined);
+    }
+    #recovering() {
+        if (this.#recoveryStarted !== undefined)
+            return;
+        this.#recoveryStarted = this.time.now();
+        this.#recoveryTimer = this.time.schedule(() => this.#stop("IM_RETRY_RECOVERY_TIMEOUT"), this.#policy.recovery_timeout_ms);
+    }
+    #progress() {
+        this.#recoveryTimer?.();
+        this.#recoveryTimer = undefined;
+        this.#recoveryStarted = undefined;
+        this.#consecutive = 0;
+    }
+    #countRetry() {
+        if (this.#consecutive >= this.#policy.max_consecutive_retries ||
+            this.#total >= this.#policy.max_total_retries) {
+            this.stopReason = "IM_RETRY_LIMIT_EXCEEDED";
+            return false;
+        }
+        this.#consecutive++;
+        this.#total++;
+        return true;
+    }
+    #observe(event) {
+        // 工具和交互可能产生外部副作用；首次出现后不再自动重放本轮。
+        if (event.type.startsWith("tool_call.") || event.type === "interaction.requested")
+            this.#replaySafe = false;
+        if (this.adapterType !== "codex" || !this.#policy.enabled)
+            return;
+        if (event.type === "run.notice" && event.payload.code === "retry_scheduled") {
+            this.#recovering();
+            if (!this.#countRetry())
+                this.#stop(this.stopReason);
+        }
+        else if ((event.type === "message.delta" && !!event.payload.text) ||
+            (event.type === "tool_call.update" && event.payload.status === "completed")) {
+            this.#progress();
+        }
+    }
+    #retryDelay(event) {
+        if (this.adapterType !== "codex" ||
+            !this.#policy.enabled ||
+            !this.#replaySafe ||
+            this.#retryStop.signal.aborted ||
+            this.#signal.aborted ||
+            event.type !== "run.failed")
+            return;
+        const failure = event.payload.failure;
+        // 只消费统一错误证据；retryable 本身不是自动重放授权。
+        if (!failure?.retryable ||
+            failure.source.adapter !== "codex" ||
+            !["OH-PRV-4005", "OH-PRV-4006"].includes(failure.code))
+            return;
+        this.#recovering();
+        if (!this.#countRetry())
+            return;
+        const backoff = Math.min(this.#policy.max_delay_ms, this.#policy.initial_delay_ms * 2 ** Math.min(this.#consecutive - 1, 16));
+        return Math.max(failure.retryAfterMs ?? 0, Math.min(this.#policy.max_delay_ms, Math.ceil(backoff * (1 + this.time.random() * 0.2))));
+    }
+    async *events() {
+        if (this.#started)
+            throw new Error("IM_TASK_ALREADY_STARTED");
+        this.#started = true;
+        const deadline = this.time.now() +
+            Number(this.request.contexts.items.find((item) => item.namespace === "octo.execution" && item.name === "limits")?.payload.run_timeout_ms ?? 86_400_000);
+        const clearDeadline = this.time.schedule(() => this.#stop("IM_TASK_DEADLINE"), deadline - this.time.now());
+        let request = this.request;
+        try {
+            while (!this.#signal.aborted) {
+                const remaining = Math.ceil(deadline - this.time.now());
+                if (remaining < 100) {
+                    this.#stop("IM_TASK_DEADLINE");
+                    break;
+                }
+                // 重试复用同一轮 Context，只更新剩余执行预算；复制后修改，保留原始快照供幂等记录使用。
+                request = { ...request, contexts: structuredClone(request.contexts) };
+                for (const item of request.contexts.items)
+                    if (item.namespace === "octo.execution" && item.name === "limits")
+                        item.payload.run_timeout_ms = remaining;
+                this.onAttempt(request);
+                this.#active = request.invocationId;
+                this.#cancelPending = undefined;
+                const attempt = {
+                    runId: request.runId,
+                    invocationId: request.invocationId,
+                    outcome: "running"
+                };
+                this.attempts.push(attempt);
+                let terminal;
+                try {
+                    for await (const event of this.host.invoke(request, {
+                        ...this.environment,
+                        signal: this.#signal
+                    })) {
+                        if (terminal)
+                            throw new Error("IM_FRAME_AFTER_TERMINAL");
+                        this.#observe(event);
+                        if (event.type === "session.update")
+                            request = {
+                                ...request,
+                                providerSession: structuredClone(event.payload.providerSession)
+                            };
+                        if (["run.completed", "run.failed", "run.cancelled"].includes(event.type))
+                            terminal = event;
+                        else
+                            yield event;
+                    }
+                }
+                catch (error) {
+                    attempt.outcome = "unknown";
+                    throw error;
+                }
+                finally {
+                    // 必须等待消费结束及取消回执；未知结果不会进入下一次 invoke。
+                    await this.#settleCancellation();
+                    this.#active = undefined;
+                }
+                if (!terminal)
+                    throw new Error("IM_RUN_WITHOUT_TERMINAL");
+                attempt.outcome = terminal.type;
+                if (terminal.type === "run.failed") {
+                    attempt.failureCode = terminal.payload.failure?.code;
+                    attempt.diagnosticId = terminal.payload.failure?.diagnosticId;
+                }
+                if (this.#signal.aborted) {
+                    yield terminal.type === "run.completed" ? terminal : this.#stoppedEvent();
+                    return;
+                }
+                const waitMs = this.#retryDelay(terminal);
+                if (waitMs === undefined) {
+                    yield terminal;
+                    return;
+                }
+                const recoveryLeft = this.#policy.recovery_timeout_ms - (this.time.now() - this.#recoveryStarted);
+                if (waitMs >= Math.min(deadline - this.time.now(), recoveryLeft)) {
+                    this.stopReason = "IM_RETRY_WAIT_EXCEEDS_BUDGET";
+                    yield terminal;
+                    return;
+                }
+                yield {
+                    protocolVersion: 2,
+                    type: "run.notice",
+                    payload: {
+                        noticeId: `im:retry:${this.#total}`,
+                        code: "retry_scheduled",
+                        severity: "warning",
+                        params: { attempt: this.attempts.length + 1 }
+                    }
+                };
+                try {
+                    await this.time.wait(waitMs, AbortSignal.any([this.#signal, this.#retryStop.signal]));
+                }
+                catch {
+                    yield this.#signal.aborted ? this.#stoppedEvent() : terminal;
+                    return;
+                }
+                if (this.#retryStop.signal.aborted) {
+                    yield terminal;
+                    return;
+                }
+                request = {
+                    ...request,
+                    runId: `run_${randomUUID()}`,
+                    invocationId: `invoke_${randomUUID()}`,
+                    runMetadata: {
+                        ...request.runMetadata,
+                        taskRunId: this.request.runId,
+                        attempt: this.attempts.length + 1
+                    }
+                };
+            }
+            yield this.#stoppedEvent();
+        }
+        finally {
+            clearDeadline();
+            this.#recoveryTimer?.();
+        }
+    }
+    #stoppedEvent() {
+        return this.stopReason
+            ? {
+                protocolVersion: 2,
+                type: "run.failed",
+                payload: {
+                    code: this.stopReason,
+                    message: this.stopReason === "IM_TASK_DEADLINE"
+                        ? "本轮任务已达到总运行时限。"
+                        : "模型服务连续故障，已达到自动恢复预算。"
+                }
+            }
+            : { protocolVersion: 2, type: "run.cancelled", payload: { reason: "IM user stop" } };
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/tool-environment.d.ts

@@ -0,0 +1,3 @@
+import type { ContextEnvsPayload } from "@mininglamp-oss/octo-runtime-protocol";
+/** Both values belong to the same configured channel, never the inbound message. */
+export declare function octoCliEnvironment(apiUrl: string, token: string): ContextEnvsPayload;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/tool-environment.js

@@ -0,0 +1,25 @@
+/** Both values belong to the same configured channel, never the inbound message. */
+export function octoCliEnvironment(apiUrl, token) {
+    if (!/^bf_[A-Za-z0-9_-]+$/.test(token))
+        throw new Error("IM_BOT_TOKEN_INVALID");
+    let url;
+    try {
+        url = new URL(apiUrl);
+    }
+    catch {
+        throw new Error("IM_API_URL_INVALID");
+    }
+    if (!["http:", "https:"].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash)
+        throw new Error("IM_API_URL_INVALID");
+    url.pathname = url.pathname.replace(/\/+$/, "").replace(/\/api$/, "");
+    return {
+        env_variables: [
+            { key: "OCTO_BOT_TOKEN", value: token },
+            { key: "OCTO_API_BASE_URL", value: url.href.replace(/\/+$/, "") }
+        ]
+    };
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/extra.d.ts

@@ -0,0 +1,3 @@
+import { type ChannelDependencies, type ExtraInitializer, type ExtraContext, type JsonObject } from "@mininglamp-oss/octo-runtime-daemon";
+export declare const name = "channel-gateway";
+export default function load(context: ExtraContext, config: JsonObject): ExtraInitializer<ChannelDependencies>;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/extra.js

@@ -0,0 +1,73 @@
+import { createContextLoader } from "@mininglamp-oss/octo-runtime-daemon";
+import { ImChannelManager } from "./lifecycle/manager.js";
+import { validateImBots, configuredCredential, imBotIdentity, IM_MAX_BOTS } from "./lifecycle/configuration.js";
+export const name = "channel-gateway";
+export default function load(context, config) {
+    // JSON 连接配置与宿主函数分别装配；插件保留 manager，不向宿主开放逐 Bot 控制。
+    return (dependencies) => initialize(context, config, dependencies);
+}
+async function initialize(context, config, dependencies) {
+    // 回调池归整个 Extra 所有，所有 Bot 共用额度；逆序清理时先停 manager，再等待业务 IO 退出。
+    const contexts = createContextLoader(dependencies.loadContexts, config.context_loading, context.signal);
+    context.onDispose(() => contexts.close());
+    const bots = config.bots ?? [];
+    const errors = [];
+    const invalidBots = [];
+    let channels = undefined;
+    context.onDispose(() => channels?.close());
+    context.onStatus(() => JSON.parse(JSON.stringify({ bots: [...(channels?.status ?? []), ...invalidBots], errors })));
+    if (!Array.isArray(bots) || bots.length > IM_MAX_BOTS) {
+        errors.push({ error: "IM_CONFIG_LIST_REQUIRED" });
+        return;
+    }
+    const spaces = config.authorized_space_ids;
+    if (spaces !== undefined &&
+        (!Array.isArray(spaces) || spaces.some((id) => typeof id !== "string" || !id.trim()))) {
+        errors.push({ error: "IM_AUTHORIZED_SPACES_INVALID" });
+        return;
+    }
+    const allowed = spaces;
+    channels = new ImChannelManager({
+        host: context.adapterHost,
+        signal: context.signal,
+        log: context.log,
+        // 只保存调用入口，不预取提示词；宿主更新业务存储后，下一个接纳的逻辑轮重新读取。
+        prepareContexts: (bot, signal) => contexts.load(bot, signal),
+        credentials: (bot) => Promise.resolve(configuredCredential(bot)),
+        ...(allowed
+            ? {
+                authorizeSpace: (spaceId) => {
+                    if (!allowed.includes(spaceId))
+                        throw new Error("IM_TENANT_NOT_ACTIVE");
+                }
+            }
+            : {})
+    });
+    const identities = new Set();
+    for (const [index, value] of bots.entries()) {
+        context.signal.throwIfAborted();
+        try {
+            const candidate = [value];
+            validateImBots(candidate);
+            const bot = candidate[0];
+            const key = imBotIdentity(bot);
+            if (identities.has(key))
+                throw new Error("IM_BOT_DUPLICATED");
+            identities.add(key);
+            await channels.upsert(bot);
+        }
+        catch (error) {
+            context.signal.throwIfAborted();
+            const code = error instanceof Error && /^IM_[A-Z0-9_]+$/.test(error.message)
+                ? error.message
+                : "IM_BOT_CONFIG_ERROR";
+            errors.push({ config_index: index, error: code });
+            invalidBots.push({
+                config_index: index,
+                state: "config_error",
+                connected: false,
+                error: code
+            });
+        }
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 公共入口：向 SDK/Daemon 暴露接入能力和协议类型。
+ * 装配由宿主显式完成；导入本包不会读配置目录、建立连接或启动 AgentRun。
+ */
+export { ImRuntime } from "./application/im-channel.js";
+export { octoCliEnvironment } from "./execution/tool-environment.js";
+export { default, name } from "./extra.js";
+export { ImChannelManager } from "./lifecycle/manager.js";
+export { MemoryImSessionStore } from "./application/session-store.js";
+export type { ImSessionStore, ImSessionBinding } from "./application/session-store.js";
+export { validateImConfig, validateImBots, configuredCredential, imBotIdentity } from "./lifecycle/configuration.js";
+export { build_im_contexts } from "./transport/contexts.js";
+export { registerBot, WukongConnection } from "./transport/wukong.js";
+export type { ImMessage, BotRegistration } from "./transport/wukong.js";
+export type * from "./contracts.js";
+export type * from "./ports.js";
+export * as imApi from "./transport/api/index.js";

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * 公共入口：向 SDK/Daemon 暴露接入能力和协议类型。
+ * 装配由宿主显式完成；导入本包不会读配置目录、建立连接或启动 AgentRun。
+ */
+export { ImRuntime } from "./application/im-channel.js";
+export { octoCliEnvironment } from "./execution/tool-environment.js";
+export { default, name } from "./extra.js";
+export { ImChannelManager } from "./lifecycle/manager.js";
+export { MemoryImSessionStore } from "./application/session-store.js";
+export { validateImConfig, validateImBots, configuredCredential, imBotIdentity } from "./lifecycle/configuration.js";
+export { build_im_contexts } from "./transport/contexts.js";
+export { registerBot, WukongConnection } from "./transport/wukong.js";
+export * as imApi from "./transport/api/index.js";

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/lifecycle/configuration.d.ts

@@ -0,0 +1,9 @@
+import type { ImBotConfig } from "../contracts.js";
+export declare const IM_MAX_BOTS = 64;
+export declare const IM_MAX_CONFIG_OPERATIONS = 64;
+export declare const IM_MAX_CONFIG_BYTES: number;
+export declare function validateImBots(value: unknown): asserts value is ImBotConfig[];
+export declare function configuredCredential(config: ImBotConfig): string | undefined;
+export declare function validateImConfig(config: ImBotConfig): void;
+/** Stable local lookup key, not a caller-supplied identity or authorization token. */
+export declare function imBotIdentity(config: ImBotConfig): string;