@shogo-ai/core 1.4.1

package/dist/stream-buffer.d.cts

@@ -0,0 +1,103 @@
+/**
+ * In-memory stream buffer + turn ledger for SSE reconnect support.
+ *
+ * Stores raw SSE bytes keyed by an arbitrary string (typically a
+ * `chatSessionId`) so that a reconnecting client can replay buffered
+ * events and continue receiving live events. Every buffered chunk is
+ * tagged with a monotonically increasing `seq` so a client can resume
+ * from the last frame it has already seen via `?fromSeq=N` style
+ * resume.
+ *
+ * Each server process (agent-runtime pod, API server, custom user
+ * service) creates its own `StreamBufferStore` singleton — no shared
+ * state between processes. For cross-process durability a higher
+ * layer (e.g. a Postgres-backed turn ledger) would wrap this store;
+ * this in-memory variant is the hot cache.
+ *
+ * Lifted into the SDK from `@shogo/shared-runtime` (was AGPL) under MIT.
+ */
+type TurnStatus = 'active' | 'completed' | 'aborted' | 'failed';
+interface TurnTerminal {
+    reason?: string;
+    error?: string;
+}
+interface StreamBufferWriter {
+    /** Append a raw byte chunk and return the seq assigned to it. */
+    append(chunk: Uint8Array): number;
+    /** Mark the turn as cleanly completed. Optional terminal reason. */
+    complete(reason?: string): void;
+    /**
+     * Mark the turn as failed (still keeps the buffer around for the grace
+     * window so a reconnecting client can see the terminal state).
+     */
+    fail(error: string): void;
+    /** The turnId this writer is bound to. */
+    readonly turnId: string;
+    /** Last seq written so far (0 if nothing has been appended). */
+    readonly lastSeq: number;
+}
+interface ReplayOptions {
+    /**
+     * Skip frames with seq <= fromSeq. Use 0 (or omit) to replay from the start.
+     */
+    fromSeq?: number;
+}
+interface TurnSnapshot {
+    turnId: string;
+    status: TurnStatus;
+    lastSeq: number;
+    terminal: TurnTerminal | null;
+    createdAt: number;
+    completedAt: number | null;
+    lastEventAt: number;
+}
+declare class StreamBufferStore {
+    private buffers;
+    private cleanupTimer;
+    constructor();
+    /**
+     * Create (or replace) a buffer for the given key. Any existing active
+     * buffer is completed and discarded. Returns a writer bound to this
+     * specific buffer instance, including the new `turnId`.
+     */
+    create(key: string, opts?: {
+        turnId?: string;
+    }): StreamBufferWriter;
+    /**
+     * Append a chunk by key (loose, untyped writer). Returns the seq assigned,
+     * or -1 if the buffer is unknown/inactive.
+     */
+    append(key: string, chunk: Uint8Array): number;
+    /** Mark a buffer as completed by key. Optional terminal reason. */
+    complete(key: string, reason?: string): void;
+    /**
+     * Abort a stream: complete subscribers and remove the buffer entirely.
+     * Future resume/replay requests for this key will return null (→ 204).
+     */
+    abort(key: string): void;
+    has(key: string): boolean;
+    /** Read-only metadata about a buffered turn. Useful for resume responses. */
+    snapshot(key: string): TurnSnapshot | null;
+    /**
+     * Create a ReadableStream that first replays all buffered chunks past
+     * `opts.fromSeq` (default: 0 → replay everything), then subscribes for
+     * any further live chunks until the stream completes.
+     *
+     * Returns null if no buffer exists for the key.
+     */
+    createReplayStream(key: string, opts?: ReplayOptions): ReadableStream<Uint8Array> | null;
+    cleanup(): void;
+    dispose(): void;
+    private completeBuffer;
+    private failBuffer;
+}
+/**
+ * TransformStream that copies every chunk into a StreamBufferStore while
+ * passing it through unchanged. On flush/cancel, completes the buffer.
+ *
+ * Note: this convenience helper does NOT propagate seq numbers back to the
+ * caller. Use `store.create(key)` directly if you need the writer's seq.
+ */
+declare function createBufferingTransform(store: StreamBufferStore, key: string): TransformStream<Uint8Array, Uint8Array>;
+
+export { type ReplayOptions, StreamBufferStore, type StreamBufferWriter, type TurnSnapshot, type TurnStatus, type TurnTerminal, createBufferingTransform };

