@openclaw/google-meet 2026.9.6 → 2026.9.7

package/node_modules/typebox/build/system/settings/internal.mjs

@@ -0,0 +1,20 @@
+import { Get } from './settings.mjs';
+// ------------------------------------------------------------------
+// TempMaxErrors
+// ------------------------------------------------------------------
+let TempMaxErrors = 0;
+// ------------------------------------------------------------------
+// [Internal] EnableParseErrors
+// ------------------------------------------------------------------
+export function EnableParseErrors() {
+    const settings = Get();
+    TempMaxErrors = settings.maxErrors;
+    settings.maxErrors = settings.maxParseErrors;
+}
+// ------------------------------------------------------------------
+// [Internal] DisableParseErrors
+// ------------------------------------------------------------------
+export function DisableParseErrors() {
+    const settings = Get();
+    settings.maxErrors = TempMaxErrors;
+}

package/node_modules/typebox/build/system/settings/settings.d.mts

@@ -16,6 +16,17 @@ export interface TSettings {
      * @default 8
      */
     maxErrors: number;
+    /**
+     * Specifies the maximum number of errors to gather for failed Parse operations. TypeBox will
+     * automatically run an error-gathering pass on failed Parses to attach diagnostics to the
+     * thrown exception. This setting controls the number of errors gathered in that pass. Higher
+     * values will reduce throughput on failure cases, so a maximum of 4 is recommended if more
+     * errors are needed. The default setting of 1 will terminate on the first error, while a
+     * setting of 0 will skip error gathering entirely.
+     *
+     * @default 1
+     */
+    maxParseErrors: number;
     /**
      * Specifies the maximum number of instantiations allowed within a top-level generic instantiation
      * context. This setting can be used to bound generic calls to a fixed count, which can be useful if

package/node_modules/typebox/build/system/settings/settings.mjs

@@ -1,8 +1,12 @@
 import { Guard } from '../../guard/index.mjs';
+// -------------------------------------------------------------------
+// State
+// -------------------------------------------------------------------
 // Internal mutable state
 const settings = {
     immutableTypes: false,
     maxErrors: 8,
+    maxParseErrors: 1,
     maxInstantiationCount: 128,
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
@@ -10,10 +14,14 @@ const settings = {
     correctiveParse: false,
     unionPrioritySort: true
 };
+// -------------------------------------------------------------------
+// Reset
+// -------------------------------------------------------------------
 /** Resets system settings to defaults */
 export function Reset() {
     settings.immutableTypes = false;
     settings.maxErrors = 8;
+    settings.maxParseErrors = 1;
     settings.maxInstantiationCount = 128;
     settings.useAcceleration = true;
     settings.exactOptionalPropertyTypes = false;
@@ -21,6 +29,9 @@ export function Reset() {
     settings.correctiveParse = false;
     settings.unionPrioritySort = true;
 }
+// -------------------------------------------------------------------
+// Set
+// -------------------------------------------------------------------
 /** Sets system settings */
 export function Set(options) {
     for (const key of Guard.Keys(options)) {
@@ -30,6 +41,9 @@ export function Set(options) {
         }
     }
 }
+// -------------------------------------------------------------------
+// Get
+// -------------------------------------------------------------------
 /** Gets current system settings */
 export function Get() {
     return settings;

package/node_modules/typebox/build/type/extends/inference.d.mts

@@ -22,7 +22,7 @@ export declare function TryRestInferable<Type extends TSchema>(type: Type): TTry
 export type TTryInferable<Type extends TSchema, Result extends TInferable | undefined = (Type extends TInfer<infer Name extends string, infer Type extends TSchema> ? TInferable<Name, Type> : undefined)> = Result;
 export declare function TryInferable<Type extends TSchema>(type: Type): TTryInferable<Type>;
 type TryInferResults<Rest extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Rest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<{}, Head, Right> extends Result.TExtendsTrueLike ? TryInferResults<Tail, Right, [...Result, Head]> : undefined : Result);
-declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result?: TSchema[]): TryInferResults<Rest, Right>;
+declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right): TryInferResults<Rest, Right>;
 export type TInferTupleResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema, Results extends TSchema[] | undefined = TryInferResults<Left, Right>> = (Results extends [...infer Results extends TSchema[]] ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
     [_ in Name]: TTuple<Results>;
 }>> : Result.TExtendsFalse);

