@percepta/create 3.4.1 → 3.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percepta/create",
-  "version": "3.4.1",
+  "version": "3.4.3",
   "description": "Scaffold a new Mosaic package",
   "keywords": [
     "cli",

package/templates/webapp/AGENTS.md

@@ -158,7 +158,7 @@ logger.info({ safe: { requestId }, unsafe: { email } }, "User action completed")
 logger.error({ safe: { documentId } }, "Processing failed", error);
 ```
 
-The app's logger is initialized in `src/services/logger/AppLogger.ts` using `createLogFactory()` and `createTracerFactory()` from this package. It uses `AsyncLocalStorage` for automatic request context propagation.
+The app's logger is initialized in `src/services/logger/AppLogger.ts` using `createLoggerRuntime()` from this package. It uses `AsyncLocalStorage` for automatic request context propagation.
 
 ### @percepta/utils — Shared Utilities
 

package/templates/webapp/agent-skills/deploy.md

@@ -2,7 +2,7 @@
 
 This guide deploys __APP_TITLE__ to `https://__APP_NAME__.percepta-test.aitco.dev` using Ryvn. Tell Claude "deploy this app to percepta-test" and it should run the direct deploy helper below.
 
-This is the existing-environment deploy motion: `percepta-test` already owns the shared platform services, and this app is wired into them. Fresh-environment platform bootstrap is separate and should use a Ryvn blueprint or environment-specific platform rollout before app deploys run.
+This is the existing-environment deploy motion: `percepta-test` already owns the shared platform services, and this app is wired into them. Fresh-environment platform bootstrap is separate and should use a Ryvn blueprint or environment-specific platform rollout before app deploys run. The `pnpm deploy:percepta-test` script delegates to the versioned `@percepta/deploy` CLI; this app owns only its Ryvn YAML and generated secrets env file.
 
 ## What's Already Scaffolded
 

package/templates/webapp/agent-skills/inngest.md

@@ -43,14 +43,14 @@ schemas validate `event.data`, so do not wrap payload schemas in another
 
 ### 1. Create a function collection
 
-Group related functions into a collection class that implements `InngestFunctionCollection`:
+Group related functions into a collection class that implements `PerceptaInngestFunctionCollection`:
 
 ```typescript
+import { type PerceptaInngestFunctionCollection } from "@percepta/inngest";
 import { type InngestFunction } from "inngest";
-import { type InngestFunctionCollection } from "../InngestFunctionCollection";
 import { InngestService } from "../InngestService";
 
-export class DocumentFunctions implements InngestFunctionCollection {
+export class DocumentFunctions implements PerceptaInngestFunctionCollection {
   private inngestService = InngestService.create();
 
   public get functions(): InngestFunction.Like[] {
@@ -85,9 +85,9 @@ export class DocumentFunctions implements InngestFunctionCollection {
 Add your collection to the `functionCollections` array in the Inngest serve endpoint:
 
 ```typescript
-const functionCollections: InngestFunctionCollection[] = compact([
+const functionCollections: PerceptaInngestFunctionCollection[] = [
   new DocumentFunctions(),
-]);
+];
 ```
 
 ## Sending Events

package/templates/webapp/agent-skills/langfuse.md

@@ -21,14 +21,14 @@ Langfuse is an open-source LLM observability platform. It captures traces, spans
 The template uses Next.js's instrumentation hook (called on server startup) to bootstrap OTEL with both the environment collector and optional Langfuse:
 
 ```typescript
-import { LangfuseSpanProcessor } from "@langfuse/otel";
-import { NodeSDK, tracing } from "@opentelemetry/sdk-node";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { NodeSDK, tracing } from "@opentelemetry/sdk-node";
+import { createLangfuseSpanProcessor } from "@percepta/ai";
 
 const sdk = new NodeSDK({
   spanProcessors: [
     new tracing.BatchSpanProcessor(otlpTraceExporter),
-    new LangfuseSpanProcessor({ baseUrl, publicKey, secretKey }),
+    createLangfuseSpanProcessor(env, logger),
   ],
   instrumentations: [getNodeAutoInstrumentations()],
 });
@@ -37,7 +37,7 @@ sdk.start();
 
 - `getNodeAutoInstrumentations()` automatically instruments HTTP calls, database queries, and other standard Node.js operations.
 - The OTLP span processor forwards general server traces to the environment collector.
-- `LangfuseSpanProcessor` forwards only AI SDK spans to Langfuse when all `LANGFUSE_*` variables are set. General HTTP, DB, and server spans stay in the OTEL/LGTM pipeline and are not sent to Langfuse by default.
+- The shared Langfuse span processor forwards only AI SDK spans to Langfuse when all `LANGFUSE_*` variables are set. General HTTP, DB, and server spans stay in the OTEL/LGTM pipeline and are not sent to Langfuse by default.
 
 **You do not need to manually instrument LLM calls.** Use `LLMService` from `src/services/llm/LLMService.ts`; it calls the Vercel AI SDK with telemetry enabled and provider/model metadata attached.
 

package/templates/webapp/agent-skills/llm.md

@@ -30,7 +30,7 @@ const stream = LLMService.create().streamText({
 
 ## Providers
 
-`LlmProviderService` chooses a provider at call time:
+The shared `@percepta/ai` provider helper chooses a provider at call time:
 
 1. `LLM_PROVIDER`, when explicitly set.
 2. Anthropic when `ANTHROPIC_API_KEY` is available.

package/templates/webapp/deploy/README.md

@@ -18,7 +18,7 @@ These files deploy to `https://__APP_NAME__.percepta-test.aitco.dev`.
 
 The default deploy helper performs the existing-environment deploy motion: it assumes the target Ryvn environment already has the shared platform services installed, then wires this app into them. For `percepta-test`, that means shared Postgres, Inngest, the OTEL collector, the LGTM stack, and Langfuse must already exist before app deploy starts. Fresh-environment platform bootstrap is a separate motion and should be handled by a Ryvn blueprint or environment-specific platform rollout.
 
-The helper talks directly to Ryvn: it preflights the existing platform services, creates/updates the services, runs the GitHub Actions release workflows, creates the schema installation, approves the schema Terraform plan, creates or updates app-scoped Ryvn secrets, creates the web installation, waits for health, and verifies the health and app routes.
+The `pnpm deploy:percepta-test` script delegates to the versioned `@percepta/deploy` CLI. The app owns only the Ryvn service/installation YAML and secrets env file. The helper talks directly to Ryvn: it preflights the existing platform services, creates/updates the services, runs the GitHub Actions release workflows, creates the schema installation, approves the schema Terraform plan, creates or updates app-scoped Ryvn secrets, creates the web installation, waits for health, and verifies the health and app routes.
 
 ## Deploying
 

package/templates/webapp/package.json.template

@@ -24,8 +24,8 @@
     "db:setup-readonly": "tsx ./scripts/setup-readonly-user.ts",
     "db:studio": "pnpm db:setup-and-migrate && drizzle-kit studio",
     "db:seed": "tsx ./scripts/seed.ts",
-    "deploy:percepta-test": "tsx ./scripts/deploy-percepta-test.ts",
-    "deploy:percepta-test:pr": "tsx ./scripts/open-ryvn-deploy-pr.ts",
+    "deploy:percepta-test": "percepta-deploy percepta-test --app __APP_NAME__ --repo __REPO_NAME__",
+    "deploy:percepta-test:pr": "percepta-deploy percepta-test pr --app __APP_NAME__ --database-schema __APP_NAME_SNAKE__",
     "test": "vitest run",
     "test:e2e": "pnpm run setup && playwright test",
     "test:e2e:install": "playwright install chromium",
@@ -33,8 +33,6 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^2.0.23",
-    "@ai-sdk/openai": "^2.0.23",
     "@aws-sdk/client-s3": "^3.888.0",
     "@aws-sdk/client-secrets-manager": "^3.914.0",
     "@aws-sdk/client-sts": "^3.913.0",
@@ -48,9 +46,6 @@
     "@grafana/faro-web-sdk": "^1.14.0",
     "@grafana/faro-web-tracing": "^1.14.0",
     "@hookform/resolvers": "^5.2.2",
-    "@inngest/middleware-validation": "^0.0.5",
-    "@langfuse/otel": "^4.0.0",
-    "@langfuse/tracing": "^4.0.0",
     "@mantine/hooks": "^8.3.1",
     "@next/env": "^15.3.5",
     "@opentelemetry/api": "^1.9.0",
@@ -58,10 +53,12 @@
     "@opentelemetry/exporter-trace-otlp-proto": "^0.203.0",
     "@opentelemetry/sdk-node": "^0.203.0",
     "@__REPO_NAME__/auth": "workspace:*",
-    "@percepta/access-control": "0.6.1",
+    "@percepta/access-control": "0.7.0",
+    "@percepta/ai": "0.1.0",
     "@percepta/design": "0.3.2",
-    "@percepta/logger": "0.0.6",
-    "@percepta/next-utils": "0.1.0",
+    "@percepta/inngest": "0.1.0",
+    "@percepta/logger": "0.1.0",
+    "@percepta/next-utils": "0.2.0",
     "@percepta/utils": "0.1.10",
     "@radix-ui/react-slot": "^1.2.3",
     "@tanstack/react-query": "^5.81.5",
@@ -69,7 +66,6 @@
     "@trpc/client": "^11.4.3",
     "@trpc/server": "^11.4.3",
     "@trpc/tanstack-react-query": "^11.4.3",
-    "ai": "^5.0.24",
     "better-auth": "^1.6.4",
     "clsx": "^2.1.1",
     "date-fns": "^4.1.0",
@@ -80,15 +76,12 @@
     "import-in-the-middle": "^1.14.2",
     "inngest": "^3.44.3",
     "keyed-type-union": "^0.1.0",
-    "langfuse": "^3.38.6",
     "lodash-es": "^4.17.21",
     "lucide-react": "^0.542.0",
     "mime-types": "^3.0.1",
     "next": "^15.3.5",
     "numeral": "^2.0.6",
     "pg": "^8.16.3",
-    "pino": "^10.1.0",
-    "pino-pretty": "^13.1.3",
     "pluralize": "^8.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
@@ -109,6 +102,7 @@
     "@next/eslint-plugin-next": "^15.3.5",
     "@playwright/test": "^1.58.2",
     "@percepta/build": "0.4.0",
+    "@percepta/deploy": "0.1.0",
     "@tailwindcss/postcss": "^4.1.11",
     "@types/formidable": "^3.4.5",
     "@types/he": "^1.2.3",

package/templates/webapp/src/app/api/inngest/route.ts

@@ -1,31 +1,21 @@
-import { serve } from "inngest/next";
-import { compact } from "lodash-es";
-import { type InngestFunctionCollection } from "../../../services/inngest/InngestFunctionCollection";
+import {
+  createPerceptaInngestNextRouteHandlers,
+  type PerceptaInngestFunctionCollection,
+} from "@percepta/inngest";
 import { InngestService } from "../../../services/inngest/InngestService";
 
 export const dynamic = "force-dynamic";
 
-const functionCollections: InngestFunctionCollection[] = compact([]);
+const functionCollections: PerceptaInngestFunctionCollection[] = [];
 
 // InngestService.create() reads env vars and throws if INNGEST_BASE_URL is
 // unset. Defer initialization until request time so `next build` can compile
 // this route without those vars present.
-type Handlers = ReturnType<typeof serve>;
+const inngestHandlers = createPerceptaInngestNextRouteHandlers({
+  getService: () => InngestService.create(),
+  getFunctions: () => functionCollections.flatMap(({ functions }) => functions),
+});
 
-let cachedHandlers: Handlers | undefined;
-
-function getHandlers(): Handlers {
-  if (cachedHandlers == null) {
-    const inngestService = InngestService.create();
-    cachedHandlers = serve({
-      client: inngestService.client,
-      functions: functionCollections.flatMap(({ functions }) => functions),
-      signingKey: inngestService.signingKey,
-    });
-  }
-  return cachedHandlers;
-}
-
-export const GET: Handlers["GET"] = (...args) => getHandlers().GET(...args);
-export const POST: Handlers["POST"] = (...args) => getHandlers().POST(...args);
-export const PUT: Handlers["PUT"] = (...args) => getHandlers().PUT(...args);
+export const GET = inngestHandlers.GET;
+export const POST = inngestHandlers.POST;
+export const PUT = inngestHandlers.PUT;

package/templates/webapp/src/instrumentation.ts

@@ -1,52 +1,12 @@
-import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
 import { NodeSDK, tracing } from "@opentelemetry/sdk-node";
+import { createLangfuseSpanProcessor } from "@percepta/ai";
 import { compact } from "lodash-es";
 import { getEnvConfig } from "./config/getEnvConfig";
 import { getLogger } from "./services/logger/AppLogger";
 
 type SpanProcessor = tracing.SpanProcessor;
-type ReadableSpan = Parameters<SpanProcessor["onEnd"]>[0];
-type OnStartArgs = Parameters<SpanProcessor["onStart"]>;
-
-class FilteringSpanProcessor implements SpanProcessor {
-  public constructor(
-    private delegate: SpanProcessor,
-    private shouldExport: (span: ReadableSpan) => boolean,
-  ) {}
-
-  public forceFlush(): Promise<void> {
-    return this.delegate.forceFlush();
-  }
-
-  public onStart(...args: OnStartArgs): void {
-    this.delegate.onStart(...args);
-  }
-
-  public onEnd(span: ReadableSpan): void {
-    if (this.shouldExport(span)) {
-      this.delegate.onEnd(span);
-    }
-  }
-
-  public shutdown(): Promise<void> {
-    return this.delegate.shutdown();
-  }
-}
-
-function isAiSdkSpan(span: ReadableSpan): boolean {
-  const operationId = span.attributes["ai.operationId"];
-  if (typeof operationId === "string" && operationId.startsWith("ai.")) {
-    return true;
-  }
-
-  if (span.name.startsWith("ai.")) {
-    return true;
-  }
-
-  return Object.keys(span.attributes).some((key) => key.startsWith("gen_ai."));
-}
 
 function getOtlpTracesEndpoint(): string | undefined {
   const {
@@ -90,28 +50,7 @@ function getOtlpSpanProcessor(): tracing.BatchSpanProcessor | undefined {
 }
 
 function getLangfuseSpanProcessor(): SpanProcessor | undefined {
-  const {
-    LANGFUSE_BASE_URL: baseUrl,
-    LANGFUSE_PUBLIC_KEY: publicKey,
-    LANGFUSE_SECRET_KEY: secretKey,
-  } = getEnvConfig();
-  if (!baseUrl || !publicKey || !secretKey) {
-    getLogger().debug(
-      undefined,
-      "Langfuse environment is incomplete. Skipping Langfuse OpenTelemetry.",
-    );
-    return undefined;
-  }
-
-  getLogger().debug(undefined, "Registering Langfuse OpenTelemetry.");
-  return new FilteringSpanProcessor(
-    new LangfuseSpanProcessor({
-      baseUrl,
-      publicKey,
-      secretKey,
-    }),
-    isAiSdkSpan,
-  );
+  return createLangfuseSpanProcessor(getEnvConfig(), getLogger());
 }
 
 const spanProcessors: tracing.SpanProcessor[] = compact([

package/templates/webapp/src/server/trpc.ts

@@ -1,8 +1,5 @@
-import type { PermissionClient, SubjectRef } from "@percepta/access-control";
-import {
-  createRequireApplicationAccess,
-  createRequirePermission,
-} from "@percepta/access-control/trpc";
+import type { SubjectRef } from "@percepta/access-control";
+import { createAppAccessControlMiddlewares } from "@percepta/access-control/trpc";
 import { TRPCError, initTRPC } from "@trpc/server";
 import superjson from "superjson";
 import { accessManifest } from "../access/access.manifest";
@@ -25,12 +22,6 @@ export interface ProtectedContext extends Context {
   session: BetterAuthSession;
 }
 
-const lazyPermissionClient = {
-  can(check) {
-    return getAccessControl().permissions.can(check);
-  },
-} satisfies Pick<PermissionClient, "can">;
-
 function getCurrentSubject(ctx: Context): SubjectRef | null {
   const userId = ctx.session?.user.id;
   return userId == null ? null : toUserSubject(userId);
@@ -76,17 +67,14 @@ const requireAuthenticatedUser = procedure.use(
   },
 );
 
-const requireApplicationAccess =
-  createRequireApplicationAccess<ProtectedContext>({
-    accessControl: lazyPermissionClient,
+const { requireApplicationAccess, requirePermission } =
+  createAppAccessControlMiddlewares<ProtectedContext>({
+    getAccessControl,
     getSubject: getCurrentSubject,
     manifest: accessManifest,
   });
 
-export const requirePermission = createRequirePermission<ProtectedContext>({
-  accessControl: lazyPermissionClient,
-  getSubject: getCurrentSubject,
-});
+export { requirePermission };
 
 export const protectedProcedure = requireAuthenticatedUser;
 

package/templates/webapp/src/services/AuthContextService.ts

@@ -1,63 +1,11 @@
-import { trace } from "@opentelemetry/api";
-import { TRPCError } from "@trpc/server";
+import {
+  createAuthContextServiceFactory,
+  type AuthContextService as PerceptaAuthContextService,
+} from "@percepta/next-utils";
 import type { BetterAuthSession } from "../lib/auth";
 
 export type AuthSession = BetterAuthSession;
 
-export class AuthContextService {
-  private static SINGLETON: AuthContextService | undefined;
-  public static create(): AuthContextService {
-    if (AuthContextService.SINGLETON == null) {
-      AuthContextService.SINGLETON = new AuthContextService();
-    }
-
-    return AuthContextService.SINGLETON;
-  }
-
-  private authAsyncLocalStorage = new AsyncLocalStorage<LocalStorage>();
-
-  private constructor() {}
-
-  public withSession<TReturn>(
-    session: AuthSession,
-    callback: () => TReturn,
-  ): TReturn {
-    // Set user email on the active OpenTelemetry span
-    const activeSpan = trace.getActiveSpan();
-    if (
-      activeSpan != null &&
-      session.user.email != null &&
-      session.user.id != null
-    ) {
-      activeSpan.setAttribute("user.email", session.user.email);
-      activeSpan.setAttribute("user.id", session.user.id);
-    }
-
-    return this.authAsyncLocalStorage.run<TReturn>({ session }, () =>
-      callback(),
-    );
-  }
-
-  public getSession(): AuthSession | undefined {
-    const context = this.authAsyncLocalStorage.getStore();
-    if (context == null) {
-      return undefined;
-    }
-
-    const { session } = context;
-    return session;
-  }
-
-  public getSessionOrThrow(): AuthSession {
-    const session = this.getSession();
-    if (session == null) {
-      throw new TRPCError({ code: "UNAUTHORIZED" });
-    }
-
-    return session;
-  }
-}
-
-interface LocalStorage {
-  session: AuthSession;
-}
+export const AuthContextService =
+  createAuthContextServiceFactory<AuthSession>();
+export type AuthContextService = PerceptaAuthContextService<AuthSession>;

package/templates/webapp/src/services/inngest/InngestService.ts

@@ -1,5 +1,9 @@
-import { validationMiddleware } from "@inngest/middleware-validation";
-import { EventSchemas, Inngest } from "inngest";
+import {
+  createPerceptaInngestServiceFactory,
+  type PerceptaInngest,
+  type PerceptaInngestService,
+} from "@percepta/inngest";
+import { EventSchemas } from "inngest";
 import { getEnvConfig } from "../../config/getEnvConfig";
 import { AppEvents } from "./events/AppEvents";
 
@@ -8,64 +12,12 @@ export interface PollOpts {
   delayMs: number;
 }
 
-export interface AppInngest extends AppInngestInternal {
-  // Externally, we should never call createFunction on the client interface.
-  createFunction: never;
-}
-type AppInngestInternal = Inngest<{
-  id: string;
-  schemas: typeof EVENT_SCHEMAS;
-}>;
-
-export class InngestService {
-  private static SINGLETON: InngestService | undefined;
-  public static create(): InngestService {
-    if (InngestService.SINGLETON == null) {
-      InngestService.SINGLETON = new InngestService();
-    }
-    return InngestService.SINGLETON;
-  }
-
-  private _signingKey: string | undefined;
-  private inngest: AppInngestInternal;
-
-  private constructor() {
-    const {
-      INNGEST_BASE_URL: baseUrl,
-      INNGEST_SIGNING_KEY: signingKey,
-      INNGEST_EVENT_KEY: eventKey,
-    } = getEnvConfig();
-
-    if (baseUrl == null) {
-      throw new Error("INNGEST_BASE_URL is not set.");
-    }
-
-    this._signingKey = signingKey;
-    this.inngest = new Inngest({
-      id: "__APP_NAME__",
-      eventKey,
-      baseUrl,
-      schemas: EVENT_SCHEMAS,
-      middleware: [validationMiddleware()],
-    });
-  }
-
-  public get client(): AppInngest {
-    return this.inngest as never;
-  }
-
-  public get signingKey(): string | undefined {
-    return this._signingKey;
-  }
-
-  public createFunction: Inngest.CreateFunction<AppInngest> = (
-    options,
-    trigger,
-    handler,
-  ) => {
-    // TODO: Add context plumbing here.
-    return this.inngest.createFunction(options, trigger, handler) as never;
-  };
-}
-
 const EVENT_SCHEMAS = new EventSchemas().fromSchema(AppEvents);
+
+export type AppInngest = PerceptaInngest<typeof EVENT_SCHEMAS>;
+export const InngestService = createPerceptaInngestServiceFactory({
+  appId: "__APP_NAME__",
+  getEnv: getEnvConfig,
+  schemas: EVENT_SCHEMAS,
+});
+export type InngestService = PerceptaInngestService<typeof EVENT_SCHEMAS>;

package/templates/webapp/src/services/langfuse/LangfuseService.ts

@@ -1,80 +1,12 @@
-import { Langfuse } from "langfuse";
+import {
+  createPerceptaLangfuseServiceFactory,
+  type PerceptaLangfuseService,
+} from "@percepta/ai";
 import { getEnvConfig } from "../../config/getEnvConfig";
 import { getLogger } from "../logger/AppLogger";
 
-export class LangfuseService {
-  private static SINGLETON: LangfuseService | undefined;
-
-  public static create(): LangfuseService {
-    if (LangfuseService.SINGLETON == null) {
-      LangfuseService.SINGLETON = new LangfuseService();
-    }
-    return LangfuseService.SINGLETON;
-  }
-
-  private readonly client: Langfuse | undefined;
-
-  private constructor() {
-    const config = getEnvConfig();
-    const baseUrl = config.LANGFUSE_BASE_URL;
-    const publicKey = config.LANGFUSE_PUBLIC_KEY;
-    const secretKey = config.LANGFUSE_SECRET_KEY;
-
-    if (baseUrl && publicKey && secretKey) {
-      this.client = new Langfuse({
-        baseUrl,
-        publicKey,
-        secretKey,
-      });
-    }
-  }
-
-  /**
-   * Check if Langfuse is configured.
-   */
-  public isConfigured(): boolean {
-    return this.client != null;
-  }
-
-  /**
-   * Update a Langfuse trace with metadata.
-   * Uses trace.update() which merges with existing metadata.
-   *
-   * @param traceId - The trace ID (same as documentPipelineRuns.id)
-   * @param metadata - The metadata to save (must be JSON-serializable)
-   */
-  public async updateTraceMetadata<T extends object>(
-    traceId: string,
-    metadata: T,
-  ): Promise<void> {
-    if (!this.isConfigured()) {
-      getLogger().warn(
-        { safe: { traceId } },
-        "[LangfuseService] Langfuse not configured, skipping trace update",
-      );
-      return;
-    }
-
-    // Capture client after isConfigured() guard for type narrowing
-    const client = this.client!;
-
-    try {
-      // Attach to existing trace by ID and update metadata
-      const trace = client.trace({ id: traceId });
-      trace.update({ metadata });
-
-      // Flush to ensure the update is sent
-      await client.flushAsync();
-
-      getLogger().info(
-        { safe: { traceId } },
-        "[LangfuseService] Updated trace with metadata",
-      );
-    } catch (error) {
-      getLogger().error(
-        { safe: { traceId }, unsafe: { error: String(error) } },
-        "[LangfuseService] Failed to update trace metadata",
-      );
-    }
-  }
-}
+export const LangfuseService = createPerceptaLangfuseServiceFactory({
+  getConfig: getEnvConfig,
+  getLogger,
+});
+export type LangfuseService = PerceptaLangfuseService;