package/dist/stream-buffer.d.ts

@@ -0,0 +1,103 @@
+/**
+ * In-memory stream buffer + turn ledger for SSE reconnect support.
+ *
+ * Stores raw SSE bytes keyed by an arbitrary string (typically a
+ * `chatSessionId`) so that a reconnecting client can replay buffered
+ * events and continue receiving live events. Every buffered chunk is
+ * tagged with a monotonically increasing `seq` so a client can resume
+ * from the last frame it has already seen via `?fromSeq=N` style
+ * resume.
+ *
+ * Each server process (agent-runtime pod, API server, custom user
+ * service) creates its own `StreamBufferStore` singleton — no shared
+ * state between processes. For cross-process durability a higher
+ * layer (e.g. a Postgres-backed turn ledger) would wrap this store;
+ * this in-memory variant is the hot cache.
+ *
+ * Lifted into the SDK from `@shogo/shared-runtime` (was AGPL) under MIT.
+ */
+type TurnStatus = 'active' | 'completed' | 'aborted' | 'failed';
+interface TurnTerminal {
+    reason?: string;
+    error?: string;
+}
+interface StreamBufferWriter {
+    /** Append a raw byte chunk and return the seq assigned to it. */
+    append(chunk: Uint8Array): number;
+    /** Mark the turn as cleanly completed. Optional terminal reason. */
+    complete(reason?: string): void;
+    /**
+     * Mark the turn as failed (still keeps the buffer around for the grace
+     * window so a reconnecting client can see the terminal state).
+     */
+    fail(error: string): void;
+    /** The turnId this writer is bound to. */
+    readonly turnId: string;
+    /** Last seq written so far (0 if nothing has been appended). */
+    readonly lastSeq: number;
+}
+interface ReplayOptions {
+    /**
+     * Skip frames with seq <= fromSeq. Use 0 (or omit) to replay from the start.
+     */
+    fromSeq?: number;
+}
+interface TurnSnapshot {
+    turnId: string;
+    status: TurnStatus;
+    lastSeq: number;
+    terminal: TurnTerminal | null;
+    createdAt: number;
+    completedAt: number | null;
+    lastEventAt: number;
+}
+declare class StreamBufferStore {
+    private buffers;
+    private cleanupTimer;
+    constructor();
+    /**
+     * Create (or replace) a buffer for the given key. Any existing active
+     * buffer is completed and discarded. Returns a writer bound to this
+     * specific buffer instance, including the new `turnId`.
+     */
+    create(key: string, opts?: {
+        turnId?: string;
+    }): StreamBufferWriter;
+    /**
+     * Append a chunk by key (loose, untyped writer). Returns the seq assigned,
+     * or -1 if the buffer is unknown/inactive.
+     */
+    append(key: string, chunk: Uint8Array): number;
+    /** Mark a buffer as completed by key. Optional terminal reason. */
+    complete(key: string, reason?: string): void;
+    /**
+     * Abort a stream: complete subscribers and remove the buffer entirely.
+     * Future resume/replay requests for this key will return null (→ 204).
+     */
+    abort(key: string): void;
+    has(key: string): boolean;
+    /** Read-only metadata about a buffered turn. Useful for resume responses. */
+    snapshot(key: string): TurnSnapshot | null;
+    /**
+     * Create a ReadableStream that first replays all buffered chunks past
+     * `opts.fromSeq` (default: 0 → replay everything), then subscribes for
+     * any further live chunks until the stream completes.
+     *
+     * Returns null if no buffer exists for the key.
+     */
+    createReplayStream(key: string, opts?: ReplayOptions): ReadableStream<Uint8Array> | null;
+    cleanup(): void;
+    dispose(): void;
+    private completeBuffer;
+    private failBuffer;
+}
+/**
+ * TransformStream that copies every chunk into a StreamBufferStore while
+ * passing it through unchanged. On flush/cancel, completes the buffer.
+ *
+ * Note: this convenience helper does NOT propagate seq numbers back to the
+ * caller. Use `store.create(key)` directly if you need the writer's seq.
+ */
+declare function createBufferingTransform(store: StreamBufferStore, key: string): TransformStream<Uint8Array, Uint8Array>;
+
+export { type ReplayOptions, StreamBufferStore, type StreamBufferWriter, type TurnSnapshot, type TurnStatus, type TurnTerminal, createBufferingTransform };

