kimaki 0.0.0 → 0.0.2

package/dist/bundle.js

@@ -0,0 +1,3019 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/video-to-ascii.ts
+var exports_video_to_ascii = {};
+__export(exports_video_to_ascii, {
+  extractFrames: () => extractFrames,
+  convertImageToAscii: () => convertImageToAscii
+});
+import fs2 from "node:fs";
+import sharp from "sharp";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+async function extractFrames({
+  videoPath,
+  outputDir,
+  fps
+}) {
+  if (!fs2.existsSync(outputDir)) {
+    fs2.mkdirSync(outputDir, { recursive: true });
+  }
+  console.log(`Extracting frames at ${fps} fps...`);
+  const command = `ffmpeg -i "${videoPath}" -vf fps=${fps} "${outputDir}/frame_%04d.png" -y`;
+  try {
+    const { stdout, stderr } = await execAsync(command);
+    console.log("Frames extracted successfully");
+  } catch (error) {
+    console.error("Error extracting frames:", error.message);
+    throw error;
+  }
+}
+async function convertImageToAscii({
+  imagePath,
+  cols,
+  rows,
+  keepAspectRatio = true,
+  colored = false
+}) {
+  try {
+    const metadata = await sharp(imagePath).metadata();
+    const originalWidth = metadata.width || 100;
+    const originalHeight = metadata.height || 100;
+    let finalCols = cols;
+    let finalRows = rows;
+    let resizeOptions = {};
+    if (keepAspectRatio) {
+      const aspectRatio = originalWidth / originalHeight;
+      const targetAspectRatio = cols * 2 / rows;
+      if (aspectRatio > targetAspectRatio) {
+        finalRows = Math.floor(cols / aspectRatio * 0.5);
+      } else {
+        finalCols = Math.floor(rows * aspectRatio * 2);
+      }
+      resizeOptions = { fit: "fill" };
+    } else {
+      const aspectRatio = originalWidth / originalHeight;
+      const targetAspectRatio = cols * 2 / rows;
+      if (aspectRatio > targetAspectRatio) {
+        const zoomHeight = Math.ceil(cols / aspectRatio * 0.5);
+        resizeOptions = {
+          width: cols,
+          height: zoomHeight,
+          fit: "cover",
+          position: "center"
+        };
+      } else {
+        const zoomWidth = Math.ceil(rows * aspectRatio * 2);
+        resizeOptions = {
+          width: zoomWidth,
+          height: rows,
+          fit: "cover",
+          position: "center"
+        };
+      }
+      finalCols = cols;
+      finalRows = rows;
+    }
+    if (colored) {
+      const { data, info } = await sharp(imagePath).resize(finalCols, finalRows, resizeOptions).raw().toBuffer({ resolveWithObject: true });
+      const asciiArt = [];
+      const channels = info.channels;
+      const actualCols = info.width;
+      const actualRows = info.height;
+      for (let y = 0;y < actualRows; y++) {
+        let row = "";
+        for (let x = 0;x < actualCols; x++) {
+          const pixelIndex = (y * actualCols + x) * channels;
+          const r = data[pixelIndex] || 0;
+          const g = data[pixelIndex + 1] || 0;
+          const b = data[pixelIndex + 2] || 0;
+          const brightness = r * 0.299 + g * 0.587 + b * 0.114;
+          const charIndex = Math.floor(brightness / 255 * (ASCII_CHARS.length - 1));
+          const char = ASCII_CHARS[charIndex] || " ";
+          const brightnessFactor = brightness / 255;
+          const adjustedR = Math.floor(r * brightnessFactor * 0.8);
+          const adjustedG = Math.floor(g * brightnessFactor * 0.8);
+          const adjustedB = Math.floor(b * brightnessFactor * 0.8);
+          row += `\x1B[38;2;${adjustedR};${adjustedG};${adjustedB}m${char}\x1B[0m`;
+        }
+        if (!keepAspectRatio) {
+          const visibleLength = stripAnsi(row).length;
+          if (visibleLength < cols) {
+            row += " ".repeat(cols - visibleLength);
+          }
+        }
+        asciiArt.push(row);
+      }
+      if (!keepAspectRatio) {
+        while (asciiArt.length < rows) {
+          asciiArt.push(" ".repeat(cols));
+        }
+      }
+      return asciiArt.join(`
+`);
+    } else {
+      const { data: resized, info } = await sharp(imagePath).resize(finalCols, finalRows, resizeOptions).greyscale().raw().toBuffer({ resolveWithObject: true });
+      const actualCols = info.width;
+      const actualRows = info.height;
+      const asciiArt = [];
+      for (let y = 0;y < actualRows; y++) {
+        let row = "";
+        for (let x = 0;x < actualCols; x++) {
+          const pixelIndex = y * actualCols + x;
+          const brightness = resized[pixelIndex] || 0;
+          const charIndex = Math.floor(brightness / 255 * (ASCII_CHARS.length - 1));
+          row += ASCII_CHARS[charIndex] || " ";
+        }
+        if (!keepAspectRatio) {
+          const visibleLength = stripAnsi(row).length;
+          if (visibleLength < cols) {
+            row += " ".repeat(cols - visibleLength);
+          }
+        }
+        asciiArt.push(row);
+      }
+      if (!keepAspectRatio) {
+        while (asciiArt.length < rows) {
+          asciiArt.push(" ".repeat(cols));
+        }
+      }
+      return asciiArt.join(`
+`);
+    }
+  } catch (error) {
+    console.error(`Error converting ${imagePath}:`, error.message);
+    throw error;
+  }
+}
+var execAsync, ASCII_CHARS = " .'`^\",:;Il!i><~+_-?][}{1)(|/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$";
+var init_video_to_ascii = __esm(() => {
+  execAsync = promisify(exec);
+});
+
+// ../liveapi/src/utils.ts
+function base64ToArrayBuffer(base64) {
+  var binaryString = atob(base64);
+  var bytes = new Uint8Array(binaryString.length);
+  for (let i = 0;i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+var map, audioContext;
+var init_utils = __esm(() => {
+  map = new Map;
+  audioContext = (() => {
+    const didInteract = new Promise((res) => {
+      if (typeof window === "undefined") {
+        res(true);
+      }
+      addEventListener("pointerdown", res, { once: true });
+      addEventListener("keydown", res, { once: true });
+    });
+    return async (options) => {
+      try {
+        const a = new Audio;
+        a.src = "data:audio/wav;base64,UklGRigAAABXQVZFZm10IBIAAAABAAEARKwAAIhYAQACABAAAABkYXRhAgAAAAEA";
+        await a.play();
+        if (options?.id && map.has(options.id)) {
+          const ctx2 = map.get(options.id);
+          if (ctx2) {
+            return ctx2;
+          }
+        }
+        const ctx = new AudioContext(options);
+        if (options?.id) {
+          map.set(options.id, ctx);
+        }
+        return ctx;
+      } catch (e) {
+        await didInteract;
+        if (options?.id && map.has(options.id)) {
+          const ctx2 = map.get(options.id);
+          if (ctx2) {
+            return ctx2;
+          }
+        }
+        const ctx = new AudioContext(options);
+        if (options?.id) {
+          map.set(options.id, ctx);
+        }
+        return ctx;
+      }
+    };
+  })();
+});
+
+// ../liveapi/src/worklets/audio-processing.ts
+var AudioRecordingWorklet = `
+class AudioProcessingWorklet extends AudioWorkletProcessor {
+
+  // send and clear buffer every 2048 samples, 
+  // which at 16khz is about 8 times a second
+  buffer = new Int16Array(2048);
+
+  // current write index
+  bufferWriteIndex = 0;
+
+  constructor() {
+    super();
+    this.hasAudio = false;
+  }
+
+  /**
+   * @param inputs Float32Array[][] [input#][channel#][sample#] so to access first inputs 1st channel inputs[0][0]
+   * @param outputs Float32Array[][]
+   */
+  process(inputs) {
+    if (inputs[0].length) {
+      const channel0 = inputs[0][0];
+      this.processChunk(channel0);
+    }
+    return true;
+  }
+
+  sendAndClearBuffer(){
+    this.port.postMessage({
+      event: "chunk",
+      data: {
+        int16arrayBuffer: this.buffer.slice(0, this.bufferWriteIndex).buffer,
+      },
+    });
+    this.bufferWriteIndex = 0;
+  }
+
+  processChunk(float32Array) {
+    const l = float32Array.length;
+    
+    for (let i = 0; i < l; i++) {
+      // convert float32 -1 to 1 to int16 -32768 to 32767
+      const int16Value = float32Array[i] * 32768;
+      this.buffer[this.bufferWriteIndex++] = int16Value;
+      if(this.bufferWriteIndex >= this.buffer.length) {
+        this.sendAndClearBuffer();
+      }
+    }
+
+    if(this.bufferWriteIndex >= this.buffer.length) {
+      this.sendAndClearBuffer();
+    }
+  }
+}
+`, audio_processing_default;
+var init_audio_processing = __esm(() => {
+  audio_processing_default = AudioRecordingWorklet;
+});
+
+// ../liveapi/src/worklets/vol-meter.ts
+var VolMeterWorket = `
+  class VolMeter extends AudioWorkletProcessor {
+    volume
+    updateIntervalInMS
+    nextUpdateFrame
+
+    constructor() {
+      super()
+      this.volume = 0
+      this.updateIntervalInMS = 25
+      this.nextUpdateFrame = this.updateIntervalInMS
+      this.port.onmessage = event => {
+        if (event.data.updateIntervalInMS) {
+          this.updateIntervalInMS = event.data.updateIntervalInMS
+        }
+      }
+    }
+
+    get intervalInFrames() {
+      return (this.updateIntervalInMS / 1000) * sampleRate
+    }
+
+    process(inputs) {
+      const input = inputs[0]
+
+      if (input.length > 0) {
+        const samples = input[0]
+        let sum = 0
+        let rms = 0
+
+        for (let i = 0; i < samples.length; ++i) {
+          sum += samples[i] * samples[i]
+        }
+
+        rms = Math.sqrt(sum / samples.length)
+        this.volume = Math.max(rms, this.volume * 0.7)
+
+        this.nextUpdateFrame -= samples.length
+        if (this.nextUpdateFrame < 0) {
+          this.nextUpdateFrame += this.intervalInFrames
+          this.port.postMessage({volume: this.volume})
+        }
+      }
+
+      return true
+    }
+  }`, vol_meter_default;
+var init_vol_meter = __esm(() => {
+  vol_meter_default = VolMeterWorket;
+});
+
+// ../liveapi/src/audio-resampler.ts
+function downSampleAudioBuffer(buffer, inputSampleRate, outputSampleRate) {
+  if (outputSampleRate >= inputSampleRate) {
+    throw new Error("Output sample rate must be less than input sample rate.");
+  }
+  const sampleRateRatio = inputSampleRate / outputSampleRate;
+  const newLength = Math.round(buffer.length / sampleRateRatio);
+  const result = new Float32Array(newLength);
+  let offsetResult = 0;
+  let offsetBuffer = 0;
+  while (offsetResult < result.length) {
+    const nextOffsetBuffer = Math.round((offsetResult + 1) * sampleRateRatio);
+    let accum = 0;
+    let count = 0;
+    for (let i = offsetBuffer;i < nextOffsetBuffer && i < buffer.length; i++) {
+      accum += buffer[i];
+      count++;
+    }
+    result[offsetResult] = accum / count;
+    offsetResult++;
+    offsetBuffer = nextOffsetBuffer;
+  }
+  return result;
+}
+function downSampleInt16Buffer(buffer, inputSampleRate, outputSampleRate) {
+  if (outputSampleRate >= inputSampleRate) {
+    throw new Error("Output sample rate must be less than input sample rate.");
+  }
+  const int16Array = new Int16Array(buffer);
+  const float32Array = new Float32Array(int16Array.length);
+  for (let i = 0;i < int16Array.length; i++) {
+    float32Array[i] = int16Array[i] / 32768;
+  }
+  const downsampled = downSampleAudioBuffer(float32Array, inputSampleRate, outputSampleRate);
+  const downsampledInt16 = new Int16Array(downsampled.length);
+  for (let i = 0;i < downsampled.length; i++) {
+    downsampledInt16[i] = Math.max(-32768, Math.min(32767, Math.floor(downsampled[i] * 32768)));
+  }
+  return downsampledInt16.buffer;
+}
+
+// ../liveapi/src/audioworklet-registry.ts
+var registeredWorklets, createWorketFromSrc = (workletName, workletSrc) => {
+  const script = new Blob([`registerProcessor("${workletName}", ${workletSrc})`], {
+    type: "application/javascript"
+  });
+  return URL.createObjectURL(script);
+};
+var init_audioworklet_registry = __esm(() => {
+  registeredWorklets = new Map;
+});
+
+// ../liveapi/src/audio-recorder.ts
+import EventEmitter from "eventemitter3";
+var AudioRecorder;
+var init_audio_recorder = __esm(() => {
+  init_utils();
+  init_audio_processing();
+  init_vol_meter();
+  init_audioworklet_registry();
+  AudioRecorder = class AudioRecorder extends EventEmitter.EventEmitter {
+    sampleRate;
+    stream;
+    audioContext;
+    source;
+    recording = false;
+    recordingWorklet;
+    vuWorklet;
+    starting = null;
+    constructor(sampleRate = 16000) {
+      super();
+      this.sampleRate = sampleRate;
+    }
+    async start() {
+      if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+        throw new Error("Could not request user media");
+      }
+      this.starting = new Promise(async (resolve, reject) => {
+        this.stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        this.audioContext = await audioContext({ sampleRate: this.sampleRate });
+        this.source = this.audioContext.createMediaStreamSource(this.stream);
+        const workletName = "audio-recorder-worklet";
+        const src = createWorketFromSrc(workletName, audio_processing_default);
+        await this.audioContext.audioWorklet.addModule(src);
+        this.recordingWorklet = new AudioWorkletNode(this.audioContext, workletName);
+        this.recordingWorklet.port.onmessage = async (ev) => {
+          const arrayBuffer = ev.data.data.int16arrayBuffer;
+          if (arrayBuffer) {
+            let outputBuffer = arrayBuffer;
+            if (this.sampleRate > 16000) {
+              outputBuffer = downSampleInt16Buffer(arrayBuffer, this.sampleRate, 16000);
+            }
+            this.emit("data", outputBuffer);
+          }
+        };
+        this.source.connect(this.recordingWorklet);
+        const vuWorkletName = "vu-meter";
+        await this.audioContext.audioWorklet.addModule(createWorketFromSrc(vuWorkletName, vol_meter_default));
+        this.vuWorklet = new AudioWorkletNode(this.audioContext, vuWorkletName);
+        this.vuWorklet.port.onmessage = (ev) => {
+          this.emit("volume", ev.data.volume);
+        };
+        this.source.connect(this.vuWorklet);
+        this.recording = true;
+        resolve();
+        this.starting = null;
+      });
+    }
+    stop() {
+      const handleStop = () => {
+        this.source?.disconnect();
+        this.stream?.getTracks?.()?.forEach((track) => track.stop());
+        this.stream = undefined;
+        this.recordingWorklet = undefined;
+        this.vuWorklet = undefined;
+      };
+      if (this.starting) {
+        this.starting.then(handleStop);
+        return;
+      }
+      handleStop();
+    }
+  };
+});
+
+// ../liveapi/src/audio-streamer.ts
+class AudioStreamer {
+  context;
+  sampleRate = 24000;
+  bufferSize = 7680;
+  audioQueue = [];
+  isPlaying = false;
+  isStreamComplete = false;
+  checkInterval = null;
+  scheduledTime = 0;
+  initialBufferTime = 0.1;
+  gainNode;
+  source;
+  endOfQueueAudioSource = null;
+  onComplete = () => {};
+  constructor(context) {
+    this.context = context;
+    this.gainNode = this.context.createGain();
+    this.source = this.context.createBufferSource();
+    this.gainNode.connect(this.context.destination);
+    this.addPCM16 = this.addPCM16.bind(this);
+  }
+  async addWorklet(workletName, workletSrc, handler) {
+    let workletsRecord = registeredWorklets.get(this.context);
+    if (workletsRecord && workletsRecord[workletName]) {
+      workletsRecord[workletName].handlers.push(handler);
+      return Promise.resolve(this);
+    }
+    if (!workletsRecord) {
+      registeredWorklets.set(this.context, {});
+      workletsRecord = registeredWorklets.get(this.context);
+    }
+    workletsRecord[workletName] = { handlers: [handler] };
+    const src = createWorketFromSrc(workletName, workletSrc);
+    await this.context.audioWorklet.addModule(src);
+    const worklet = new AudioWorkletNode(this.context, workletName);
+    workletsRecord[workletName].node = worklet;
+    return this;
+  }
+  _processPCM16Chunk(chunk) {
+    const float32Array = new Float32Array(chunk.length / 2);
+    const dataView = new DataView(chunk.buffer);
+    for (let i = 0;i < chunk.length / 2; i++) {
+      try {
+        const int16 = dataView.getInt16(i * 2, true);
+        float32Array[i] = int16 / 32768;
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    return float32Array;
+  }
+  addPCM16(chunk) {
+    this.isStreamComplete = false;
+    let processingBuffer = this._processPCM16Chunk(chunk);
+    while (processingBuffer.length >= this.bufferSize) {
+      const buffer = processingBuffer.slice(0, this.bufferSize);
+      this.audioQueue.push(buffer);
+      processingBuffer = processingBuffer.slice(this.bufferSize);
+    }
+    if (processingBuffer.length > 0) {
+      this.audioQueue.push(processingBuffer);
+    }
+    if (!this.isPlaying) {
+      this.isPlaying = true;
+      this.scheduledTime = this.context.currentTime + this.initialBufferTime;
+      this.scheduleNextBuffer();
+    }
+  }
+  createAudioBuffer(audioData) {
+    const audioBuffer = this.context.createBuffer(1, audioData.length, this.sampleRate);
+    audioBuffer.getChannelData(0).set(audioData);
+    return audioBuffer;
+  }
+  scheduleNextBuffer() {
+    const SCHEDULE_AHEAD_TIME = 0.2;
+    while (this.audioQueue.length > 0 && this.scheduledTime < this.context.currentTime + SCHEDULE_AHEAD_TIME) {
+      const audioData = this.audioQueue.shift();
+      const audioBuffer = this.createAudioBuffer(audioData);
+      const source = this.context.createBufferSource();
+      if (this.audioQueue.length === 0) {
+        if (this.endOfQueueAudioSource) {
+          this.endOfQueueAudioSource.onended = null;
+        }
+        this.endOfQueueAudioSource = source;
+        source.onended = () => {
+          if (!this.audioQueue.length && this.endOfQueueAudioSource === source) {
+            this.endOfQueueAudioSource = null;
+            this.onComplete();
+          }
+        };
+      }
+      source.buffer = audioBuffer;
+      source.connect(this.gainNode);
+      const worklets = registeredWorklets.get(this.context);
+      if (worklets) {
+        Object.entries(worklets).forEach(([workletName, graph]) => {
+          const { node, handlers } = graph;
+          if (node) {
+            source.connect(node);
+            node.port.onmessage = function(ev) {
+              handlers.forEach((handler) => {
+                handler.call(node.port, ev);
+              });
+            };
+            node.connect(this.context.destination);
+          }
+        });
+      }
+      const startTime = Math.max(this.scheduledTime, this.context.currentTime);
+      source.start(startTime);
+      this.scheduledTime = startTime + audioBuffer.duration;
+    }
+    if (this.audioQueue.length === 0) {
+      if (this.isStreamComplete) {
+        this.isPlaying = false;
+        if (this.checkInterval) {
+          clearInterval(this.checkInterval);
+          this.checkInterval = null;
+        }
+      } else {
+        if (!this.checkInterval) {
+          this.checkInterval = setInterval(() => {
+            if (this.audioQueue.length > 0) {
+              this.scheduleNextBuffer();
+            }
+          }, 100);
+        }
+      }
+    } else {
+      const nextCheckTime = (this.scheduledTime - this.context.currentTime) * 1000;
+      setTimeout(() => this.scheduleNextBuffer(), Math.max(0, nextCheckTime - 50));
+    }
+  }
+  stop() {
+    this.isPlaying = false;
+    this.isStreamComplete = true;
+    this.audioQueue = [];
+    this.scheduledTime = this.context.currentTime;
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+    this.gainNode.gain.linearRampToValueAtTime(0, this.context.currentTime + 0.1);
+    setTimeout(() => {
+      this.gainNode.disconnect();
+      this.gainNode = this.context.createGain();
+      this.gainNode.connect(this.context.destination);
+    }, 200);
+  }
+  async resume() {
+    if (this.context.state === "suspended") {
+      await this.context.resume();
+    }
+    this.isStreamComplete = false;
+    this.scheduledTime = this.context.currentTime + this.initialBufferTime;
+    this.gainNode.gain.setValueAtTime(1, this.context.currentTime);
+  }
+  complete() {
+    this.isStreamComplete = true;
+    this.onComplete();
+  }
+}
+var init_audio_streamer = __esm(() => {
+  init_audioworklet_registry();
+});
+
+// ../liveapi/src/live-api-client.ts
+import {
+  GoogleGenAI,
+  MediaResolution
+} from "@google/genai";
+
+class LiveAPIClient {
+  client;
+  session = null;
+  audioStreamer = null;
+  audioRecorder = null;
+  model;
+  onStateChange;
+  onMessage;
+  state = {
+    connected: false,
+    muted: false,
+    inVolume: 0,
+    outVolume: 0,
+    logs: [],
+    config: {
+      inputAudioTranscription: {},
+      outputAudioTranscription: {},
+      mediaResolution: MediaResolution.MEDIA_RESOLUTION_MEDIUM,
+      contextWindowCompression: {
+        triggerTokens: "25600",
+        slidingWindow: { targetTokens: "12800" }
+      }
+    },
+    isAssistantSpeaking: false
+  };
+  onUserAudioChunk;
+  tools = [];
+  sessionHandle = null;
+  isExplicitDisconnect = false;
+  reconnectAttempts = 0;
+  maxReconnectAttempts;
+  reconnectTimeout = null;
+  autoReconnect;
+  autoMuteOnAssistantSpeaking;
+  userMutedState = false;
+  constructor(options) {
+    const {
+      model,
+      onStateChange,
+      onMessage,
+      onUserAudioChunk,
+      apiKey,
+      enableGoogleSearch,
+      recordingSampleRate = 16000,
+      config,
+      autoReconnect = true,
+      maxReconnectAttempts = 5,
+      autoMuteOnAssistantSpeaking = true
+    } = options;
+    if (!apiKey) {
+      throw new Error("API key is required");
+    }
+    this.client = new GoogleGenAI({ apiKey });
+    this.model = model || "models/gemini-2.0-flash-exp";
+    this.onStateChange = onStateChange;
+    this.onMessage = onMessage;
+    this.onUserAudioChunk = onUserAudioChunk;
+    this.autoReconnect = autoReconnect;
+    this.maxReconnectAttempts = maxReconnectAttempts;
+    this.autoMuteOnAssistantSpeaking = autoMuteOnAssistantSpeaking;
+    this.tools = config?.tools || [];
+    if (enableGoogleSearch) {
+      this.tools.push({ googleSearch: {} });
+    }
+    if (config) {
+      this.state.config = { ...this.state.config, ...config };
+    }
+    this.audioRecorder = new AudioRecorder(recordingSampleRate);
+    this.setupAudioRecorder();
+  }
+  updateState(updates) {
+    this.state = { ...this.state, ...updates };
+    this.onStateChange?.(this.state);
+  }
+  getState() {
+    return { ...this.state };
+  }
+  async initAudioStreamer() {
+    if (!this.audioStreamer) {
+      const audioCtx = await audioContext({ id: "audio-out" });
+      this.audioStreamer = new AudioStreamer(audioCtx);
+      await this.audioStreamer.addWorklet("vumeter-out", vol_meter_default, (ev) => {
+        this.updateState({ outVolume: ev.data.volume });
+      });
+      this.audioStreamer.onComplete = () => {
+        this.onAssistantStopSpeaking();
+      };
+    }
+  }
+  setupAudioRecorder() {
+    if (!this.audioRecorder)
+      return;
+    this.audioRecorder.on("data", (arrayBuffer) => {
+      if (this.state.connected && !this.state.muted) {
+        const binary = String.fromCharCode(...new Uint8Array(arrayBuffer));
+        const base64 = btoa(binary);
+        this.sendRealtimeInput([
+          {
+            mimeType: "audio/pcm;rate=16000",
+            data: base64
+          }
+        ]);
+        if (this.onUserAudioChunk) {
+          this.onUserAudioChunk(arrayBuffer.slice(0));
+        }
+      }
+    });
+    this.audioRecorder.on("volume", (volume) => {
+      this.updateState({ inVolume: volume });
+    });
+  }
+  log(message) {
+    console.log(message);
+    const newEvents = [...this.state.logs, message];
+    if (newEvents.length > 200) {
+      this.updateState({ logs: newEvents.slice(-150) });
+    } else {
+      this.updateState({ logs: newEvents });
+    }
+  }
+  async connect() {
+    if (this.state.connected) {
+      return false;
+    }
+    this.isExplicitDisconnect = false;
+    this.reconnectAttempts = 0;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    await this.initAudioStreamer();
+    const callbacks = {
+      onopen: this.onOpen.bind(this),
+      onmessage: this.handleMessage.bind(this),
+      onerror: this.onError.bind(this),
+      onclose: this.onClose.bind(this)
+    };
+    const connectConfig = { ...this.state.config };
+    if (this.sessionHandle && connectConfig.sessionResumption) {
+      connectConfig.sessionResumption = {
+        ...connectConfig.sessionResumption,
+        handle: this.sessionHandle
+      };
+      this.log("connect: Attempting to resume session with handle");
+    }
+    try {
+      this.session = await this.client.live.connect({
+        model: this.model,
+        config: connectConfig,
+        callbacks
+      });
+    } catch (e) {
+      console.error("Error connecting to GenAI Live:", e);
+      this.log("error: " + JSON.stringify({ message: "Failed to connect", error: e }));
+      return false;
+    }
+    return true;
+  }
+  disconnect() {
+    if (!this.session) {
+      return false;
+    }
+    this.isExplicitDisconnect = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.session?.close();
+    this.session = null;
+    this.setConnected(false);
+    this.audioRecorder?.stop();
+    this.audioStreamer?.stop();
+    this.onAssistantStopSpeaking();
+    this.sessionHandle = null;
+    this.reconnectAttempts = 0;
+    this.log("close: " + JSON.stringify({ reason: "User disconnected" }));
+    return true;
+  }
+  setConnected(value) {
+    this.updateState({ connected: value });
+    if (value && !this.state.muted) {
+      this.audioRecorder?.start();
+    } else {
+      this.audioRecorder?.stop();
+    }
+  }
+  onOpen() {
+    this.setConnected(true);
+    this.log("open");
+  }
+  onError(e) {
+    this.log("error: " + JSON.stringify({ message: e.message, error: e }));
+  }
+  async onClose(e) {
+    this.setConnected(false);
+    this.log("close: " + JSON.stringify({ reason: e.reason, code: e.code }));
+    if (this.autoReconnect && !this.isExplicitDisconnect && this.sessionHandle) {
+      await this.attemptReconnect();
+    }
+  }
+  async attemptReconnect() {
+    console.log(`attempting to reconnect`);
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.log("error: Max reconnection attempts reached, giving up");
+      this.sessionHandle = null;
+      this.reconnectAttempts = 0;
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts - 1), 1e4);
+    this.log(`reconnect: Attempting reconnection ${this.reconnectAttempts}/${this.maxReconnectAttempts} in ${delay}ms`);
+    this.reconnectTimeout = setTimeout(async () => {
+      this.reconnectTimeout = null;
+      try {
+        const success = await this.connect();
+        if (success) {
+          this.log("reconnect: Successfully reconnected to session");
+          this.reconnectAttempts = 0;
+        } else {
+          this.log("reconnect: Failed to reconnect, will retry");
+        }
+      } catch (error) {
+        this.log("reconnect: Error during reconnection: " + JSON.stringify(error));
+      }
+    }, delay);
+  }
+  async handleMessage(message) {
+    const clonedMessage = JSON.parse(JSON.stringify(message));
+    this.onMessage?.(clonedMessage);
+    if (message.setupComplete) {
+      this.log("setupcomplete");
+      return;
+    }
+    if (message.sessionResumptionUpdate) {
+      const update = message.sessionResumptionUpdate;
+      if (update.resumable && update.newHandle) {
+        this.sessionHandle = update.newHandle;
+        this.log("sessionResumption: Updated handle for resumption " + update.newHandle);
+      } else if (!update.resumable) {
+        this.sessionHandle = null;
+        this.log("sessionResumption: Session not resumable at this point");
+      }
+      return;
+    }
+    if (message.goAway) {
+      this.log("goAway: Server will disconnect, preparing for reconnection");
+      return;
+    }
+    if (message.toolCall) {
+      this.log("toolcall: " + JSON.stringify(message.toolCall));
+      if (message.toolCall.functionCalls) {
+        await this.handleToolCalls(message.toolCall.functionCalls);
+      }
+      return;
+    }
+    if (message.toolCallCancellation) {
+      this.log("toolcallcancellation: " + JSON.stringify(message.toolCallCancellation));
+      return;
+    }
+    if (message.serverContent) {
+      const { serverContent } = message;
+      if (serverContent.interrupted) {
+        this.log("interrupted");
+        this.audioStreamer?.stop();
+        this.onAssistantStopSpeaking();
+        return;
+      }
+      if (serverContent.turnComplete) {
+        this.log("turncomplete");
+      }
+      if (serverContent.modelTurn) {
+        let parts = serverContent.modelTurn?.parts || [];
+        const [audioParts, otherParts] = partition(parts, (p) => p.inlineData && p.inlineData.mimeType?.startsWith("audio/pcm"));
+        const base64s = audioParts.map((p) => p.inlineData?.data);
+        base64s.forEach((b64, index) => {
+          if (b64) {
+            if (index === 0 && !this.state.isAssistantSpeaking) {
+              this.onAssistantStartSpeaking();
+            }
+            const data = base64ToArrayBuffer(b64);
+            this.audioStreamer?.addPCM16(new Uint8Array(data));
+          }
+        });
+        if (otherParts.length) {
+          this.log("content: " + JSON.stringify({ modelTurn: { parts: otherParts } }));
+          otherParts.forEach((part) => {
+            if (part.executableCode && part.executableCode.language === "PYTHON" && part.executableCode.code) {
+              const preview = part.executableCode.code;
+              this.log(`python executableCode:
+` + preview);
+            }
+          });
+        }
+      }
+    }
+  }
+  setMuted(muted) {
+    this.userMutedState = muted;
+    this.updateState({ muted });
+    if (this.state.connected) {
+      if (muted) {
+        this.audioRecorder?.stop();
+      } else {
+        this.audioRecorder?.start();
+      }
+    }
+  }
+  onAssistantStartSpeaking() {
+    this.updateState({ isAssistantSpeaking: true });
+    if (this.autoMuteOnAssistantSpeaking && !this.userMutedState && !this.state.muted) {
+      this.updateState({ muted: true });
+      if (this.state.connected) {
+        this.audioRecorder?.stop();
+      }
+    }
+  }
+  onAssistantStopSpeaking() {
+    this.updateState({ isAssistantSpeaking: false });
+    if (this.autoMuteOnAssistantSpeaking && !this.userMutedState && this.state.muted) {
+      this.updateState({ muted: false });
+      if (this.state.connected) {
+        this.audioRecorder?.start();
+      }
+    }
+  }
+  sendText(text, turnComplete = true) {
+    if (!this.session)
+      return;
+    const parts = [{ text }];
+    this.session.sendClientContent({ turns: parts, turnComplete });
+    this.log("client-send: " + JSON.stringify({ turns: parts, turnComplete }));
+  }
+  sendRealtimeInput(chunks) {
+    if (!this.session)
+      return;
+    let hasAudio = false;
+    let hasVideo = false;
+    for (const ch of chunks) {
+      this.session.sendRealtimeInput({ media: ch });
+      if (ch.mimeType.includes("audio")) {
+        hasAudio = true;
+      }
+      if (ch.mimeType.includes("image")) {
+        hasVideo = true;
+      }
+    }
+    const mediaType = (() => {
+      if (hasAudio && hasVideo)
+        return "audio+video";
+      if (hasAudio)
+        return "audio";
+      if (hasVideo)
+        return "video";
+      return "unknown";
+    })();
+  }
+  async handleToolCalls(functionCalls) {
+    if (!this.session) {
+      console.log("No session active in handleToolCalls");
+      return;
+    }
+    if (!this.tools.length) {
+      console.log("No tools registered in handleToolCalls");
+      return;
+    }
+    try {
+      for (const tool2 of this.tools) {
+        if (!functionCalls.some((x) => x.name === tool2.name)) {
+          continue;
+        }
+        const parts = await tool2.callTool(functionCalls);
+        const functionResponses = parts.filter((part) => part.functionResponse).map((part) => ({
+          response: part.functionResponse.response,
+          id: part.functionResponse.id,
+          name: part.functionResponse.name
+        }));
+        if (functionResponses.length > 0) {
+          this.session.sendToolResponse({ functionResponses });
+          this.log("client-toolResponse: " + JSON.stringify({ functionResponses }));
+        } else {
+          console.log(`no tool call response!`);
+        }
+      }
+    } catch (error) {
+      console.error("Error handling tool calls:", error);
+      this.log("error: " + JSON.stringify({ message: "Tool call failed", error }));
+    }
+  }
+  sendToolResponse(response) {
+    if (!this.session) {
+      console.error("Cannot send tool response: session not connected");
+      return;
+    }
+    this.session.sendToolResponse(response);
+    this.log("client-toolResponse: " + JSON.stringify(response));
+  }
+  setConfig(config) {
+    if (config.tools) {
+      this.tools = config.tools;
+    }
+    this.updateState({ config });
+  }
+  getConfig() {
+    return { ...this.state.config };
+  }
+  destroy() {
+    console.log(`calling destroy()`);
+    this.isExplicitDisconnect = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.disconnect();
+    this.audioRecorder?.stop();
+    this.audioStreamer?.stop();
+    this.onAssistantStopSpeaking();
+    this.tools = [];
+    this.sessionHandle = null;
+    this.reconnectAttempts = 0;
+  }
+}
+function partition(arr, predicate) {
+  const truthy = [];
+  const falsy = [];
+  arr.forEach((item, index) => {
+    if (predicate(item, index, arr)) {
+      truthy.push(item);
+    } else {
+      falsy.push(item);
+    }
+  });
+  return [truthy, falsy];
+}
+var init_live_api_client = __esm(() => {
+  init_audio_recorder();
+  init_audio_streamer();
+  init_utils();
+  init_vol_meter();
+});
+
+// ../liveapi/src/ai-tool-to-genai.ts
+import { Type } from "@google/genai";
+import { toJSONSchema } from "zod";
+function jsonSchemaToGenAISchema(jsonSchema) {
+  const schema = {};
+  if (jsonSchema.type) {
+    switch (jsonSchema.type) {
+      case "string":
+        schema.type = Type.STRING;
+        break;
+      case "number":
+        schema.type = Type.NUMBER;
+        schema.format = jsonSchema.format || "float";
+        break;
+      case "integer":
+        schema.type = Type.INTEGER;
+        schema.format = jsonSchema.format || "int32";
+        break;
+      case "boolean":
+        schema.type = Type.BOOLEAN;
+        break;
+      case "array":
+        schema.type = Type.ARRAY;
+        if (jsonSchema.items) {
+          schema.items = jsonSchemaToGenAISchema(jsonSchema.items);
+        }
+        if (jsonSchema.minItems !== undefined) {
+          schema.minItems = jsonSchema.minItems;
+        }
+        if (jsonSchema.maxItems !== undefined) {
+          schema.maxItems = jsonSchema.maxItems;
+        }
+        break;
+      case "object":
+        schema.type = Type.OBJECT;
+        if (jsonSchema.properties) {
+          schema.properties = {};
+          for (const [key, value] of Object.entries(jsonSchema.properties)) {
+            schema.properties[key] = jsonSchemaToGenAISchema(value);
+          }
+        }
+        if (jsonSchema.required) {
+          schema.required = jsonSchema.required;
+        }
+        break;
+      default:
+        schema.type = jsonSchema.type;
+    }
+  }
+  if (jsonSchema.description) {
+    schema.description = jsonSchema.description;
+  }
+  if (jsonSchema.enum) {
+    schema.enum = jsonSchema.enum.map(String);
+  }
+  if (jsonSchema.default !== undefined) {
+    schema.default = jsonSchema.default;
+  }
+  if (jsonSchema.example !== undefined) {
+    schema.example = jsonSchema.example;
+  }
+  if (jsonSchema.nullable) {
+    schema.nullable = true;
+  }
+  if (jsonSchema.anyOf) {
+    schema.anyOf = jsonSchema.anyOf.map((s) => jsonSchemaToGenAISchema(s));
+  } else if (jsonSchema.oneOf) {
+    schema.anyOf = jsonSchema.oneOf.map((s) => jsonSchemaToGenAISchema(s));
+  }
+  if (jsonSchema.minimum !== undefined) {
+    schema.minimum = jsonSchema.minimum;
+  }
+  if (jsonSchema.maximum !== undefined) {
+    schema.maximum = jsonSchema.maximum;
+  }
+  if (jsonSchema.minLength !== undefined) {
+    schema.minLength = jsonSchema.minLength;
+  }
+  if (jsonSchema.maxLength !== undefined) {
+    schema.maxLength = jsonSchema.maxLength;
+  }
+  if (jsonSchema.pattern) {
+    schema.pattern = jsonSchema.pattern;
+  }
+  return schema;
+}
+function aiToolToGenAIFunction(tool2) {
+  const inputSchema = tool2.inputSchema;
+  let toolName = "tool";
+  let jsonSchema = {};
+  if (inputSchema) {
+    jsonSchema = toJSONSchema(inputSchema);
+    const description = inputSchema.description;
+    if (description) {
+      const nameMatch = description.match(/name:\s*(\w+)/);
+      if (nameMatch) {
+        toolName = nameMatch[1];
+      }
+    }
+  }
+  const genAISchema = jsonSchemaToGenAISchema(jsonSchema);
+  const functionDeclaration = {
+    name: toolName,
+    description: tool2.description || jsonSchema.description || "Tool function",
+    parameters: genAISchema
+  };
+  return functionDeclaration;
+}
+function aiToolToCallableTool(tool2, name) {
+  const toolName = name || "tool";
+  return {
+    name,
+    async tool() {
+      const functionDeclaration = aiToolToGenAIFunction(tool2);
+      if (name) {
+        functionDeclaration.name = name;
+      }
+      return {
+        functionDeclarations: [functionDeclaration]
+      };
+    },
+    async callTool(functionCalls) {
+      const parts = [];
+      for (const functionCall of functionCalls) {
+        if (functionCall.name !== toolName && name && functionCall.name !== name) {
+          continue;
+        }
+        if (tool2.execute) {
+          try {
+            const result = await tool2.execute(functionCall.args || {}, {
+              toolCallId: functionCall.id || "",
+              messages: []
+            });
+            parts.push({
+              functionResponse: {
+                id: functionCall.id,
+                name: functionCall.name || toolName,
+                response: {
+                  output: result
+                }
+              }
+            });
+          } catch (error) {
+            parts.push({
+              functionResponse: {
+                id: functionCall.id,
+                name: functionCall.name || toolName,
+                response: {
+                  error: error instanceof Error ? error.message : String(error)
+                }
+              }
+            });
+          }
+        }
+      }
+      return parts;
+    }
+  };
+}
+function extractSchemaFromTool(tool2) {
+  const inputSchema = tool2.inputSchema;
+  if (!inputSchema) {
+    return {};
+  }
+  return toJSONSchema(inputSchema);
+}
+function callableToolsFromObject(tools) {
+  return Object.entries(tools).map(([name, tool2]) => aiToolToCallableTool(tool2, name));
+}
+var init_ai_tool_to_genai = () => {};
+
+// ../liveapi/src/genai-to-ui-message.ts
+import { createIdGenerator } from "ai";
+
+class LiveMessageAssembler {
+  currentUserParts = [];
+  currentAssistantParts = [];
+  allMessages = [];
+  idGenerator;
+  constructor(options = {}) {
+    this.idGenerator = options.idGenerator ?? createIdGenerator({
+      prefix: "msg",
+      size: 24
+    });
+  }
+  processMessage(message) {
+    const updates = this.processServerMessage(message);
+    const newMessages = this.addParts(updates);
+    if (newMessages.length > 0) {
+      this.allMessages.push(...newMessages);
+    }
+    if (message.serverContent?.interrupted) {
+      const flushedMessages = this.flushPending();
+      this.allMessages.push(...flushedMessages);
+    }
+    const allMessages = [...this.allMessages];
+    if (this.currentUserParts.length > 0) {
+      allMessages.push(this.createMessage("user", this.currentUserParts));
+    }
+    if (this.currentAssistantParts.length > 0) {
+      allMessages.push(this.createMessage("assistant", this.currentAssistantParts));
+    }
+    return allMessages.map(mergeConsecutiveTextParts);
+  }
+  clear() {
+    this.currentUserParts = [];
+    this.currentAssistantParts = [];
+    this.allMessages = [];
+  }
+  getAllMessages() {
+    return [...this.allMessages];
+  }
+  processServerMessage(message) {
+    const updates = [];
+    if (message.serverContent?.modelTurn) {
+      const parts = this.extractPartsFromContent(message.serverContent.modelTurn);
+      for (const part of parts) {
+        updates.push({
+          part,
+          role: "assistant",
+          isFinal: false
+        });
+      }
+      if (message.serverContent.turnComplete) {
+        updates.push({
+          part: { type: "text", text: "" },
+          role: "assistant",
+          isFinal: true
+        });
+      }
+    }
+    if (message.serverContent?.inputTranscription?.text) {
+      updates.push({
+        part: {
+          type: "text",
+          text: message.serverContent.inputTranscription.text
+        },
+        role: "user",
+        isFinal: message.serverContent.inputTranscription.finished || false
+      });
+    }
+    if (message.serverContent?.outputTranscription?.text) {
+      updates.push({
+        part: {
+          type: "text",
+          text: message.serverContent.outputTranscription.text
+        },
+        role: "assistant",
+        isFinal: message.serverContent.outputTranscription.finished || false
+      });
+    }
+    if (message.toolCall?.functionCalls) {
+      for (const functionCall of message.toolCall.functionCalls) {
+        updates.push({
+          part: this.functionCallToToolPart(functionCall),
+          role: "assistant",
+          isFinal: false
+        });
+      }
+    }
+    return updates;
+  }
+  processClientMessage(message) {
+    const updates = [];
+    if (message.clientContent?.turns) {
+      for (const turn of message.clientContent.turns) {
+        const role = this.determineRole(turn.role);
+        const parts = this.extractPartsFromContent(turn);
+        for (const part of parts) {
+          updates.push({
+            part,
+            role,
+            isFinal: false
+          });
+        }
+      }
+      if (message.clientContent.turnComplete) {
+        const lastTurn = message.clientContent.turns[message.clientContent.turns.length - 1];
+        const role = this.determineRole(lastTurn?.role);
+        updates.push({
+          part: { type: "text", text: "" },
+          role,
+          isFinal: true
+        });
+      }
+    }
+    if (message.realtimeInput) {
+      const parts = this.processRealtimeInput(message.realtimeInput);
+      const isActivityEnd = !!message.realtimeInput.activityEnd;
+      for (const part of parts) {
+        updates.push({
+          part,
+          role: "user",
+          isFinal: isActivityEnd
+        });
+      }
+    }
+    if (message.toolResponse?.functionResponses) {
+      for (const response of message.toolResponse.functionResponses) {
+        updates.push({
+          part: this.functionResponseToToolPart(response),
+          role: "user",
+          isFinal: false
+        });
+      }
+    }
+    return updates;
+  }
+  addParts(updates) {
+    const completedMessages = [];
+    for (const update of updates) {
+      if (update.part.type === "text" && update.part.text === "" && update.isFinal) {
+        if (update.role === "user" && this.currentUserParts.length > 0) {
+          completedMessages.push(this.createMessage("user", this.currentUserParts));
+          this.currentUserParts = [];
+        } else if (update.role === "assistant" && this.currentAssistantParts.length > 0) {
+          completedMessages.push(this.createMessage("assistant", this.currentAssistantParts));
+          this.currentAssistantParts = [];
+        }
+      } else {
+        if (update.role === "user") {
+          this.currentUserParts.push(update.part);
+        } else if (update.role === "assistant") {
+          this.currentAssistantParts.push(update.part);
+        }
+        if (update.isFinal) {
+          if (update.role === "user" && this.currentUserParts.length > 0) {
+            completedMessages.push(this.createMessage("user", this.currentUserParts));
+            this.currentUserParts = [];
+          } else if (update.role === "assistant" && this.currentAssistantParts.length > 0) {
+            completedMessages.push(this.createMessage("assistant", this.currentAssistantParts));
+            this.currentAssistantParts = [];
+          }
+        }
+      }
+    }
+    return completedMessages;
+  }
+  getCurrentParts(role) {
+    return role === "user" ? [...this.currentUserParts] : [...this.currentAssistantParts];
+  }
+  flushPending() {
+    const messages = [];
+    if (this.currentUserParts.length > 0) {
+      messages.push(this.createMessage("user", this.currentUserParts));
+      this.currentUserParts = [];
+    }
+    if (this.currentAssistantParts.length > 0) {
+      messages.push(this.createMessage("assistant", this.currentAssistantParts));
+      this.currentAssistantParts = [];
+    }
+    return messages;
+  }
+  flush() {
+    const messages = this.flushPending();
+    this.allMessages.push(...messages);
+    return [...this.allMessages];
+  }
+  extractPartsFromContent(content) {
+    if (!content.parts)
+      return [];
+    return content.parts.map((part) => this.convertPartToUIPart(part)).filter((p) => p !== null);
+  }
+  processRealtimeInput(input) {
+    const parts = [];
+    if (input.text) {
+      parts.push({
+        type: "text",
+        text: input.text,
+        state: input.activityEnd ? "done" : "streaming"
+      });
+    }
+    if (input.mediaChunks) {
+      for (const chunk of input.mediaChunks) {
+        if (chunk && typeof chunk === "object" && chunk.mimeType) {
+          if (chunk.mimeType?.startsWith("audio/") || chunk.mimeType?.startsWith("video/")) {
+            continue;
+          }
+          parts.push({
+            type: "data-url",
+            data: {
+              mimeType: chunk.mimeType || "application/octet-stream",
+              url: `data:${chunk.mimeType};base64,${chunk.data}`
+            }
+          });
+        }
+      }
+    }
+    return parts;
+  }
+  convertPartToUIPart(part) {
+    if (typeof part === "string") {
+      return {
+        type: "text",
+        text: part
+      };
+    }
+    if (part.text) {
+      return {
+        type: "text",
+        text: part.text,
+        providerMetadata: part.thought ? { thought: { value: true } } : undefined
+      };
+    }
+    if (part.inlineData) {
+      if (part.inlineData.mimeType?.startsWith("audio/") || part.inlineData.mimeType?.startsWith("video/")) {
+        return null;
+      }
+      const mimeType = part.inlineData.mimeType || "application/octet-stream";
+      return {
+        type: "data-url",
+        data: {
+          mimeType,
+          url: `data:${mimeType};base64,${part.inlineData.data}`
+        }
+      };
+    }
+    if (part.fileData) {
+      return {
+        type: "file",
+        name: part.fileData.fileUri || "file",
+        url: part.fileData.fileUri,
+        mediaType: part.fileData.mimeType || "application/octet-stream"
+      };
+    }
+    if (part.functionCall) {
+      return this.functionCallToToolPart(part.functionCall);
+    }
+    if (part.functionResponse) {
+      return this.functionResponseToToolPart(part.functionResponse);
+    }
+    if (part.codeExecutionResult) {
+      return {
+        type: "tool-result",
+        toolCallId: this.idGenerator(),
+        toolName: "executableCode",
+        state: part.codeExecutionResult.outcome === "OUTCOME_OK" ? "output-available" : "output-error",
+        input: {},
+        output: part.codeExecutionResult.output || ""
+      };
+    }
+    if (part.executableCode) {
+      return {
+        type: "tool-call",
+        toolCallId: this.idGenerator(),
+        toolName: "executableCode",
+        state: "input-available",
+        input: {
+          language: part.executableCode.language || "unknown",
+          code: part.executableCode.code || ""
+        }
+      };
+    }
+    return null;
+  }
+  functionCallToToolPart(functionCall) {
+    return {
+      type: "tool-call",
+      toolCallId: functionCall.id || this.idGenerator(),
+      toolName: functionCall.name,
+      state: "input-available",
+      input: functionCall.args || {}
+    };
+  }
+  functionResponseToToolPart(response) {
+    const responseData = response.response || {};
+    const isError = responseData.error !== undefined;
+    if (isError) {
+      return {
+        type: "tool-result",
+        toolCallId: response.id || this.idGenerator(),
+        toolName: response.name,
+        state: "output-error",
+        input: {},
+        errorText: JSON.stringify(responseData.error)
+      };
+    }
+    return {
+      type: "tool-result",
+      toolCallId: response.id || this.idGenerator(),
+      toolName: response.name,
+      state: "output-available",
+      input: {},
+      output: responseData.output || responseData
+    };
+  }
+  createMessage(role, parts) {
+    return {
+      id: this.idGenerator(),
+      role,
+      parts: [...parts]
+    };
+  }
+  determineRole(role) {
+    if (!role)
+      return "user";
+    if (role === "model")
+      return "assistant";
+    if (role === "system" || role === "user" || role === "assistant")
+      return role;
+    return "user";
+  }
+}
+function mergeConsecutiveTextParts(message) {
+  const mergedParts = message.parts.reduce((acc, part) => {
+    const lastPart = acc[acc.length - 1];
+    if (part.type === "text" && lastPart?.type === "text") {
+      const mergedTextPart = {
+        type: "text",
+        text: lastPart.text + part.text
+      };
+      const currentTextPart = part;
+      if (currentTextPart.state) {
+        mergedTextPart.state = currentTextPart.state;
+      } else if (lastPart.state) {
+        mergedTextPart.state = lastPart.state;
+      }
+      const lastTextPart = lastPart;
+      if (lastTextPart.providerMetadata || currentTextPart.providerMetadata) {
+        mergedTextPart.providerMetadata = {
+          ...lastTextPart.providerMetadata,
+          ...currentTextPart.providerMetadata
+        };
+      }
+      acc[acc.length - 1] = mergedTextPart;
+    } else {
+      acc.push(part);
+    }
+    return acc;
+  }, []);
+  return {
+    ...message,
+    parts: mergedParts
+  };
+}
+function uiMessageToClientMessage(message, turnComplete = true) {
+  const toolResponses = message.parts.filter((part) => part.type === "tool-result").map((part) => {
+    const toolPart = part;
+    return {
+      id: toolPart.toolCallId,
+      name: "",
+      response: toolPart.state === "output-error" ? { error: toolPart.errorText } : toolPart.output || {}
+    };
+  });
+  if (toolResponses.length > 0) {
+    return {
+      toolResponse: {
+        functionResponses: toolResponses
+      }
+    };
+  }
+  const parts = message.parts.map((part) => uiPartToGenAIPart(part)).filter((p) => p !== null);
+  return {
+    clientContent: {
+      turns: [
+        {
+          role: message.role,
+          parts
+        }
+      ],
+      turnComplete
+    }
+  };
+}
+function uiPartToGenAIPart(part) {
+  switch (part.type) {
+    case "text":
+      return {
+        text: part.text
+      };
+    case "file":
+      const filePart = part;
+      return {
+        fileData: {
+          fileUri: filePart.url,
+          mimeType: filePart.mediaType
+        }
+      };
+    case "tool-call":
+      const toolCall = part;
+      return {
+        functionCall: {
+          id: toolCall.toolCallId,
+          name: "",
+          args: toolCall.input
+        }
+      };
+    default:
+      if (part.type.startsWith("data-")) {
+        const dataPart = part;
+        if (dataPart.data && typeof dataPart.data === "object" && "url" in dataPart.data && dataPart.data.url) {
+          const dataUrl = dataPart.data.url;
+          const base64Match = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
+          if (base64Match) {
+            const mimeType = base64Match[1] || "application/octet-stream";
+            return {
+              inlineData: {
+                mimeType,
+                data: base64Match[2]
+              }
+            };
+          }
+        }
+      }
+      return null;
+  }
+}
+var init_genai_to_ui_message = () => {};
+
+// ../liveapi/src/api.ts
+import { GoogleGenAI as GoogleGenAI2, Modality } from "@google/genai";
+function createAudioChatAPI(options) {
+  const { geminiApiKey, tools, onRequest } = options;
+  const ai = new GoogleGenAI2({
+    apiKey: geminiApiKey,
+    apiVersion: "v1alpha"
+  });
+  return async function handler(request) {
+    try {
+      if (onRequest) {
+        await onRequest({ request });
+      }
+      const method = request.method.toUpperCase();
+      if (method === "GET") {
+        const url = new URL(request.url);
+        const model = url.searchParams.get("model") || "gemini-2.0-flash-live-001";
+        let token;
+        try {
+          const authToken = await ai.authTokens.create({
+            config: {
+              uses: 1,
+              expireTime: new Date(Date.now() + 30 * 60 * 1000).toISOString(),
+              newSessionExpireTime: new Date(Date.now() + 60 * 1000).toISOString(),
+              liveConnectConstraints: {
+                model,
+                config: {
+                  responseModalities: [Modality.AUDIO, Modality.TEXT],
+                  sessionResumption: {},
+                  temperature: 0.7
+                }
+              }
+            }
+          });
+          token = authToken.name || "";
+        } catch (error) {
+          console.error("Error generating token:", error);
+          return new Response(JSON.stringify({ error: "Failed to generate token" }), {
+            status: 500,
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+        const toolDefinitions = Object.entries(tools).map(([name, tool2]) => ({
+          name,
+          description: tool2.description || `Tool: ${name}`,
+          inputSchema: extractSchemaFromTool(tool2)
+        }));
+        const response = {
+          token,
+          tools: toolDefinitions
+        };
+        return new Response(JSON.stringify(response), {
+          status: 200,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+      }
+      if (method === "POST") {
+        const body = await request.json();
+        const toolRequest = body;
+        const { tool: toolName, input } = toolRequest;
+        if (!toolName) {
+          return new Response(JSON.stringify({ error: "Missing tool name" }), {
+            status: 400,
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+        const tool2 = tools[toolName];
+        if (!tool2) {
+          return new Response(JSON.stringify({ error: `Tool not found: ${toolName}` }), {
+            status: 404,
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+        if (!tool2.execute) {
+          return new Response(JSON.stringify({
+            error: `Tool ${toolName} has no execute function`
+          }), {
+            status: 400,
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+        try {
+          const result = await tool2.execute(input || {}, {
+            toolCallId: crypto.randomUUID(),
+            messages: []
+          });
+          return new Response(JSON.stringify(result), {
+            status: 200,
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        } catch (error) {
+          console.error(`Error executing tool ${toolName}:`, error);
+          return new Response(JSON.stringify({
+            error: error instanceof Error ? error.message : "Tool execution failed"
+          }), {
+            status: 500,
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+      }
+      return new Response(JSON.stringify({ error: "Method not allowed" }), {
+        status: 405,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (error) {
+      console.error("API handler error:", error);
+      if (error instanceof Error && error.message.toLowerCase().includes("unauthorized")) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), {
+          status: 401,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+      }
+      return new Response(JSON.stringify({
+        error: error instanceof Error ? error.message : "Internal server error"
+      }), {
+        status: 500,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    }
+  };
+}
+var init_api = __esm(() => {
+  init_ai_tool_to_genai();
+});
+
+// ../liveapi/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  uiMessageToClientMessage: () => uiMessageToClientMessage,
+  mergeConsecutiveTextParts: () => mergeConsecutiveTextParts,
+  extractSchemaFromTool: () => extractSchemaFromTool,
+  downSampleInt16Buffer: () => downSampleInt16Buffer,
+  downSampleAudioBuffer: () => downSampleAudioBuffer,
+  createAudioChatAPI: () => createAudioChatAPI,
+  callableToolsFromObject: () => callableToolsFromObject,
+  aiToolToGenAIFunction: () => aiToolToGenAIFunction,
+  aiToolToCallableTool: () => aiToolToCallableTool,
+  LiveMessageAssembler: () => LiveMessageAssembler,
+  LiveAPIClient: () => LiveAPIClient
+});
+var init_src = __esm(() => {
+  init_live_api_client();
+  init_ai_tool_to_genai();
+  init_genai_to_ui_message();
+  init_api();
+});
+
+// src/cli.tsx
+import { cac } from "cac";
+
+// ../node_modules/.pnpm/string-dedent@3.0.2/node_modules/string-dedent/dist/dedent.mjs
+var cache = new WeakMap;
+var newline = /(\n|\r\n?|\u2028|\u2029)/g;
+var leadingWhitespace = /^\s*/;
+var nonWhitespace = /\S/;
+var slice = Array.prototype.slice;
+var zero = 48;
+var nine = 57;
+var lowerA = 97;
+var lowerF = 102;
+var upperA = 65;
+var upperF = 70;
+function dedent(arg) {
+  if (typeof arg === "string") {
+    return process2([arg])[0];
+  }
+  if (typeof arg === "function") {
+    return function() {
+      const args = slice.call(arguments);
+      args[0] = processTemplateStringsArray(args[0]);
+      return arg.apply(this, args);
+    };
+  }
+  const strings = processTemplateStringsArray(arg);
+  let s = getCooked(strings, 0);
+  for (let i = 1;i < strings.length; i++) {
+    s += arguments[i] + getCooked(strings, i);
+  }
+  return s;
+}
+function getCooked(strings, index) {
+  const str = strings[index];
+  if (str === undefined)
+    throw new TypeError(`invalid cooked string at index ${index}`);
+  return str;
+}
+function processTemplateStringsArray(strings) {
+  const cached = cache.get(strings);
+  if (cached)
+    return cached;
+  const raw = process2(strings.raw);
+  const cooked = raw.map(cook);
+  Object.defineProperty(cooked, "raw", {
+    value: Object.freeze(raw)
+  });
+  Object.freeze(cooked);
+  cache.set(strings, cooked);
+  return cooked;
+}
+function process2(strings) {
+  const splitQuasis = strings.map((quasi) => quasi.split(newline));
+  let common;
+  for (let i = 0;i < splitQuasis.length; i++) {
+    const lines = splitQuasis[i];
+    const firstSplit = i === 0;
+    const lastSplit = i + 1 === splitQuasis.length;
+    if (firstSplit) {
+      if (lines.length === 1 || lines[0].length > 0) {
+        throw new Error("invalid content on opening line");
+      }
+      lines[1] = "";
+    }
+    if (lastSplit) {
+      if (lines.length === 1 || nonWhitespace.test(lines[lines.length - 1])) {
+        throw new Error("invalid content on closing line");
+      }
+      lines[lines.length - 2] = "";
+      lines[lines.length - 1] = "";
+    }
+    for (let j = 2;j < lines.length; j += 2) {
+      const text = lines[j];
+      const lineContainsTemplateExpression = j + 1 === lines.length && !lastSplit;
+      const leading = leadingWhitespace.exec(text)[0];
+      if (!lineContainsTemplateExpression && leading.length === text.length) {
+        lines[j] = "";
+        continue;
+      }
+      common = commonStart(leading, common);
+    }
+  }
+  const min = common ? common.length : 0;
+  return splitQuasis.map((lines) => {
+    let quasi = lines[0];
+    for (let i = 1;i < lines.length; i += 2) {
+      const newline2 = lines[i];
+      const text = lines[i + 1];
+      quasi += newline2 + text.slice(min);
+    }
+    return quasi;
+  });
+}
+function commonStart(a, b) {
+  if (b === undefined || a === b)
+    return a;
+  let i = 0;
+  for (const len = Math.min(a.length, b.length);i < len; i++) {
+    if (a[i] !== b[i])
+      break;
+  }
+  return a.slice(0, i);
+}
+function cook(raw) {
+  let out = "";
+  let start = 0;
+  let i = 0;
+  while ((i = raw.indexOf("\\", i)) > -1) {
+    out += raw.slice(start, i);
+    if (++i === raw.length)
+      return;
+    const next = raw[i++];
+    switch (next) {
+      case "b":
+        out += "\b";
+        break;
+      case "t":
+        out += "\t";
+        break;
+      case "n":
+        out += `
+`;
+        break;
+      case "v":
+        out += "\v";
+        break;
+      case "f":
+        out += "\f";
+        break;
+      case "r":
+        out += "\r";
+        break;
+      case "\r":
+        if (i < raw.length && raw[i] === `
+`)
+          ++i;
+      case `
+`:
+      case "\u2028":
+      case "\u2029":
+        break;
+      case "0":
+        if (isDigit(raw, i))
+          return;
+        out += "\x00";
+        break;
+      case "x": {
+        const n = parseHex(raw, i, i + 2);
+        if (n === -1)
+          return;
+        i += 2;
+        out += String.fromCharCode(n);
+        break;
+      }
+      case "u": {
+        let n;
+        if (i < raw.length && raw[i] === "{") {
+          const end = raw.indexOf("}", ++i);
+          if (end === -1)
+            return;
+          n = parseHex(raw, i, end);
+          i = end + 1;
+        } else {
+          n = parseHex(raw, i, i + 4);
+          i += 4;
+        }
+        if (n === -1 || n > 1114111)
+          return;
+        out += String.fromCodePoint(n);
+        break;
+      }
+      default:
+        if (isDigit(next, 0))
+          return;
+        out += next;
+    }
+    start = i;
+  }
+  return out + raw.slice(start);
+}
+function isDigit(str, index) {
+  const c = str.charCodeAt(index);
+  return c >= zero && c <= nine;
+}
+function parseHex(str, index, end) {
+  if (end >= str.length)
+    return -1;
+  let n = 0;
+  for (;index < end; index++) {
+    const c = hexToInt(str.charCodeAt(index));
+    if (c === -1)
+      return -1;
+    n = n * 16 + c;
+  }
+  return n;
+}
+function hexToInt(c) {
+  if (c >= zero && c <= nine)
+    return c - zero;
+  if (c >= lowerA && c <= lowerF)
+    return c - lowerA + 10;
+  if (c >= upperA && c <= upperF)
+    return c - upperA + 10;
+  return -1;
+}
+
+// src/cli.tsx
+import { mediaDevices } from "node-web-audio-api";
+import { MediaResolution as MediaResolution2, Modality as Modality2 } from "@google/genai";
+import * as webAudioApi from "node-web-audio-api";
+import fs3 from "node:fs";
+import path2 from "node:path";
+import WaveFile from "wavefile";
+import pc2 from "picocolors";
+
+// src/tools.ts
+import { tool } from "ai";
+import { z as z2 } from "zod";
+import { spawn } from "node:child_process";
+import net from "node:net";
+import {
+  createOpencodeClient
+} from "@opencode-ai/sdk";
+import { formatDistanceToNow } from "date-fns";
+
+// src/config.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+var PreferredModelSchema = z.object({
+  providerId: z.string(),
+  modelId: z.string()
+});
+var KimakiConfigSchema = z.object({
+  preferredModel: PreferredModelSchema.optional()
+});
+var configDir = path.join(os.homedir(), ".kimaki");
+var configPath = path.join(configDir, "kimaki.json");
+async function readConfig() {
+  try {
+    const configData = await fs.promises.readFile(configPath, "utf-8");
+    const config = JSON.parse(configData);
+    return KimakiConfigSchema.parse(config);
+  } catch (error) {
+    return {};
+  }
+}
+async function writeConfig(config) {
+  await fs.promises.mkdir(configDir, { recursive: true });
+  await fs.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function updateConfig(updates) {
+  const config = await readConfig();
+  const updatedConfig = { ...config, ...updates };
+  await writeConfig(updatedConfig);
+}
+
+// src/markdown.ts
+import { DateTime } from "luxon";
+import * as yaml from "js-yaml";
+
+class ShareMarkdown {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async generate(options) {
+    const { sessionID, includeSystemInfo, lastAssistantOnly } = options;
+    const sessionResponse = await this.client.session.get({
+      path: { id: sessionID }
+    });
+    if (!sessionResponse.data) {
+      throw new Error(`Session ${sessionID} not found`);
+    }
+    const session = sessionResponse.data;
+    const messagesResponse = await this.client.session.messages({
+      path: { id: sessionID }
+    });
+    if (!messagesResponse.data) {
+      throw new Error(`No messages found for session ${sessionID}`);
+    }
+    const messages = messagesResponse.data;
+    const messagesToRender = lastAssistantOnly ? (() => {
+      const assistantMessages = messages.filter((m) => m.info.role === "assistant");
+      return assistantMessages.length > 0 ? [assistantMessages[assistantMessages.length - 1]] : [];
+    })() : messages;
+    const lines = [];
+    if (!lastAssistantOnly) {
+      lines.push(`# ${session.title || "Untitled Session"}`);
+      lines.push("");
+      if (includeSystemInfo === true) {
+        lines.push("## Session Information");
+        lines.push("");
+        lines.push(`- **Created**: ${DateTime.fromMillis(session.time.created).toLocaleString(DateTime.DATETIME_MED)}`);
+        lines.push(`- **Updated**: ${DateTime.fromMillis(session.time.updated).toLocaleString(DateTime.DATETIME_MED)}`);
+        if (session.version) {
+          lines.push(`- **OpenCode Version**: v${session.version}`);
+        }
+        lines.push("");
+      }
+      lines.push("## Conversation");
+      lines.push("");
+    }
+    for (const message of messagesToRender) {
+      const messageLines = this.renderMessage(message.info, message.parts);
+      lines.push(...messageLines);
+      lines.push("");
+    }
+    return lines.join(`
+`);
+  }
+  renderMessage(message, parts) {
+    const lines = [];
+    if (message.role === "user") {
+      lines.push("### \uD83D\uDC64 User");
+      lines.push("");
+      for (const part of parts) {
+        if (part.type === "text" && part.text) {
+          lines.push(part.text);
+          lines.push("");
+        } else if (part.type === "file") {
+          lines.push(`\uD83D\uDCCE **Attachment**: ${part.filename || "unnamed file"}`);
+          if (part.url) {
+            lines.push(`   - URL: ${part.url}`);
+          }
+          lines.push("");
+        }
+      }
+    } else if (message.role === "assistant") {
+      lines.push(`### \uD83E\uDD16 Assistant (${message.modelID || "unknown model"})`);
+      lines.push("");
+      const filteredParts = parts.filter((part) => {
+        if (part.type === "step-start" && parts.indexOf(part) > 0)
+          return false;
+        if (part.type === "snapshot")
+          return false;
+        if (part.type === "patch")
+          return false;
+        if (part.type === "step-finish")
+          return false;
+        if (part.type === "text" && part.synthetic === true)
+          return false;
+        if (part.type === "tool" && part.tool === "todoread")
+          return false;
+        if (part.type === "text" && !part.text)
+          return false;
+        if (part.type === "tool" && (part.state.status === "pending" || part.state.status === "running"))
+          return false;
+        return true;
+      });
+      for (const part of filteredParts) {
+        const partLines = this.renderPart(part, message);
+        lines.push(...partLines);
+      }
+      if (message.time?.completed) {
+        const duration = message.time.completed - message.time.created;
+        lines.push("");
+        lines.push(`*Completed in ${this.formatDuration(duration)}*`);
+      }
+    }
+    return lines;
+  }
+  renderPart(part, message) {
+    const lines = [];
+    switch (part.type) {
+      case "text":
+        if (part.text) {
+          lines.push(part.text);
+          lines.push("");
+        }
+        break;
+      case "reasoning":
+        if (part.text) {
+          lines.push("<details>");
+          lines.push("<summary>\uD83D\uDCAD Thinking</summary>");
+          lines.push("");
+          lines.push(part.text);
+          lines.push("");
+          lines.push("</details>");
+          lines.push("");
+        }
+        break;
+      case "tool":
+        if (part.state.status === "completed") {
+          lines.push(`#### \uD83D\uDEE0️ Tool: ${part.tool}`);
+          lines.push("");
+          if (part.state.input && Object.keys(part.state.input).length > 0) {
+            lines.push("**Input:**");
+            lines.push("```yaml");
+            lines.push(yaml.dump(part.state.input, { lineWidth: -1 }));
+            lines.push("```");
+            lines.push("");
+          }
+          if (part.state.output) {
+            lines.push("**Output:**");
+            lines.push("```");
+            lines.push(part.state.output);
+            lines.push("```");
+            lines.push("");
+          }
+          if (part.state.time?.start && part.state.time?.end) {
+            const duration = part.state.time.end - part.state.time.start;
+            if (duration > 2000) {
+              lines.push(`*Duration: ${this.formatDuration(duration)}*`);
+              lines.push("");
+            }
+          }
+        } else if (part.state.status === "error") {
+          lines.push(`#### ❌ Tool Error: ${part.tool}`);
+          lines.push("");
+          lines.push("```");
+          lines.push(part.state.error || "Unknown error");
+          lines.push("```");
+          lines.push("");
+        }
+        break;
+      case "step-start":
+        lines.push(`**Started using ${message.providerID}/${message.modelID}**`);
+        lines.push("");
+        break;
+    }
+    return lines;
+  }
+  formatDuration(ms) {
+    if (ms < 1000)
+      return `${ms}ms`;
+    if (ms < 60000)
+      return `${(ms / 1000).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.floor(ms % 60000 / 1000);
+    return `${minutes}m ${seconds}s`;
+  }
+}
+
+// src/tools.ts
+import pc from "picocolors";
+async function getOpenPort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, () => {
+      const address = server.address();
+      if (address && typeof address === "object") {
+        const port = address.port;
+        server.close(() => {
+          resolve(port);
+        });
+      } else {
+        reject(new Error("Failed to get port"));
+      }
+    });
+    server.on("error", reject);
+  });
+}
+async function waitForServer(port, maxAttempts = 30) {
+  for (let i = 0;i < maxAttempts; i++) {
+    try {
+      const endpoints = [
+        `http://localhost:${port}/api/health`,
+        `http://localhost:${port}/`,
+        `http://localhost:${port}/api`
+      ];
+      for (const endpoint of endpoints) {
+        try {
+          const response = await fetch(endpoint);
+          if (response.status < 500) {
+            console.log(pc.green(`OpenCode server ready on port ${port}`));
+            return true;
+          }
+        } catch (e) {}
+      }
+    } catch (e) {}
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+  throw new Error(`Server did not start on port ${port} after ${maxAttempts} seconds`);
+}
+async function startOpencodeServer(port) {
+  console.log(pc.cyan(`Starting OpenCode server on port ${port}...`));
+  const serverProcess = spawn("opencode", ["serve", "--port", port.toString()], {
+    stdio: "pipe",
+    detached: false,
+    env: {
+      ...process.env,
+      OPENCODE_PORT: port.toString()
+    }
+  });
+  serverProcess.stdout?.on("data", (data) => {
+    console.log(pc.gray(`[OpenCode] ${data.toString().trim()}`));
+  });
+  serverProcess.stderr?.on("data", (data) => {
+    console.error(pc.yellow(`[OpenCode Error] ${data.toString().trim()}`));
+  });
+  serverProcess.on("error", (error) => {
+    console.error(pc.red("Failed to start OpenCode server:"), error);
+  });
+  await waitForServer(port);
+  return serverProcess;
+}
+async function selectModelProvider(providedModel) {
+  if (providedModel) {
+    return {
+      providerID: providedModel.providerId,
+      modelID: providedModel.modelId
+    };
+  }
+  const config = await readConfig();
+  if (config.preferredModel) {
+    return {
+      providerID: config.preferredModel.providerId,
+      modelID: config.preferredModel.modelId
+    };
+  }
+  throw new Error("No model specified and no preferred model set. Please call getModels to see available models and ask user to choose one. Do not spell model names exactly, give rough names like Sonnet or GPT5. Prefer latest versions");
+}
+async function getTools({
+  onMessageCompleted
+} = {}) {
+  const port = await getOpenPort();
+  const serverProcess = await startOpencodeServer(port);
+  const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+  const markdownRenderer = new ShareMarkdown(client);
+  const providersResponse = await client.config.providers({});
+  const providers = providersResponse.data?.providers || [];
+  const config = await readConfig();
+  const preferredModel = config.preferredModel;
+  process.on("exit", () => {
+    if (serverProcess && !serverProcess.killed) {
+      serverProcess.kill("SIGTERM");
+    }
+  });
+  process.on("SIGINT", () => {
+    if (serverProcess && !serverProcess.killed) {
+      serverProcess.kill("SIGTERM");
+    }
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    if (serverProcess && !serverProcess.killed) {
+      serverProcess.kill("SIGTERM");
+    }
+    process.exit(0);
+  });
+  const getSessionModel = async (sessionId) => {
+    const res = await client.session.messages({ path: { id: sessionId } });
+    const data = res.data;
+    if (!data || data.length === 0)
+      return;
+    for (let i = data.length - 1;i >= 0; i--) {
+      const info = data[i].info;
+      if (info.role === "assistant") {
+        const ai = info;
+        if (!ai.summary && ai.providerID && ai.modelID) {
+          return { providerID: ai.providerID, modelID: ai.modelID };
+        }
+      }
+    }
+    return;
+  };
+  const tools = {
+    submitMessage: tool({
+      description: "Submit a message to an existing chat session. Does not wait for the message to complete",
+      inputSchema: z2.object({
+        sessionId: z2.string().describe("The session ID to send message to"),
+        message: z2.string().describe("The message text to send")
+      }),
+      execute: async ({ sessionId, message }) => {
+        const sessionModel = await getSessionModel(sessionId);
+        client.session.prompt({
+          path: { id: sessionId },
+          body: {
+            parts: [{ type: "text", text: message }],
+            model: sessionModel
+          }
+        }).then(async (response) => {
+          const markdown = await markdownRenderer.generate({
+            sessionID: sessionId,
+            lastAssistantOnly: true
+          });
+          onMessageCompleted?.({
+            sessionId,
+            messageId: "",
+            data: response.data,
+            markdown
+          });
+        }).catch((error) => {
+          onMessageCompleted?.({
+            sessionId,
+            messageId: "",
+            error
+          });
+        });
+        return {
+          success: true,
+          sessionId,
+          directive: "Tell user that message has been sent successfully"
+        };
+      }
+    }),
+    createNewChat: tool({
+      description: "Start a new chat session with an initial message. Does not wait for the message to complete",
+      inputSchema: z2.object({
+        message: z2.string().describe("The initial message to start the chat with"),
+        title: z2.string().optional().describe("Optional title for the session"),
+        model: z2.object({
+          providerId: z2.string().describe('The provider ID (e.g., "anthropic", "openai")'),
+          modelId: z2.string().describe('The model ID (e.g., "claude-opus-4-20250514", "gpt-5")')
+        }).optional().describe("Optional model to use for this session")
+      }),
+      execute: async ({ message, title, model }) => {
+        if (!message.trim()) {
+          throw new Error(`message must be a non empty string`);
+        }
+        try {
+          const { providerID, modelID } = await selectModelProvider(model);
+          if (model) {
+            await updateConfig({
+              preferredModel: {
+                providerId: model.providerId,
+                modelId: model.modelId
+              }
+            });
+          }
+          const session = await client.session.create({
+            body: {
+              title: title || message.slice(0, 50)
+            }
+          });
+          if (!session.data) {
+            throw new Error("Failed to create session");
+          }
+          client.session.prompt({
+            path: { id: session.data.id },
+            body: {
+              parts: [{ type: "text", text: message }],
+              model: modelID && providerID ? { modelID, providerID } : undefined
+            }
+          }).then(async (response) => {
+            const markdown = await markdownRenderer.generate({
+              sessionID: session.data.id,
+              lastAssistantOnly: true
+            });
+            onMessageCompleted?.({
+              sessionId: session.data.id,
+              messageId: "",
+              data: response.data,
+              markdown
+            });
+          }).catch((error) => {
+            onMessageCompleted?.({
+              sessionId: session.data.id,
+              messageId: "",
+              error
+            });
+          });
+          return {
+            success: true,
+            sessionId: session.data.id,
+            title: session.data.title
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to create chat session"
+          };
+        }
+      }
+    }),
+    listChats: tool({
+      description: "Get a list of available chat sessions sorted by most recent",
+      inputSchema: z2.object({}),
+      execute: async () => {
+        console.log(`listing opencode sessions`);
+        const sessions = await client.session.list();
+        if (!sessions.data) {
+          return { success: false, error: "No sessions found" };
+        }
+        const sortedSessions = [...sessions.data].sort((a, b) => {
+          return b.time.updated - a.time.updated;
+        }).slice(0, 20);
+        const sessionList = sortedSessions.map(async (session) => {
+          const finishedAt = session.time.updated;
+          const status = await (async () => {
+            if (session.revert)
+              return "error";
+            const messagesResponse = await client.session.messages({
+              path: { id: session.id }
+            });
+            const messages = messagesResponse.data || [];
+            const lastMessage = messages[messages.length - 1];
+            if (lastMessage?.info.role === "assistant" && !lastMessage.info.time.completed) {
+              return "in_progress";
+            }
+            return "finished";
+          })();
+          return {
+            id: session.id,
+            folder: session.directory,
+            status,
+            finishedAt: formatDistanceToNow(new Date(finishedAt), {
+              addSuffix: true
+            }),
+            title: session.title,
+            prompt: session.title
+          };
+        });
+        const resolvedList = await Promise.all(sessionList);
+        return {
+          success: true,
+          sessions: resolvedList
+        };
+      }
+    }),
+    searchFiles: tool({
+      description: "Search for files in a folder",
+      inputSchema: z2.object({
+        folder: z2.string().optional().describe("The folder path to search in, optional. only use if user specifically asks for it"),
+        query: z2.string().describe("The search query for files")
+      }),
+      execute: async ({ folder, query }) => {
+        const results = await client.find.files({
+          query: {
+            query,
+            directory: folder
+          }
+        });
+        return {
+          success: true,
+          files: results.data || []
+        };
+      }
+    }),
+    readSessionMessages: tool({
+      description: "Read messages from a chat session",
+      inputSchema: z2.object({
+        sessionId: z2.string().describe("The session ID to read messages from"),
+        lastAssistantOnly: z2.boolean().optional().describe("Only read the last assistant message")
+      }),
+      execute: async ({ sessionId, lastAssistantOnly = false }) => {
+        if (lastAssistantOnly) {
+          const messages = await client.session.messages({
+            path: { id: sessionId }
+          });
+          if (!messages.data) {
+            return { success: false, error: "No messages found" };
+          }
+          const assistantMessages = messages.data.filter((m) => m.info.role === "assistant");
+          if (assistantMessages.length === 0) {
+            return {
+              success: false,
+              error: "No assistant messages found"
+            };
+          }
+          const lastMessage = assistantMessages[assistantMessages.length - 1];
+          const status = "completed" in lastMessage.info.time && lastMessage.info.time.completed ? "completed" : "in_progress";
+          const markdown = await markdownRenderer.generate({
+            sessionID: sessionId,
+            lastAssistantOnly: true
+          });
+          return {
+            success: true,
+            markdown,
+            status
+          };
+        } else {
+          const markdown = await markdownRenderer.generate({
+            sessionID: sessionId
+          });
+          const messages = await client.session.messages({
+            path: { id: sessionId }
+          });
+          const lastMessage = messages.data?.[messages.data.length - 1];
+          const status = lastMessage?.info.role === "assistant" && lastMessage?.info.time && "completed" in lastMessage.info.time && !lastMessage.info.time.completed ? "in_progress" : "completed";
+          return {
+            success: true,
+            markdown,
+            status
+          };
+        }
+      }
+    }),
+    abortChat: tool({
+      description: "Abort/stop an in-progress chat session",
+      inputSchema: z2.object({
+        sessionId: z2.string().describe("The session ID to abort")
+      }),
+      execute: async ({ sessionId }) => {
+        try {
+          const result = await client.session.abort({
+            path: { id: sessionId }
+          });
+          if (!result.data) {
+            return {
+              success: false,
+              error: "Failed to abort session"
+            };
+          }
+          return {
+            success: true,
+            sessionId,
+            message: "Session aborted successfully"
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error occurred"
+          };
+        }
+      }
+    }),
+    getModels: tool({
+      description: "Get all available AI models from all providers",
+      inputSchema: z2.object({}),
+      execute: async () => {
+        try {
+          const providersResponse2 = await client.config.providers({});
+          const providers2 = providersResponse2.data?.providers || [];
+          const models = [];
+          providers2.forEach((provider) => {
+            if (provider.models && typeof provider.models === "object") {
+              Object.entries(provider.models).forEach(([modelId, model]) => {
+                models.push({
+                  providerId: provider.id,
+                  modelId
+                });
+              });
+            }
+          });
+          return {
+            success: true,
+            models,
+            totalCount: models.length
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to fetch models",
+            models: []
+          };
+        }
+      }
+    })
+  };
+  return {
+    tools,
+    providers,
+    preferredModel
+  };
+}
+
+// src/cli.tsx
+import { render, Box, Text, useStdout } from "ink";
+import { useState, useEffect } from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+var cli = cac("kimaki");
+cli.help();
+function AsciiVideoPlayer() {
+  const [frameIndex, setFrameIndex] = useState(0);
+  const [asciiFrame, setAsciiFrame] = useState("Loading frames...");
+  const [frames, setFrames] = useState([]);
+  const { stdout } = useStdout();
+  useEffect(() => {
+    const framesDir = path2.join(path2.dirname(new URL(import.meta.url).pathname), "../assets/frames");
+    try {
+      const files = fs3.readdirSync(framesDir).filter((f) => f.endsWith(".png")).sort();
+      setFrames(files.map((f) => path2.join(framesDir, f)));
+    } catch (error) {
+      setAsciiFrame("Error: Could not find frames directory");
+    }
+  }, []);
+  useEffect(() => {
+    if (frames.length === 0)
+      return;
+    const loadFrame = async () => {
+      const { convertImageToAscii: convertImageToAscii2 } = await Promise.resolve().then(() => (init_video_to_ascii(), exports_video_to_ascii));
+      const ascii = await convertImageToAscii2({
+        imagePath: frames[frameIndex],
+        cols: 80,
+        rows: 22,
+        colored: true,
+        keepAspectRatio: false
+      });
+      setAsciiFrame(ascii);
+    };
+    loadFrame();
+    const timer = setTimeout(() => {
+      setFrameIndex((prev) => (prev + 1) % frames.length);
+    }, 50);
+    return () => clearTimeout(timer);
+  }, [frameIndex, frames]);
+  return /* @__PURE__ */ jsxDEV(Box, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV(Text, {
+        children: asciiFrame
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(Text, {
+        dimColor: true,
+        children: [
+          "Press Ctrl+C to exit • Frame ",
+          frameIndex + 1,
+          "/",
+          frames.length
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function KimakiTUI({
+  messages,
+  isConnected
+}) {
+  const formatMessage = (msg) => {
+    const data = msg.data;
+    if (data.serverContent?.modelTurn?.parts?.[0]?.text) {
+      return `\uD83E\uDD16 ${data.serverContent.modelTurn.parts[0].text.slice(0, 80)}...`;
+    }
+    if (data.serverContent?.turnComplete) {
+      return "✅ Turn completed";
+    }
+    if (data.toolCall) {
+      return `\uD83D\uDD27 Tool: ${data.toolCall.name}`;
+    }
+    if (data.toolResponse) {
+      return `\uD83D\uDCE6 Tool response received`;
+    }
+    if (data.interrupted) {
+      return "⚠️ Interrupted";
+    }
+    if (data.setupComplete) {
+      return "\uD83D\uDE80 Setup complete";
+    }
+    return JSON.stringify(data).slice(0, 80);
+  };
+  return /* @__PURE__ */ jsxDEV(Box, {
+    flexDirection: "column",
+    paddingX: 1,
+    children: [
+      /* @__PURE__ */ jsxDEV(Box, {
+        borderStyle: "single",
+        paddingX: 1,
+        marginBottom: 1,
+        children: /* @__PURE__ */ jsxDEV(Text, {
+          color: isConnected ? "green" : "yellow",
+          children: [
+            "Kimaki Voice Assistant -",
+            " ",
+            isConnected ? "● Connected to Gemini Live API" : "⏳ Connecting..."
+          ]
+        }, undefined, true, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(Box, {
+        borderStyle: "single",
+        paddingX: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: "white",
+            bold: true,
+            children: "Debug Messages:"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Box, {
+            flexDirection: "column",
+            marginTop: 1,
+            children: messages.length === 0 ? /* @__PURE__ */ jsxDEV(Text, {
+              dimColor: true,
+              children: "No messages yet..."
+            }, undefined, false, undefined, this) : messages.slice(-15).map((msg, index) => /* @__PURE__ */ jsxDEV(Box, {
+              marginBottom: 0,
+              children: [
+                /* @__PURE__ */ jsxDEV(Text, {
+                  color: "cyan",
+                  children: [
+                    "[",
+                    new Date(msg.timestamp).toLocaleTimeString(),
+                    "]",
+                    " "
+                  ]
+                }, undefined, true, undefined, this),
+                /* @__PURE__ */ jsxDEV(Text, {
+                  color: "white",
+                  children: formatMessage(msg)
+                }, undefined, false, undefined, this)
+              ]
+            }, index, true, undefined, this))
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+cli.command("", "Spawn Kimaki to orchestrate code agents").action(async (options) => {
+  try {
+    const token = process.env.GEMINI_API_KEY;
+    Object.assign(globalThis, webAudioApi);
+    navigator.mediaDevices = mediaDevices;
+    const { LiveAPIClient: LiveAPIClient2, callableToolsFromObject: callableToolsFromObject2 } = await Promise.resolve().then(() => (init_src(), exports_src));
+    let liveApiClient = null;
+    let audioChunks = [];
+    let isModelSpeaking = false;
+    let debugMessages = [];
+    let isConnected = false;
+    let updateUI = null;
+    const { tools, providers, preferredModel } = await getTools({
+      onMessageCompleted: (params) => {
+        if (!liveApiClient)
+          return;
+        const text = params.error ? `<systemMessage>
+Chat message failed for session ${params.sessionId}. Error: ${params.error?.message || String(params.error)}
+</systemMessage>` : `<systemMessage>
+Chat message completed for session ${params.sessionId}.
+
+Assistant response:
+${params.markdown}
+</systemMessage>`;
+        liveApiClient.sendText(text);
+      }
+    });
+    const saveUserAudio = async () => {
+      console.log("saveUserAudio", audioChunks.length);
+      if (audioChunks.length === 0)
+        return;
+      try {
+        const timestamp = Date.now();
+        const dir = "useraudio";
+        if (!fs3.existsSync(dir)) {
+          fs3.mkdirSync(dir, { recursive: true });
+        }
+        const totalLength = audioChunks.reduce((acc, chunk) => acc + chunk.byteLength, 0);
+        const combinedBuffer = new ArrayBuffer(totalLength);
+        const combinedView = new Int16Array(combinedBuffer);
+        let offset = 0;
+        for (const chunk of audioChunks) {
+          const chunkView = new Int16Array(chunk);
+          combinedView.set(chunkView, offset);
+          offset += chunkView.length;
+        }
+        const wav = new WaveFile.WaveFile;
+        wav.fromScratch(1, 16000, "16", Array.from(combinedView));
+        const filename = path2.join(dir, `${timestamp}.wav`);
+        await fs3.promises.writeFile(filename, Buffer.from(wav.toBuffer()));
+        console.log(`Saved user audio to ${filename} (${audioChunks.length} chunks)`);
+        audioChunks = [];
+      } catch (error) {
+        console.error("Failed to save audio file:", error);
+      }
+    };
+    const model = "models/gemini-2.5-flash-live-preview";
+    const newClient = new LiveAPIClient2({
+      apiKey: token,
+      model,
+      recordingSampleRate: 44100,
+      autoMuteOnAssistantSpeaking: false,
+      onUserAudioChunk: (chunk) => {
+        if (!isModelSpeaking) {
+          audioChunks.push(chunk);
+        }
+      },
+      onMessage: (message) => {
+        debugMessages.push({
+          timestamp: Date.now(),
+          data: message
+        });
+        if (debugMessages.length > 50) {
+          debugMessages = debugMessages.slice(-50);
+        }
+        if (updateUI) {
+          updateUI([...debugMessages], isConnected);
+        }
+        process.env.DEBUG && console.log(message);
+        if (message.serverContent?.turnComplete && audioChunks.length > 0) {
+          isModelSpeaking = true;
+          process.env.DEBUG && saveUserAudio();
+        }
+        if (message.serverContent?.turnComplete) {
+          isModelSpeaking = false;
+        }
+      },
+      config: {
+        tools: callableToolsFromObject2(tools),
+        responseModalities: [Modality2.AUDIO],
+        speechConfig: {
+          voiceConfig: {
+            prebuiltVoiceConfig: {
+              voiceName: "Charon"
+            }
+          }
+        },
+        mediaResolution: MediaResolution2.MEDIA_RESOLUTION_MEDIUM,
+        contextWindowCompression: {
+          triggerTokens: "25600",
+          slidingWindow: { targetTokens: "12800" }
+        },
+        systemInstruction: {
+          parts: [
+            {
+              text: dedent`
+                You are Kimaki, an AI similar to Jarvis: you help your user (an engineer) controlling his coding agent, just like Jarvis controls Ironman armor and machines. Speak fast.
+
+                You should talk like Jarvis, British accent, satirical, joking and calm. Be short and concise. Speak fast.
+
+                After tool calls give a super short summary of the assistant message, you should say what the assistant message writes.
+
+                Before starting a new session ask for confirmation if it is not clear if the user finished describing it. ask "message ready, send?"
+
+                NEVER repeat the whole tool call parameters or message.
+
+                Your job is to manage many opencode agent chat instances. Opencode is the agent used to write the code, it is similar to Claude Code.
+
+                For everything the user asks it is implicit that the user is asking for you to proxy the requests to opencode sessions.
+
+                You can
+                - start new chats on a given project
+                - read the chats to report progress to the user
+                - submit messages to the chat
+                - list files for a given projects, so you can translate imprecise user prompts to precise messages that mention filename paths using @
+
+                Common patterns
+                - to get the last session use the listChats tool
+                - when user asks you to do something you submit a new session to do it. it's implicit that you proxy requests to the agents chat!
+                - when you submit a session assume the session will take a minute or 2 to complete the task
+
+                Rules
+                - never spell files by mentioning dots, letters, etc. instead give a brief description of the filename
+                - NEVER spell hashes or IDs
+                - never read session ids or other ids
+
+                Your voice is calm and monotone, NEVER excited and goofy. But you speak without jargon or bs and do veiled short jokes.
+                You speak like you knew something other don't. You are cool and cold.
+                `
+            }
+          ]
+        }
+      },
+      onStateChange: (state) => {}
+    });
+    liveApiClient = newClient;
+    const connected = await newClient.connect();
+    isConnected = true;
+    await new Promise((res) => setTimeout(res, 500));
+    const App = () => {
+      const [messages, setMessages] = useState([]);
+      const [connectionStatus, setConnectionStatus] = useState(isConnected);
+      useEffect(() => {
+        updateUI = (msgs, connected2) => {
+          setMessages(msgs);
+          setConnectionStatus(connected2);
+        };
+        setMessages([...debugMessages]);
+        setConnectionStatus(isConnected);
+        return () => {
+          updateUI = null;
+        };
+      }, []);
+      return /* @__PURE__ */ jsxDEV(KimakiTUI, {
+        messages,
+        isConnected: connectionStatus
+      }, undefined, false, undefined, this);
+    };
+    render(/* @__PURE__ */ jsxDEV(App, {}, undefined, false, undefined, this));
+  } catch (error) {
+    console.error(pc2.red(`
+Error initializing project:`));
+    console.error(pc2.red(error));
+    process.exit(1);
+  }
+});
+cli.command("ascii", "Play ASCII video").action(async () => {
+  render(/* @__PURE__ */ jsxDEV(AsciiVideoPlayer, {}, undefined, false, undefined, this));
+});
+
+// src/bin.ts
+cli.parse();