diff --git a/bun.lockb b/bun.lockb
index cdd6e8eaa..b446dea7f 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/docs/integrations/sources/README.md b/docs/integrations/sources/README.md
new file mode 100644
index 000000000..d26f3f101
--- /dev/null
+++ b/docs/integrations/sources/README.md
@@ -0,0 +1,40 @@
+# Content sources 
+
+Integrations can act as sources for computing content from external sources. Use-cases include:
+
+- Translation: auto-translate another content and keeping it updated
+- Changelog
+- Code documentation
+
+
+## Flow
+
+## Create a content source
+
+First of all, content sources should be listed in the `gitbook-manifest.yaml` file, under `sources`:
+
+```yaml
+sources:
+    - id: pirate
+      title: Content as a Pirate
+```
+
+Then the content source can be implemented:
+
+```ts
+import { createContentSource } from '@gitbook/runtime';
+
+const pirate = createContentSource({
+    sourceId: 'pirate',
+    getPages: () => {
+
+    },
+    getPageDocument: () => {
+
+    }
+});
+```
+
+## Refreshing content when source has changed
+
+At the moment, an integration source can only depend on a GitBook space as a dependency. But we plan on implementing supporting for custom dependencies that can be refreshed.
diff --git a/integrations/github-copilot/src/configuration.tsx b/integrations/github-copilot/src/configuration.tsx
index 131b994a9..bad78ee2d 100644
--- a/integrations/github-copilot/src/configuration.tsx
+++ b/integrations/github-copilot/src/configuration.tsx
@@ -1,22 +1,20 @@
 import { ContentKitIcon } from '@gitbook/api';
-import { createComponent, getOAuthToken } from '@gitbook/runtime';
+import { InstallationConfigurationProps, createComponent, getOAuthToken } from '@gitbook/runtime';
 
 import { fetchGitHubInstallations } from './github';
 import { getGitHubOAuthConfiguration } from './oauth';
-import type { GitHubCopilotConfiguration, GitHubCopilotRuntimeContext } from './types';
+import type {
+    GitHubCopilotConfiguration,
+    GitHubCopilotRuntimeContext,
+    GitHubCopilotRuntimeEnvironment,
+} from './types';
 import { createGitHubSetupState } from './setup';
 
-type ConfigureProps = {
-    installation: {
-        configuration?: GitHubCopilotConfiguration;
-    };
-};
-
 /**
  * ContentKit component to configure the GitHub Copilot integration.
  */
 export const configurationComponent = createComponent<
-    ConfigureProps,
+    InstallationConfigurationProps<GitHubCopilotRuntimeEnvironment>,
     {
         installations: string[];
     },