package/dist/stream-buffer.js

@@ -0,0 +1,9 @@
+import {
+  StreamBufferStore,
+  createBufferingTransform
+} from "./chunk-ELMG6OXT.js";
+export {
+  StreamBufferStore,
+  createBufferingTransform
+};
+//# sourceMappingURL=stream-buffer.js.map

package/dist/tech-stack-registry.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tech-stack-registry.ts
+var tech_stack_registry_exports = {};
+__export(tech_stack_registry_exports, {
+  TECH_STACK_REGISTRY: () => TECH_STACK_REGISTRY,
+  getStackEntry: () => getStackEntry,
+  isMobileTechStack: () => isMobileTechStack,
+  stackSeedsItself: () => stackSeedsItself,
+  usesMetroBundler: () => usesMetroBundler
+});
+module.exports = __toCommonJS(tech_stack_registry_exports);
+var TECH_STACK_REGISTRY = {
+  // Web (Vite-based) — share a bundled Vite template, so apps/api seeds them.
+  "react-app": { id: "react-app", target: "web" },
+  "threejs-game": { id: "threejs-game", target: "web" },
+  "phaser-game": { id: "phaser-game", target: "web" },
+  // Mobile (Metro/Expo) — agent-runtime owns the seed.
+  "expo-app": { id: "expo-app", target: "mobile", metro: true, seedsOwnTemplate: true },
+  "expo-three": { id: "expo-three", target: "mobile", metro: true, seedsOwnTemplate: true },
+  "react-native": { id: "react-native", target: "mobile", metro: true, seedsOwnTemplate: true },
+  // Data / scripting
+  "python-data": { id: "python-data", target: "data", seedsOwnTemplate: true },
+  // Native (full game engines)
+  "unity-game": { id: "unity-game", target: "native", seedsOwnTemplate: true },
+  // Bare / no-stack
+  none: { id: "none", target: "none", seedsOwnTemplate: true }
+};
+function getStackEntry(techStackId) {
+  if (!techStackId) return null;
+  return TECH_STACK_REGISTRY[techStackId] ?? null;
+}
+function isMobileTechStack(techStackId) {
+  return getStackEntry(techStackId)?.target === "mobile";
+}
+function usesMetroBundler(techStackId) {
+  return getStackEntry(techStackId)?.metro === true;
+}
+function stackSeedsItself(techStackId) {
+  return getStackEntry(techStackId)?.seedsOwnTemplate === true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TECH_STACK_REGISTRY,
+  getStackEntry,
+  isMobileTechStack,
+  stackSeedsItself,
+  usesMetroBundler
+});
+//# sourceMappingURL=tech-stack-registry.cjs.map

package/dist/tech-stack-registry.d.cts

