@stainless-api/docs 0.1.0-beta.137 → 0.1.0-beta.139

package/plugin/specs/defaultSpecLoader.ts

@@ -0,0 +1,192 @@
+import path from 'path';
+import type { SpecLoaderFn, SpecLoaderParams } from './utils';
+import Stainless, { APIError } from '@stainless-api/sdk';
+import { DocsLanguage } from '@stainless-api/docs-ui/routing';
+import { bold } from '../../shared/terminalUtils';
+import { mkdir, readdir, readFile, rm, writeFile } from 'fs/promises';
+import { generateSpecFromStrings, previewWorkerCode } from '@stainless/sdk-json/spec';
+import { Spec, SpecLanguage } from '@stainless/sdk-json';
+import crypto from 'crypto';
+
+function resolvePath(inputPath: string) {
+  return path.resolve(process.cwd(), inputPath);
+}
+
+function getLocalFilePaths() {
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  const oasPath = process.env.OPENAPI_PATH;
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  const configPath = process.env.STAINLESS_CONFIG_PATH;
+
+  if (!oasPath || !configPath) {
+    return null;
+  }
+
+  return {
+    oasPath: resolvePath(oasPath),
+    configPath: resolvePath(configPath),
+  };
+}
+
+async function fetchVersionInfo(project: string, apiKey: string): Promise<Record<DocsLanguage, string>> {
+  const data = await fetch(`https://api.stainless.com/api/projects/${project}/package-versions`, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+  });
+
+  const content = await data.text();
+  return JSON.parse(content) as Record<DocsLanguage, string>;
+}
+
+function redactApiKey(apiKey: string) {
+  return apiKey
+    .split('')
+    .map((char, index) => (index < 10 ? char : '*'))
+    .join('');
+}
+
+async function loadInputs({ apiKey, logger, stainlessProject, branch }: SpecLoaderParams) {
+  const localFilePaths = getLocalFilePaths();
+
+  if (localFilePaths) {
+    try {
+      const oasStr = await readFile(localFilePaths.oasPath, 'utf8');
+      const configStr = await readFile(localFilePaths.configPath, 'utf8');
+      return {
+        oasStr,
+        configStr,
+        versionInfo: null,
+      };
+    } catch (e) {
+      logger.error(bold('Failed to load spec inputs from files:'));
+      logger.error(e instanceof Error ? e.message : String(e));
+      process.exit(1);
+    }
+  }
+
+  if (!apiKey) {
+    logger.error(
+      [
+        bold(
+          'No Stainless credentials found. Please choose one of the following options to authenticate with Stainless:',
+        ),
+        '- Run `stl auth login` to authenticate via the Stainless CLI',
+        '- Provide a Stainless API key via the `STAINLESS_API_KEY` environment variable (eg. in a .env file)',
+        '- Set the `apiKey` option in the Stainless Docs config',
+      ].join('\n'),
+    );
+    process.exit(1);
+  }
+
+  try {
+    const client = new Stainless({ apiKey });
+    const configs = await client.projects.configs.retrieve({
+      project: stainlessProject,
+      branch: branch,
+      include: 'openapi',
+    });
+    const versionInfo = await fetchVersionInfo(stainlessProject, apiKey);
+
+    const configYML = Object.values(configs)[0] as { content: unknown };
+    const oasJson = Object.values(configs)[1] as { content: unknown };
+    const oasStr = oasJson['content'];
+    const configStr = configYML['content'];
+
+    if (typeof oasStr !== 'string' || typeof configStr !== 'string') {
+      logger.error('Received invalid OAS or config from Stainless');
+      process.exit(1);
+    }
+
+    return {
+      oasStr,
+      configStr,
+      versionInfo,
+    };
+  } catch (e) {
+    if (e instanceof APIError && e.status >= 400 && e.status < 500) {
+      logger.error(`Failed to load requested project slug: "${stainlessProject}"`);
+      if (apiKey) {
+        logger.error(`API key: "${redactApiKey(apiKey)}"`);
+      }
+      logger.error(
+        `This error can usually be corrected by re-authenticating with the Stainless.  Use the CLI (stl auth login) or verify that the Stainless API key you're using can access the project mentioned above.`,
+      );
+    }
+    process.exit(1);
+  }
+}
+
+async function maybeLoadJSONFile<T>(filePath: string): Promise<T | null> {
+  try {
+    const fileContents = await readFile(filePath, 'utf8');
+    return JSON.parse(fileContents) as T;
+  } catch {
+    return null;
+  }
+}
+
+async function cleanupDirectory(directory: string, filesToKeep: string[]) {
+  const allFiles = await readdir(directory);
+  const unusedFiles = allFiles.filter((file) => !filesToKeep.includes(file));
+  await Promise.all(unusedFiles.map((file) => rm(path.join(directory, file))));
+  return {
+    deletedCount: unusedFiles.length,
+  };
+}
+
+export const defaultSpecLoader: SpecLoaderFn = async (params) => {
+  const { createCodegenDir } = params;
+
+  const inputs = await loadInputs(params);
+
+  const specsDirectory = path.join(createCodegenDir().pathname, 'specs2');
+  await mkdir(specsDirectory, { recursive: true });
+
+  const fileName =
+    crypto
+      .createHash('sha256')
+      .update(JSON.stringify(inputs) + previewWorkerCode)
+      .digest('hex')
+      .slice(0, 10) + '.json';
+
+  const filePath = path.join(specsDirectory, fileName);
+
+  const cachedSpec = await maybeLoadJSONFile<{ languages: SpecLanguage[]; sdkJson: Spec }>(filePath);
+  // skip generation since we already have a cached spec
+  if (cachedSpec) {
+    params.logger.info(`Loaded cached spec: ${fileName}`);
+    return [
+      {
+        filePath,
+        languages: cachedSpec.languages,
+        sdkJson: cachedSpec.sdkJson,
+      },
+    ];
+  }
+
+  const result = await generateSpecFromStrings({
+    oasStr: inputs.oasStr,
+    configStr: inputs.configStr,
+    languageOverrides: {
+      mode: 'exclude',
+      list: params.excludeLanguages ?? [],
+    },
+    versionInfo: inputs.versionInfo,
+    stainlessProject: params.stainlessProject,
+  });
+
+  await writeFile(filePath, JSON.stringify(result), 'utf8');
+  params.logger.info(`Generated: ${fileName}`);
+
+  const { deletedCount } = await cleanupDirectory(specsDirectory, [fileName]);
+  if (deletedCount > 0) {
+    params.logger.info(`Cleaned up ${deletedCount} unused spec file(s)`);
+  }
+
+  return [
+    {
+      filePath,
+      languages: result.languages.filter((language) => language !== 'sql' && language !== 'openapi'),
+      sdkJson: result.sdkJson,
+    },
+  ];
+};