package/node_modules/typebox/build/type/extends/inference.mjs

@@ -45,8 +45,21 @@ export function TryInferable(type) {
     return (IsInfer(type) ? Inferrable(type.name, type.extends) :
         undefined);
 }
-function TryInferResults(rest, right, result = []) {
-    return Guard.ShiftLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
+// function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result: TSchema[] = []): TryInferResults<Rest, Right> {
+//   return Guard.ShiftLeft(rest, (head, tail) =>
+//     Result.Match(ExtendsLeft({}, head, right),
+//       () => TryInferResults(tail, right, [...result, head]), // Stack Overflow Here (Large Rest)
+//       () => undefined),
+//     () => result) as never
+// }
+function TryInferResults(rest, right) {
+    const result = [];
+    for (const head of rest) {
+        if (!Result.IsExtendsTrueLike(ExtendsLeft({}, head, right)))
+            return undefined;
+        result.push(head);
+    }
+    return result;
 }
 export function InferTupleResult(inferred, name, left, right) {
     const results = TryInferResults(left, right);

package/node_modules/typebox/build/type/extends/tuple.d.mts

@@ -16,7 +16,8 @@ type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftR
 type TElementsRight<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsLeft<Inferred, Reversed, LeftRest, Head, Tail> : LeftRest['length'] extends 0 ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 type TElements<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = TElementsRight<Inferred, Reversed, LeftRest, RightRest>;
 type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
-type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArray<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArrayReduce<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : TExtendsTupleToArrayReduce<Inferred, Left, Right>);
 export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
 export declare function ExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTuple<Inferred, Left, Right>;
 export {};

package/node_modules/typebox/build/type/extends/tuple.mjs

@@ -47,11 +47,31 @@ function ExtendsTupleToTuple(inferred, left, right) {
     const reversed = Reversed(instantiatedRight);
     return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
 }
+// function ExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>
+//   (inferred: Inferred, left: [...Left], right: Right):
+//     TExtendsTupleToArrayReduce<Inferred, Left, Right> {
+//   return (
+//     Guard.ShiftLeft(left, (head, tail) =>
+//       Result.Match(ExtendsLeft(inferred, head, right), inferred =>
+//         ExtendsTupleToArrayReduce(inferred, tail, right), // Stack Overflow Here (Large Left)
+//         () => Result.ExtendsFalse()),
+//       () => Result.ExtendsTrue(inferred))
+//   ) as never
+// }
+function ExtendsTupleToArrayReduce(inferred, left, right) {
+    for (const head of left) {
+        const result = ExtendsLeft(inferred, head, right);
+        if (!Result.IsExtendsTrueLike(result))
+            return result;
+        inferred = result.inferred; // (review-assign-to-argument)
+    }
+    return Result.ExtendsTrue(inferred);
+}
 function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
         ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
-        : Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
+        : ExtendsTupleToArrayReduce(inferred, left, right));
 }
 export function ExtendsTuple(inferred, left, right) {
     const instantiatedLeft = InstantiateElements(inferred, State([], []), left);

package/node_modules/typebox/build/value/parse/parse.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { Settings } from '../../system/system.mjs';
-import { Arguments } from '../../system/arguments/index.mjs';
+import { EnableParseErrors, DisableParseErrors } from '../../system/settings/internal.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -18,8 +18,11 @@ export class ParseError extends AssertError {
     }
 }
 function Assert(context, type, value) {
+    EnableParseErrors();
+    const errors = Errors(context, type, value);
+    DisableParseErrors();
     if (!Check(context, type, value))
-        throw new ParseError(value, Errors(context, type, value));
+        throw new ParseError(value, errors);
     return value;
 }
 // ------------------------------------------------------------------
