@ohos-ports/genkit 1.42.0-beta.0

package/tests/genkit_test.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as assert from 'assert';
+import { describe, it } from 'node:test';
+import { genkit, getClientHeader } from '../src/index.js';
+
+describe('genkit', () => {
+  it('sets the client headers', async () => {
+    genkit({});
+
+    assert.ok(getClientHeader().includes('genkit-node/'));
+    assert.ok(!getClientHeader().includes('foo'));
+
+    genkit({ clientHeader: 'foo' });
+
+    assert.ok(getClientHeader().includes('genkit-node/'));
+    assert.ok(getClientHeader().includes('foo'));
+  });
+});

package/tests/helpers.ts

@@ -0,0 +1,176 @@
+/**
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { MessageData } from '@genkit-ai/ai';
+import type { BaseEvalDataPoint } from '@genkit-ai/ai/evaluator';
+import type { ModelAction, ModelInfo } from '@genkit-ai/ai/model';
+import type { SessionData, SessionStore } from '@genkit-ai/ai/session';
+import type { StreamingCallback } from '@genkit-ai/core';
+import type { Genkit } from '../src/genkit';
+import type {
+  GenerateRequest,
+  GenerateResponseChunkData,
+  GenerateResponseData,
+} from '../src/model';
+
+export function defineEchoModel(
+  ai: Genkit,
+  modelInfo?: ModelInfo
+): ModelAction {
+  const model = ai.defineModel(
+    {
+      name: 'echoModel',
+      ...modelInfo,
+    },
+    async (request, sendChunk) => {
+      (model as any).__test__lastRequest = request;
+      (model as any).__test__lastStreamingCallback = sendChunk;
+      if (sendChunk) {
+        await runAsync(() => {
+          sendChunk({
+            content: [
+              {
+                text: '3',
+              },
+            ],
+          });
+        });
+        await runAsync(() => {
+          sendChunk({
+            content: [
+              {
+                text: '2',
+              },
+            ],
+          });
+        });
+        await runAsync(() => {
+          sendChunk({
+            content: [
+              {
+                text: '1',
+              },
+            ],
+          });
+        });
+      }
+      return await runAsync(() => ({
+        message: {
+          role: 'model',
+          content: [
+            {
+              text:
+                'Echo: ' +
+                request.messages
+                  .map(
+                    (m) =>
+                      (m.role === 'user' || m.role === 'model'
+                        ? ''
+                        : `${m.role}: `) + m.content.map((c) => c.text).join()
+                  )
+                  .join(),
+            },
+            {
+              text: '; config: ' + JSON.stringify(request.config),
+            },
+          ],
+        },
+        finishReason: 'stop',
+      }));
+    }
+  );
+  return model;
+}
+
+export function bonknessEvaluator(ai: Genkit) {
+  return ai.defineEvaluator(
+    {
+      name: 'bonkness',
+      displayName: 'Bonkness',
+      definition: 'Judges whether a statement is bonk',
+    },
+    async (datapoint: BaseEvalDataPoint) => {
+      return {
+        testCaseId: datapoint.testCaseId,
+        evaluation: {
+          score: 'Much bonk',
+          details: {
+            reasoning: 'Because I said so!',
+          },
+        },
+      };
+    }
+  );
+}
+
+export async function runAsync<O>(fn: () => O): Promise<O> {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(fn()), 0);
+  });
+}
+
+export class TestMemorySessionStore<S> implements SessionStore<S> {
+  private data: Record<string, SessionData<S>> = {};
+
+  async get(sessionId: string): Promise<SessionData<S> | undefined> {
+    return this.data[sessionId];
+  }
+
+  async save(sessionId: string, sessionData: SessionData<S>): Promise<void> {
+    this.data[sessionId] = sessionData;
+  }
+}
+export function defineStaticResponseModel(
+  ai: Genkit,
+  message: MessageData
+): ModelAction {
+  return ai.defineModel(
+    {
+      name: 'staticResponseModel',
+    },
+    async () => {
+      return await runAsync(() => ({
+        message,
+      }));
+    }
+  );
+}
+
+export type ProgrammableModel = ModelAction & {
+  handleResponse: (
+    req: GenerateRequest,
+    sendChunk?: StreamingCallback<GenerateResponseChunkData>
+  ) => Promise<GenerateResponseData>;
+
+  lastRequest?: GenerateRequest;
+};
+
+export function defineProgrammableModel(ai: Genkit): ProgrammableModel {
+  const pm = ai.defineModel(
+    {
+      name: 'programmableModel',
+      supports: {
+        tools: true,
+      },
+    },
+    async (request, sendChunk) => {
+      pm.lastRequest = JSON.parse(JSON.stringify(request));
+      return pm.handleResponse(request, sendChunk);
+    }
+  ) as ProgrammableModel;
+
+  return pm;
+}

package/tests/mock-model_test.ts

@@ -0,0 +1,490 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { echoModel, mockModel, type MockResponse } from '@genkit-ai/ai/testing';
+import { z } from '@genkit-ai/core';
+import { initNodeFeatures } from '@genkit-ai/core/node';
+import * as assert from 'assert';
+import { beforeEach, describe, it } from 'node:test';
+import { genkit as genkitBeta, type GenkitBeta } from '../src/beta';
+import { genkit, type Genkit } from '../src/genkit';
+
+initNodeFeatures();
+
+describe('mockModel', () => {
+  let ai: Genkit;
+
+  beforeEach(() => {
+    ai = genkit({});
+  });
+
+  it('returns the scripted text and records the request', async () => {
+    const model = mockModel(ai, { respond: () => ({ text: 'a summary' }) });
+
+    const summarize = ai.defineFlow(
+      'summarize',
+      async (doc: string) =>
+        (await ai.generate({ model, prompt: `Summarize: ${doc}` })).text
+    );
+
+    assert.strictEqual(await summarize('long text'), 'a summary');
+    assert.strictEqual(model.requestCount, 1);
+    assert.match(model.lastRequestMessage!.text, /Summarize: long text/);
+  });
+
+  it('accepts a bare string as shorthand for text', async () => {
+    const model = mockModel(ai, { respond: () => 'hi there' });
+    const res = await ai.generate({ model, prompt: 'x' });
+    assert.strictEqual(res.text, 'hi there');
+  });
+
+  it('streams chunks via sendChunk', async () => {
+    const model = mockModel(ai, {
+      respond: (_req, { sendChunk }) => {
+        sendChunk('hel');
+        sendChunk('lo');
+        return { text: 'hello' };
+      },
+    });
+
+    const { response, stream } = ai.generateStream({ model, prompt: 'hi' });
+    const chunks: string[] = [];
+    for await (const chunk of stream) {
+      chunks.push(chunk.text);
+    }
+
+    assert.deepStrictEqual(chunks, ['hel', 'lo']);
+    assert.strictEqual((await response).text, 'hello');
+  });
+
+  it('emits tool requests that the framework dispatches', async () => {
+    const lookup = ai.defineTool(
+      {
+        name: 'lookup',
+        description: 'look something up',
+        inputSchema: z.object({ id: z.number() }),
+        outputSchema: z.string(),
+      },
+      async ({ id }) => `item-${id}`
+    );
+
+    const model = mockModel(ai, {
+      info: { supports: { tools: true } },
+      respond: (req) => {
+        const toolResponded = req.messages.some((m) =>
+          m.content.some((c) => c.toolResponse)
+        );
+        return toolResponded
+          ? { text: 'done' }
+          : { toolRequests: [{ name: 'lookup', input: { id: 1 } }] };
+      },
+    });
+
+    const res = await ai.generate({ model, prompt: 'go', tools: [lookup] });
+
+    assert.strictEqual(res.text, 'done');
+    assert.strictEqual(model.requestCount, 2);
+  });
+
+  it('records every request, oldest first', async () => {
+    const model = mockModel(ai, { respond: () => ({ text: 'ok' }) });
+    await ai.generate({ model, prompt: 'first' });
+    await ai.generate({ model, prompt: 'second' });
+
+    assert.strictEqual(model.requests.length, 2);
+    assert.match(model.requests[0].messages.at(-1)!.content[0].text!, /first/);
+    assert.match(model.requests[1].messages.at(-1)!.content[0].text!, /second/);
+  });
+
+  it('snapshots the request so later runs do not mutate history', async () => {
+    const model = mockModel(ai, { respond: () => ({ text: 'ok' }) });
+    await ai.generate({ model, prompt: 'first' });
+    const captured = model.lastRequest;
+    await ai.generate({ model, prompt: 'second' });
+
+    assert.match(captured!.messages.at(-1)!.content[0].text!, /first/);
+  });
+
+  it('separates adjacent messages so their text does not fuse', async () => {
+    const model = mockModel(ai, { respond: () => ({ text: 'ok' }) });
+    await ai.generate({ model, system: 'alpha', prompt: 'beta' });
+
+    // The last word of one message must not run into the first of the next,
+    // or boundary-spanning assertions silently break.
+    assert.doesNotMatch(model.lastRequestText!, /alphabeta/);
+    assert.match(model.lastRequestText!, /alpha\nbeta/);
+  });
+
+  it('returns a defensive copy from lastRequest and requests', async () => {
+    const model = mockModel(ai, { respond: () => ({ text: 'ok' }) });
+    await ai.generate({ model, prompt: 'hello' });
+
+    // Mutating the view must not corrupt recorded history.
+    model.lastRequest!.messages.length = 0;
+    model.requests[0].messages.length = 0;
+
+    assert.ok(model.lastRequest!.messages.length > 0);
+    assert.ok(model.requests[0].messages.length > 0);
+  });
+
+  it('defaults finishReason to stop when a full response leaves it undefined', async () => {
+    const model = mockModel(ai, {
+      respond: () => ({
+        message: { role: 'model', content: [{ text: 'x' }] },
+        finishReason: undefined,
+      }),
+    });
+
+    const res = await ai.generate({ model, prompt: 'hi' });
+    assert.strictEqual(res.finishReason, 'stop');
+  });
+
+  it('consumes an array of responses one per call, repeating the last', async () => {
+    const model = mockModel(ai, { respond: ['first', 'second'] });
+
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'a' })).text,
+      'first'
+    );
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'b' })).text,
+      'second'
+    );
+    // Past the end, the last response repeats rather than throwing.
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'c' })).text,
+      'second'
+    );
+    assert.strictEqual(model.requestCount, 3);
+  });
+
+  it('throws a queued Error to inject a failure on a given turn', async () => {
+    const model = mockModel(ai, {
+      respond: ['ok', new Error('rate limited')],
+    });
+
+    assert.strictEqual((await ai.generate({ model, prompt: 'a' })).text, 'ok');
+    await assert.rejects(ai.generate({ model, prompt: 'b' }), /rate limited/);
+  });
+
+  it('treats an empty-string response as empty text, not a missing message', async () => {
+    const model = mockModel(ai, { respond: '' });
+    const res = await ai.generate({ model, prompt: 'x' });
+    assert.strictEqual(res.text, '');
+    assert.deepStrictEqual(res.message?.content, [{ text: '' }]);
+  });
+
+  it('accepts a single static response, returned on every call', async () => {
+    const model = mockModel(ai, { respond: 'always this' });
+
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'a' })).text,
+      'always this'
+    );
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'b' })).text,
+      'always this'
+    );
+  });
+
+  it('swaps behavior for subsequent calls via respondWith', async () => {
+    const model = mockModel(ai, { respond: 'initial' });
+
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'a' })).text,
+      'initial'
+    );
+
+    model.respondWith(['first', 'second']);
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'b' })).text,
+      'first'
+    );
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'c' })).text,
+      'second'
+    );
+    // respondWith leaves recorded history untouched.
+    assert.strictEqual(model.requestCount, 3);
+  });
+
+  it('clears history and re-arms the construction respond via reset', async () => {
+    const model = mockModel(ai, { respond: ['first', 'second'] });
+
+    await ai.generate({ model, prompt: 'a' });
+    await ai.generate({ model, prompt: 'b' });
+    model.respondWith('overridden');
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'c' })).text,
+      'overridden'
+    );
+
+    model.reset();
+
+    assert.strictEqual(model.requestCount, 0);
+    assert.deepStrictEqual(model.requests, []);
+    assert.strictEqual(model.lastRequest, undefined);
+    // Back to the construction-time queue, re-armed from its first item.
+    assert.strictEqual(
+      (await ai.generate({ model, prompt: 'd' })).text,
+      'first'
+    );
+  });
+
+  it('exposes tool results fed back to the model via toolResponses', async () => {
+    const lookup = ai.defineTool(
+      {
+        name: 'lookup',
+        description: 'look something up',
+        inputSchema: z.object({ id: z.number() }),
+        outputSchema: z.string(),
+      },
+      async ({ id }) => `item-${id}`
+    );
+
+    const model = mockModel(ai, {
+      info: { supports: { tools: true } },
+      // A queued tool loop: request the tool, then answer.
+      respond: [
+        { toolRequests: [{ name: 'lookup', input: { id: 1 } }] },
+        'done',
+      ],
+    });
+
+    await ai.generate({ model, prompt: 'go', tools: [lookup] });
+
+    assert.deepStrictEqual(
+      model.toolResponses.map((t) => t.name),
+      ['lookup']
+    );
+    assert.strictEqual(model.toolResponses[0].output, 'item-1');
+  });
+
+  it('treats a falsy respond result as an empty response', async () => {
+    // A callback that streams but forgets to return (void) must not crash.
+    const model = mockModel(ai, {
+      respond: () => undefined as unknown as MockResponse,
+    });
+    const res = await ai.generate({ model, prompt: 'x' });
+    assert.strictEqual(res.text, '');
+  });
+
+  it('records a request even when it carries a non-serializable value', async () => {
+    const model = mockModel(ai, { respond: () => 'ok' });
+    // A function in config can't be structuredClone'd; recording must not throw.
+    await ai.generate({
+      model,
+      prompt: 'hi',
+      config: { onEvent: () => 1 } as unknown as Record<string, unknown>,
+    });
+    assert.strictEqual(model.requestCount, 1);
+    assert.match(model.lastRequestText!, /hi/);
+  });
+
+  it('flattens the whole assembled request via lastRequestText', async () => {
+    // Works even with an output schema, where echoModel can't be used: the mock
+    // returns conforming JSON, and assembly is asserted by inspection.
+    const model = mockModel(ai, {
+      respond: () => ({ text: JSON.stringify({ x: 'ok' }) }),
+    });
+
+    await ai.generate({
+      model,
+      system: 'Be terse',
+      prompt: 'hello',
+      output: { schema: z.object({ x: z.string() }) },
+    });
+
+    assert.match(model.lastRequestText!, /system: Be terse/);
+    assert.match(model.lastRequestText!, /hello/);
+  });
+
+  it('exposes the output schema to respond by default (native constrained)', async () => {
+    let seenSchema: unknown;
+    const model = mockModel(ai, {
+      respond: (req) => {
+        seenSchema = req.output?.schema;
+        return { text: JSON.stringify({ x: 'ok' }) };
+      },
+    });
+
+    await ai.generate({
+      model,
+      prompt: 'hello',
+      output: { schema: z.object({ x: z.string() }) },
+    });
+
+    // Native constrained: the schema is handed to the model on the request...
+    assert.ok(seenSchema, 'respond should see request.output.schema');
+    // ...not injected into the prompt.
+    assert.doesNotMatch(
+      model.lastRequestText!,
+      /conform to the following schema/i
+    );
+  });
+
+  it('simulates constrained output when supports.constrained is none', async () => {
+    let seenSchema: unknown = 'unset';
+    const model = mockModel(ai, {
+      info: { supports: { constrained: 'none' } },
+      respond: (req) => {
+        seenSchema = req.output?.schema;
+        return { text: JSON.stringify({ x: 'ok' }) };
+      },
+    });
+
+    await ai.generate({
+      model,
+      prompt: 'hello',
+      output: { schema: z.object({ x: z.string() }) },
+    });
+
+    // Simulated path strips the schema from what the model sees...
+    assert.strictEqual(seenSchema, undefined);
+    // ...and injects it into the prompt instead.
+    assert.match(model.lastRequestText!, /conform to the following schema/i);
+  });
+});
+
+describe('echoModel', () => {
+  let ai: Genkit;
+
+  beforeEach(() => {
+    ai = genkit({});
+  });
+
+  it('echoes the rendered request, for prompt-assembly assertions', async () => {
+    const model = echoModel(ai);
+    const res = await ai.generate({
+      model,
+      system: 'Be terse',
+      prompt: 'hello',
+    });
+
+    assert.match(res.text, /system: Be terse/);
+    assert.match(res.text, /hello/);
+  });
+
+  it('throws a clear error when the request carries an output schema', async () => {
+    const model = echoModel(ai);
+
+    await assert.rejects(
+      ai.generate({
+        model,
+        prompt: 'hi',
+        output: { schema: z.object({ x: z.string() }) },
+      }),
+      /can't satisfy an output schema/
+    );
+  });
+});
+
+// These cover the two features most likely to need dedicated helpers —
+// interrupts (human-in-the-loop) and agent handoff — and show that `mockModel`
+// already tests them with no extra machinery: an interrupt is just a tool
+// request the framework turns into a pause, and a handoff is just a
+// prompt-as-tool request. Both live on the beta surface (`chat`, resume).
+describe('mockModel — interrupts and agent handoff', () => {
+  let ai: GenkitBeta;
+
+  beforeEach(() => {
+    ai = genkitBeta({});
+  });
+
+  it('drives an interrupt round-trip, then resumes to completion', async () => {
+    // A human-in-the-loop tool: it interrupts on first run, and completes once
+    // the generation is resumed with an answer.
+    const confirmAction = ai.defineTool(
+      { name: 'confirmAction', description: 'needs human confirmation' },
+      async (_input, { interrupt, resumed }) => {
+        if (resumed) return 'approved';
+        return interrupt({ ask: 'Proceed?' });
+      }
+    );
+
+    let turn = 0;
+    const model = mockModel(ai, {
+      info: { supports: { tools: true } },
+      respond: () =>
+        turn++ === 0
+          ? { toolRequests: [{ name: 'confirmAction', input: {} }] }
+          : { text: 'all done' },
+    });
+
+    // Turn 1: the model calls the tool, the tool interrupts, generation pauses.
+    const paused = await ai.generate({
+      model,
+      prompt: 'do the thing',
+      tools: [confirmAction],
+    });
+    assert.strictEqual(paused.interrupts.length, 1);
+    assert.strictEqual(paused.interrupts[0].toolRequest.name, 'confirmAction');
+
+    // Turn 2: a human approves; resuming re-runs the tool and the model finishes.
+    const finished = await ai.generate({
+      model,
+      messages: paused.messages,
+      tools: [confirmAction],
+      resume: { respond: confirmAction.respond(paused.interrupts[0], 'yes') },
+    });
+
+    assert.strictEqual(finished.text, 'all done');
+    assert.strictEqual(model.requestCount, 2);
+  });
+
+  it('drives a defineAgent tool loop with mockModel, exposing the preamble', async () => {
+    // Migrated from an `app.chat(promptAgent)` handoff test: the beta Chat API
+    // (and its cross-agent preamble swap) was removed in #5248. This keeps the
+    // same mockModel surface under test — a multi-turn tool loop, with the
+    // agent's rendered system preamble asserted via `lastRequestText` — using
+    // the current `defineAgent(...).chat().send(...)` API.
+    const app = genkitBeta({ model: 'agentModel' });
+
+    app.defineTool(
+      { name: 'lookup', description: "Look up today's special." },
+      async () => 'Mushroom risotto'
+    );
+
+    const model = mockModel(app, {
+      name: 'agentModel',
+      info: { supports: { tools: true } },
+      respond: (req) => {
+        // The model's two-turn view of one `send`: call the tool, then once its
+        // result is in the conversation, finish.
+        const sawToolResult = req.messages.some((m) =>
+          m.content.some((c) => c.toolResponse?.output === 'Mushroom risotto')
+        );
+        return sawToolResult
+          ? { text: 'Booked: Mushroom risotto' }
+          : { toolRequests: [{ name: 'lookup', input: {} }] };
+      },
+    });
+
+    const agent = app.defineAgent({
+      name: 'concierge',
+      model: 'agentModel',
+      system: 'You are the booking concierge.',
+      tools: ['lookup'],
+    });
+
+    const { text } = await agent.chat().send('book me the special');
+
+    assert.strictEqual(text, 'Booked: Mushroom risotto');
+    assert.strictEqual(model.requestCount, 2);
+    // The agent's system preamble is what the model saw.
+    assert.match(model.lastRequestText!, /You are the booking concierge/);
+  });
+});