package/plugin/specs/fetchSpecSSR.ts

@@ -1,7 +1,7 @@
 import { readFile } from 'fs/promises';
 
 import { api } from 'virtual:stainless-apis-manifest';
-import { SpecWithAuth } from './generateSpec';
+import type { SpecWithAuth } from '@stainless/sdk-json/spec';
 import { DocsLanguage } from '@stainless-api/docs-ui/routing';
 
 const cachedSpecWithAuth: Record<string, SpecWithAuth> = {};

package/plugin/specs/utils.ts

@@ -0,0 +1,86 @@
+import { Spec } from '@stainless/sdk-json';
+import { readFile } from 'fs/promises';
+import { DocsLanguage } from '@stainless-api/docs-ui/routing';
+import { AstroIntegrationLogger } from 'astro';
+
+type PossibleLanguage = NonNullable<NonNullable<NonNullable<Spec['docs']>['languages']>[number]>;
+
+export type SpecLoaderParams = {
+  /**
+   * The slug of your Stainless project.
+   */
+  stainlessProject: string;
+  /**
+   * The branch of your Stainless project.
+   */
+  branch: string;
+  /**
+   * The Stainless API key. This can be used to make requests against the Stainless API.
+   */
+  apiKey: string | null;
+  /**
+   * The languages that the user has explicitly asked to be excluded from the API reference.
+   */
+  excludeLanguages: DocsLanguage[] | null;
+  /**
+   * An Astro logger. This should be used for logging messages.
+   */
+  logger: AstroIntegrationLogger;
+  /**
+   * A function that creates a directory in .astro. See: https://docs.astro.build/en/reference/integrations-reference/#createcodegendir
+   */
+  createCodegenDir: () => URL;
+};
+
+type SpecLoaderResult = {
+  /**
+   * The file path to the loaded spec. The spec MUST be written to a path on disk.
+   * If you are not sure where to place it, create a directory in .astro using the `createCodegenDir` function passed in the parameters of the spec loader function.
+   */
+  filePath: string;
+  /**
+   * The languages that are represented in the spec.
+   */
+  languages: PossibleLanguage[];
+  /**
+   * Optionally, if you already have already the spec in memory, you can provide it. If not provided, the contents of the file at `filePath` will be read.
+   * IMPORTANT: This should be equivalent to the contents of the file at `filePath`. If not, bugs and inconsistencies will arise.
+   */
+  sdkJson?: Spec;
+};
+
+export type SpecLoaderFn = (opts: SpecLoaderParams) => Promise<SpecLoaderResult[]>;
+
+async function readSpecFromFile(filePath: string) {
+  const txt = await readFile(filePath, 'utf8');
+  const json = JSON.parse(txt) as Spec;
+  return json;
+}
+
+export async function loadAllSpecs(specLoaderResultsPromise: Promise<SpecLoaderResult[]>) {
+  const specLoaderResults = await specLoaderResultsPromise;
+  const specs = await Promise.all(
+    specLoaderResults.map(async (result) => {
+      return {
+        filePath: result.filePath,
+        languages: result.languages,
+        sdkJson: result.sdkJson ?? (await readSpecFromFile(result.filePath)),
+      };
+    }),
+  );
+  return specs;
+}
+
+export type LoadedSpecs = Awaited<ReturnType<typeof loadAllSpecs>>;
+
+export function flatSpecsList(specs: LoadedSpecs) {
+  return specs
+    .map((s) =>
+      s.languages.map((language) => ({
+        language,
+        sdkJson: s.sdkJson,
+        filePath: s.filePath,
+      })),
+    )
+    .flat();
+}