@@ -43,5 +46,8 @@ export function Parse(...args) {
         return value;
     if (Settings.Get().correctiveParse)
         return Parser(context, type, value);
-    throw new ParseError(value, Errors(context, type, value));
+    EnableParseErrors();
+    const errors = Errors(context, type, value);
+    DisableParseErrors();
+    throw new ParseError(value, errors);
 }

package/node_modules/typebox/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.3.30",
+  "version": "1.3.34",
   "keywords": [
     "typescript",
     "jsonschema"

package/node_modules/typebox/readme.md

@@ -166,9 +166,11 @@ import Schema from 'typebox/schema'
 
 ### Compile
 
-The compiler accepts both TypeBox types and plain JSON Schema objects. The Compile function will return a new Validator instance which can be used to check and parse values. The example below compiles a Script definition into a validator.
+The compiler accepts TypeBox types as well as plain JSON Schema objects, and returns a Validator instance which can be used to check values. The following compiles a Vector type.
 
 ```typescript
+import Schema from 'typebox/schema'
+
 // Compile
 
 const Vector = Schema.Compile(Type.Script(`{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/google-meet",
-  "version": "2026.9.6",
+  "version": "2026.9.7",
   "description": "OpenClaw Google Meet participant plugin for joining calls through Chrome or Twilio transports.",
   "repository": {
     "type": "git",
@@ -9,10 +9,10 @@
   "type": "module",
   "dependencies": {
     "jszip": "3.10.2",
-    "typebox": "1.3.30"
+    "typebox": "1.3.34"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.9.6"
+    "openclaw": ">=2026.9.7"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -30,10 +30,10 @@
       "minHostVersion": ">=2026.4.20"
     },
     "compat": {
-      "pluginApi": ">=2026.9.6"
+      "pluginApi": ">=2026.9.7"
     },
     "build": {
-      "openclawVersion": "2026.9.6"
+      "openclawVersion": "2026.9.7"
     },
     "release": {
       "publishToClawHub": true,

package/dist/.setup/config-C-6enWkx.mjs

@@ -1,328 +0,0 @@
-import { asBoolean, asRecord, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalTrimmedStringList, parseBooleanValue } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { addTimerTimeoutGraceMs, resolvePositiveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, resolveRealtimeVoiceAgentConsultToolPolicy } from "openclaw/plugin-sdk/realtime-voice";
-//#region extensions/google-meet/src/config.ts
-function resolveGoogleMeetGatewayOperationTimeoutMs(config) {
-	return Math.max(6e4, addTimerTimeoutGraceMs(config.chrome.joinTimeoutMs, 3e4) ?? 1, addTimerTimeoutGraceMs(config.voiceCall.requestTimeoutMs, 1e4) ?? 1);
-}
-const SOX_DEFAULT_BUFFER_BYTES = 8192;
-const SOX_MIN_BUFFER_BYTES = 17;
-const DEFAULT_GOOGLE_MEET_AUDIO_BUFFER_BYTES = SOX_DEFAULT_BUFFER_BYTES / 2;
-const PLAIN_DECIMAL_NUMBER_RE = /^\d+(?:\.\d+)?$/;
-function buildGoogleMeetAudioCommands(backend, format, bufferBytes) {
-	const pipeWire = backend === "pipewire-pulse" || backend === "auto" && process.platform === "linux";
-	const sampleRate = format === "g711-ulaw-8khz" ? 8e3 : 24e3;
-	const bits = format === "g711-ulaw-8khz" ? 8 : 16;
-	if (pipeWire) {
-		const pulseFormat = format === "g711-ulaw-8khz" ? "ulaw" : "s16le";
-		const latencyMs = Math.max(1, Math.ceil(bufferBytes / (sampleRate * Math.ceil(bits / 8)) * 1e3));
-		const common = [
-			"--device=openclaw_meeting_audio",
-			`--format=${pulseFormat}`,
-			`--rate=${sampleRate}`,
-			"--channels=1",
-			`--latency-msec=${latencyMs}`
-		];
-		return {
-			inputCommand: [
-				"parec",
-				"--raw",
-				...common
-			],
-			outputCommand: [
-				"pacat",
-				"--raw",
-				"--playback",
-				...common
-			]
-		};
-	}
-	const wire = format === "g711-ulaw-8khz" ? [
-		"-t",
-		"raw",
-		"-r",
-		"8000",
-		"-c",
-		"1",
-		"-e",
-		"mu-law",
-		"-b",
-		"8",
-		"-"
-	] : [
-		"-t",
-		"raw",
-		"-r",
-		"24000",
-		"-c",
-		"1",
-		"-e",
-		"signed-integer",
-		"-b",
-		"16",
-		"-L",
-		"-"
-	];
-	const withBuffer = (executable, args) => [
-		executable,
-		"-q",
-		"--buffer",
-		String(bufferBytes),
-		...args
-	];
-	return {
-		inputCommand: withBuffer("sox", [
-			"-t",
-			"coreaudio",
-			"BlackHole 2ch",
-			...wire
-		]),
-		outputCommand: withBuffer("sox", [
-			...wire,
-			"-t",
-			"coreaudio",
-			"BlackHole 2ch"
-		])
-	};
-}
-const DEFAULT_GOOGLE_MEET_AUDIO_COMMANDS = buildGoogleMeetAudioCommands("blackhole-2ch", "pcm16-24khz", DEFAULT_GOOGLE_MEET_AUDIO_BUFFER_BYTES);
-const DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND = DEFAULT_GOOGLE_MEET_AUDIO_COMMANDS.inputCommand;
-const DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND = DEFAULT_GOOGLE_MEET_AUDIO_COMMANDS.outputCommand;
-const DEFAULT_GOOGLE_MEET_CHROME_AUDIO_FORMAT = "pcm16-24khz";
-const DEFAULT_GOOGLE_MEET_BARGE_IN_RMS_THRESHOLD = 650;
-const DEFAULT_GOOGLE_MEET_BARGE_IN_PEAK_THRESHOLD = 2500;
-const DEFAULT_GOOGLE_MEET_BARGE_IN_COOLDOWN_MS = 900;
-const DEFAULT_GOOGLE_MEET_REALTIME_MODEL = void 0;
-const DEFAULT_GOOGLE_MEET_REALTIME_INSTRUCTIONS = `You are joining a private Google Meet as an OpenClaw voice transport. Keep spoken replies brief and natural. In agent mode, wait for OpenClaw consult results and speak them exactly. In bidi mode, answer directly and call ${REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME} for deeper reasoning, current information, or tools.`;
-const DEFAULT_GOOGLE_MEET_REALTIME_INTRO_MESSAGE = "Say exactly: I'm here and listening.";
-const DEFAULT_GOOGLE_MEET_CONFIG = {
-	enabled: true,
-	defaults: {},
-	preview: { enrollmentAcknowledged: false },
-	defaultTransport: "chrome",
-	defaultMode: "agent",
-	chrome: {
-		audioBackend: "auto",
-		audioFormat: DEFAULT_GOOGLE_MEET_CHROME_AUDIO_FORMAT,
-		audioBufferBytes: DEFAULT_GOOGLE_MEET_AUDIO_BUFFER_BYTES,
-		launch: true,
-		guestName: "OpenClaw Agent",
-		reuseExistingTab: true,
-		autoJoin: true,
-		joinTimeoutMs: 3e4,
-		waitForInCallMs: 2e4,
-		audioInputCommand: [...DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND],
-		audioOutputCommand: [...DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND],
-		bargeInRmsThreshold: DEFAULT_GOOGLE_MEET_BARGE_IN_RMS_THRESHOLD,
-		bargeInPeakThreshold: DEFAULT_GOOGLE_MEET_BARGE_IN_PEAK_THRESHOLD,
-		bargeInCooldownMs: DEFAULT_GOOGLE_MEET_BARGE_IN_COOLDOWN_MS
-	},
-	chromeNode: {},
-	twilio: {},
-	voiceCall: {
-		enabled: true,
-		requestTimeoutMs: 3e4,
-		dtmfDelayMs: 12e3,
-		postDtmfSpeechDelayMs: 5e3
-	},
-	realtime: {
-		strategy: "agent",
-		provider: "openai",
-		transcriptionProvider: "openai",
-		model: DEFAULT_GOOGLE_MEET_REALTIME_MODEL,
-		instructions: DEFAULT_GOOGLE_MEET_REALTIME_INSTRUCTIONS,
-		introMessage: DEFAULT_GOOGLE_MEET_REALTIME_INTRO_MESSAGE,
-		toolPolicy: "safe-read-only",
-		providers: {}
-	},
-	oauth: {},
-	auth: { provider: "google-oauth" }
-};
-const GOOGLE_MEET_CLIENT_ID_KEYS = ["OPENCLAW_GOOGLE_MEET_CLIENT_ID", "GOOGLE_MEET_CLIENT_ID"];
-const GOOGLE_MEET_CLIENT_SECRET_KEYS = ["OPENCLAW_GOOGLE_MEET_CLIENT_SECRET", "GOOGLE_MEET_CLIENT_SECRET"];
-const GOOGLE_MEET_REFRESH_TOKEN_KEYS = ["OPENCLAW_GOOGLE_MEET_REFRESH_TOKEN", "GOOGLE_MEET_REFRESH_TOKEN"];
-const GOOGLE_MEET_ACCESS_TOKEN_KEYS = ["OPENCLAW_GOOGLE_MEET_ACCESS_TOKEN", "GOOGLE_MEET_ACCESS_TOKEN"];
-const GOOGLE_MEET_ACCESS_TOKEN_EXPIRES_AT_KEYS = ["OPENCLAW_GOOGLE_MEET_ACCESS_TOKEN_EXPIRES_AT", "GOOGLE_MEET_ACCESS_TOKEN_EXPIRES_AT"];
-const GOOGLE_MEET_DEFAULT_MEETING_KEYS = ["OPENCLAW_GOOGLE_MEET_DEFAULT_MEETING", "GOOGLE_MEET_DEFAULT_MEETING"];
-const GOOGLE_MEET_PREVIEW_ACK_KEYS = ["OPENCLAW_GOOGLE_MEET_PREVIEW_ACK", "GOOGLE_MEET_PREVIEW_ACK"];
-function resolveBoolean(value, fallback) {
-	return asBoolean(value) ?? fallback;
-}
-function resolveNumber(value, fallback) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
-}
-function resolveTimerConfigMs(value, fallback) {
-	return resolvePositiveTimerTimeoutMs(resolveNumber(value, fallback), fallback);
-}
-function resolveOptionalNumber(value) {
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string" && value.trim()) {
-		const trimmed = value.trim();
-		const parsed = PLAIN_DECIMAL_NUMBER_RE.test(trimmed) ? Number(trimmed) : NaN;
-		return Number.isFinite(parsed) ? parsed : void 0;
-	}
-}
-function readEnvString(env, keys) {
-	for (const key of keys) {
-		const value = normalizeOptionalString(env[key]);
-		if (value) return value;
-	}
-}
-function normalizeStringAllowEmpty(value) {
-	return typeof value === "string" ? value.trim() : void 0;
-}
-function readEnvBoolean(env, keys) {
-	return parseBooleanValue(readEnvString(env, keys));
-}
-function readEnvNumber(env, keys) {
-	return resolveOptionalNumber(readEnvString(env, keys));
-}
-function resolveStringArray(value) {
-	return normalizeOptionalTrimmedStringList(value);
-}
-function resolveProvidersConfig(value) {
-	const raw = asRecord(value);
-	const providers = {};
-	for (const [key, entry] of Object.entries(raw)) {
-		const providerId = normalizeOptionalLowercaseString(key);
-		if (!providerId) continue;
-		providers[providerId] = asRecord(entry);
-	}
-	return providers;
-}
-function resolveTransport(value, fallback) {
-	const normalized = normalizeOptionalLowercaseString(value);
-	return normalized === "chrome" || normalized === "chrome-node" || normalized === "twilio" ? normalized : fallback;
-}
-function resolveMode(value, fallback) {
-	const normalized = normalizeOptionalLowercaseString(value);
-	if (normalized === "realtime") return "agent";
-	return normalized === "agent" || normalized === "bidi" || normalized === "transcribe" ? normalized : fallback;
-}
-function resolveRealtimeStrategy(value, fallback) {
-	const normalized = normalizeOptionalLowercaseString(value);
-	return normalized === "agent" || normalized === "bidi" ? normalized : fallback;
-}
-function resolveChromeAudioFormat(value) {
-	switch (normalizeOptionalString(value)?.toLowerCase().replaceAll("_", "-")) {
-		case "pcm16-24khz":
-		case "pcm16-24k":
-		case "pcm24":
-		case "pcm": return "pcm16-24khz";
-		case "g711-ulaw-8khz":
-		case "g711-ulaw-8k":
-		case "g711-ulaw":
-		case "mulaw":
-		case "mu-law": return "g711-ulaw-8khz";
-		default: return;
-	}
-}
-function resolveAudioBufferBytes(value, fallback) {
-	const number = resolveNumber(value, fallback);
-	if (!Number.isFinite(number) || number <= 0) return fallback;
-	return Math.max(SOX_MIN_BUFFER_BYTES, Math.trunc(number));
-}
-function defaultAudioInputCommand(backend, format, bufferBytes) {
-	return buildGoogleMeetAudioCommands(backend, format, bufferBytes).inputCommand;
-}
-function defaultAudioOutputCommand(backend, format, bufferBytes) {
-	return buildGoogleMeetAudioCommands(backend, format, bufferBytes).outputCommand;
-}
-function resolveAudioBackend(value) {
-	const normalized = normalizeOptionalLowercaseString(value)?.replaceAll("_", "-");
-	return normalized === "blackhole-2ch" || normalized === "pipewire-pulse" ? normalized : "auto";
-}
-function resolveGoogleMeetConfig(input) {
-	return resolveGoogleMeetConfigWithEnv(input);
-}
-function resolveGoogleMeetConfigWithEnv(input, env = process.env) {
-	const raw = asRecord(input);
-	const defaults = asRecord(raw.defaults);
-	const preview = asRecord(raw.preview);
-	const chrome = asRecord(raw.chrome);
-	const configuredAudioInputCommand = resolveStringArray(chrome.audioInputCommand);
-	const configuredAudioOutputCommand = resolveStringArray(chrome.audioOutputCommand);
-	const hasCustomAudioCommand = configuredAudioInputCommand !== void 0 || configuredAudioOutputCommand !== void 0;
-	const audioFormat = resolveChromeAudioFormat(chrome.audioFormat) ?? (hasCustomAudioCommand ? "g711-ulaw-8khz" : DEFAULT_GOOGLE_MEET_CONFIG.chrome.audioFormat);
-	const audioBufferBytes = resolveAudioBufferBytes(chrome.audioBufferBytes, DEFAULT_GOOGLE_MEET_CONFIG.chrome.audioBufferBytes);
-	const audioBackend = resolveAudioBackend(chrome.audioBackend);
-	const chromeNode = asRecord(raw.chromeNode);
-	const twilio = asRecord(raw.twilio);
-	const voiceCall = asRecord(raw.voiceCall);
-	const realtime = asRecord(raw.realtime);
-	const realtimeProvider = normalizeOptionalString(realtime.provider);
-	const resolvedRealtimeProvider = realtimeProvider ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.provider;
-	const oauth = asRecord(raw.oauth);
-	const auth = asRecord(raw.auth);
-	return {
-		enabled: resolveBoolean(raw.enabled, DEFAULT_GOOGLE_MEET_CONFIG.enabled),
-		defaults: { meeting: normalizeOptionalString(defaults.meeting) ?? readEnvString(env, GOOGLE_MEET_DEFAULT_MEETING_KEYS) },
-		preview: { enrollmentAcknowledged: resolveBoolean(preview.enrollmentAcknowledged, readEnvBoolean(env, GOOGLE_MEET_PREVIEW_ACK_KEYS) ?? DEFAULT_GOOGLE_MEET_CONFIG.preview.enrollmentAcknowledged) },
-		defaultTransport: resolveTransport(raw.defaultTransport, DEFAULT_GOOGLE_MEET_CONFIG.defaultTransport),
-		defaultMode: resolveMode(raw.defaultMode, DEFAULT_GOOGLE_MEET_CONFIG.defaultMode),
-		chrome: {
-			audioBackend,
-			audioFormat,
-			audioBufferBytes,
-			launch: resolveBoolean(chrome.launch, DEFAULT_GOOGLE_MEET_CONFIG.chrome.launch),
-			browserProfile: normalizeOptionalString(chrome.browserProfile),
-			guestName: normalizeOptionalString(chrome.guestName) ?? DEFAULT_GOOGLE_MEET_CONFIG.chrome.guestName,
-			reuseExistingTab: resolveBoolean(chrome.reuseExistingTab, DEFAULT_GOOGLE_MEET_CONFIG.chrome.reuseExistingTab),
-			autoJoin: resolveBoolean(chrome.autoJoin, DEFAULT_GOOGLE_MEET_CONFIG.chrome.autoJoin),
-			joinTimeoutMs: resolveTimerConfigMs(chrome.joinTimeoutMs, DEFAULT_GOOGLE_MEET_CONFIG.chrome.joinTimeoutMs),
-			waitForInCallMs: resolveTimerConfigMs(chrome.waitForInCallMs, DEFAULT_GOOGLE_MEET_CONFIG.chrome.waitForInCallMs),
-			audioInputCommand: configuredAudioInputCommand ?? defaultAudioInputCommand(audioBackend, audioFormat, audioBufferBytes),
-			audioOutputCommand: configuredAudioOutputCommand ?? defaultAudioOutputCommand(audioBackend, audioFormat, audioBufferBytes),
-			audioInputCommandOverride: configuredAudioInputCommand,
-			audioOutputCommandOverride: configuredAudioOutputCommand,
-			bargeInInputCommand: resolveStringArray(chrome.bargeInInputCommand),
-			bargeInRmsThreshold: resolveNumber(chrome.bargeInRmsThreshold, DEFAULT_GOOGLE_MEET_CONFIG.chrome.bargeInRmsThreshold),
-			bargeInPeakThreshold: resolveNumber(chrome.bargeInPeakThreshold, DEFAULT_GOOGLE_MEET_CONFIG.chrome.bargeInPeakThreshold),
-			bargeInCooldownMs: resolveTimerConfigMs(chrome.bargeInCooldownMs, DEFAULT_GOOGLE_MEET_CONFIG.chrome.bargeInCooldownMs),
-			audioBridgeCommand: resolveStringArray(chrome.audioBridgeCommand),
-			audioBridgeHealthCommand: resolveStringArray(chrome.audioBridgeHealthCommand)
-		},
-		chromeNode: { node: normalizeOptionalString(chromeNode.node) },
-		twilio: {
-			defaultDialInNumber: normalizeOptionalString(twilio.defaultDialInNumber),
-			defaultPin: normalizeOptionalString(twilio.defaultPin),
-			defaultDtmfSequence: normalizeOptionalString(twilio.defaultDtmfSequence)
-		},
-		voiceCall: {
-			enabled: resolveBoolean(voiceCall.enabled, DEFAULT_GOOGLE_MEET_CONFIG.voiceCall.enabled),
-			gatewayUrl: normalizeOptionalString(voiceCall.gatewayUrl),
-			token: normalizeOptionalString(voiceCall.token),
-			requestTimeoutMs: resolveTimerConfigMs(voiceCall.requestTimeoutMs, DEFAULT_GOOGLE_MEET_CONFIG.voiceCall.requestTimeoutMs),
-			dtmfDelayMs: resolveTimerConfigMs(voiceCall.dtmfDelayMs, DEFAULT_GOOGLE_MEET_CONFIG.voiceCall.dtmfDelayMs),
-			postDtmfSpeechDelayMs: resolveTimerConfigMs(voiceCall.postDtmfSpeechDelayMs, DEFAULT_GOOGLE_MEET_CONFIG.voiceCall.postDtmfSpeechDelayMs),
-			introMessage: normalizeOptionalString(voiceCall.introMessage)
-		},
-		realtime: {
-			strategy: resolveRealtimeStrategy(realtime.strategy, DEFAULT_GOOGLE_MEET_CONFIG.realtime.strategy),
-			provider: resolvedRealtimeProvider,
-			transcriptionProvider: normalizeOptionalString(realtime.transcriptionProvider) ?? (realtimeProvider && realtimeProvider !== "google" ? resolvedRealtimeProvider : DEFAULT_GOOGLE_MEET_CONFIG.realtime.transcriptionProvider),
-			voiceProvider: normalizeOptionalString(realtime.voiceProvider),
-			model: normalizeOptionalString(realtime.model) ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.model,
-			instructions: normalizeOptionalString(realtime.instructions) ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.instructions,
-			introMessage: normalizeStringAllowEmpty(realtime.introMessage) ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.introMessage,
-			agentId: normalizeOptionalString(realtime.agentId),
-			toolPolicy: resolveRealtimeVoiceAgentConsultToolPolicy(realtime.toolPolicy, DEFAULT_GOOGLE_MEET_CONFIG.realtime.toolPolicy),
-			providers: resolveProvidersConfig(realtime.providers)
-		},
-		oauth: {
-			clientId: normalizeOptionalString(oauth.clientId) ?? normalizeOptionalString(auth.clientId) ?? readEnvString(env, GOOGLE_MEET_CLIENT_ID_KEYS),
-			clientSecret: normalizeOptionalString(oauth.clientSecret) ?? normalizeOptionalString(auth.clientSecret) ?? readEnvString(env, GOOGLE_MEET_CLIENT_SECRET_KEYS),
-			refreshToken: normalizeOptionalString(oauth.refreshToken) ?? readEnvString(env, GOOGLE_MEET_REFRESH_TOKEN_KEYS),
-			accessToken: normalizeOptionalString(oauth.accessToken) ?? readEnvString(env, GOOGLE_MEET_ACCESS_TOKEN_KEYS),
-			expiresAt: resolveOptionalNumber(oauth.expiresAt) ?? readEnvNumber(env, GOOGLE_MEET_ACCESS_TOKEN_EXPIRES_AT_KEYS)
-		},
-		auth: {
-			provider: "google-oauth",
-			clientId: normalizeOptionalString(auth.clientId),
-			clientSecret: normalizeOptionalString(auth.clientSecret),
-			tokenPath: normalizeOptionalString(auth.tokenPath)
-		}
-	};
-}
-//#endregion
-export { resolveGoogleMeetGatewayOperationTimeoutMs as i, DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND as n, resolveGoogleMeetConfig as r, DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND as t };

package/dist/.setup/google-api-errors-BDYXfKRa.mjs

@@ -1,17 +0,0 @@
-import { readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
-//#region extensions/google-meet/src/google-api-errors.ts
-const REAUTH_HINT = "Re-run `openclaw googlemeet auth login` and store the refreshed oauth block.";
-const GOOGLE_API_ERROR_BODY_LIMIT_BYTES = 8192;
-function scopeText(scopes) {
-	return scopes.map((scope) => `\`${scope}\``).join(", ");
-}
-async function readGoogleApiErrorDetail(response) {
-	return await readResponseTextLimited(response, GOOGLE_API_ERROR_BODY_LIMIT_BYTES);
-}
-async function googleApiError(params) {
-	const detail = await readGoogleApiErrorDetail(params.response);
-	const scopeHint = params.scopes && params.scopes.length > 0 ? ` Required OAuth scope: ${scopeText(params.scopes)}. ${REAUTH_HINT}` : "";
-	return /* @__PURE__ */ new Error(`${params.prefix} failed (${params.response.status}): ${detail}${scopeHint}`);
-}
-//#endregion
-export { readGoogleApiErrorDetail as n, googleApiError as t };