language-model-prompt.tentative.https.window.js

Enable keyboard shortcuts

This test has a WPT meta file that expects 6 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /ai/language-model/language-model-prompt.tentative.https.window.html - WPT Dashboard Interop Dashboard

// META: title=Language Model Prompt

// META: script=/resources/testdriver.js

// META: script=../resources/util.js

// META: timeout=long

'use strict';

promise_test(async () => {

  await ensureLanguageModel();

  const session = await createLanguageModel();

  const result = await session.prompt(kTestPrompt);

  assert_equals(typeof result, 'string');

}, 'Simple LanguageModel.prompt() call');

promise_test(async (t) => {

  await ensureLanguageModel();

  const session = await createLanguageModel();

  assert_true(!!(await session.prompt([])));

  // Invalid input should be stringified.

  assert_regexp_match(await session.prompt({}), /\[object Object\]/);

}, 'Check empty input');

promise_test(async (t) => {

  await ensureLanguageModel();

  const session = await createLanguageModel();

  assert_regexp_match(await session.prompt('shorthand'), /shorthand/);

  assert_regexp_match(

      await session.prompt([{role: 'system', content: 'shorthand'}]),

      /shorthand/);

}, 'Check Shorthand');

promise_test(async () => {

  const options = {

    initialPrompts:

        [{role: 'user', content: [{type: 'text', value: 'The word of the day is regurgitation.'}]}]

};

  await ensureLanguageModel(options);

  const session = await LanguageModel.create(options);

  const tokenLength = await session.measureInputUsage(options.initialPrompts);

  assert_greater_than(tokenLength, 0);

  assert_equals(session.inputUsage, tokenLength);

  assert_regexp_match(

      await session.prompt([{role: 'system', content: ''}]),

      /regurgitation/);

}, 'Test that initialPrompt counts towards session inputUsage');

promise_test(async () => {

  await ensureLanguageModel();

  const session = await createLanguageModel();

  const promise = new Promise(resolve => {

    session.addEventListener("quotaoverflow", resolve);

});

  // Make sure there is something to evict.

  const kLongPrompt = kTestPrompt.repeat(10);

  const usage = await session.measureInputUsage(kLongPrompt);

  assert_greater_than(session.inputQuota, usage);

  await session.prompt(kLongPrompt);

  // Generate a repeated kLongPrompt string that exceeds inputQuota.

  assert_greater_than(session.inputUsage, 0);

  const repeatCount = session.inputQuota / session.inputUsage;

  const promptString = kLongPrompt.repeat(repeatCount);

  // The prompt promise succeeds, while causing older input to be evicted.

  await Promise.all([promise, session.prompt(promptString)]);

}, 'The `quotaoverflow` event is fired when overall usage exceeds the quota');

promise_test(async t => {

  await ensureLanguageModel();

  const session = await createLanguageModel();

  const promptString = kTestPrompt.repeat(session.inputQuota);

  const requested = await session.measureInputUsage(promptString);

  await promise_rejects_quotaexceedederror(t, session.prompt(promptString), requested, session.inputQuota);

}, 'Test that prompt input exeeding the total quota rejects');