@ai2070/l0/dist/adapters/helpers.js

L0: The Missing Reliability Substrate for AI

async function* toL0Events(stream, extractText) {
  try {
    for await (const chunk of stream) {
      const text = extractText(chunk);
      if (text != null) {
        yield {
          type: "token",
          value: text,
          timestamp: Date.now()
        };
      }
    }
    yield {
      type: "complete",
      timestamp: Date.now()
    };
  } catch (err) {
    yield {
      type: "error",
      error: err instanceof Error ? err : new Error(String(err)),
      timestamp: Date.now()
    };
  }
}
async function* toL0EventsWithMessages(stream, handlers) {
  try {
    for await (const chunk of stream) {
      const text = handlers.extractText(chunk);
      if (text != null) {
        yield {
          type: "token",
          value: text,
          timestamp: Date.now()
        };
        continue;
      }
      if (handlers.extractMessage) {
        const message = handlers.extractMessage(chunk);
        if (message != null) {
          yield {
            type: "message",
            value: message.value,
            role: message.role,
            timestamp: Date.now()
          };
        }
      }
    }
    yield {
      type: "complete",
      timestamp: Date.now()
    };
  } catch (err) {
    yield {
      type: "error",
      error: err instanceof Error ? err : new Error(String(err)),
      timestamp: Date.now()
    };
  }
}
function createAdapterTokenEvent(value) {
  return {
    type: "token",
    value,
    timestamp: Date.now()
  };
}
function createAdapterDoneEvent() {
  return {
    type: "complete",
    timestamp: Date.now()
  };
}
function createAdapterErrorEvent(err) {
  return {
    type: "error",
    error: err instanceof Error ? err : new Error(String(err)),
    timestamp: Date.now()
  };
}
function createAdapterMessageEvent(value, role) {
  return {
    type: "message",
    value,
    role,
    timestamp: Date.now()
  };
}
function createAdapterDataEvent(payload) {
  return {
    type: "data",
    data: payload,
    timestamp: Date.now()
  };
}
function createAdapterProgressEvent(progress) {
  return {
    type: "progress",
    progress,
    timestamp: Date.now()
  };
}
function createImageEvent(options) {
  const payload = {
    contentType: "image",
    mimeType: options.mimeType ?? "image/png",
    url: options.url,
    base64: options.base64,
    bytes: options.bytes,
    metadata: {
      width: options.width,
      height: options.height,
      seed: options.seed,
      model: options.model
    }
  };
  if (payload.metadata) {
    payload.metadata = Object.fromEntries(
      Object.entries(payload.metadata).filter(([_, v]) => v !== void 0)
    );
    if (Object.keys(payload.metadata).length === 0) {
      delete payload.metadata;
    }
  }
  return createAdapterDataEvent(payload);
}
function createAudioEvent(options) {
  const payload = {
    contentType: "audio",
    mimeType: options.mimeType ?? "audio/mp3",
    url: options.url,
    base64: options.base64,
    bytes: options.bytes,
    metadata: {
      duration: options.duration,
      model: options.model
    }
  };
  if (payload.metadata) {
    payload.metadata = Object.fromEntries(
      Object.entries(payload.metadata).filter(([_, v]) => v !== void 0)
    );
    if (Object.keys(payload.metadata).length === 0) {
      delete payload.metadata;
    }
  }
  return createAdapterDataEvent(payload);
}
function createJsonDataEvent(data, metadata) {
  return createAdapterDataEvent({
    contentType: "json",
    mimeType: "application/json",
    json: data,
    metadata
  });
}
async function* toMultimodalL0Events(stream, handlers) {
  try {
    for await (const chunk of stream) {
      if (handlers.extractText) {
        const text = handlers.extractText(chunk);
        if (text != null) {
          yield createAdapterTokenEvent(text);
          continue;
        }
      }
      if (handlers.extractData) {
        const data = handlers.extractData(chunk);
        if (data != null) {
          yield createAdapterDataEvent(data);
          continue;
        }
      }
      if (handlers.extractProgress) {
        const progress = handlers.extractProgress(chunk);
        if (progress != null) {
          yield createAdapterProgressEvent(progress);
          continue;
        }
      }
      if (handlers.extractMessage) {
        const message = handlers.extractMessage(chunk);
        if (message != null) {
          yield createAdapterMessageEvent(message.value, message.role);
          continue;
        }
      }
    }
    yield createAdapterDoneEvent();
  } catch (err) {
    yield createAdapterErrorEvent(err);
  }
}
export {
  createAdapterDataEvent,
  createAdapterDoneEvent,
  createAdapterErrorEvent,
  createAdapterMessageEvent,
  createAdapterProgressEvent,
  createAdapterTokenEvent,
  createAudioEvent,
  createImageEvent,
  createJsonDataEvent,
  toL0Events,
  toL0EventsWithMessages,
  toMultimodalL0Events
};
//# sourceMappingURL=helpers.js.map