openai_browser.module

<?php

/**
 * @file
 * Hook implementations for the OpenAI Browser Provider module.
 */

/**
 * Implements hook_openai_provider_info().
 */
function openai_browser_openai_provider_info() {
  return [
    'browser' => [
      'label' => t('Browser Client'),
      'description' => t('Provides the possibility to trigger AI from the browser - currently Google Chrome with the LanguageModel/Translation/Summarizer APIs enabled.'),
      'class' => 'BrowserAdapter',
      'website' => 'https://developer.chrome.com/docs/ai/prompt-api',
    ],
  ];
}

/**
 * Implements hook_config_info().
 */
function openai_browser_config_info() {
  return [
    'openai_browser.settings' => [
      'label' => t('OpenAI Browser Settings'),
      'group' => t('Configuration'),
    ],
  ];
}

/**
 * Return normalized browser provider configuration.
 *
 * The OpenAI settings form stores provider settings under
 * `providers[browser_settings]`. Nested fieldsets such as `browser_features`
 * and `browser_download_messages` can therefore end up saved as nested arrays.
 * This helper flattens those legacy/nested values so the runtime code and the
 * adapter can read a consistent structure.
 *
 * @param array|null $provider_config
 *   Optional raw provider config to normalize. When omitted, the config is
 *   loaded from `openai.settings`.
 *
 * @return array
 *   Normalized provider configuration.
 */
function openai_browser_get_provider_config(?array $provider_config = NULL) {
  if ($provider_config === NULL) {
    $providers_root = config_get('openai.settings', 'providers') ?: [];
    $provider_config = !empty($providers_root['browser']) && is_array($providers_root['browser']) ? $providers_root['browser'] : [];
  }

  $provider_config = is_array($provider_config) ? $provider_config : [];
  $features = !empty($provider_config['browser_features']) && is_array($provider_config['browser_features']) ? $provider_config['browser_features'] : [];
  $download_messages = !empty($provider_config['browser_download_messages']) && is_array($provider_config['browser_download_messages']) ? $provider_config['browser_download_messages'] : [];

  foreach (['browser_enable_chat', 'browser_enable_translate', 'browser_enable_summarize'] as $key) {
    if (!isset($provider_config[$key]) && isset($features[$key])) {
      $provider_config[$key] = $features[$key];
    }
  }

  foreach (['browser_download_message_chat', 'browser_download_message_summarize', 'browser_download_message_translate'] as $key) {
    if (!isset($provider_config[$key]) && isset($download_messages[$key])) {
      $provider_config[$key] = $download_messages[$key];
    }
  }

  return $provider_config;
}

/**
 * Determine whether the browser provider is enabled globally.
 *
 * @param array|null $provider_config
 *   Optional normalized provider configuration.
 *
 * @return bool
 *   TRUE when the provider is enabled in OpenAI settings.
 */
function openai_browser_is_enabled(?array $provider_config = NULL) {
  $provider_config = openai_browser_get_provider_config($provider_config);

  return !empty($provider_config['enabled']);
}

/**
 * Determine whether the current user can use a browser operation.
 *
 * @param string $operation
 *   One of: chat, translate, summarize.
 * @param array|null $provider_config
 *   Optional normalized provider configuration.
 *
 * @return bool
 *   TRUE when the provider is enabled and the feature is enabled.
 */
function openai_browser_user_can_use($operation, ?array $provider_config = NULL) {
  $provider_config = openai_browser_get_provider_config($provider_config);

  if (!openai_browser_is_enabled($provider_config)) {
    return FALSE;
  }

  $operation_map = [
    'chat' => [
      'config' => 'browser_enable_chat',
      'permission' => 'use browser ai chat',
    ],
    'translate' => [
      'config' => 'browser_enable_translate',
      'permission' => 'use browser ai translate',
    ],
    'summarize' => [
      'config' => 'browser_enable_summarize',
      'permission' => 'use browser ai summarize',
    ],
  ];

  if (empty($operation_map[$operation])) {
    return FALSE;
  }

  return !empty($provider_config[$operation_map[$operation]['config']]) && user_access($operation_map[$operation]['permission']);
}

/**
 * Ensure the PHP session is available for browser-provider request storage.
 */
function openai_browser_ensure_session() {
  if (session_status() !== PHP_SESSION_ACTIVE) {
    // If Backdrop's static flag is still set but PHP says the session is
    // inactive, it means the session was closed via session_write_close().
    // We must reset the flag to force a real re-open with fresh data.
    if (function_exists('backdrop_session_started') && backdrop_session_started()) {
      backdrop_session_started(FALSE);
      // Clear the current stale session array so backdrop_session_start()
      // doesn't merge old local data over the fresh database values.
      $_SESSION = [];
    }
    backdrop_session_start();
  }
}

