@pikku/core 0.12.62 → 0.12.64

package/src/wirings/rpc/rpc-runner.ts

@@ -6,10 +6,13 @@ import type {
 import type { SessionService } from '../../services/user-session-service.js'
 import type { CoreUserSession } from '../../types/core.types.js'
 import { runPikkuFunc } from '../../function/function-runner.js'
+import type { AddonInstance } from './addon-runner.js'
+import { addonInstanceForNamespace } from './addon-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import { PikkuError, addError } from '../../errors/error-handler.js'
 import type { PikkuRPC, ResolvedFunction } from './rpc-types.js'
 import { parseVersionedId } from '../../version.js'
+import { resolveRemoteAddonToken } from './remote-addon-auth.js'
 
 export class RPCNotFoundError extends PikkuError {
   public readonly rpcName: string
@@ -23,11 +26,43 @@ addError(RPCNotFoundError, {
   mcpCode: -32601,
   message: 'RPC function not found.',
 })
+
+/** A `wireRemoteAddon` namespace is missing a usable `serverUrl`. */
+export class RemoteAddonConfigError extends PikkuError {
+  constructor(namespace: string, detail: string) {
+    super(`Remote addon '${namespace}' is misconfigured: ${detail}`)
+  }
+}
+addError(RemoteAddonConfigError, {
+  status: 500,
+  message: 'Remote addon is misconfigured.',
+})
+
+/** The hosted addon returned a non-2xx response for a remote RPC. */
+export class RemoteAddonRequestError extends PikkuError {
+  public readonly httpStatus: number
+  constructor(
+    namespace: string,
+    fnName: string,
+    status: number,
+    detail: string
+  ) {
+    super(
+      `Remote addon '${namespace}:${fnName}' returned ${status}${detail ? `: ${detail}` : ''}`
+    )
+    this.httpStatus = status
+  }
+}
+addError(RemoteAddonRequestError, {
+  status: 502,
+  message: 'Remote addon request failed.',
+})
 import type { AIAgentInput } from '../ai-agent/ai-agent.types.js'
 import type { AIStreamChannel } from '../ai-agent/ai-agent.types.js'
 import type { StreamAIAgentOptions } from '../ai-agent/ai-agent-prepare.js'
 import { runAIAgent, resumeAIAgentSync } from '../ai-agent/ai-agent-runner.js'
 import { streamAIAgent, resumeAIAgent } from '../ai-agent/ai-agent-stream.js'
+import { wrapChannelWithAGUI } from '../ai-agent/ai-agent-agui.js'
 
 /**
  * Resolve a namespaced function reference to package and function names
@@ -164,6 +199,12 @@ export class ContextAwareRPCService {
     // 'namespace:func' boundary via invokeAddonFunction.
     try {
       const resolved = resolvePikkuFunction(funcName, this.packageName)
+      const addonInstance = resolved.packageName
+        ? addonInstanceForNamespace(
+            this.wire.addonNamespace,
+            resolved.packageName
+          )
+        : undefined
       return await runPikkuFunc<In, Out>(
         'rpc',
         funcName,
@@ -174,6 +215,7 @@ export class ContextAwareRPCService {
           data: () => data,
           wire: updatedWire,
           packageName: resolved.packageName,
+          addonInstance,
         }
       )
     } catch (e) {
@@ -213,6 +255,21 @@ export class ContextAwareRPCService {
       throw new RPCNotFoundError(namespacedFunction)
     }
 
+    const namespace = namespacedFunction.slice(
+      0,
+      namespacedFunction.indexOf(':')
+    )
+
+    // wireRemoteAddon: the addon ships as a devDependency (types only) and its
+    // handlers run on the host — dispatch over HTTP, not through local meta.
+    if (resolved.addonConfig?.remote) {
+      return this.invokeRemoteAddonFunction<In, Out>(
+        namespace,
+        resolved.function,
+        data
+      )
+    }
+
     // Get the function meta from the addon package
     // Addon packages use function meta, not RPC meta
     const addonFunctionMeta = pikkuState(resolved.package, 'function', 'meta')
@@ -228,6 +285,15 @@ export class ContextAwareRPCService {
       ...(funcMeta.tags ?? []),
     ]
 
+    // The namespace is the consumer-facing wireAddon name; it selects the
+    // per-instance singleton services and secret/variable/credential overrides.
+    const addonInstance: AddonInstance = {
+      namespace,
+      secretOverrides: resolved.addonConfig?.secretOverrides,
+      variableOverrides: resolved.addonConfig?.variableOverrides,
+      credentialOverrides: resolved.addonConfig?.credentialOverrides,
+    }
+
     // Execute the function using runPikkuFunc with the addon package's state
     // We use the parent services (this.services) since addon packages share services
     // Pass the function's tags so tag-based middleware/permissions are applied
@@ -238,9 +304,78 @@ export class ContextAwareRPCService {
       wire,
       packageName: resolved.package,
       tags,
+      addonInstance,
     })
   }
 
+  /**
+   * Dispatch a `wireRemoteAddon` RPC over HTTP to the hosting service.
+   *
+   * The consumer sends the addon's own function name (not the namespaced form)
+   * to the host's `/remote/rpc/:rpcName` endpoint, authenticating as a client
+   * with the token bound in `wireRemoteAddon({ auth })`. The addon's handlers
+   * live on the host, so there is no local function meta to resolve.
+   */
+  private async invokeRemoteAddonFunction<In = any, Out = any>(
+    namespace: string,
+    fnName: string,
+    data: In
+  ): Promise<Out> {
+    const cfg = pikkuState(null, 'addons', 'packages').get(namespace)
+    if (!cfg?.remote) {
+      throw new RPCNotFoundError(`${namespace}:${fnName}`)
+    }
+
+    const serverUrl =
+      typeof cfg.serverUrl === 'function'
+        ? await cfg.serverUrl(this.services)
+        : cfg.serverUrl
+    if (!serverUrl) {
+      throw new RemoteAddonConfigError(namespace, 'serverUrl resolved empty')
+    }
+
+    const remoteFn = cfg.remoteName ? cfg.remoteName(fnName) : fnName
+    const token = await resolveRemoteAddonToken(
+      cfg.remoteAuth,
+      this.services,
+      this.wire,
+      namespace
+    )
+
+    const headers: Record<string, string> = {
+      'content-type': 'application/json',
+      accept: 'application/json',
+    }
+    if (token) {
+      headers.authorization = `Bearer ${token}`
+    }
+    if (this.wire.traceId) {
+      headers['x-trace-id'] = this.wire.traceId
+    }
+
+    const base = serverUrl.replace(/\/+$/, '')
+    const res = await fetch(
+      `${base}/remote/rpc/${encodeURIComponent(remoteFn)}`,
+      {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ rpcName: remoteFn, data }),
+      }
+    )
+
+    if (!res.ok) {
+      // Best-effort body read to enrich the thrown error (mirrors postRpc).
+      const detail = (await res.text().catch(() => '')).slice(0, 300)
+      throw new RemoteAddonRequestError(namespace, remoteFn, res.status, detail)
+    }
+
+    if (res.status === 204) {
+      return undefined as Out
+    }
+    const text = await res.text()
+    return (text ? JSON.parse(text) : undefined) as Out
+  }
+
   public async rpcWithWire<In = any, Out = any>(
     rpcName: string,
     data: In,
@@ -257,12 +392,19 @@ export class ContextAwareRPCService {
 
     try {
       const resolved = resolvePikkuFunction(rpcName, this.packageName)
+      const addonInstance = resolved.packageName
+        ? addonInstanceForNamespace(
+            this.wire.addonNamespace,
+            resolved.packageName
+          )
+        : undefined
       return await runPikkuFunc<In, Out>('rpc', rpcName, resolved.pikkuFuncId, {
         auth: this.options.requiresAuth,
         singletonServices: this.services,
         data: () => data,
         wire: mergedWire,
         packageName: resolved.packageName,
+        addonInstance,
       })
     } catch (e) {
       if (e instanceof RPCNotFoundError && this.services.deploymentService) {
@@ -338,16 +480,26 @@ export class ContextAwareRPCService {
       ) => {
         const channel = this.wire.channel as unknown as AIStreamChannel
         if (!channel) throw new Error('No channel available for streaming')
+        let currentRunId: string | undefined
         await streamAIAgent(
           agentName,
           input,
-          channel,
+          wrapChannelWithAGUI(channel, {
+            threadId: input.threadId,
+            getRunId: () => currentRunId,
+          }),
           {
             sessionService: this.options.sessionService,
             getCredential: this.wire.getCredential?.bind(this.wire),
           },
           undefined,
-          options
+          {
+            ...options,
+            onRunCreated: (runId) => {
+              currentRunId = runId
+              options?.onRunCreated?.(runId)
+            },
+          }
         )
       },
       resume: async (
@@ -359,7 +511,7 @@ export class ContextAwareRPCService {
         if (!channel) throw new Error('No channel available for streaming')
         await resumeAIAgent(
           { runId, ...input },
-          channel,
+          wrapChannelWithAGUI(channel, { runId }),
           {
             sessionService: this.options.sessionService,
             getCredential: this.wire.getCredential?.bind(this.wire),

package/src/wirings/rpc/rpc-types.ts

@@ -1,9 +1,9 @@
 export type PikkuRPC<
-  Invoke extends Function = any,
-  Remote extends Function = any,
-  startWorkflow extends Function = any,
-  AgentRun extends Function = any,
-  AgentStream extends Function = any,
+  Invoke extends (...args: any[]) => any = (...args: any[]) => any,
+  Remote extends (...args: any[]) => any = (...args: any[]) => any,
+  startWorkflow extends (...args: any[]) => any = (...args: any[]) => any,
+  AgentRun extends (...args: any[]) => any = (...args: any[]) => any,
+  AgentStream extends (...args: any[]) => any = (...args: any[]) => any,
 > = {
   depth: number
   global: boolean
@@ -52,5 +52,16 @@ export interface ResolvedFunction {
     auth?: boolean
     tags?: string[]
     rpcEndpoint?: string
+    secretOverrides?: Record<string, string>
+    variableOverrides?: Record<string, string>
+    credentialOverrides?: Record<string, string>
+    /** Set by `wireRemoteAddon`: dispatch this namespace's RPCs over HTTP */
+    remote?: boolean
+    serverUrl?: string | ((services: any) => string | Promise<string>)
+    remoteAuth?:
+      | { credentialId: string }
+      | { secretId: string }
+      | { resolve: (services: any, wire: any) => string | Promise<string> }
+    remoteName?: (fn: string) => string
   }
 }

package/src/wirings/rpc/wire-addon.test.ts

@@ -17,9 +17,9 @@ describe('wireAddon', () => {
       auth: true,
       mcp: true,
       tags: ['payments', 'billing'],
-      secretOverrides: { apiKey: 'secretName' },
-      variableOverrides: { region: 'eu-west-1' },
-      credentialOverrides: { oauth: 'credentialName' },
+      secretOverrides: { apiKey: 'STRIPE_API_KEY' },
+      variableOverrides: { region: 'AWS_REGION' },
+      credentialOverrides: { oauth: 'stripeOAuth' },
     })
 
     assert.deepEqual(pikkuState(null, 'addons', 'packages').get('stripe'), {
@@ -27,6 +27,9 @@ describe('wireAddon', () => {
       rpcEndpoint: 'https://rpc.example.com',
       auth: true,
       tags: ['payments', 'billing'],
+      secretOverrides: { apiKey: 'STRIPE_API_KEY' },
+      variableOverrides: { region: 'AWS_REGION' },
+      credentialOverrides: { oauth: 'stripeOAuth' },
     })
   })
 

package/src/wirings/rpc/wire-addon.ts

@@ -18,5 +18,14 @@ export const wireAddon = (config: WireAddonConfig): void => {
     rpcEndpoint: config.rpcEndpoint,
     auth: config.auth,
     tags: config.tags,
+    ...(config.secretOverrides
+      ? { secretOverrides: config.secretOverrides }
+      : {}),
+    ...(config.variableOverrides
+      ? { variableOverrides: config.variableOverrides }
+      : {}),
+    ...(config.credentialOverrides
+      ? { credentialOverrides: config.credentialOverrides }
+      : {}),
   })
 }

package/src/wirings/rpc/wire-remote-addon.ts

@@ -0,0 +1,57 @@
+import { pikkuState } from '../../pikku-state.js'
+import type { CoreServices, PikkuWire } from '../../types/core.types.js'
+
+/**
+ * How the consumer supplies the token the hosted addon's auth expects.
+ *
+ * This is a CLIENT authenticating to a hosted library — NOT pikku's trusted
+ * machine-to-machine mesh (which uses `PIKKU_REMOTE_SECRET`). The consumer binds
+ * the addon's declared auth requirement to a local source:
+ *  - `credentialId` — per-user credential, resolved via `wire.getCredential(id)`
+ *  - `secretId`     — platform key, resolved via the secrets service
+ *  - `resolve`      — custom escape hatch
+ * Omit entirely when the addon declares its remote surface is public.
+ *
+ * The value is sent `Authorization: Bearer <token>` by default; a non-default
+ * header is declared once by the addon (its meta), never chosen here.
+ */
+export type RemoteAddonAuth =
+  | { credentialId: string }
+  | { secretId: string }
+  | { resolve: (services: CoreServices, wire: PikkuWire) => string | Promise<string> }
+
+export type WireRemoteAddonConfig = {
+  /** Consumer-facing namespace, e.g. `registry` → `rpc('registry:getOpenApi')` */
+  name: string
+  /**
+   * The addon package. Installed as a **devDependency** (types only — its
+   * handlers run on the host); `pikku verify` enforces this.
+   */
+  package: string
+  /** Base URL of the host serving the addon's remote surface. */
+  serverUrl: string | ((services: CoreServices) => string | Promise<string>)
+  /** Bind the addon's declared auth to a local source. Omit if the surface is public. */
+  auth?: RemoteAddonAuth
+  /** Map a consumer-facing fn name → the remote fn name, when they differ (rare). */
+  remoteName?: (fn: string) => string
+  tags?: string[]
+}
+
+/**
+ * Consume a hosted addon's `remote: true` RPCs transparently over HTTP.
+ *
+ * Unlike `wireAddon` (which bundles the addon's functions in-process, a
+ * production dependency), `wireRemoteAddon` dispatches `rpc('name:fn')` to the
+ * host at `serverUrl`, fully typed — the addon ships as a devDependency (types
+ * only). See {@link RemoteAddonAuth} for how auth is bound.
+ */
+export const wireRemoteAddon = (config: WireRemoteAddonConfig): void => {
+  pikkuState(null, 'addons', 'packages').set(config.name, {
+    package: config.package,
+    tags: config.tags,
+    remote: true,
+    serverUrl: config.serverUrl,
+    ...(config.auth ? { remoteAuth: config.auth } : {}),
+    ...(config.remoteName ? { remoteName: config.remoteName } : {}),
+  })
+}

package/src/wirings/scope/index.ts

@@ -0,0 +1,14 @@
+export { wireScope } from './wire-scope.js'
+export {
+  flattenScopeDefinitions,
+  validateAndBuildScopeDefinitionsMeta,
+} from './validate-scope-definitions.js'
+export type {
+  CoreScopes,
+  CoreScopeNode,
+  FlatScope,
+  ScopeDefinitionMeta,
+  ScopeDefinitionsMeta,
+  ScopeDefinitions,
+  ScopeNodeMeta,
+} from './scope.types.js'

package/src/wirings/scope/scope.test.ts

@@ -0,0 +1,135 @@
+import { describe, test } from 'node:test'
+import * as assert from 'node:assert'
+import {
+  flattenScopeDefinitions,
+  validateAndBuildScopeDefinitionsMeta,
+} from './validate-scope-definitions.js'
+import type { ScopeDefinitions } from './scope.types.js'
+
+describe('flattenScopeDefinitions', () => {
+  test('a flat scope yields itself', () => {
+    const definitions: ScopeDefinitions = [
+      { name: 'admin', description: 'Administration' },
+    ]
+
+    assert.deepEqual(flattenScopeDefinitions(definitions), [
+      { id: 'admin', description: 'Administration' },
+    ])
+  })
+
+  test('nested scopes yield every intermediate level', () => {
+    const definitions: ScopeDefinitions = [
+      {
+        name: 'admin',
+        scopes: {
+          invoices: {
+            description: 'Invoice management',
+            scopes: { create: { description: 'Create invoices' } },
+          },
+        },
+      },
+    ]
+
+    assert.deepEqual(flattenScopeDefinitions(definitions), [
+      { id: 'admin', description: undefined },
+      { id: 'admin:invoices', description: 'Invoice management' },
+      { id: 'admin:invoices:create', description: 'Create invoices' },
+    ])
+  })
+
+  test('siblings are flattened depth-first', () => {
+    const definitions: ScopeDefinitions = [
+      {
+        name: 'billing',
+        scopes: { read: {}, write: {} },
+      },
+    ]
+
+    assert.deepEqual(
+      flattenScopeDefinitions(definitions).map((s) => s.id),
+      ['billing', 'billing:read', 'billing:write']
+    )
+  })
+
+  test('several definitions are flattened together', () => {
+    const definitions: ScopeDefinitions = [
+      { name: 'admin', scopes: { users: {} } },
+      { name: 'billing' },
+    ]
+
+    assert.deepEqual(
+      flattenScopeDefinitions(definitions).map((s) => s.id),
+      ['admin', 'admin:users', 'billing']
+    )
+  })
+})
+
+describe('validateAndBuildScopeDefinitionsMeta', () => {
+  test('keys definitions by name', () => {
+    const meta = validateAndBuildScopeDefinitionsMeta([
+      { name: 'admin', description: 'Administration' },
+    ])
+
+    assert.equal(meta.admin!.name, 'admin')
+    assert.equal(meta.admin!.description, 'Administration')
+  })
+
+  test('an identical duplicate is tolerated', () => {
+    const meta = validateAndBuildScopeDefinitionsMeta([
+      { name: 'admin', scopes: { users: {} } },
+      { name: 'admin', scopes: { users: {} } },
+    ])
+
+    assert.equal(Object.keys(meta).length, 1)
+  })
+
+  test('a conflicting duplicate throws and names both files', () => {
+    assert.throws(
+      () =>
+        validateAndBuildScopeDefinitionsMeta([
+          { name: 'admin', scopes: { users: {} }, sourceFile: 'a.ts' },
+          { name: 'admin', scopes: { invoices: {} }, sourceFile: 'b.ts' },
+        ]),
+      (err: Error) => {
+        assert.match(err.message, /admin/)
+        assert.match(err.message, /a\.ts/)
+        assert.match(err.message, /b\.ts/)
+        return true
+      }
+    )
+  })
+
+  test('rejects a name containing the separator', () => {
+    assert.throws(
+      () => validateAndBuildScopeDefinitionsMeta([{ name: 'admin:users' }]),
+      /separator/i
+    )
+  })
+
+  test('rejects a nested key containing the separator', () => {
+    assert.throws(
+      () =>
+        validateAndBuildScopeDefinitionsMeta([
+          { name: 'admin', scopes: { 'a:b': {} } },
+        ]),
+      /separator/i
+    )
+  })
+
+  test('rejects a wildcard as a declared name', () => {
+    assert.throws(
+      () => validateAndBuildScopeDefinitionsMeta([{ name: '*' }]),
+      /wildcard/i
+    )
+  })
+
+  test('rejects a wildcard nested inside a scope', () => {
+    assert.throws(
+      () =>
+        validateAndBuildScopeDefinitionsMeta([
+          { name: 'admin', scopes: { '*': {} } },
+        ]),
+      /wildcard/i
+    )
+  })
+})

package/src/wirings/scope/scope.types.ts

@@ -0,0 +1,44 @@
+/**
+ * A node within a scope tree. Every node is itself a grantable scope — given
+ * `admin` containing `invoices` containing `create`, all three of `admin`,
+ * `admin:invoices` and `admin:invoices:create` are valid scope ids.
+ */
+export type CoreScopeNode = {
+  /** Short human-readable name, e.g. "Administration". */
+  displayName?: string
+  /** Longer-form description, surfaced in the console when granting. */
+  description?: string
+  /** Nested scopes, keyed by their segment. */
+  scopes?: Record<string, CoreScopeNode>
+}
+
+/**
+ * Scope trees to declare, keyed by their root segment. A root is just a node —
+ * it is named by its key, exactly like every node beneath it. A key must not
+ * contain `:` or be `*`.
+ */
+export type CoreScopes = Record<string, CoreScopeNode>
+
+export type ScopeNodeMeta = {
+  displayName?: string
+  description?: string
+  scopes?: Record<string, ScopeNodeMeta>
+}
+
+export type ScopeDefinitionMeta = {
+  name: string
+  displayName?: string
+  description?: string
+  scopes?: Record<string, ScopeNodeMeta>
+  sourceFile?: string
+}
+
+export type ScopeDefinitions = ScopeDefinitionMeta[]
+export type ScopeDefinitionsMeta = Record<string, ScopeDefinitionMeta>
+
+/** A single scope, flattened out of the declared tree. */
+export type FlatScope = {
+  /** Colon-delimited id, e.g. `admin:invoices:create`. */
+  id: string
+  description?: string
+}

package/src/wirings/scope/validate-scope-definitions.ts

@@ -0,0 +1,110 @@
+import type {
+  FlatScope,
+  ScopeDefinitions,
+  ScopeDefinitionsMeta,
+  ScopeNodeMeta,
+} from './scope.types.js'
+
+const SEPARATOR = ':'
+const WILDCARD = '*'
+
+const assertSegment = (segment: string, scopeName: string): void => {
+  if (segment.includes(SEPARATOR)) {
+    throw new Error(
+      `Scope segment '${segment}' in '${scopeName}' contains the '${SEPARATOR}' separator. ` +
+        `Nest scopes with the 'scopes' property instead of embedding '${SEPARATOR}' in a name.`
+    )
+  }
+  if (segment === WILDCARD) {
+    throw new Error(
+      `Scope segment '${segment}' in '${scopeName}' is the wildcard. ` +
+        `'${WILDCARD}' is reserved for granting a scope and its descendants, and cannot be declared.`
+    )
+  }
+  if (segment.length === 0) {
+    throw new Error(`Scope '${scopeName}' contains an empty segment.`)
+  }
+}
+
+const assertNodesValid = (
+  nodes: Record<string, ScopeNodeMeta> | undefined,
+  scopeName: string
+): void => {
+  for (const [segment, node] of Object.entries(nodes ?? {})) {
+    assertSegment(segment, scopeName)
+    assertNodesValid(node.scopes, scopeName)
+  }
+}
+
+const flattenNodes = (
+  nodes: Record<string, ScopeNodeMeta> | undefined,
+  prefix: string,
+  out: FlatScope[]
+): void => {
+  for (const [segment, node] of Object.entries(nodes ?? {})) {
+    const id = `${prefix}${SEPARATOR}${segment}`
+    out.push({ id, description: node.description })
+    flattenNodes(node.scopes, id, out)
+  }
+}
+
+/**
+ * Flattens declared scope trees into the full list of grantable scope ids,
+ * depth-first. Every node is emitted, including intermediate ones.
+ *
+ * Used by codegen to build the `ScopeId` union, and by a ScopeService to sync
+ * the declared set into its store.
+ */
+export const flattenScopeDefinitions = (
+  definitions: ScopeDefinitions
+): FlatScope[] => {
+  const out: FlatScope[] = []
+  for (const def of definitions) {
+    out.push({ id: def.name, description: def.description })
+    flattenNodes(def.scopes, def.name, out)
+  }
+  return out
+}
+
+/**
+ * Validates declared scopes and keys them by name.
+ *
+ * Definitions sharing a name must be identical; a conflicting redeclaration is
+ * a hard error naming both source files.
+ */
+export function validateAndBuildScopeDefinitionsMeta(
+  definitions: ScopeDefinitions
+): ScopeDefinitionsMeta {
+  const meta: ScopeDefinitionsMeta = {}
+
+  for (const def of definitions) {
+    assertSegment(def.name, def.name)
+    assertNodesValid(def.scopes, def.name)
+
+    const existing = meta[def.name]
+    if (existing) {
+      const sameShape =
+        JSON.stringify(existing.scopes ?? {}) ===
+        JSON.stringify(def.scopes ?? {})
+      if (!sameShape) {
+        throw new Error(
+          `Scope '${def.name}' is declared with different nested scopes.\n` +
+            `  First declaration: ${existing.sourceFile ?? 'unknown'}\n` +
+            `  Second declaration: ${def.sourceFile ?? 'unknown'}\n` +
+            `Scopes sharing a name must declare the same tree.`
+        )
+      }
+      continue
+    }
+
+    meta[def.name] = {
+      name: def.name,
+      displayName: def.displayName,
+      description: def.description,
+      scopes: def.scopes,
+      sourceFile: def.sourceFile,
+    }
+  }
+
+  return meta
+}