@yukino.js/yukino 0.0.1

package/dist/lib/chunk-AZRC67RW.js

@@ -0,0 +1,512 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/telemetry/providers.ts
+var providers_exports = {};
+__export(providers_exports, {
+  createTelemetryRuntime: () => createTelemetryRuntime,
+  parseExporterTypes: () => parseExporterTypes
+});
+import { LangfuseSpanProcessor } from "@langfuse/otel";
+import {
+  setLangfuseTracerProvider,
+  startObservation
+} from "@langfuse/tracing";
+import {
+  SpanStatusCode
+} from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  ConsoleLogRecordExporter,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  ConsoleMetricExporter,
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import {
+  BasicTracerProvider,
+  BatchSpanProcessor,
+  ConsoleSpanExporter
+} from "@opentelemetry/sdk-trace-base";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION
+} from "@opentelemetry/semantic-conventions";
+
+// src/version.ts
+var version_exports = {};
+__export(version_exports, {
+  version: () => version
+});
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+var PackageJsonSchema = z.object({
+  version: z.string()
+});
+function resolveVersion() {
+  if (true) {
+    return "0.0.1";
+  }
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  for (const levels of ["..", "../.."]) {
+    const candidate = path.resolve(here, levels, "package.json");
+    try {
+      const raw = JSON.parse(readFileSync(candidate, "utf-8"));
+      const parsed = PackageJsonSchema.safeParse(raw);
+      if (parsed.success) {
+        return parsed.data.version;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Could not resolve package version");
+}
+var version = resolveVersion();
+
+// src/telemetry/providers.ts
+var DEFAULT_EXPORT_INTERVAL_MS = 6e4;
+var SHUTDOWN_TIMEOUT_MS = 2e3;
+function parseExporterTypes(value) {
+  return (value ?? "").split(",").map((item) => item.trim()).filter((item) => item.length > 0 && item !== "none");
+}
+function parsePositiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function getProtocol(signal) {
+  const signalKey = `OTEL_EXPORTER_OTLP_${signal.toUpperCase()}_PROTOCOL`;
+  const configured = process.env[signalKey]?.trim() || process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim();
+  const protocol = configured || "http/protobuf";
+  if (protocol === "grpc" || protocol === "http/json" || protocol === "http/protobuf") {
+    return protocol;
+  }
+  throw new Error(`Unsupported OpenTelemetry protocol: ${protocol}`);
+}
+function parseResourceAttributes(value) {
+  const attributes = {};
+  for (const entry of value?.split(",") ?? []) {
+    const separator = entry.indexOf("=");
+    if (separator <= 0) {
+      continue;
+    }
+    const key = entry.slice(0, separator).trim();
+    const rawValue = entry.slice(separator + 1).trim();
+    if (key && rawValue) {
+      try {
+        attributes[decodeURIComponent(key)] = decodeURIComponent(rawValue);
+      } catch {
+        attributes[key] = rawValue;
+      }
+    }
+  }
+  return attributes;
+}
+function createResource() {
+  return resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: "yukino",
+    [ATTR_SERVICE_VERSION]: version,
+    ...parseResourceAttributes(process.env.OTEL_RESOURCE_ATTRIBUTES),
+    ...process.env.OTEL_SERVICE_NAME ? { [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME } : {}
+  });
+}
+async function createTraceExporter(protocol) {
+  switch (protocol) {
+    case "grpc": {
+      const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-grpc");
+      return new OTLPTraceExporter();
+    }
+    case "http/json": {
+      const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-http");
+      return new OTLPTraceExporter();
+    }
+    case "http/protobuf": {
+      const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-proto");
+      return new OTLPTraceExporter();
+    }
+  }
+}
+async function createLogExporter(protocol) {
+  switch (protocol) {
+    case "grpc": {
+      const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-grpc");
+      return new OTLPLogExporter();
+    }
+    case "http/json": {
+      const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-http");
+      return new OTLPLogExporter();
+    }
+    case "http/protobuf": {
+      const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-proto");
+      return new OTLPLogExporter();
+    }
+  }
+}
+async function createMetricExporter(protocol) {
+  switch (protocol) {
+    case "grpc": {
+      const { OTLPMetricExporter } = await import("@opentelemetry/exporter-metrics-otlp-grpc");
+      return new OTLPMetricExporter();
+    }
+    case "http/json": {
+      const { OTLPMetricExporter } = await import("@opentelemetry/exporter-metrics-otlp-http");
+      return new OTLPMetricExporter();
+    }
+    case "http/protobuf": {
+      const { OTLPMetricExporter } = await import("@opentelemetry/exporter-metrics-otlp-proto");
+      return new OTLPMetricExporter();
+    }
+  }
+}
+async function createTracerProvider(resource) {
+  const processors = [];
+  const exporterTypes = parseExporterTypes(process.env.OTEL_TRACES_EXPORTER);
+  for (const exporterType of exporterTypes) {
+    if (exporterType === "console") {
+      processors.push(new BatchSpanProcessor(new ConsoleSpanExporter()));
+    } else if (exporterType === "otlp") {
+      processors.push(
+        new BatchSpanProcessor(
+          await createTraceExporter(getProtocol("traces"))
+        )
+      );
+    } else {
+      throw new Error(`Unsupported trace exporter: ${exporterType}`);
+    }
+  }
+  if (process.env.LANGFUSE_PUBLIC_KEY && process.env.LANGFUSE_SECRET_KEY) {
+    processors.push(
+      new LangfuseSpanProcessor({
+        mediaUploadEnabled: false,
+        release: process.env.LANGFUSE_RELEASE ?? version
+      })
+    );
+  }
+  if (processors.length === 0) {
+    return null;
+  }
+  const provider = new BasicTracerProvider({
+    resource,
+    spanProcessors: processors
+  });
+  setLangfuseTracerProvider(provider);
+  return provider;
+}
+async function createLoggerProvider(resource) {
+  const processors = [];
+  for (const exporterType of parseExporterTypes(
+    process.env.OTEL_LOGS_EXPORTER
+  )) {
+    let exporter;
+    if (exporterType === "console") {
+      exporter = new ConsoleLogRecordExporter();
+    } else if (exporterType === "otlp") {
+      exporter = await createLogExporter(getProtocol("logs"));
+    } else {
+      throw new Error(`Unsupported log exporter: ${exporterType}`);
+    }
+    processors.push(new BatchLogRecordProcessor({ exporter }));
+  }
+  return processors.length > 0 ? new LoggerProvider({ resource, processors }) : null;
+}
+async function createMetricReaders() {
+  const readers = [];
+  const exportIntervalMillis = parsePositiveInteger(
+    process.env.OTEL_METRIC_EXPORT_INTERVAL,
+    DEFAULT_EXPORT_INTERVAL_MS
+  );
+  for (const exporterType of parseExporterTypes(
+    process.env.OTEL_METRICS_EXPORTER
+  )) {
+    if (exporterType === "prometheus") {
+      const { PrometheusExporter } = await import("@opentelemetry/exporter-prometheus");
+      readers.push(new PrometheusExporter());
+      continue;
+    }
+    let exporter;
+    if (exporterType === "console") {
+      exporter = new ConsoleMetricExporter();
+    } else if (exporterType === "otlp") {
+      exporter = await createMetricExporter(getProtocol("metrics"));
+    } else {
+      throw new Error(`Unsupported metric exporter: ${exporterType}`);
+    }
+    readers.push(
+      new PeriodicExportingMetricReader({ exporter, exportIntervalMillis })
+    );
+  }
+  return readers;
+}
+async function initializeSentry() {
+  if (!process.env.SENTRY_DSN) {
+    return null;
+  }
+  const sentry = await import("@sentry/node");
+  sentry.init({
+    debug: process.env.SENTRY_DEBUG?.toLowerCase() === "true",
+    dsn: process.env.SENTRY_DSN,
+    environment: process.env.SENTRY_ENVIRONMENT,
+    includeLocalVariables: false,
+    integrations: (defaultIntegrations) => defaultIntegrations.filter(
+      (integration) => integration.name !== "OnUncaughtException" && integration.name !== "OnUnhandledRejection"
+    ),
+    registerEsmLoaderHooks: false,
+    release: process.env.SENTRY_RELEASE ?? version,
+    sendDefaultPii: false,
+    skipOpenTelemetrySetup: true,
+    tracesSampleRate: 0
+  });
+  return sentry;
+}
+async function safely(operation) {
+  try {
+    return await operation();
+  } catch {
+    return null;
+  }
+}
+function withTimeout(operation) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, SHUTDOWN_TIMEOUT_MS);
+    timer.unref();
+    void operation.then(
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      () => {
+        clearTimeout(timer);
+        resolve();
+      }
+    );
+  });
+}
+function severityNumber(severity) {
+  switch (severity) {
+    case "error":
+      return SeverityNumber.ERROR;
+    case "info":
+      return SeverityNumber.INFO;
+    case "warn":
+      return SeverityNumber.WARN;
+  }
+}
+function createRootObservation(kind, name, attributes) {
+  switch (kind) {
+    case "agent":
+      return startObservation(
+        name,
+        { metadata: attributes },
+        { asType: "agent" }
+      );
+    case "generation": {
+      const model = typeof attributes.model === "string" ? attributes.model : void 0;
+      return startObservation(
+        name,
+        { metadata: attributes, model },
+        { asType: "generation" }
+      );
+    }
+    case "tool":
+      return startObservation(
+        name,
+        { metadata: attributes },
+        { asType: "tool" }
+      );
+  }
+}
+function createChildObservation(parent, kind, name, attributes) {
+  switch (kind) {
+    case "agent":
+      return parent.startObservation(
+        name,
+        { metadata: attributes },
+        { asType: "agent" }
+      );
+    case "generation": {
+      const model = typeof attributes.model === "string" ? attributes.model : void 0;
+      return parent.startObservation(
+        name,
+        { metadata: attributes, model },
+        { asType: "generation" }
+      );
+    }
+    case "tool":
+      return parent.startObservation(
+        name,
+        { metadata: attributes },
+        { asType: "tool" }
+      );
+  }
+}
+var ProviderObservation = class _ProviderObservation {
+  constructor(observation) {
+    this.observation = observation;
+  }
+  observation;
+  end() {
+    this.observation.end();
+  }
+  recordException(error) {
+    const errorType = error instanceof Error ? error.name : typeof error;
+    this.observation.otelSpan.setAttribute("error.type", errorType);
+    this.observation.otelSpan.setStatus({ code: SpanStatusCode.ERROR });
+    this.observation.updateOtelSpanAttributes({
+      level: "ERROR",
+      statusMessage: errorType
+    });
+  }
+  startChild(kind, name, attributes = {}) {
+    return new _ProviderObservation(
+      createChildObservation(this.observation, kind, name, attributes)
+    );
+  }
+  update(update) {
+    this.observation.updateOtelSpanAttributes(update);
+  }
+};
+var ProviderRuntime = class {
+  constructor(tracerProvider, loggerProvider, meterProvider, meter, logger, sentry) {
+    this.tracerProvider = tracerProvider;
+    this.loggerProvider = loggerProvider;
+    this.meterProvider = meterProvider;
+    this.meter = meter;
+    this.logger = logger;
+    this.sentry = sentry;
+  }
+  tracerProvider;
+  loggerProvider;
+  meterProvider;
+  meter;
+  logger;
+  sentry;
+  counters = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  mode = "unknown";
+  captureError(error, context) {
+    this.sentry?.captureException(error, {
+      tags: { context, mode: this.mode }
+    });
+    this.emitLog("yukino.error", "error", {
+      context,
+      "error.type": error instanceof Error ? error.name : typeof error
+    });
+  }
+  emitLog(name, severity, attributes = {}) {
+    this.logger?.emit({
+      attributes: { ...attributes, "yukino.mode": this.mode },
+      body: name,
+      severityNumber: severityNumber(severity),
+      severityText: severity.toUpperCase()
+    });
+  }
+  async flush() {
+    const operations = [];
+    if (this.tracerProvider) {
+      operations.push(this.tracerProvider.forceFlush());
+    }
+    if (this.loggerProvider) {
+      operations.push(this.loggerProvider.forceFlush());
+    }
+    if (this.meterProvider) {
+      operations.push(this.meterProvider.forceFlush());
+    }
+    if (this.sentry) {
+      operations.push(this.sentry.flush(SHUTDOWN_TIMEOUT_MS));
+    }
+    await withTimeout(Promise.allSettled(operations).then(() => void 0));
+  }
+  recordMetric(name, kind, value, attributes = {}) {
+    if (!this.meter) {
+      return;
+    }
+    const mergedAttributes = { ...attributes, "yukino.mode": this.mode };
+    if (kind === "counter") {
+      let counter = this.counters.get(name);
+      if (!counter) {
+        counter = this.meter.createCounter(name);
+        this.counters.set(name, counter);
+      }
+      counter.add(value, mergedAttributes);
+      return;
+    }
+    let histogram = this.histograms.get(name);
+    if (!histogram) {
+      histogram = this.meter.createHistogram(name, { unit: "ms" });
+      this.histograms.set(name, histogram);
+    }
+    histogram.record(value, mergedAttributes);
+  }
+  setMode(mode) {
+    this.mode = mode;
+    this.sentry?.setTag("yukino.mode", mode);
+  }
+  async shutdown() {
+    const operations = [];
+    if (this.tracerProvider) {
+      operations.push(this.tracerProvider.shutdown());
+    }
+    if (this.loggerProvider) {
+      operations.push(this.loggerProvider.shutdown());
+    }
+    if (this.meterProvider) {
+      operations.push(this.meterProvider.shutdown());
+    }
+    if (this.sentry) {
+      operations.push(this.sentry.close(SHUTDOWN_TIMEOUT_MS));
+    }
+    await withTimeout(Promise.allSettled(operations).then(() => void 0));
+    setLangfuseTracerProvider(null);
+  }
+  startObservation(kind, name, attributes = {}) {
+    if (!this.tracerProvider) {
+      return {
+        end: () => void 0,
+        recordException: () => void 0,
+        startChild: (childKind, childName, childAttributes) => this.startObservation(childKind, childName, childAttributes),
+        update: () => void 0
+      };
+    }
+    return new ProviderObservation(
+      createRootObservation(kind, name, {
+        ...attributes,
+        "yukino.mode": this.mode
+      })
+    );
+  }
+};
+async function createTelemetryRuntime() {
+  const resource = createResource();
+  const otelEnabled = process.env.OTEL_SDK_DISABLED?.toLowerCase() !== "true";
+  const [tracerProvider, loggerProvider, metricReaders, sentry] = await Promise.all([
+    otelEnabled ? safely(() => createTracerProvider(resource)) : Promise.resolve(null),
+    otelEnabled ? safely(() => createLoggerProvider(resource)) : Promise.resolve(null),
+    otelEnabled ? safely(createMetricReaders) : Promise.resolve(null),
+    safely(initializeSentry)
+  ]);
+  const meterProvider = metricReaders && metricReaders.length > 0 ? new MeterProvider({ readers: metricReaders, resource }) : null;
+  const meter = meterProvider?.getMeter("@yukino.js/yukino", version) ?? null;
+  const logger = loggerProvider?.getLogger("@yukino.js/yukino", version) ?? null;
+  return new ProviderRuntime(
+    tracerProvider,
+    loggerProvider,
+    meterProvider,
+    meter,
+    logger,
+    sentry
+  );
+}
+
+export {
+  version,
+  version_exports,
+  parseExporterTypes,
+  createTelemetryRuntime,
+  providers_exports
+};