diff --git a/integrations/openai-translate/assets/icon.png b/integrations/openai-translate/assets/icon.png
new file mode 100644
index 000000000..fc71f647c
Binary files /dev/null and b/integrations/openai-translate/assets/icon.png differ
diff --git a/integrations/openai-translate/gitbook-manifest.yaml b/integrations/openai-translate/gitbook-manifest.yaml
new file mode 100644
index 000000000..e284e2044
--- /dev/null
+++ b/integrations/openai-translate/gitbook-manifest.yaml
@@ -0,0 +1,31 @@
+name: openai-translate
+title: Translate with OpenAI
+organization: gitbook
+visibility: public
+description: Automatically generate translation content using OpenAI
+icon: ./assets/icon.png
+externalLinks:
+    - label: OpenAI Platform
+      url: https://platform.openai.com/
+categories:
+    - collaboration
+summary: |
+    # Overview
+
+    Automically generate translations of your content that are kept to date to any changes using OpenAI GPT models.
+
+    # How to use it
+
+    Install the integration on your account and grant access to the source space and the target space.
+script: src/index.ts
+scopes:
+    - space:content:read
+configurations:
+    account:
+        componentId: configure
+contentSources:
+    - id: translate
+      title: Translate with AI
+      description: Generate automatic translation from a space using AI.
+      configuration:
+          componentId: configureSource
diff --git a/integrations/openai-translate/package.json b/integrations/openai-translate/package.json
new file mode 100644
index 000000000..a7b55a0e3
--- /dev/null
+++ b/integrations/openai-translate/package.json
@@ -0,0 +1,23 @@
+{
+    "name": "@gitbook/integration-openai-translate",
+    "version": "0.0.0",
+    "private": true,
+    "scripts": {
+        "typecheck": "tsc --noEmit",
+        "check": "gitbook check",
+        "publish-integrations": "gitbook publish .",
+        "publish-integrations-staging": "gitbook publish .",
+        "logs": "gitbook tail",
+        "dev": "gitbook dev",
+        "test": "bun test"
+    },
+    "dependencies": {
+        "@gitbook/api": "*",
+        "@gitbook/runtime": "*",
+        "openai": "^4.67.1"
+    },
+    "devDependencies": {
+        "@gitbook/cli": "workspace:*",
+        "@gitbook/tsconfig": "workspace:*"
+    }
+}
diff --git a/integrations/openai-translate/src/configureComponent.tsx b/integrations/openai-translate/src/configureComponent.tsx
new file mode 100644
index 000000000..609023019
--- /dev/null
+++ b/integrations/openai-translate/src/configureComponent.tsx
@@ -0,0 +1,90 @@
+import { createComponent, InstallationConfigurationProps } from '@gitbook/runtime';
+
+import {
+    DEFAULT_MODEL,
+    type OpenAITranslateRuntimeContext,
+    type OpenAITranslateRuntimeEnvironment,
+} from './types';
+
+/**
+ * ContentKit component to configure the integration.
+ */
+export const configureComponent = createComponent<
+    InstallationConfigurationProps<OpenAITranslateRuntimeEnvironment>,
+    {
+        apiKey: string;
+        model: string;
+        apiUrl: string;
+    },
+    { action: 'save' },
+    OpenAITranslateRuntimeContext
+>({
+    componentId: 'configure',
+    initialState: (props, _, context) => {
+        return {
+            apiKey: props.installation.configuration.apiKey ?? '',
+            model: props.installation.configuration.model ?? DEFAULT_MODEL,
+            apiUrl: props.installation.configuration.apiUrl ?? '',
+        };
+    },
+    action: async (element, action, ctx) => {
+        const { integration, installation } = ctx.environment;
+        if (action.action === 'save' && installation) {
+            await ctx.api.integrations.updateIntegrationInstallation(
+                integration.name,
+                installation.id,
+                {
+                    configuration: {
+                        apiKey: element.state.apiKey,
+                        model: element.state.model,
+                        apiUrl: element.state.apiUrl,
+                    },
+                },
+            );
+        }
+
+        return element;
+    },
+    render: async (element, context) => {
+        return (
+            <block>
+                <input
+                    label="API Key"
+                    hint="OpenAI API key"
+                    element={<textinput state="apiKey" />}
+                />
+                <input
+                    label="API URL"
+                    hint="When using a custom provider or proxy, enter the URL of the OpenAI API."
+                    element={<textinput state="apiUrl" />}
+                />
+                <input
+                    label="Model"
+                    hint="Select the model to use for translation. We recommend picking powerful models like GPT-4 or GPT-4o."
+                    element={
+                        <select
+                            state="model"
+                            options={[
+                                {
+                                    id: 'gpt-4',
+                                    label: 'GPT-4',
+                                },
+                                {
+                                    id: 'gpt-4o',
+                                    label: 'GPT-4o',
+                                },
+                            ]}
+                        />
+                    }
+                />
+                <button
+                    style="primary"
+                    label="Save"
+                    onPress={{
+                        action: 'save',
+                    }}
+                />
+            </block>
+        );
+    },
+});
diff --git a/integrations/openai-translate/src/configureSourceComponent.tsx b/integrations/openai-translate/src/configureSourceComponent.tsx
new file mode 100644
index 000000000..0c78b010d
--- /dev/null
+++ b/integrations/openai-translate/src/configureSourceComponent.tsx
@@ -0,0 +1,94 @@
+import { createComponent } from '@gitbook/runtime';
+
+import type { OpenAITranslateRuntimeContext } from './types';
+
+/**
+ * ContentKit component to configure the Translation source.
+ */
+export const configureSourceComponent = createComponent<
+    {},
+    {
+        space?: string;
+        language: string;
+    },
+    void,
+    OpenAITranslateRuntimeContext
+>({
+    componentId: 'configureSource',
+    initialState: (props, _, context) => {
+        return {
+            language: 'en',
+        };
+    },
+    render: async (element, context) => {
+        const { api, environment } = context;
+        const { integration, installation } = environment;
+
+        if (!installation) {
+            throw new Error('Installation not found');
+        }
+
+        const {
+            data: { items: spaces },
+        } = await api.integrations.listIntegrationInstallationSpaces(
+            integration.name,
+            installation.id,
+        );
+        return (
+            <block>
+                <input
+                    label="Source space"
+                    hint="Select the space to translate content from."
+                    element={
+                        <select
+                            state="space"
+                            options={spaces.map((space) => ({
+                                id: space.space,
+                                label: space.space,
+                            }))}
+                        />
+                    }
+                />
+                <input
+                    label="Language"
+                    hint="Select the language to translate content to."
+                    element={
+                        <select
+                            state="language"
+                            options={[
+                                { label: 'English', id: 'en' },
+                                { label: 'French', id: 'fr' },
+                                { label: 'German', id: 'de' },
+                                { label: 'Italian', id: 'it' },
+                                { label: 'Japanese', id: 'ja' },
+                                { label: 'Korean', id: 'ko' },
+                                { label: 'Portuguese', id: 'pt' },
+                                { label: 'Russian', id: 'ru' },
+                                { label: 'Spanish', id: 'es' },
+                            ]}
+                        />
+                    }
+                />
+                <button
+                    style="primary"
+                    label="Continue"
+                    onPress={{
+                        action: '@ui.submit',
+                        returnValue: {
+                            props: {
+                                space: element.dynamicState('space'),
+                                language: element.dynamicState('language'),
+                            },
+                            dependsOn: [
+                                {
+                                    kind: 'space',
+                                    space: element.dynamicState('space'),
+                                },
+                            ],
+                        },
+                    }}
+                />
+            </block>
+        );
+    },
+});
diff --git a/integrations/openai-translate/src/index.ts b/integrations/openai-translate/src/index.ts
new file mode 100644
index 000000000..a8d14fe3e
--- /dev/null
+++ b/integrations/openai-translate/src/index.ts
@@ -0,0 +1,9 @@
+import { createIntegration } from '@gitbook/runtime';
+import { translateContentSource } from './translateContentSource';
+import { configureComponent } from './configureComponent';
+import { configureSourceComponent } from './configureSourceComponent';
+
+export default createIntegration({
+    contentSources: [translateContentSource],
+    components: [configureComponent, configureSourceComponent],
+});
diff --git a/integrations/openai-translate/src/openai.ts b/integrations/openai-translate/src/openai.ts
new file mode 100644
index 000000000..17a9ce103
--- /dev/null
+++ b/integrations/openai-translate/src/openai.ts
@@ -0,0 +1,82 @@
+import { OpenAI } from 'openai';
+import { ExposableError } from '@gitbook/runtime';
+import { OpenAITranslateRuntimeContext } from './types';
+import { deepExtract, deepMerge } from './utils';
+
+/**
+ * Get the OpenAI client associated with the current runtime context.
+ */
+export function getOpenAI(ctx: OpenAITranslateRuntimeContext): OpenAI {
+    const apiKey = ctx.environment.installation?.configuration.apiKey;
+    if (!apiKey) {
+        throw new ExposableError('OpenAI API key is missing');
+    }
+    return new OpenAI({
+        apiKey,
+        baseURL: 'https://gateway.ai.cloudflare.com/v1/4401d86825a13bf607936cc3a9f3897a/integrations/openai' // ctx.environment.installation?.configuration.apiUrl,
+    });
+}
+
+const languageNames: Record<string, string> = {
+    en: 'English',
+    it: 'Italian',
+    fr: 'French',
+    es: 'Spanish',
+    de: 'German',
+    pt: 'Portuguese',
+    ru: 'Russian',
+    ja: 'Japanese',
+    ko: 'Korean',
+};
+
+/**
+ * Translate a JSON object using OpenAI, by indicating the properties that can be translated.
+ */
+export async function translateJSON<T extends object>(
+    ctx: OpenAITranslateRuntimeContext,
+    language: string,
+    object: T,
+    properties: string[],
+): Promise<T> {
+    // To optimize AI performances, we want to pass a minimal JSON structure to it.
+    const partial = deepExtract(object, (input) => {
+        return properties.reduce(
+            (acc, prop) => {
+                if (prop in input && typeof input[prop] === 'string' && input[prop].length > 0) {
+                    acc[prop] = input[prop];
+                }
+                return acc;
+            },
+            {} as { [key: string]: string },
+        );
+    });
+
+    const openai = getOpenAI(ctx);
+    const result = await openai.chat.completions.create({
+        model: 'gpt-4o-mini', // ctx.environment.installation?.configuration.model ??
+        messages: [
+            {
+                role: 'system',
+                content: [
+                    'You are an AI that can translate JSON input, a powerful language model designed for seamless translation of text across multiple languages.',
+                    `You excel at generating structured data in JSON format and follow this rules: you never translate the key, you always use the double quotes to surround key and value, you always escape single quotes and backslashes contained in the value, you never write a comma at the end of the last row in the file.`,
+                    `Translate the following JSON input into ${languageNames[language] ?? language} while preserving its structure. Only the properties ${properties.map((prop) => JSON.stringify(prop)).join(', ')} can be translated and will be modified.`,
+                ].join('\n'),
+            },
+            {
+                role: 'user',
+                content: JSON.stringify(partial),
+            },
+        ],
+        response_format: {
+            type: 'json_object',
+        },
+    });
+
+    try {
+        const translated = JSON.parse(result.choices[0].message.content!);
+        return deepMerge(object, translated);
+    } catch (error) {
+        throw new ExposableError('Failed to translate content: ' + (error as Error).message);
+    }
+}
diff --git a/integrations/openai-translate/src/translateContentSource.ts b/integrations/openai-translate/src/translateContentSource.ts
new file mode 100644
index 000000000..1e157a140
--- /dev/null
+++ b/integrations/openai-translate/src/translateContentSource.ts
@@ -0,0 +1,139 @@
+import { createContentSource } from '@gitbook/runtime';
+import { OpenAITranslateRuntimeContext } from './types';
+import { translateJSON } from './openai';
+import {
+    InputPageComputed,
+    InputPageDocument,
+    InputPageGroup,
+    InputPageLink,
+    Revision,
+    RevisionPageComputed,
+    RevisionPageDocument,
+    RevisionPageGroup,
+    RevisionPageLink,
+} from '@gitbook/api';
+
+type TranslateProps = {
+    /** Language to translate to */
+    language: string;
+    /** ID of the space */
+    space: string;
+};
+
+type TranslateDocumentProps = TranslateProps & {
+    /** ID of the origin document in the source space */
+    document: string;
+};
+
+/**
+ * Content source that translates pages from an origin space into a given language.
+ */
+export const translateContentSource = createContentSource<
+    TranslateProps | TranslateDocumentProps,
+    OpenAITranslateRuntimeContext
+>({
+    sourceId: 'translate',
+    getRevision: async (input, ctx) => {
+        const { data: revision } = await ctx.api.spaces.getCurrentRevision(input.props.space);
+        const pages = getInputsFromRevision(ctx, input.props, revision);
+
+        const translated = await translateJSON(
+            ctx,
+            input.props.language,
+            {
+                pages,
+            },
+            ['title', 'description'],
+        );
+
+        return {
+            pages: translated.pages,
+            files: revision.files,
+        };
+    },
+    getPageDocument: async (input, ctx) => {
+        if (!('document' in input.props)) {
+            return;
+        }
+
+        const { data: document } = await ctx.api.spaces.getDocumentById(
+            input.props.space,
+            input.props.document,
+        );
+
+        const translated = await translateJSON(ctx, input.props.language, document, ['text']);
+        return { document: translated };
+    },
+});
+
+function getInputsFromRevision(
+    ctx: OpenAITranslateRuntimeContext,
+    inputProps: TranslateProps,
+    revision: Revision,
+) {
+    return getInputsFromPages(ctx, inputProps, revision.pages);
+}
+
+function getInputsFromPages(
+    ctx: OpenAITranslateRuntimeContext,
+    inputProps: TranslateProps,
+    pages: Array<
+        RevisionPageGroup | RevisionPageLink | RevisionPageDocument | RevisionPageComputed
+    >,
+) {
+    return pages.map((page) => getInputFromPage(ctx, inputProps, page));
+}
+
+function getInputFromPage(
+    ctx: OpenAITranslateRuntimeContext,
+    inputProps: TranslateProps,
+    page: RevisionPageGroup | RevisionPageLink | RevisionPageDocument | RevisionPageComputed,
+): InputPageDocument | InputPageGroup | InputPageLink | InputPageComputed {
+    switch (page.type) {
+        case 'document':
+            return {
+                type: 'document',
+                id: page.id,
+                title: page.title,
+                slug: page.slug,
+                description: page.description,
+                pages: getInputsFromPages(ctx, inputProps, page.pages) as Array<
+                    InputPageDocument | InputPageLink | InputPageComputed
+                >,
+                computed: page.documentId
+                    ? {
+                          integration: ctx.environment.integration.name,
+                          source: 'translate',
+                          props: {
+                              ...inputProps,
+                              document: page.documentId,
+                          },
+                      }
+                    : undefined,
+            };
+        case 'group':
+            return {
+                type: 'group',
+                id: page.id,
+                title: page.title,
+                slug: page.slug,
+                pages: getInputsFromPages(ctx, inputProps, page.pages) as Array<
+                    InputPageDocument | InputPageLink | InputPageComputed
+                >,
+            };
+        case 'link':
+            return {
+                type: 'link',
+                id: page.id,
+                title: page.title,
+                target: page.target,
+            };
+        case 'computed':
+            return {
+                type: 'computed',
+                id: page.id,
+                title: page.title,
+                computed: page.computed,
+            };
+    }
+}
diff --git a/integrations/openai-translate/src/types.ts b/integrations/openai-translate/src/types.ts
new file mode 100644
index 000000000..c46a61260
--- /dev/null
+++ b/integrations/openai-translate/src/types.ts
@@ -0,0 +1,26 @@
+import type { RuntimeContext, RuntimeEnvironment } from '@gitbook/runtime';
+
+export const DEFAULT_MODEL = 'gpt-4o';
+
+export type OpenAITranslateConfiguration = {
+    /**
+     * API key for OpenAI.
+     */
+    apiKey?: string;
+
+    /**
+     * URL of the OpenAI API.
+     */
+    apiUrl?: string;
+
+    /**
+     * Model to use for translation.
+     */
+    model?: string;
+};
+
+export type OpenAITranslateRuntimeEnvironment = RuntimeEnvironment<
+    OpenAITranslateConfiguration,
+    {}
+>;
+export type OpenAITranslateRuntimeContext = RuntimeContext<OpenAITranslateRuntimeEnvironment>;
diff --git a/integrations/openai-translate/src/utils.test.ts b/integrations/openai-translate/src/utils.test.ts
new file mode 100644
index 000000000..6e50396b8
--- /dev/null
+++ b/integrations/openai-translate/src/utils.test.ts
@@ -0,0 +1,87 @@
+import { describe, it, expect } from 'bun:test';
+import { deepExtract, deepMerge } from './utils';
+
+describe('deepMerge', () => {
+    it('should replace values', () => {
+        expect(deepMerge({ a: 1 }, { a: 2 })).toEqual({ a: 2 });
+    });
+
+    it('should preserve other values', () => {
+        expect(deepMerge({ a: 1, c: 3 }, { a: 2 })).toEqual({ a: 2, c: 3 });
+    });
+
+    it('should recurse over objects', () => {
+        expect(deepMerge({ a: { b: 1, c: 3 } }, { a: { b: 2 } })).toEqual({ a: { b: 2, c: 3 } });
+    });
+
+    it('should recurse over array', () => {
+        expect(
+            deepMerge({ a: [{ b: 1 }, { b: 2 }, { b: 3 }] }, { a: [{ b: 4 }, { b: 5 }, { b: 6 }] }),
+        ).toEqual({ a: [{ b: 4 }, { b: 5 }, { b: 6 }] });
+    });
+});
+
+it('should merge back as expected', () => {
+    const inputs = {
+        pages: [
+            {
+                id: '1',
+                title: 'title 1',
+                description: 'description 1',
+                pages: [
+                    {
+                        id: '2',
+                        title: 'title 2',
+                        description: 'description 2',
+                        pages: [
+                            {
+                                id: '3',
+                                title: 'title 3',
+                                description: 'description 3',
+                                pages: [],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+
+    const extracted = deepExtract(inputs, (input) => {
+        return {
+            ...('title' in input ? { title: input.title } : {}),
+            ...('description' in input ? { description: input.description } : {}),
+        };
+    });
+
+    expect(extracted).toEqual({
+        pages: [
+            {
+                title: 'title 1',
+                description: 'description 1',
+                pages: [
+                    {
+                        title: 'title 2',
+                        description: 'description 2',
+                        pages: [
+                            {
+                                title: 'title 3',
+                                description: 'description 3',
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    });
+
+    // Test with an a non-modified extracted object
+    const merged = deepMerge(inputs, extracted);
+    expect(merged).toEqual(inputs);
+
+    // Modify the extracted object
+    extracted.pages[0].title = 'new title';
+    const merged2 = deepMerge(inputs, extracted);
+    expect(merged2).not.toEqual(inputs);
+    expect(merged2.pages[0].title).toEqual('new title');
+});
diff --git a/integrations/openai-translate/src/utils.ts b/integrations/openai-translate/src/utils.ts
new file mode 100644
index 000000000..1be4caa5b
--- /dev/null
+++ b/integrations/openai-translate/src/utils.ts
@@ -0,0 +1,82 @@
+import { PlainObject } from '@gitbook/api';
+
+/**
+ * Top optimize AI performances, we want to pass a minimal JSON structure to it.
+ * To do so we we extract only the parts we care about from the JSON structure.
+ */
+export function deepExtract<T extends PlainObject>(
+    input: T,
+    extract: (input: PlainObject) => PlainObject,
+): any {
+    const keys = Object.keys(input as object);
+    const output = extract(input);
+
+    const mapValue = (value: any): any => {
+        if (Array.isArray(value)) {
+            return value.map((item) => {
+                return mapValue(item);
+            });
+        }
+        if (typeof value === 'object') {
+            return deepExtract(value, extract);
+        }
+        return value;
+    };
+
+    for (const key of keys) {
+        // @ts-ignore
+        const value: any = input[key];
+
+        if (Array.isArray(value)) {
+            const result = mapValue(value);
+            if (result.length > 0) {
+                output[key] = result;
+            }
+        } else if (value && typeof value === 'object') {
+            const result = mapValue(value);
+            if (Object.keys(result).length > 0) {
+                output[key] = result;
+            }
+        }
+    }
+
+    return output;
+}
+
+/**
+ * Annotate the JSON structure with the annotations splitted from `deepExtract`.
+ */
+export function deepMerge<T extends PlainObject>(input: T, extracted: object): T {
+    const keys = Object.keys(input as object);
+    // @ts-ignore
+    const result = { ...input };
+
+    const mergeValues = (value: any, extractedValue: any): any => {
+        if (Array.isArray(value)) {
+            return value.map((item, index) => {
+                const other = extractedValue?.[index];
+                if (other === undefined || other === null) {
+                    return item;
+                }
+                return mergeValues(item, other);
+            });
+        }
+        if (typeof value === 'object') {
+            return deepMerge(value, extractedValue);
+        }
+        return extractedValue;
+    };
+
+    for (const key of keys) {
+        // @ts-ignore
+        const extractedValue = extracted[key];
+
+        if (extractedValue === undefined || extractedValue === null) {
+            continue;
+        }
+
+        result[key] = mergeValues(result[key], extractedValue);
+    }
+
+    return result;
+}
diff --git a/integrations/openai-translate/tsconfig.json b/integrations/openai-translate/tsconfig.json
new file mode 100644
index 000000000..976b65989
--- /dev/null
+++ b/integrations/openai-translate/tsconfig.json
@@ -0,0 +1,9 @@
+{
+    "extends": "@gitbook/tsconfig/integration.json",
+    "compilerOptions": {
+        "strict": true,
+        "lib": ["ESNext", "DOM"],
+        "downlevelIteration": true,
+        "types": ["bun"]
+    }
+}
diff --git a/packages/cli/src/manifest.ts b/packages/cli/src/manifest.ts
index b4649a1a9..f465cf412 100644
--- a/packages/cli/src/manifest.ts
+++ b/packages/cli/src/manifest.ts
@@ -63,6 +63,14 @@ const IntegrationManifestBlock = z.object({
         .optional(),
 });
 
+const IntegrationManifestContentSource = z.object({
+    id: z.string(),
+    title: z.string().min(2).max(40),
+    description: z.string().min(0).max(150).optional(),
+    icon: z.string().optional(),
+    configuration: IntegrationManifestConfigurationComponent.optional(),
+});
+
 const IntegrationManifestSchema = z.object({
     name: z.string(),
     title: z.string(),
@@ -74,6 +82,7 @@ const IntegrationManifestSchema = z.object({
     scopes: z.array(z.nativeEnum(api.IntegrationScope)),
     categories: z.array(z.nativeEnum(api.IntegrationCategory)).optional(),
     blocks: z.array(IntegrationManifestBlock).optional(),
+    contentSources: z.array(IntegrationManifestContentSource).optional(),
     configurations: z
         .object({
             account: IntegrationManifestConfiguration.optional(),
diff --git a/packages/cli/src/publish.ts b/packages/cli/src/publish.ts
index 60cbd19ac..e0a601e26 100644
--- a/packages/cli/src/publish.ts
+++ b/packages/cli/src/publish.ts
@@ -40,6 +40,7 @@ export async function publishIntegration(
         categories: manifest.categories,
         blocks: manifest.blocks,
         configurations: manifest.configurations,
+        contentSources: manifest.contentSources,
         secrets: manifest.secrets,
         visibility: manifest.visibility,
         target: manifest.target,
diff --git a/packages/runtime/src/common.ts b/packages/runtime/src/common.ts
new file mode 100644
index 000000000..1320c2038
--- /dev/null
+++ b/packages/runtime/src/common.ts
@@ -0,0 +1,11 @@
+type PlainObjectValue =
+    | number
+    | string
+    | boolean
+    | PlainObject
+    | undefined
+    | null
+    | PlainObjectValue[];
+export type PlainObject = {
+    [key: string]: PlainObjectValue;
+};
diff --git a/packages/runtime/src/components.ts b/packages/runtime/src/components.ts
index 64e4b0735..b364c39be 100644
--- a/packages/runtime/src/components.ts
+++ b/packages/runtime/src/components.ts
@@ -6,24 +6,38 @@ import {
     ContentKitDefaultAction,
 } from '@gitbook/api';
 
-import { RuntimeCallback, RuntimeContext } from './context';
-
-type PlainObjectValue =
-    | number
-    | string
-    | boolean
-    | PlainObject
-    | undefined
-    | null
-    | PlainObjectValue[];
-type PlainObject = {
-    [key: string]: PlainObjectValue;
+import { RuntimeCallback, RuntimeEnvironment, RuntimeContext } from './context';
+import { PlainObject } from './common';
+
+/**
+ * Props for an installation configuration component.
+ */
+export type InstallationConfigurationProps<Env extends RuntimeEnvironment> = {
+    installation: {
+        configuration: Env extends RuntimeEnvironment<infer Config, any> ? Config : never;
+    };
 };
 
+/**
+ * Props for an installation configuration component.
+ */
+export type SpaceInstallationConfigurationProps<Env extends RuntimeEnvironment> =
+    InstallationConfigurationProps<Env> & {
+        spaceInstallation: {
+            configuration?: Env extends RuntimeEnvironment<any, infer Config> ? Config : never;
+        };
+    };
+
+/**
+ * Cache configuration for the output of a component.
+ */
 export interface ComponentRenderCache {
     maxAge: number;
 }
 
+/**
+ * Instance of a component, passed to the `render` and `action` function.
+ */
 export interface ComponentInstance<Props extends PlainObject, State extends PlainObject> {
     props: Props;
     state: State;
@@ -40,6 +54,9 @@ export interface ComponentInstance<Props extends PlainObject, State extends Plai
     dynamicState<Key extends keyof State>(key: Key): { $state: Key };
 }
 
+/**
+ * Definition of a component. Exported from `createComponent` and should be passed to `components` in the integration.
+ */
 export interface ComponentDefinition<Context extends RuntimeContext = RuntimeContext> {
     componentId: string;
     render: RuntimeCallback<[UIRenderEvent], Promise<Response>, Context>;
diff --git a/packages/runtime/src/contentSources.ts b/packages/runtime/src/contentSources.ts
new file mode 100644
index 000000000..7528641fa
--- /dev/null
+++ b/packages/runtime/src/contentSources.ts
@@ -0,0 +1,84 @@
+import {
+    ContentComputeDocumentEvent,
+    ContentComputeRevisionEventResponse,
+    ContentComputeRevisionEvent,
+    Document,
+} from '@gitbook/api';
+import { PlainObject } from './common';
+import { RuntimeCallback, RuntimeContext } from './context';
+
+export interface ContentSourceDefinition<Context extends RuntimeContext = RuntimeContext> {
+    sourceId: string;
+    compute: RuntimeCallback<
+        [ContentComputeRevisionEvent | ContentComputeDocumentEvent],
+        Promise<Response>,
+        Context
+    >;
+}
+
+/**
+ * Create a content source. The result should be bind to the integration using `contentSources`.
+ */
+export function createContentSource<
+    Props extends PlainObject = {},
+    Context extends RuntimeContext = RuntimeContext,
+>(source: {
+    /**
+     * ID of the source, referenced in the YAML file.
+     */
+    sourceId: string;
+
+    /**
+     * Callback to generate the pages.
+     */
+    getRevision: RuntimeCallback<
+        [
+            {
+                props: Props;
+            },
+        ],
+        Promise<ContentComputeRevisionEventResponse>,
+        Context
+    >;
+
+    /**
+     * Callback to generate the document of a page.
+     */
+    getPageDocument: RuntimeCallback<
+        [
+            {
+                props: Props;
+            },
+        ],
+        Promise<Document | void>,
+        Context
+    >;
+}): ContentSourceDefinition<Context> {
+    return {
+        sourceId: source.sourceId,
+        compute: async (event, context) => {
+            const output =
+                event.type === 'content_compute_revision'
+                    ? await source.getRevision(
+                          {
+                              props: event.props as Props,
+                          },
+                          context,
+                      )
+                    : {
+                          document: await source.getPageDocument(
+                              {
+                                  props: event.props as Props,
+                              },
+                              context,
+                          ),
+                      };
+
+            return new Response(JSON.stringify(output), {
+                headers: {
+                    'content-type': 'application/json',
+                },
+            });
+        },
+    };
+}
diff --git a/packages/runtime/src/index.ts b/packages/runtime/src/index.ts
index dbeea2148..87d7bec59 100644
--- a/packages/runtime/src/index.ts
+++ b/packages/runtime/src/index.ts
@@ -5,5 +5,6 @@ export * from './events';
 export * from './context';
 export * from './logger';
 export * from './errors';
+export * from './contentSources';
 export type * from './jsx-runtime';
 export type * from './global';
diff --git a/packages/runtime/src/integrations.ts b/packages/runtime/src/integrations.ts
index ed2484be8..b40e2ea10 100644
--- a/packages/runtime/src/integrations.ts
+++ b/packages/runtime/src/integrations.ts
@@ -10,6 +10,7 @@ import {
 } from './events';
 import { Logger } from './logger';
 import { ExposableError } from './errors';
+import { ContentSourceDefinition } from './contentSources';
 
 const logger = Logger('integrations');
 
@@ -39,6 +40,11 @@ interface IntegrationRuntimeDefinition<Context extends RuntimeContext = RuntimeC
      * Components to expose in the integration.
      */
     components?: Array<ComponentDefinition<Context>>;
+
+    /**
+     * Content sources to expose in the integration.
+     */
+    contentSources?: Array<ContentSourceDefinition<Context>>;
 }
 
 /**
@@ -47,7 +53,7 @@ interface IntegrationRuntimeDefinition<Context extends RuntimeContext = RuntimeC
 export function createIntegration<Context extends RuntimeContext = RuntimeContext>(
     definition: IntegrationRuntimeDefinition<Context>,
 ) {
-    const { events = {}, components = [] } = definition;
+    const { events = {}, components = [], contentSources = [] } = definition;
 
     /**
      * Handle a fetch event sent by the integration dispatcher.
@@ -161,6 +167,17 @@ export function createIntegration<Context extends RuntimeContext = RuntimeContex
                     return await component.render(event, context);
                 }
 
+                case 'content_compute_revision':
+                case 'content_compute_document': {
+                    const contentSource = contentSources.find((c) => c.sourceId === event.sourceId);
+
+                    if (!contentSource) {
+                        throw new ExposableError(`Content source ${event.sourceId} not found`, 404);
+                    }
+
+                    return await contentSource.compute(event, context);
+                }
+
                 default: {
                     const cb = events[event.type];
 
@@ -178,10 +195,10 @@ export function createIntegration<Context extends RuntimeContext = RuntimeContex
                         return new Response('OK', { status: 200 });
                     }
 
-                    logger.info(`integration does not handle ${event.type} events`);
-                    return new Response(`Integration does not handle ${event.type} events`, {
-                        status: 200,
-                    });
+                    throw new ExposableError(
+                        `Integration does not handle "${event.type}" events`,
+                        406,
+                    );
                 }
             }
         } catch (err) {