package/shared/virtualModule.ts

@@ -10,23 +10,6 @@ export function buildVirtualModuleString<T extends Record<string, unknown>>(vars
     .join('\n');
 }
 
-export function makeVirtualModPlugin(bareId: string, content: string): VitePlugin {
-  return {
-    name: `stl-virtual-module-loader-${bareId}`,
-    resolveId(id) {
-      // The '\0' prefix tells Vite “this is a virtual module” and prevents it from being resolved again.
-      if (id === bareId) {
-        return `\0${bareId}`;
-      }
-    },
-    load(id) {
-      if (id === `\0${bareId}`) {
-        return content;
-      }
-    },
-  };
-}
-
 export function makeAsyncVirtualModPlugin<T extends Record<string, unknown>>(
   bareId: string,
   contentLoader: () => Promise<T | string>,

package/stl-docs/aiChatExamples.ts

@@ -1,95 +1,31 @@
-import { AstroIntegrationLogger } from 'astro';
-import z from 'zod';
-import {
-  buildVirtualModuleString,
-  makeAsyncVirtualModPlugin,
-  makeVirtualModPlugin,
-} from '../shared/virtualModule';
+import { buildVirtualModuleString } from '../shared/virtualModule';
 import type * as virtualExampleModule from 'virtual:stl-docs-ai-chat-examples';
 type VirtualExampleModule = typeof virtualExampleModule;
 
-const exampleSchema = z.array(
-  z.object({
-    shortPrompt: z.string(),
-    longPrompt: z.string(),
-    icon: z.string(),
-  }),
-);
-export type ExamplePromptResponse = z.infer<typeof exampleSchema>;
+export type ExamplePromptResponse = {
+  shortPrompt: string;
+  longPrompt: string;
+  icon: string;
+}[];
 
-// handles actually retrieving the information via the Stainless API
-async function loadExamples(
-  projectName: string,
-  logger: AstroIntegrationLogger,
-): Promise<ExamplePromptResponse | undefined> {
-  try {
-    const response = await fetch(`https://api.stainless.com/api/ai/steelie-examples/${projectName}`, {
-      method: 'GET',
-    });
-
-    const text = await response.text();
-    if (!response.ok) {
-      logger.error(`failed to fetch AI chat examples: ${text}`);
-      return undefined;
-    }
-    const examples = exampleSchema.parse(JSON.parse(text));
-    return examples;
-  } catch (error) {
-    if (error instanceof Error) logger.error(`failed to fetch AI chat examples: ${error.message}`);
-    else throw error;
-    return undefined;
-  }
-}
-
-export default async function generateExamplesPlugin({
-  projectName,
-  logger,
-  exampleOverrides,
-}: {
-  projectName: string | undefined;
-  logger: AstroIntegrationLogger;
-  exampleOverrides?: ExamplePromptResponse;
-}) {
-  // if the user has specified any examples, return those immediately
-  // instead of loading them via the web.
-  if (exampleOverrides) {
-    return makeVirtualModPlugin(
-      'virtual:stl-docs-ai-chat-examples',
-      generateVirtualModuleString(exampleOverrides),
-    );
+export function generateExamplesVirtualModule(exampleOverrides: ExamplePromptResponse | undefined): string {
+  if (!exampleOverrides) {
+    return buildVirtualModuleString({ examples: undefined } satisfies VirtualExampleModule);
   }
-  // if we don't have a defined project name, don't try to fetch examples
-  if (!projectName) {
-    return makeVirtualModPlugin(
-      'virtual:stl-docs-ai-chat-examples',
-      buildVirtualModuleString({ examples: undefined } satisfies VirtualExampleModule),
-    );
-  }
-
-  // otherwise, promise to get the right examples at some point later on
-  const examplesPromise = loadExamples(projectName, logger);
-  return makeAsyncVirtualModPlugin<VirtualExampleModule>('virtual:stl-docs-ai-chat-examples', async () => {
-    const examples = await examplesPromise;
-    return generateVirtualModuleString(examples);
-  });
-}
-
-function generateVirtualModuleString(examples: ExamplePromptResponse | undefined) {
-  if (!examples) return 'export const examples = undefined;';
 
   // Generate icon imports
   // prettier-ignore
   const pascalToKebab = (str: string) => str.split(/(?=[A-Z])/).join('-').toLowerCase();
   const iconImportPath = (iconName: string) =>
     import.meta.resolve(`lucide-react/dist/esm/icons/${pascalToKebab(iconName)}.js`);
-  const iconImports = examples.map(
+  const iconImports = exampleOverrides.map(
     ({ icon }) => `import ${icon} from ${JSON.stringify(iconImportPath(icon))}`,
   );
 
   // Reference icon imports in `examples` exported object
   // "icon":"Sparkles" -> "icon":Sparkles
   const iconStringsToIdents = (jsonBlob: string) => jsonBlob.replace(/"icon":\s*"(\w+)"/g, '"icon":$1');
-  const exportBody = `export const examples = ${iconStringsToIdents(JSON.stringify(examples))};`;
+  const exportBody = `export const examples = ${iconStringsToIdents(JSON.stringify(exampleOverrides))};`;
 
   return [...iconImports, exportBody].join('\n');
 }

package/stl-docs/index.ts

@@ -20,13 +20,12 @@ import {
 import { buildVirtualModuleString } from '../shared/virtualModule';
 import { resolveSrcFile } from '../resolveSrcFile';
 import { stainlessDocsMarkdownRenderer } from './proseMarkdown/proseMarkdownIntegration';
-import { getSharedLogger, setSharedLogger } from '../shared/getSharedLogger';
+import { setSharedLogger } from '../shared/getSharedLogger';
 import { stainlessDocsVectorProseIndexing } from './proseDocSync';
-import { stainlessDocsAlgoliaProseIndexing } from './proseSearchIndexing';
 import { stainlessStarlight } from '../plugin';
 import { getFontRoles, flattenFonts } from './fonts';
 import conditionalIntegration from '../shared/conditionalIntegration';
-import generateExamplesPlugin from './aiChatExamples';
+import { generateExamplesVirtualModule } from './aiChatExamples';
 import { ogImageStarlightPlugin } from './og-image';
 
 export * from '../plugin';
@@ -172,8 +171,7 @@ function stainlessDocsIntegration(
   return {
     name: 'stl-docs-astro',
     hooks: {
-      'astro:config:setup': async ({ updateConfig, command, config: astroConfig, logger: localLogger }) => {
-        const logger = getSharedLogger({ fallback: localLogger });
+      'astro:config:setup': ({ updateConfig, command, config: astroConfig }) => {
         // we only handle redirects for builds
         // in dev, Astro handles them for us
         if (command === 'build' && astroConfig.redirects) {
@@ -195,30 +193,35 @@ function stainlessDocsIntegration(
           vmAiChatHandlerExport = `export { default as AI_CHAT_HANDLER } from '${handlerEntrypoint}';`;
         }
 
-        const virtualModules = new Map(
-          Object.entries({
-            'virtual:stl-docs-virtual-module': [
-              buildVirtualModuleString({
-                TABS: config.tabs.map((tab) => ({ ...tab, link: withBase(tab.link) })),
-                SPLIT_TABS_ENABLED: config.splitTabsEnabled,
-                HEADER_LINKS: config.header.links.map((link) => ({ ...link, link: withBase(link.link) })),
-                HEADER_LAYOUT: config.header.layout,
-                ENABLE_CLIENT_ROUTER: config.enableClientRouter,
-                API_REFERENCE_BASE_PATH: apiReferenceBasePath ?? '/api',
-                ENABLE_PROSE_MARKDOWN_RENDERING: config.enableProseMarkdownRendering,
-                ENABLE_CONTEXT_MENU: !!config.contextMenu, // TODO: do not duplicate this between both virtual modules
-                CONTEXT_MENU_ENABLE_THIRD_PARTY:
-                  (typeof config.contextMenu === 'object' ? config.contextMenu.thirdParty : null) ?? true,
-                RENDER_PAGE_DESCRIPTIONS: config.renderPageDescriptions,
-                FONTS: getFontRoles(config.fonts),
-                LINK_GROUP_TITLES_TO_OVERVIEW_PAGES: config.linkGroupTitlesToOverviewPages,
-                RENDER_CREDITS: config.credits,
-                SITE_TITLE: config.siteTitle,
-              }),
-            ].join('\n'),
-            'virtual:stl-docs-ai-chat': vmAiChatHandlerExport,
-          }),
-        );
+        const virtualModules = new Map<string, string>([
+          [
+            'virtual:stl-docs-virtual-module',
+            buildVirtualModuleString({
+              TABS: config.tabs.map((tab) => ({ ...tab, link: withBase(tab.link) })),
+              SPLIT_TABS_ENABLED: config.splitTabsEnabled,
+              HEADER_LINKS: config.header.links.map((link) => ({ ...link, link: withBase(link.link) })),
+              HEADER_LAYOUT: config.header.layout,
+              ENABLE_CLIENT_ROUTER: config.enableClientRouter,
+              API_REFERENCE_BASE_PATH: apiReferenceBasePath ?? '/api',
+              ENABLE_PROSE_MARKDOWN_RENDERING: config.enableProseMarkdownRendering,
+              ENABLE_CONTEXT_MENU: !!config.contextMenu, // TODO: do not duplicate this between both virtual modules
+              CONTEXT_MENU_ENABLE_THIRD_PARTY:
+                (typeof config.contextMenu === 'object' ? config.contextMenu.thirdParty : null) ?? true,
+              RENDER_PAGE_DESCRIPTIONS: config.renderPageDescriptions,
+              FONTS: getFontRoles(config.fonts),
+              LINK_GROUP_TITLES_TO_OVERVIEW_PAGES: config.linkGroupTitlesToOverviewPages,
+              RENDER_CREDITS: config.credits,
+              SITE_TITLE: config.siteTitle,
+            }),
+          ],
+          ['virtual:stl-docs-ai-chat', vmAiChatHandlerExport],
+        ]);
+        if (config.aiChat) {
+          virtualModules.set(
+            'virtual:stl-docs-ai-chat-examples',
+            generateExamplesVirtualModule(config.aiChat.examples),
+          );
+        }
 
         updateConfig({
           fonts: [...flattenFonts(config.fonts), ...(astroConfig?.fonts ?? [])],
@@ -239,17 +242,6 @@ function stainlessDocsIntegration(
                   if (virtualModules.has(bare)) return virtualModules.get(bare);
                 },
               },
-              // Separate plugin for the examples because it has async resolution; not a simple string
-              // like the above plugins
-              ...(config.aiChat
-                ? [
-                    await generateExamplesPlugin({
-                      projectName: config.apiReference?.stainlessProject ?? undefined,
-                      logger,
-                      exampleOverrides: config.aiChat.examples,
-                    }),
-                  ]
-                : []),
             ],
           },
           build: {
@@ -311,11 +303,6 @@ export function stainlessDocs(config: StainlessDocsUserConfig): AstroIntegration
       integration: stainlessDocsMarkdownRenderer({ apiReferenceBasePath }),
       reason: 'disabled by experimental config "disableProseMarkdownRendering"',
     }),
-    conditionalIntegration({
-      condition: !config.experimental?.disableStainlessProseIndexing,
-      integration: stainlessDocsAlgoliaProseIndexing({ apiReferenceBasePath }),
-      reason: 'disabled by experimental config "disableStainlessProseIndexing"',
-    }),
     conditionalIntegration({
       condition: !config.experimental?.disableStainlessProseIndexing,
       integration: stainlessDocsVectorProseIndexing(normalizedConfig, apiReferenceBasePath),

package/tsconfig.json

@@ -7,7 +7,7 @@
     ".stl-docs/**/*",
     "./plugin/**/*"
   ],
-  "exclude": ["dist", "**/preview.worker.docs.js"],
+  "exclude": ["dist"],
   "compilerOptions": {
     "jsx": "react-jsx",
     "jsxImportSource": "react"

package/plugin/specs/FileCache.ts

@@ -1,99 +0,0 @@
-import crypto from 'crypto';
-import path from 'path';
-import { readdir, readFile, rm, writeFile } from 'fs/promises';
-
-type CacheResultSource = 'memory' | 'disk' | 'generation';
-
-type CacheGetResult<T> = {
-  resultSource: CacheResultSource;
-  data: T;
-  filePath: string;
-};
-
-export class FileCache<Inputs extends Record<string, unknown>, Output> {
-  private memoryCache: Map<string, Output> = new Map();
-
-  private cacheDirectory: string | null = null;
-
-  public setCacheDirectory(cacheDirectory: string) {
-    this.cacheDirectory = cacheDirectory;
-  }
-  public getCacheDirectory() {
-    if (!this.cacheDirectory) {
-      console.error(`Tried to retrieve entry from cache, but no cache directory was set.`);
-      process.exit(1);
-    }
-    return this.cacheDirectory;
-  }
-
-  private hashInputs(inputs: Inputs): string {
-    return crypto
-      .createHash('sha256')
-      .update(JSON.stringify(inputs) + this.config.globalHashBits)
-      .digest('hex')
-      .slice(0, 10);
-  }
-
-  private getFileName(hash: string) {
-    return `${hash}.json`;
-  }
-
-  public async cleanupUnusedFiles() {
-    const allFiles = await readdir(this.getCacheDirectory());
-    const usedFiles = Array.from(this.memoryCache.keys()).map((key) => this.getFileName(key));
-    const unusedFiles = allFiles.filter((file) => !usedFiles.includes(file));
-    await Promise.all(unusedFiles.map((file) => rm(path.join(this.getCacheDirectory(), file))));
-    return {
-      deletedCount: unusedFiles.length,
-    };
-  }
-
-  public async get(inputs: Inputs): Promise<CacheGetResult<Output>> {
-    const hash = this.hashInputs(inputs);
-    const filePath = path.join(this.getCacheDirectory(), this.getFileName(hash));
-
-    const memoryCacheResult = this.memoryCache.get(hash);
-    if (memoryCacheResult) {
-      return {
-        resultSource: 'memory',
-        data: memoryCacheResult,
-        filePath,
-      };
-    }
-
-    const getFromFileOrGenerate = async () => {
-      try {
-        const fileContents = await readFile(filePath, 'utf8');
-        return {
-          resultSource: 'disk' as const,
-          data: JSON.parse(fileContents) as Output,
-          filePath,
-        };
-      } catch {
-        const data = await this.config.generate(inputs);
-        await writeFile(filePath, JSON.stringify(data), 'utf8');
-        return {
-          resultSource: 'generation' as const,
-          data,
-          filePath,
-        };
-      }
-    };
-
-    const result = await getFromFileOrGenerate();
-    this.memoryCache.set(hash, result.data);
-    return result;
-  }
-
-  constructor(
-    private config: {
-      /**
-       * Additional information to include in the hash of the inputs.
-       * This is useful for cases where the inputs are the same, but the global state is different.
-       * Eg: The preview worker source can be used here.
-       */
-      globalHashBits: string;
-      generate: (inputs: Inputs) => Promise<Output>;
-    },
-  ) {}
-}