package/dist/lib/chunk-F2YJG72O.js

@@ -0,0 +1,150 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/tools/types.ts
+var types_exports = {};
+__export(types_exports, {
+  SKIP_DIRS: () => SKIP_DIRS,
+  isToolResultContentBlock: () => isToolResultContentBlock,
+  normalizeToolResultContentBlock: () => normalizeToolResultContentBlock
+});
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+function isImageMediaType(value) {
+  return IMAGE_MEDIA_TYPES.has(value);
+}
+function normalizeTextBlock(value) {
+  return isRecord(value) && value.type === "text" && typeof value.text === "string" ? { type: "text", text: value.text } : null;
+}
+function normalizeImageBlock(value) {
+  if (!isRecord(value) || value.type !== "image" || !isRecord(value.source)) {
+    return null;
+  }
+  if (value.source.type === "url" && typeof value.source.url === "string") {
+    return { type: "image", source: { type: "url", url: value.source.url } };
+  }
+  if (value.source.type === "base64" && typeof value.source.media_type === "string" && isImageMediaType(value.source.media_type) && typeof value.source.data === "string") {
+    return {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: value.source.media_type,
+        data: value.source.data
+      }
+    };
+  }
+  return null;
+}
+function normalizeDocumentBlock(value) {
+  if (value.type !== "document" || !isRecord(value.source)) {
+    return null;
+  }
+  let source = null;
+  if (value.source.type === "url" && typeof value.source.url === "string") {
+    source = { type: "url", url: value.source.url };
+  } else if (value.source.type === "base64" && value.source.media_type === "application/pdf" && typeof value.source.data === "string") {
+    source = {
+      type: "base64",
+      media_type: "application/pdf",
+      data: value.source.data
+    };
+  } else if (value.source.type === "text" && value.source.media_type === "text/plain" && typeof value.source.data === "string") {
+    source = {
+      type: "text",
+      media_type: "text/plain",
+      data: value.source.data
+    };
+  } else if (value.source.type === "content") {
+    if (typeof value.source.content === "string") {
+      source = { type: "content", content: value.source.content };
+    } else if (Array.isArray(value.source.content)) {
+      const content = [];
+      for (const raw of value.source.content) {
+        const block = normalizeTextBlock(raw) ?? normalizeImageBlock(raw);
+        if (!block) {
+          return null;
+        }
+        content.push(block);
+      }
+      source = { type: "content", content };
+    }
+  }
+  if (!source) {
+    return null;
+  }
+  return {
+    type: "document",
+    source,
+    ...typeof value.title === "string" || value.title === null ? { title: value.title } : {},
+    ...typeof value.context === "string" || value.context === null ? { context: value.context } : {}
+  };
+}
+function normalizeToolResultContentBlock(value) {
+  const text = normalizeTextBlock(value);
+  if (text) {
+    return text;
+  }
+  const image = normalizeImageBlock(value);
+  if (image) {
+    return image;
+  }
+  if (!isRecord(value)) {
+    return null;
+  }
+  if (value.type === "tool_reference" && typeof value.tool_name === "string") {
+    return { type: "tool_reference", tool_name: value.tool_name };
+  }
+  if (value.type === "search_result" && typeof value.source === "string" && typeof value.title === "string" && Array.isArray(value.content)) {
+    const content = [];
+    for (const raw of value.content) {
+      const block = normalizeTextBlock(raw);
+      if (!block) {
+        return null;
+      }
+      content.push(block);
+    }
+    return {
+      type: "search_result",
+      source: value.source,
+      title: value.title,
+      content
+    };
+  }
+  return normalizeDocumentBlock(value);
+}
+function isToolResultContentBlock(value) {
+  return normalizeToolResultContentBlock(value) !== null;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".agents",
+  ".git",
+  // Git
+  ".yukino",
+  // Yukino
+  ".next",
+  // Next.js
+  ".venv",
+  // Python venv
+  ".mypy_cache",
+  // Python mypy
+  "__pycache__",
+  // Python
+  "dist",
+  // Webpack, Vite
+  "node_modules"
+  // Node.js
+]);
+
+export {
+  normalizeToolResultContentBlock,
+  SKIP_DIRS,
+  types_exports
+};