tirtc-devtools-cli 0.0.5 → 0.0.7

package/dist/devtools/cli/src/token_command.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTokenCommands = registerTokenCommands;
+const facade_1 = require("./facade");
+const token_tool_1 = require("./token_tool");
+const kTokenIssueAccessIdEnvVar = 'TIRTC_CONN_ACCESS_ID';
+const kTokenIssueSecretKeyEnvVar = 'TIRTC_CONN_SECRET_KEY';
+function normalizeTokenCommandError(error) {
+    if (error instanceof Error) {
+        return {
+            reasonCode: 'internal_error',
+            message: error.message,
+            data: undefined,
+        };
+    }
+    if (typeof error === 'object' && error !== null) {
+        const typed = error;
+        return {
+            reasonCode: typed.reasonCode ?? 'internal_error',
+            message: typed.message ?? 'Internal error',
+            data: typed.data,
+        };
+    }
+    return {
+        reasonCode: 'internal_error',
+        message: 'Internal error',
+        data: undefined,
+    };
+}
+function printTokenCommandError(error, options) {
+    const normalized = normalizeTokenCommandError(error);
+    const reasonCode = normalized.reasonCode;
+    const exitCode = facade_1.ErrorReasonCodeMapping[reasonCode] ?? 1;
+    if (options.json) {
+        console.log(JSON.stringify({
+            code: exitCode,
+            message: normalized.message,
+            data: normalized.data,
+        }));
+    }
+    else {
+        console.error('Error (' + reasonCode + '): ' + normalized.message);
+    }
+    return exitCode;
+}
+async function runTokenIssue(params, options) {
+    try {
+        const result = await (0, token_tool_1.issueTokenWithQrcode)(params);
+        if (options.json) {
+            console.log(JSON.stringify({
+                code: 0,
+                message: 'OK',
+                data: {
+                    payload: result.payload,
+                    payloadJson: result.payloadJson,
+                    token: result.token,
+                    qrCodePngPath: result.qrCodePngPath,
+                },
+            }));
+        }
+        else {
+            console.log((0, token_tool_1.formatTokenIssueConsoleOutput)(result));
+        }
+        return 0;
+    }
+    catch (error) {
+        return printTokenCommandError(error, options);
+    }
+}
+function resolveTokenIssueCredential(explicitValue, envVarName, optionName) {
+    const normalizedExplicit = explicitValue?.trim();
+    if (normalizedExplicit) {
+        return normalizedExplicit;
+    }
+    const normalizedEnv = process.env[envVarName]?.trim();
+    if (normalizedEnv) {
+        return normalizedEnv;
+    }
+    throw new Error('missing credential: set environment variable ' + envVarName +
+        ' or pass ' + optionName + ' explicitly');
+}
+async function runTokenIssueFromCli(peerId, commandOptions, options) {
+    const parsePositiveInt = (name, raw) => {
+        if (raw === undefined) {
+            return undefined;
+        }
+        const parsed = Number.parseInt(raw, 10);
+        if (!Number.isInteger(parsed) || parsed <= 0) {
+            throw new Error(name + ' must be a positive integer');
+        }
+        return parsed;
+    };
+    const parseQrErrorCorrectionLevel = (raw) => {
+        if (raw === undefined) {
+            return undefined;
+        }
+        const normalized = raw.trim().toUpperCase();
+        if (normalized !== 'L' && normalized !== 'M' && normalized !== 'Q' && normalized !== 'H') {
+            throw new Error('qr-error-correction-level must be one of: L, M, Q, H');
+        }
+        return normalized;
+    };
+    try {
+        const accessId = resolveTokenIssueCredential(commandOptions.accessId, kTokenIssueAccessIdEnvVar, '--access-id');
+        const secretKey = resolveTokenIssueCredential(commandOptions.secretKey, kTokenIssueSecretKeyEnvVar, '--secret-key');
+        return await runTokenIssue({
+            accessId,
+            secretKey,
+            localId: commandOptions.localId?.trim() || peerId,
+            peerId,
+            openapiEntry: commandOptions.openapiEntry,
+            serviceEntry: commandOptions.serviceEntry,
+            userTtlSeconds: parsePositiveInt('user-ttl-seconds', commandOptions.userTtlSeconds),
+            channelTtlSeconds: parsePositiveInt('channel-ttl-seconds', commandOptions.channelTtlSeconds),
+            qrErrorCorrectionLevel: parseQrErrorCorrectionLevel(commandOptions.qrErrorCorrectionLevel),
+            asciiMaxColumns: parsePositiveInt('ascii-max-columns', commandOptions.asciiMaxColumns),
+        }, options);
+    }
+    catch (error) {
+        return printTokenCommandError(error, options);
+    }
+}
+function registerTokenCommands(program, getCliOptions, runAndExit) {
+    const token = program.command('token').description('Token 工具：签发 token，并输出可直接使用的 JSON 与本地二维码 PNG');
+    token.command('issue <peer_id>')
+        .description('默认从环境变量读取 access/secret，并以 peer_id 作为默认 local_id 来签发 token')
+        .option('--access-id <accessId>', '显式 access id；不传时读取 ' + kTokenIssueAccessIdEnvVar)
+        .option('--secret-key <secretKey>', '显式 secret key；不传时读取 ' + kTokenIssueSecretKeyEnvVar)
+        .option('--local-id <localId>', '显式 local id；不传时默认使用 peer_id')
+        .option('--openapi-entry <url>', '可选 openapi entry；留空时走 runtime 默认值')
+        .option('--service-entry <entry>', '可选 service entry；用于组合连接 payload 与二维码 PNG')
+        .option('--user-ttl-seconds <seconds>', '可选 user token ttl（秒）')
+        .option('--channel-ttl-seconds <seconds>', '可选 channel token ttl（秒）')
+        .option('--qr-error-correction-level <level>', '二维码纠错级别：L/M/Q/H；默认 M')
+        .option('--ascii-max-columns <columns>', 'ASCII 二维码最大宽度；不传时优先读取当前终端宽度或 COLUMNS')
+        .action((peerId, commandOptions) => {
+        runAndExit(runTokenIssueFromCli(peerId, commandOptions, getCliOptions()));
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirtc-devtools-cli",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "private": false,
   "main": "dist/index.js",
   "bin": {

package/vendor/app-server/bin/runtime/macos-arm64/include/tirtc/trp.h

@@ -154,6 +154,20 @@ typedef struct TirtcConnConnectOptions {
   const char* token;
 } TirtcConnConnectOptions;
 
+/**
+ * @brief Optional observer bound when a connection object is created.
+ *
+ * The implementation copies the observer structure and stores the supplied
+ * user_data pointer with the created connection handle.
+ */
+typedef struct TirtcConnCreateOptions {
+  /** @brief Optional observer copied into the new connection object. */
+  const struct TirtcConnObserver* observer;
+
+  /** @brief Opaque pointer returned to observer callbacks. */
+  void* user_data;
+} TirtcConnCreateOptions;
+
 /** @brief Opaque handle returned by ::tirtc_conn_service_start. */
 typedef struct TirtcConnService TirtcConnService;
 
@@ -376,17 +390,12 @@ typedef struct TirtcConnServiceObserver {
 /**
  * @brief Optional observer for connection lifecycle and control-plane events.
  *
- * The implementation stores a copy of this structure. Passing NULL to
- * ::tirtc_conn_set_observer clears the current observer.
- *
- * Replay contract:
- * - Installing or replacing an observer immediately replays the current state.
- * - If the connection has already disconnected, the terminal disconnected
- *   callback is replayed as part of observer installation.
+ * The implementation stores a copy of this structure inside the owning
+ * connection object.
  *
  * Callback threading is not restricted to a single caller thread. Some
- * callbacks may be replayed synchronously by API calls such as
- * ::tirtc_conn_set_observer, while others may arrive asynchronously from the
+ * callbacks may be replayed synchronously when a connection object becomes
+ * visible to the caller, while others may arrive asynchronously from the
  * internal transport layer.
  */
 typedef struct TirtcConnObserver {
@@ -475,25 +484,29 @@ TirtcError tirtc_conn_service_stop(TirtcConnService* service);
  * The runtime must already be initialized. The returned handle starts in
  * ::TIRTC_CONN_STATE_IDLE and must be released with ::tirtc_conn_destroy.
  *
+ * The observer, when provided, becomes part of the connection object's stable
+ * lifecycle contract. After creation succeeds, reconnects on the same handle
+ * keep using that observer.
+ *
+ * @param options Optional creation options. Pass NULL to create a connection
+ * without an observer.
  * @param out_connection Receives the created connection handle on success.
  * @return ::TIRTC_ERROR_OK on success.
  */
-TirtcError tirtc_conn_create(TirtcConn** out_connection);
+TirtcError tirtc_conn_create(const TirtcConnCreateOptions* options, TirtcConn** out_connection);
 
 /**
  * @brief Install, replace, or clear the connection observer.
  *
+ * This legacy API remains available for accepted service connections and
+ * existing consumers that still bind observers after handle creation.
+ * New standalone-connection callers should prefer binding the observer through
+ * ::TirtcConnCreateOptions.
+ *
  * Passing NULL for ::observer clears the current observer and its user data.
- * The implementation stores a copy of the observer structure and does not
- * require it to outlive this call.
  * After a non-NULL observer is installed, the implementation immediately
  * replays the current state and, when applicable, the terminal disconnected
  * callback.
- *
- * @param connection Target connection.
- * @param observer Observer to install, or NULL to clear.
- * @param user_data Opaque pointer returned to observer callbacks.
- * @return ::TIRTC_ERROR_OK on success.
  */
 TirtcError tirtc_conn_set_observer(TirtcConn* connection, const TirtcConnObserver* observer,
                                    void* user_data);

package/vendor/app-server/bin/runtime/macos-arm64/manifest.txt

@@ -1,5 +1,5 @@
 platform=macos-arm64
-staged_at_utc=2026-04-09T05:56:18Z
+staged_at_utc=2026-04-09T14:57:31Z
 source_sdk=/Users/allenfeng/Development/Repositories/tirtc-nexus/tirtc-matrix/.build/sdk/macos-arm64
 
 dcca0b7ab8055d84e5bcfab7f1dde56df9037c40ddb99e9ca924ef2e867d8309  include/tirtc/audio.h
@@ -25,7 +25,7 @@ ae805545a9515edc9b94262e72ad2c7b7d649288166f4daeb450d8a55e82ae0b  include/tirtc/
 a4f8ab44c1a20ad37f250363a403a9d4d007e61ddb2426c7966dbc05f6a04b4f  include/tirtc/media_live_source.h
 1b3be6954e547f91a047866438bff1820c8406afaf91cef68ddee29a6ac70234  include/tirtc/media_uplink.h
 1e12daf9c5fc2e2f848444688081c9be0cb738245f0155327e8003b49308058f  include/tirtc/transport.h
-99b4b31b8359009ee74f0f2a52be6473d9c6c37b184e53eeb554d4bf61f6ee33  include/tirtc/trp.h
+137729c534213cb161c0853a8d4d38fcdc397c41a7fd8c813fbe0e80083ec931  include/tirtc/trp.h
 dff5b0a0ac4a40ad17c93e1e56b3c416371c81ab365e287ea8cd6ce37ccbed3b  include/tirtc/video_codec.h
 e51379666c199588cc33279ccf52248035d1cae3d1d468b1615ebf29f0b39c9c  include/tirtc/video_frame.h
 d920afad955b9f206b02b19ca152315190fa84ab6f24e895a5b24c3ab9ffd701  include/tirtc/video_io.h
@@ -36,14 +36,14 @@ cae0bbeb884e5466a56da15182c78cc22baab6c743f349a58d3595f623333585  include/tirtc/
 8cd6b66bea14890a665cc317f8572429b2c3e4463773f8b77c1e4dc30a4a8747  include/tirtc/video_processing.h
 b39daee6a3d39bf0ca20c45084601133c4198de8dca848dcff6dd9c70ae99016  lib/libcrypto.a
 c052857ef315e3d61db9c862cad10709a3a6b2487dc41799cbe4d74a805de875  lib/libcrypto.dylib
-6ad596f3ad055be11f121f418aeff4e02c650f3cec6b37c471ed54e9498a1268  lib/libmatrix_runtime_audio.a
-42d1a2e4aa59d53c0c35ad204a365b7d7d83698c21857f5ffe7421da240da3e1  lib/libmatrix_runtime_credential.a
-2153ac1352ebb401f7920e8358c4988f9bd7f5275009ab94f6c4b7d7eb2a71c3  lib/libmatrix_runtime_facade.a
-25d70d18d4b69e0f28514035811a4ae8e18a1dcbcdd88d6a68e3d7609e2537bb  lib/libmatrix_runtime_foundation_http.a
-78b82c288d2e58f1219d5f56772a1dc8683e8da5f2f4724c160e6bf97f9ddadc  lib/libmatrix_runtime_foundation_logging.a
-548230c283e262838d2492ae28817870cd191eb3b9cb3e943446645562a2e20f  lib/libmatrix_runtime_media.a
-e5afb3d24fd62ad5f4fd68ea7ba65957e79bf27d5669a8d6bceb44aa9f297c16  lib/libmatrix_runtime_transport.a
-e0a087c9d0b0c929a20677db1aa8e053813baa3682458f407f04dc751d0d225a  lib/libmatrix_runtime_video.a
+240fb613f79b39ce4ed74ebd2e56c714141a0ef858f106e1121c7d540cea7e64  lib/libmatrix_runtime_audio.a
+e1070b1e7b262ad8a8e1dbec1ac9d524fbf4a7fdcc855bb84f69bdd13f31ae9d  lib/libmatrix_runtime_credential.a
+7081b1021d32939a1cbf399bbfa2b4f72a74e7eb48f111f34c80450f8d8a4bfe  lib/libmatrix_runtime_facade.a
+d268be4f9309c1af33f7734a692e0bf89402c96a6fe689f6d7df691d5563b391  lib/libmatrix_runtime_foundation_http.a
+d7c51d52995b0c1be194fafb3d922b98f8c87eccbfb3a240bad1d4b7b27de1b2  lib/libmatrix_runtime_foundation_logging.a
+37332652b4cb75f1d6a0a3a7209013d05ec55874b5103b89fd37ecd3b4601702  lib/libmatrix_runtime_media.a
+e0ed1c103c4e2392c423aacdbf314bf13848281318c6f57496136756664c4275  lib/libmatrix_runtime_transport.a
+f00064a09bc2c03963518e05c659becc0a24e2ec6b696ce13ca03fa1ec576f22  lib/libmatrix_runtime_video.a
 c11c65d373a127028350c41fa58cd2d1223f2b5d70a84e13b115d90daaba25ca  lib/libssl.a
 ef1c1104bbdd2528ed7b958fb7252bd6249875f92300b0c9577d6c4bd6c0d88a  lib/libssl.dylib
 dc3e0e6ded26e90fd59c166933a5289d57f4cf25fbe6246b6b83c86fe898e63d  lib/libwebrtc_apm.a

package/vendor/app-server/dist/host/HostProtocol.d.ts

@@ -1,4 +1,4 @@
-import { StreamRequestPolicyMode, StreamSource } from './HostState';
+import { StreamSource } from './HostState';
 export type JsonRpcId = string | number;
 export type JsonRpcRequest = {
     id?: JsonRpcId;
@@ -22,6 +22,7 @@ export type ServiceStartParams = {
     serviceEntry?: string;
     license: string;
     timeoutMs: number;
+    bootstrapSendStreams?: StreamSendStartParams[];
 };
 export type ConnectionAutoTokenConfig = {
     openapiEntry?: string;
@@ -47,6 +48,10 @@ export type StreamSendStartParams = {
 export type StreamStopParams = {
     streamId: number;
 };
+export type StreamMessageSendParams = {
+    streamId: number;
+    payload: string;
+};
 export type StreamReceiveStartParams = {
     streamId: number;
     media: 'audio' | 'video';
@@ -78,9 +83,6 @@ export type EventsSubscribeParams = {
 export type ArtifactExportParams = {
     outputPath: string;
 };
-export type StreamRequestPolicySetParams = {
-    mode: StreamRequestPolicyMode;
-};
 export type DebugTokenQrcodeParams = {
     payload: string;
     outputStem?: string;
@@ -96,12 +98,12 @@ export declare function parseServiceStartParams(params: Record<string, unknown>)
 export declare function parseConnectionConnectParams(params: Record<string, unknown>): ConnectionConnectParams;
 export declare function parseStreamSendStartParams(params: Record<string, unknown>): StreamSendStartParams;
 export declare function parseStreamStopParams(params: Record<string, unknown>): StreamStopParams;
+export declare function parseStreamMessageSendParams(params: Record<string, unknown>): StreamMessageSendParams;
 export declare function parseStreamReceiveStartParams(params: Record<string, unknown>): StreamReceiveStartParams;
 export declare function parseOutputAttachParams(params: Record<string, unknown>): OutputAttachParams;
 export declare function parseOutputDetachParams(params: Record<string, unknown>): OutputDetachParams;
 export declare function parseCommandSendParams(params: Record<string, unknown>): CommandSendParams;
 export declare function parseEventsSubscribeParams(params: Record<string, unknown>): EventsSubscribeParams;
 export declare function parseArtifactExportParams(params: Record<string, unknown>): ArtifactExportParams;
-export declare function parseStreamRequestPolicySetParams(params: Record<string, unknown>): StreamRequestPolicySetParams;
 export declare function parseDebugTokenQrcodeParams(params: Record<string, unknown>): DebugTokenQrcodeParams;
 export declare function normalizeError(error: unknown): HostProtocolError;

package/vendor/app-server/dist/host/HostProtocol.js

@@ -7,13 +7,13 @@ exports.parseServiceStartParams = parseServiceStartParams;
 exports.parseConnectionConnectParams = parseConnectionConnectParams;
 exports.parseStreamSendStartParams = parseStreamSendStartParams;
 exports.parseStreamStopParams = parseStreamStopParams;
+exports.parseStreamMessageSendParams = parseStreamMessageSendParams;
 exports.parseStreamReceiveStartParams = parseStreamReceiveStartParams;
 exports.parseOutputAttachParams = parseOutputAttachParams;
 exports.parseOutputDetachParams = parseOutputDetachParams;
 exports.parseCommandSendParams = parseCommandSendParams;
 exports.parseEventsSubscribeParams = parseEventsSubscribeParams;
 exports.parseArtifactExportParams = parseArtifactExportParams;
-exports.parseStreamRequestPolicySetParams = parseStreamRequestPolicySetParams;
 exports.parseDebugTokenQrcodeParams = parseDebugTokenQrcodeParams;
 exports.normalizeError = normalizeError;
 class HostProtocolError extends Error {
@@ -122,10 +122,24 @@ function parseStreamSource(source) {
     };
 }
 function parseServiceStartParams(params) {
+    const bootstrapSendStreamsRaw = params.bootstrapSendStreams;
+    let bootstrapSendStreams;
+    if (bootstrapSendStreamsRaw !== undefined) {
+        if (!Array.isArray(bootstrapSendStreamsRaw)) {
+            throw new HostProtocolError('invalid_request', 'Invalid bootstrapSendStreams', false);
+        }
+        bootstrapSendStreams = bootstrapSendStreamsRaw.map((entry) => {
+            if (!isRecord(entry)) {
+                throw new HostProtocolError('invalid_request', 'Invalid bootstrapSendStreams item', false);
+            }
+            return parseStreamSendStartParams(entry);
+        });
+    }
     return {
         serviceEntry: getOptionalString(params, 'serviceEntry'),
         license: getString(params, 'license'),
         timeoutMs: getNumber(params, 'timeoutMs'),
+        bootstrapSendStreams,
     };
 }
 function parseConnectionConnectParams(params) {
@@ -178,6 +192,12 @@ function parseStreamSendStartParams(params) {
 function parseStreamStopParams(params) {
     return { streamId: getNumber(params, 'streamId') };
 }
+function parseStreamMessageSendParams(params) {
+    return {
+        streamId: getNumber(params, 'streamId'),
+        payload: getString(params, 'payload'),
+    };
+}
 function parseStreamReceiveStartParams(params) {
     const media = getString(params, 'media');
     if (media !== 'audio' && media !== 'video') {
@@ -230,15 +250,6 @@ function parseArtifactExportParams(params) {
         outputPath: getString(params, 'outputPath'),
     };
 }
-function parseStreamRequestPolicySetParams(params) {
-    const mode = getString(params, 'mode');
-    if (mode !== 'manual' && mode !== 'auto-if-bound') {
-        throw new HostProtocolError('invalid_request', 'Invalid mode', false);
-    }
-    return {
-        mode,
-    };
-}
 function parseDebugTokenQrcodeParams(params) {
     return {
         payload: getString(params, 'payload'),

package/vendor/app-server/dist/host/HostServer.d.ts

@@ -18,6 +18,7 @@ export declare class HostServer {
     removeEventSink(sink: (event: Record<string, unknown>) => void): void;
     appendHostLog(line: string): void;
     private handleRuntimeEvent;
+    private noteIncomingConnection;
     private maybeAutoStartStreamFromRemoteDemand;
     private dispatch;
     private handleInitialize;
@@ -34,10 +35,9 @@ export declare class HostServer {
     private handleStreamList;
     private handleStreamSendStart;
     private handleStreamSendStop;
+    private handleStreamMessageSend;
     private handleStreamReceiveStart;
     private handleStreamReceiveStop;
-    private handleStreamRequestPolicyGet;
-    private handleStreamRequestPolicySet;
     private handleOutputAttach;
     private handleOutputDetach;
     private handleCommandSend;

package/vendor/app-server/dist/host/HostServer.js

@@ -175,18 +175,30 @@ class HostServer {
         if (family !== 'runtime') {
             return;
         }
-        if (kind === 'transport.remote.request') {
+        if (kind === 'transport.remote.request_audio' ||
+            kind === 'transport.remote.request_video' ||
+            kind === 'transport.remote.request_iframe') {
             const streamId = Number(payload.streamId);
-            const mediaRaw = String(payload.media ?? '');
-            if ((mediaRaw === 'audio' || mediaRaw === 'video') && Number.isFinite(streamId)) {
-                this.maybeAutoStartStreamFromRemoteDemand(streamId, mediaRaw, payload);
+            if (!Number.isFinite(streamId)) {
+                return;
             }
+            const media = kind === 'transport.remote.request_audio' ? 'audio' : 'video';
+            this.noteIncomingConnection(payload);
+            this.maybeAutoStartStreamFromRemoteDemand(streamId, media, payload);
         }
     }
-    maybeAutoStartStreamFromRemoteDemand(streamId, media, payload) {
-        if (this.state.streamRequestPolicy.mode !== 'auto-if-bound') {
+    noteIncomingConnection(payload) {
+        if (this.state.connection.state === 'connected') {
             return;
         }
+        this.state.connection = {
+            state: 'connected',
+            direction: 'incoming',
+            peerId: typeof payload.peerId === 'string' && payload.peerId.length > 0 ? payload.peerId : undefined,
+            connectedAt: new Date().toISOString(),
+        };
+    }
+    maybeAutoStartStreamFromRemoteDemand(streamId, media, payload) {
         const key = streamBindingKey(streamId, media);
         const bound = this.state.streamSourceBindings.get(key);
         if (!bound) {
@@ -248,14 +260,12 @@ class HostServer {
                 return this.handleStreamSendStart((0, HostProtocol_1.parseStreamSendStartParams)(params));
             case 'stream/sendStop':
                 return this.handleStreamSendStop((0, HostProtocol_1.parseStreamStopParams)(params));
+            case 'stream/message/send':
+                return this.handleStreamMessageSend((0, HostProtocol_1.parseStreamMessageSendParams)(params));
             case 'stream/receiveStart':
                 return this.handleStreamReceiveStart((0, HostProtocol_1.parseStreamReceiveStartParams)(params));
             case 'stream/receiveStop':
                 return this.handleStreamReceiveStop((0, HostProtocol_1.parseStreamStopParams)(params));
-            case 'stream/requestPolicy/get':
-                return this.handleStreamRequestPolicyGet();
-            case 'stream/requestPolicy/set':
-                return this.handleStreamRequestPolicySet((0, HostProtocol_1.parseStreamRequestPolicySetParams)(params));
             case 'output/attach':
                 return this.handleOutputAttach((0, HostProtocol_1.parseOutputAttachParams)(params));
             case 'output/detach':
@@ -285,11 +295,7 @@ class HostServer {
             protocolVersion: this.state.protocolVersion,
             runtimeTarget: this.state.runtimeTarget,
             hostEndpoint: this.state.hostEndpoint,
-            capabilities: {
-                streamRequestPolicy: {
-                    mode: this.state.streamRequestPolicy.mode,
-                },
-            },
+            capabilities: {},
         };
     }
     async handleHostStatus() {
@@ -301,7 +307,6 @@ class HostServer {
             startedAt: this.state.startedAt,
             service: this.state.service,
             connection: this.state.connection,
-            streamRequestPolicy: this.state.streamRequestPolicy,
             artifactPaths: this.artifactManager.getPaths(),
         };
     }
@@ -327,6 +332,44 @@ class HostServer {
             serviceEntry: resolvedServiceEntry,
             startedAt: new Date().toISOString(),
         };
+        if (params.bootstrapSendStreams && params.bootstrapSendStreams.length > 0) {
+            const bootstrapStreams = params.bootstrapSendStreams.map((streamParams) => ({
+                streamId: streamParams.streamId,
+                media: streamParams.media,
+                source: streamParams.source,
+            }));
+            const sendResults = this.runtimeAdapter.startSendStreams
+                ? await this.runtimeAdapter.startSendStreams(bootstrapStreams)
+                : await Promise.all(bootstrapStreams.map(async (streamParams) => await this.runtimeAdapter.startSendStream(streamParams.streamId, streamParams.media, streamParams.source)));
+            const updatedAt = new Date().toISOString();
+            bootstrapStreams.forEach((streamParams, index) => {
+                const stream = {
+                    streamId: streamParams.streamId,
+                    media: streamParams.media,
+                    direction: 'send',
+                    state: this.state.connection.state === 'connected' ? 'active' : 'pending_on_connection',
+                    source: streamParams.source,
+                    updatedAt,
+                };
+                this.state.streams.set(streamParams.streamId, stream);
+                this.state.streamSourceBindings.set(streamBindingKey(streamParams.streamId, streamParams.media), {
+                    streamId: streamParams.streamId,
+                    media: streamParams.media,
+                    source: streamParams.source,
+                    updatedAt,
+                });
+                this.writeEvent('stream', 'send.bootstrap.bound', {
+                    streamId: streamParams.streamId,
+                    media: streamParams.media,
+                    sourceMode: streamParams.source.mode,
+                    assetsDir: streamParams.source.local_assets.assets_dir,
+                    autoStarted: sendResults[index]?.autoStarted ?? false,
+                    workerPid: sendResults[index]?.workerPid,
+                    state: stream.state,
+                    at: updatedAt,
+                });
+            });
+        }
         return this.state.service;
     }
     async handleServiceStop() {
@@ -510,6 +553,40 @@ class HostServer {
         stream.updatedAt = new Date().toISOString();
         return stream;
     }
+    async handleStreamMessageSend(params) {
+        const acceptedAt = new Date().toISOString();
+        this.writeEvent('stream', 'message.send.requested', {
+            streamId: params.streamId,
+            payloadPreview: params.payload.slice(0, 120),
+            payloadLength: params.payload.length,
+            at: acceptedAt,
+        });
+        try {
+            await this.runtimeAdapter.sendStreamMessage(params.streamId, params.payload);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.writeEvent('stream', 'message.send.failed', {
+                streamId: params.streamId,
+                payloadPreview: params.payload.slice(0, 120),
+                payloadLength: params.payload.length,
+                message,
+                at: new Date().toISOString(),
+            });
+            throw error;
+        }
+        this.writeEvent('stream', 'message.send.completed', {
+            streamId: params.streamId,
+            payloadPreview: params.payload.slice(0, 120),
+            payloadLength: params.payload.length,
+            at: new Date().toISOString(),
+        });
+        return {
+            streamId: params.streamId,
+            payloadLength: params.payload.length,
+            acceptedAt,
+        };
+    }
     async handleStreamReceiveStart(params) {
         await this.runtimeAdapter.startReceiveStream(params.streamId, params.media);
         const stream = {
@@ -532,24 +609,6 @@ class HostServer {
         stream.updatedAt = new Date().toISOString();
         return stream;
     }
-    async handleStreamRequestPolicyGet() {
-        return {
-            mode: this.state.streamRequestPolicy.mode,
-            updatedAt: new Date().toISOString(),
-        };
-    }
-    async handleStreamRequestPolicySet(params) {
-        this.state.streamRequestPolicy.mode = params.mode;
-        const updatedAt = new Date().toISOString();
-        this.writeEvent('stream', 'request_policy.updated', {
-            mode: params.mode,
-            at: updatedAt,
-        });
-        return {
-            mode: this.state.streamRequestPolicy.mode,
-            updatedAt,
-        };
-    }
     async handleOutputAttach(params) {
         const attachment = await this.runtimeAdapter.attachOutput(params.streamId, params.consumer, params.mediaView, params.format, params.delivery, params.targetPath, params.maxFiles);
         return {
@@ -600,7 +659,6 @@ class HostServer {
             service: this.state.service,
             connection: this.state.connection,
             streams: Array.from(this.state.streams.values()),
-            streamRequestPolicy: this.state.streamRequestPolicy,
             artifacts: this.artifactManager.getPaths(),
             lastError: this.state.lastError,
         };

package/vendor/app-server/dist/host/HostState.d.ts

@@ -29,10 +29,6 @@ export interface StreamLocalAssetsSource {
     };
 }
 export type StreamSource = StreamLocalAssetsSource;
-export type StreamRequestPolicyMode = 'manual' | 'auto-if-bound';
-export interface StreamRequestPolicy {
-    mode: StreamRequestPolicyMode;
-}
 export interface StreamSourceBinding {
     streamId: number;
     media: 'audio' | 'video';
@@ -45,7 +41,6 @@ export declare class HostState {
     streams: Map<number, StreamSnapshot>;
     subscriptions: Set<string>;
     internalConnections: Set<string>;
-    streamRequestPolicy: StreamRequestPolicy;
     streamSourceBindings: Map<string, StreamSourceBinding>;
     protocolVersion: string;
     serverVersion: string;

package/vendor/app-server/dist/host/HostState.js

@@ -7,7 +7,6 @@ class HostState {
     streams = new Map();
     subscriptions = new Set();
     internalConnections = new Set();
-    streamRequestPolicy = { mode: 'manual' };
     streamSourceBindings = new Map();
     protocolVersion = '1.0.0';
     serverVersion = '1.0.0';