/**
 * Implements hook_openai_provider_settings_alter().
 *
 * Adds browser-specific settings to the main OpenAI settings form.
 */
function openai_browser_openai_provider_settings_alter(&$settings, $context) {
  // Only add settings if Browser is the selected provider
  if ($context['provider'] !== 'browser') {
    return;
  }

  $provider_config = openai_browser_get_provider_config();

  $settings['browser_timeout'] = [
    '#type' => 'number',
    '#title' => t('Timeout (seconds)'),
    '#default_value' => isset($provider_config['browser_timeout']) ? $provider_config['browser_timeout'] : 120,
    '#min' => 1,
    '#description' => t('Maximum time to wait for a response from the browser AI provider.'),
    '#required' => TRUE,
    '#weight' => 0,
  ];

  $settings['browser_polling_interval'] = [
    '#type' => 'number',
    '#title' => t('Polling Interval (seconds)'),
    '#default_value' => isset($provider_config['browser_polling_interval']) ? $provider_config['browser_polling_interval'] : 5,
    '#min' => 1,
    '#description' => t('Interval between polling attempts when checking for a response.'),
    '#required' => TRUE,
    '#weight' => 1,
  ];

  $settings['browser_foreground_only'] = [
    '#type' => 'checkbox',
    '#title' => t('Only poll in foreground'),
    '#default_value' => isset($provider_config['browser_foreground_only']) ? $provider_config['browser_foreground_only'] : TRUE,
    '#description' => t('When checked, polling for AI requests will pause when the browser tab is not in focus. This reduces unnecessary network requests from background tabs.'),
    '#weight' => 2,
  ];

  $settings['browser_features'] = [
    '#type' => 'fieldset',
    '#title' => t('Enabled Browser AI Features'),
    '#description' => t('Enable or disable specific browser-native AI APIs.'),
    '#weight' => 3,
  ];

  $settings['browser_features']['browser_enable_chat'] = [
    '#type' => 'checkbox',
    '#title' => t('Enable Chat/Prompt'),
    '#default_value' => isset($provider_config['browser_enable_chat']) ? $provider_config['browser_enable_chat'] : TRUE,
    '#description' => t('Enable or disable the chat/prompt browser provider. Users also need the "Use Browser AI Chat/Prompt" permission.'),
  ];

  $settings['browser_features']['browser_enable_translate'] = [
    '#type' => 'checkbox',
    '#title' => t('Enable Translate'),
    '#default_value' => isset($provider_config['browser_enable_translate']) ? $provider_config['browser_enable_translate'] : FALSE,
    '#description' => t('Enable or disable the translate browser provider. Users also need the "Use Browser AI Translate" permission.'),
  ];

  $settings['browser_features']['browser_enable_summarize'] = [
    '#type' => 'checkbox',
    '#title' => t('Enable Summarize'),
    '#default_value' => isset($provider_config['browser_enable_summarize']) ? $provider_config['browser_enable_summarize'] : FALSE,
    '#description' => t('Enable or disable the summarize browser provider. Users also need the "Use Browser AI Summarize" permission.'),
  ];

  $settings['browser_download_messages'] = [
    '#type' => 'fieldset',
    '#title' => t('Download Messages'),
    '#collapsible' => TRUE,
    '#collapsed' => TRUE,
    '#weight' => 10,
  ];

  $settings['browser_download_messages']['browser_download_message_chat'] = [
    '#type' => 'textarea',
    '#title' => t('Chat Model Download Message'),
    '#default_value' => isset($provider_config['browser_download_message_chat']) ? $provider_config['browser_download_message_chat'] : t('The browser AI provider requires downloading a language model to function. This is a one-time download.'),
    '#rows' => 2,
  ];

  $settings['browser_download_messages']['browser_download_message_summarize'] = [
    '#type' => 'textarea',
    '#title' => t('Summarization Model Download Message'),
    '#default_value' => isset($provider_config['browser_download_message_summarize']) ? $provider_config['browser_download_message_summarize'] : t('The browser AI provider requires downloading the summarization model. This is a one-time download.'),
    '#rows' => 2,
  ];

  $settings['browser_download_messages']['browser_download_message_translate'] = [
    '#type' => 'textarea',
    '#title' => t('Translation Language Pack Download Message'),
    '#default_value' => isset($provider_config['browser_download_message_translate']) ? $provider_config['browser_download_message_translate'] : t('A language pack is needed for translation. This is a one-time download.'),
    '#rows' => 2,
  ];

  // Add custom submit handler to normalize nested browser settings into the
  // flat structure expected by the runtime code.
  if (isset($context['form'])) {
    $context['form']['#submit'][] = 'openai_browser_settings_submit';
  }
}

/**
 * Custom submit handler to save browser-specific settings.
 */