@@ -0,0 +1,88 @@
+/**
+ * Tech-Stack Registry
+ * --------------------------------------------------------------------------
+ * Single source of truth for "what kind of project is this?" answered at
+ * runtime by the API and the agent-runtime.
+ *
+ * Why this exists: we used to do `techStackId.startsWith('expo')` to decide
+ * whether a project was mobile. That heuristic broke the moment we added a
+ * stack like `expo-cli-tools` (would falsely match) and would silently miss
+ * a future stack like `react-native-bare` or `flutter` (would falsely not
+ * match).
+ *
+ * The replacement is an explicit, typed map keyed by stack id, with a
+ * `target` field that captures the platform the stack actually runs on.
+ * `apps/api` reads it to size pods correctly; the agent-runtime mirrors
+ * the same metadata in each stack's `stack.json` so the registry and the
+ * stack files stay in sync.
+ *
+ * Adding a new stack:
+ *   1. Add an entry below with `target: 'mobile' | 'web' | 'data' | 'native'`.
+ *   2. Add the matching `target` field to the stack's `stack.json`.
+ *   3. The runtime/API automatically pick up the new stack's class —
+ *      no `if (id.startsWith(…))` to update.
+ *
+ * Lifted into the SDK from `@shogo/shared-runtime` (was AGPL) under MIT.
+ * The original `@shogo/shared-runtime/tech-stack-registry` re-exports this
+ * module unchanged for backwards compatibility.
+ */
+/**
+ * Platform a stack ultimately runs on. Drives:
+ *   - instance-size floors (mobile needs `small`+ for Metro/RN node_modules)
+ *   - disk overlay (mobile needs ~6 GiB for node_modules + Metro caches)
+ *   - runtime image variant (mobile uses the bun-cache pre-warmed image)
+ *   - dev-server selection (mobile → Metro, web → Vite)
+ */
+type StackTarget = 'mobile' | 'web' | 'data' | 'native' | 'none';
+interface StackRegistryEntry {
+    id: string;
+    target: StackTarget;
+    /**
+     * Whether this stack runs Metro/Expo bundler. Distinct from `target` —
+     * a future `flutter` stack would be `target: 'mobile'` but `metro: false`.
+     */
+    metro?: boolean;
+    /**
+     * Whether the agent-runtime's `seedTechStack(id)` is responsible for laying
+     * down this stack's initial files. When `true`, apps/api skips copying the
+     * bundled Vite template into the workspace and instead just creates an
+     * empty directory; the agent-runtime fills it on first start. When `false`
+     * (or omitted), the legacy bundled-template path is used.
+     *
+     * The default `react-app`/`threejs-game`/`phaser-game` stacks use the
+     * bundled Vite template; everything else seeds itself.
+     */
+    seedsOwnTemplate?: boolean;
+}
+/**
+ * Canonical registry of every first-party tech stack we ship. Kept here in
+ * code (not loaded from disk) because `apps/api` doesn't have the
+ * `packages/agent-runtime/tech-stacks/` directory bundled into its
+ * container image, so it can't `readFileSync` stack.json at runtime.
+ *
+ * The agent-runtime side validates these entries against the on-disk
+ * stack.json files at boot — see `assertRegistryMatchesDisk()` in
+ * `packages/agent-runtime/src/workspace-defaults.ts`.
+ */
+declare const TECH_STACK_REGISTRY: Record<string, StackRegistryEntry>;
+/** Lookup an entry, returning `null` for unknown ids. */
+declare function getStackEntry(techStackId: string | null | undefined): StackRegistryEntry | null;
+/**
+ * True for any stack whose `target` is `mobile`. Replaces the old
+ * `techStackId.startsWith('expo') || techStackId === 'react-native'`
+ * heuristic.
+ */
+declare function isMobileTechStack(techStackId: string | null | undefined): boolean;
+/** True if the stack is bundled with Metro (Expo / RN). */
+declare function usesMetroBundler(techStackId: string | null | undefined): boolean;
+/**
+ * True if the agent-runtime's `seedTechStack(id)` is responsible for laying
+ * down this stack's initial files. apps/api uses this to decide whether to
+ * skip copying the bundled Vite template into the workspace.
+ *
+ * Unknown stacks default to `false` (legacy bundled-template path) so that
+ * adding a new stack doesn't accidentally break the default behaviour.
+ */
+declare function stackSeedsItself(techStackId: string | null | undefined): boolean;
+
+export { type StackRegistryEntry, type StackTarget, TECH_STACK_REGISTRY, getStackEntry, isMobileTechStack, stackSeedsItself, usesMetroBundler };