function openai_browser_settings_submit($form, &$form_state) {
  $central = config('openai.settings');
  $providers = $central->get('providers') ?: [];
  if (!isset($providers['browser']) || !is_array($providers['browser'])) {
    $providers['browser'] = [];
  }

  $providers_values = !empty($form_state['values']['providers']) && is_array($form_state['values']['providers']) ? $form_state['values']['providers'] : [];
  $browser_settings = !empty($providers_values['browser_settings']) && is_array($providers_values['browser_settings']) ? $providers_values['browser_settings'] : [];
  $browser_settings = openai_browser_get_provider_config($browser_settings);

  $providers['browser']['enabled'] = !empty($providers_values['enabled_providers_browser']) ? 1 : 0;

  $flat_fields = [
    'browser_timeout',
    'browser_polling_interval',
    'browser_foreground_only',
    'browser_enable_chat',
    'browser_enable_translate',
    'browser_enable_summarize',
    'browser_download_message_chat',
    'browser_download_message_summarize',
    'browser_download_message_translate',
  ];

  foreach ($flat_fields as $config_key) {
    if (isset($browser_settings[$config_key])) {
      $providers['browser'][$config_key] = $browser_settings[$config_key];
    }
  }

  unset($providers['browser']['browser_enabled'], $providers['browser']['browser_features'], $providers['browser']['browser_download_messages']);

  $central->set('providers', $providers);
  $central->save();
}

/**
 * Implements hook_autoload_info().
 */
function openai_browser_autoload_info() {
  return [
    'BrowserAdapter' => 'includes/BrowserAdapter.php',
  ];
}

/**
 * Implements hook_menu().
 */
function openai_browser_menu() {
  $items = [];

  // Poll for requests.
  $items['openai-browser/poll'] = [
    'title' => 'Poll for requests',
    'page callback' => 'openai_browser_poll_page',
    'access callback' => 'openai_browser_access_check',
    'type' => MENU_CALLBACK,
  ];

  // Submit result.
  $items['openai-browser/submit'] = [
    'title' => 'Submit result',
    'page callback' => 'openai_browser_submit_page',
    'access callback' => 'openai_browser_access_check',
    'type' => MENU_CALLBACK,
  ];

  return $items;
}

/**
 * Access check callback for browser AI endpoints.
 */
function openai_browser_access_check() {
  $provider_config = openai_browser_get_provider_config();

  $access = openai_browser_user_can_use('chat', $provider_config)
    || openai_browser_user_can_use('translate', $provider_config)
    || openai_browser_user_can_use('summarize', $provider_config);

  if (!$access) {
    global $user;
    // Help debug why the browser client might be failing to poll.
    watchdog('openai_browser', 'Access denied to browser AI endpoint for user @uid. If this is 0, the session is likely being lost.', [
      '@uid' => $user->uid,
    ], WATCHDOG_DEBUG);
  }

  return $access;
}

/**
 * Implements hook_permission().
 */
function openai_browser_permission() {
  return [
    'use browser ai chat' => [
      'title' => t('Use Browser AI Chat/Prompt'),
      'description' => t('Allows the user to process Chat/Prompt requests using their browser\'s native APIs.'),
    ],
    'use browser ai translate' => [
      'title' => t('Use Browser AI Translate'),
      'description' => t('Allows the user to process translation requests using their browser\'s native APIs.'),
    ],
    'use browser ai summarize' => [
      'title' => t('Use Browser AI Summarize'),
      'description' => t('Allows the user to process summarization requests using their browser\'s native APIs.'),
    ],
  ];
}

/**
 * Page callback: Poll for pending requests.
 */
function openai_browser_poll_page() {
  openai_browser_ensure_session();

  $requests = [];
  if (isset($_SESSION['openai_browser_requests'])) {
    $provider_config = openai_browser_get_provider_config();
    $timeout = !empty($provider_config['browser_timeout']) ? (int) $provider_config['browser_timeout'] : 60;

    foreach ($_SESSION['openai_browser_requests'] as $uuid => $request) {
      $created = !empty($request['created']) ? (int) $request['created'] : 0;

      // Remove requests that are so old the PHP waiter has definitely already
      // timed out and abandoned them (2× timeout as a safe margin). These are
      // zombie requests that would loop forever without this cleanup.
      if ($created && (REQUEST_TIME - $created > $timeout * 2)) {
        unset($_SESSION['openai_browser_requests'][$uuid]);
        cache_clear_all('openai_browser_seen:' . $uuid, 'cache');
        cache_clear_all('openai_browser_result:' . $uuid, 'cache');
        continue;
      }

      // Skip requests that are currently being processed by the browser client.
      // A request is considered in-flight until it has been seen within the
      // active timeout window. This prevents the same request from being
      // re-processed on every subsequent poll, which would cause duplicate
      // results and confusing error/success pairs in the watchdog log.
      if (!empty($request['browser_seen']) && (REQUEST_TIME - $request['browser_seen'] < $timeout)) {
        continue;
      }

      // Mark as seen and include in the response.
      $_SESSION['openai_browser_requests'][$uuid]['browser_seen'] = REQUEST_TIME;
      $requests[$uuid] = $_SESSION['openai_browser_requests'][$uuid];

      // Also update cache for more reliable concurrent signaling.
      cache_set('openai_browser_seen:' . $uuid, REQUEST_TIME, 'cache', REQUEST_TIME + 600);
    }
  }

  backdrop_json_output($requests);
  backdrop_exit();
}