package/dist/tech-stack-registry.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Tech-Stack Registry
+ * --------------------------------------------------------------------------
+ * Single source of truth for "what kind of project is this?" answered at
+ * runtime by the API and the agent-runtime.
+ *
+ * Why this exists: we used to do `techStackId.startsWith('expo')` to decide
+ * whether a project was mobile. That heuristic broke the moment we added a
+ * stack like `expo-cli-tools` (would falsely match) and would silently miss
+ * a future stack like `react-native-bare` or `flutter` (would falsely not
+ * match).
+ *
+ * The replacement is an explicit, typed map keyed by stack id, with a
+ * `target` field that captures the platform the stack actually runs on.
+ * `apps/api` reads it to size pods correctly; the agent-runtime mirrors
+ * the same metadata in each stack's `stack.json` so the registry and the
+ * stack files stay in sync.
+ *
+ * Adding a new stack:
+ *   1. Add an entry below with `target: 'mobile' | 'web' | 'data' | 'native'`.
+ *   2. Add the matching `target` field to the stack's `stack.json`.
+ *   3. The runtime/API automatically pick up the new stack's class —
+ *      no `if (id.startsWith(…))` to update.
+ *
+ * Lifted into the SDK from `@shogo/shared-runtime` (was AGPL) under MIT.
+ * The original `@shogo/shared-runtime/tech-stack-registry` re-exports this
+ * module unchanged for backwards compatibility.
+ */
+/**
+ * Platform a stack ultimately runs on. Drives:
+ *   - instance-size floors (mobile needs `small`+ for Metro/RN node_modules)
+ *   - disk overlay (mobile needs ~6 GiB for node_modules + Metro caches)
+ *   - runtime image variant (mobile uses the bun-cache pre-warmed image)
+ *   - dev-server selection (mobile → Metro, web → Vite)
+ */
+type StackTarget = 'mobile' | 'web' | 'data' | 'native' | 'none';
+interface StackRegistryEntry {
+    id: string;
+    target: StackTarget;
+    /**
+     * Whether this stack runs Metro/Expo bundler. Distinct from `target` —
+     * a future `flutter` stack would be `target: 'mobile'` but `metro: false`.
+     */
+    metro?: boolean;
+    /**
+     * Whether the agent-runtime's `seedTechStack(id)` is responsible for laying
+     * down this stack's initial files. When `true`, apps/api skips copying the
+     * bundled Vite template into the workspace and instead just creates an
+     * empty directory; the agent-runtime fills it on first start. When `false`
+     * (or omitted), the legacy bundled-template path is used.
+     *
+     * The default `react-app`/`threejs-game`/`phaser-game` stacks use the
+     * bundled Vite template; everything else seeds itself.
+     */
+    seedsOwnTemplate?: boolean;
+}
+/**
+ * Canonical registry of every first-party tech stack we ship. Kept here in
+ * code (not loaded from disk) because `apps/api` doesn't have the
+ * `packages/agent-runtime/tech-stacks/` directory bundled into its
+ * container image, so it can't `readFileSync` stack.json at runtime.
+ *
+ * The agent-runtime side validates these entries against the on-disk
+ * stack.json files at boot — see `assertRegistryMatchesDisk()` in
+ * `packages/agent-runtime/src/workspace-defaults.ts`.
+ */
+declare const TECH_STACK_REGISTRY: Record<string, StackRegistryEntry>;
+/** Lookup an entry, returning `null` for unknown ids. */
+declare function getStackEntry(techStackId: string | null | undefined): StackRegistryEntry | null;
+/**
+ * True for any stack whose `target` is `mobile`. Replaces the old
+ * `techStackId.startsWith('expo') || techStackId === 'react-native'`
+ * heuristic.
+ */
+declare function isMobileTechStack(techStackId: string | null | undefined): boolean;
+/** True if the stack is bundled with Metro (Expo / RN). */
+declare function usesMetroBundler(techStackId: string | null | undefined): boolean;
+/**
+ * True if the agent-runtime's `seedTechStack(id)` is responsible for laying
+ * down this stack's initial files. apps/api uses this to decide whether to
+ * skip copying the bundled Vite template into the workspace.
+ *
+ * Unknown stacks default to `false` (legacy bundled-template path) so that
+ * adding a new stack doesn't accidentally break the default behaviour.
+ */
+declare function stackSeedsItself(techStackId: string | null | undefined): boolean;
+
+export { type StackRegistryEntry, type StackTarget, TECH_STACK_REGISTRY, getStackEntry, isMobileTechStack, stackSeedsItself, usesMetroBundler };

package/dist/tech-stack-registry.js

@@ -0,0 +1,15 @@
+import {
+  TECH_STACK_REGISTRY,
+  getStackEntry,
+  isMobileTechStack,
+  stackSeedsItself,
+  usesMetroBundler
+} from "./chunk-KTDDFWXM.js";
+export {
+  TECH_STACK_REGISTRY,
+  getStackEntry,
+  isMobileTechStack,
+  stackSeedsItself,
+  usesMetroBundler
+};
+//# sourceMappingURL=tech-stack-registry.js.map

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@shogo-ai/core",
+  "version": "1.4.1",
+  "description": "Shogo Core — generic utilities (logger, instrumentation, stream-buffer, chat-message). Zero required peers.",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./logger": {
+      "types": "./dist/logger.d.ts",
+      "import": "./dist/logger.js",
+      "require": "./dist/logger.cjs"
+    },
+    "./instrumentation": {
+      "types": "./dist/instrumentation.d.ts",
+      "import": "./dist/instrumentation.js",
+      "require": "./dist/instrumentation.cjs"
+    },
+    "./stream-buffer": {
+      "types": "./dist/stream-buffer.d.ts",
+      "import": "./dist/stream-buffer.js",
+      "require": "./dist/stream-buffer.cjs"
+    },
+    "./chat-message": {
+      "types": "./dist/chat-message.d.ts",
+      "import": "./dist/chat-message.js",
+      "require": "./dist/chat-message.cjs"
+    },
+    "./macos-junk": {
+      "types": "./dist/macos-junk.d.ts",
+      "import": "./dist/macos-junk.js",
+      "require": "./dist/macos-junk.cjs"
+    },
+    "./tech-stack-registry": {
+      "types": "./dist/tech-stack-registry.d.ts",
+      "import": "./dist/tech-stack-registry.js",
+      "require": "./dist/tech-stack-registry.cjs"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.cjs",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.cts"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "bun --no-env-file test src/"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.9.0",
+    "@opentelemetry/sdk-node": ">=0.213.0",
+    "@opentelemetry/exporter-trace-otlp-http": ">=0.213.0",
+    "@opentelemetry/sdk-trace-base": ">=2.5.0",
+    "@opentelemetry/resources": ">=2.5.0",
+    "@opentelemetry/semantic-conventions": ">=1.39.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-node": {
+      "optional": true
+    },
+    "@opentelemetry/exporter-trace-otlp-http": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-trace-base": {
+      "optional": true
+    },
+    "@opentelemetry/resources": {
+      "optional": true
+    },
+    "@opentelemetry/semantic-conventions": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
+    "@opentelemetry/resources": "^2.5.1",
+    "@opentelemetry/sdk-node": "^0.213.0",
+    "@opentelemetry/sdk-trace-base": "^2.5.1",
+    "@opentelemetry/semantic-conventions": "^1.39.0",
+    "@types/node": "^25.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^6.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "shogo",
+    "logger",
+    "opentelemetry",
+    "stream-buffer"
+  ],
+  "author": "Shogo Labs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shogo-labs/shogo-ai.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/shogo-labs/shogo-ai/tree/main/packages/core#readme",
+  "bugs": {
+    "url": "https://github.com/shogo-labs/shogo-ai/issues"
+  }
+}