/**
 * Page callback: Submit a result for a request.
 */
function openai_browser_submit_page() {
  openai_browser_ensure_session();

  $data = json_decode(file_get_contents('php://input'), TRUE);
  if ($data && !empty($data['uuid'])) {
    $uuid = $data['uuid'];
    $status = !empty($data['status']) ? $data['status'] : 'completed';
    $result_data = [
      'status' => $status,
      'result' => array_key_exists('result', $data) ? $data['result'] : NULL,
      'error' => !empty($data['error']) ? $data['error'] : NULL,
    ];
    $_SESSION['openai_browser_results'][$uuid] = $result_data;

    // Also update cache for more reliable concurrent signaling.
    cache_set('openai_browser_result:' . $uuid, $result_data, 'cache', REQUEST_TIME + 600);

    if ($status !== 'completed' && !empty($data['error'])) {
      watchdog('openai_browser', 'Browser client error for request @uuid: @error', [
        '@uuid' => $uuid,
        '@error' => $data['error'],
      ], WATCHDOG_WARNING);
    }
    else {
      watchdog('openai_browser', 'Browser client submitted @status for request @uuid.', [
        '@uuid' => $uuid,
        '@status' => $status,
      ], WATCHDOG_INFO);
    }
  }

  backdrop_json_output(['status' => 'ok']);
  backdrop_exit();
}

/**
 * Attach browser provider JS/settings once for the current page request.
 *
 * @param array $provider_config
 *   Normalized provider configuration.
 */
function openai_browser_attach_assets(array $provider_config) {
  static $attached = FALSE;
  if ($attached) {
    return;
  }

  if (!openai_browser_is_enabled($provider_config)) {
    return;
  }

  $chat_enabled = openai_browser_user_can_use('chat', $provider_config);
  $translate_enabled = openai_browser_user_can_use('translate', $provider_config);
  $summarize_enabled = openai_browser_user_can_use('summarize', $provider_config);

  if (!$chat_enabled && !$translate_enabled && !$summarize_enabled) {
    return;
  }

  $path = backdrop_get_path('module', 'openai_browser');

  $settings = [
    'openaiBrowser' => [
      'pollUrl' => url('openai-browser/poll', ['absolute' => TRUE]),
      'submitUrl' => url('openai-browser/submit', ['absolute' => TRUE]),
      'timeout' => isset($provider_config['browser_timeout']) ? (int) $provider_config['browser_timeout'] : 60,
      'pollingInterval' => isset($provider_config['browser_polling_interval']) ? (int) $provider_config['browser_polling_interval'] : 5,
      'foregroundOnly' => isset($provider_config['browser_foreground_only']) ? (bool) $provider_config['browser_foreground_only'] : TRUE,
      'enabledFeatures' => [
        'chat' => $chat_enabled,
        'translate' => $translate_enabled,
        'summarize' => $summarize_enabled,
      ],
      'downloadMessages' => [
        'chat' => isset($provider_config['browser_download_message_chat']) ? $provider_config['browser_download_message_chat'] : t('The browser AI provider requires downloading a language model to function. This is a one-time download.'),
        'summarize' => isset($provider_config['browser_download_message_summarize']) ? $provider_config['browser_download_message_summarize'] : t('The browser AI provider requires downloading the summarization model. This is a one-time download.'),
        'translate' => isset($provider_config['browser_download_message_translate']) ? $provider_config['browser_download_message_translate'] : t('A language pack is needed for translation. This is a one-time download.'),
      ],
    ],
  ];

  backdrop_add_js($settings, 'setting');
  backdrop_add_js($path . '/js/openai_browser.js');
  $attached = TRUE;
}

/**
 * Implements hook_init().
 */
function openai_browser_init() {
  $provider_config = openai_browser_get_provider_config();
  openai_browser_attach_assets($provider_config);
}

/**
 * Implements hook_page_build().
 */
function openai_browser_page_build(&$page) {
  $provider_config = openai_browser_get_provider_config();
  openai_browser_attach_assets($provider_config);
}