test: cover uncovered diff lines from the unicorn v65 rewrite

The unicorn autofix touched branches no existing spec exercised:

1. ws: a connection carrying x-forwarded-proto now asserts the server
   span's http.url resolves to wss, reaching getRequestProtocol's proxy
   arm (and the getSegment call inside it).
2. oracledb: a callback-form pool.getConnection pins the callback path,
   which only the promise form covered before.
3. ai-sdk: generateObject/generateText driven by messages (no top-level
   prompt) reach the `messages.findLast(...)` arm that prompt short-circuits.

The ai-sdk cases need a VCR cassette recorded against a real OPENAI_API_KEY
before they pass in replay-only CI.

Author: BridgeAR

packages/datadog-plugin-oracledb/test/index.spec.js

@@ -256,6 +256,31 @@ describe('Plugin', () => {
             assert.strictEqual(tracer.scope().active(), null)
           })
 
+          it('should instrument pool.getConnection with a callback', async () => {
+            const callbackConnection = await new Promise((resolve, reject) => {
+              pool.getConnection((error, conn) => error ? reject(error) : resolve(conn))
+            })
+
+            try {
+              await Promise.all([
+                agent.assertFirstTraceSpan({
+                  name: expectedSchema.outbound.opName,
+                  service: expectedSchema.outbound.serviceName,
+                  resource: dbQuery,
+                  type: 'sql',
+                  meta: {
+                    'span.kind': 'client',
+                    component: 'oracledb',
+                    'db.instance': dbInstance,
+                  },
+                }),
+                callbackConnection.execute(dbQuery),
+              ])
+            } finally {
+              await callbackConnection.close()
+            }
+          })
+
           it('should instrument errors', async () => {
             try {
               await connection.execute('invalid')

packages/datadog-plugin-ws/test/index.spec.js

@@ -248,6 +248,20 @@ describe('Plugin', () => {
           client.on('error', done)
         })
 
+        it('should derive the wss protocol from the x-forwarded-proto header', () => {
+          wsServer.on('connection', (ws) => {
+            ws.send('echo')
+          })
+
+          connectClient(`/${route}?active=true`, { headers: { 'x-forwarded-proto': 'https' } })
+
+          return agent.assertSomeTraces(traces => {
+            const span = findSpan(traces, s => s.name === 'web.request' && s.type === 'websocket')
+            assert.ok(span, 'Should have a web.request websocket span')
+            assert.match(span.meta['http.url'], /^wss:\/\//)
+          })
+        })
+
         it('should instrument message sending once per message', () => {
           wsServer.on('connection', ws => {
             connectionReceived = true

packages/dd-trace/test/llmobs/plugins/ai/index.spec.js

@@ -225,6 +225,75 @@ describe('Plugin', () => {
       })
     })
 
+    it('creates a span for generateText from messages without a prompt', async () => {
+      const options = {
+        model: openai('gpt-4o-mini'),
+        messages: [
+          { role: 'user', content: 'Hello, OpenAI!' },
+          { role: 'assistant', content: 'Hi! How can I help?' },
+          { role: 'user', content: 'What is the capital of France?' },
+        ],
+        experimental_telemetry: {
+          metadata: MOCK_TELEMETRY_METADATA,
+        },
+      }
+      if (semifies(realVersion, '>=5.0.0')) {
+        options.maxOutputTokens = 100
+      } else {
+        options.maxTokens = 100
+      }
+
+      await ai.generateText(options)
+
+      const { apmSpans, llmobsSpans } = await getEvents()
+
+      assertLlmObsSpanEvent(llmobsSpans[0], {
+        span: apmSpans[0],
+        name: 'generateText',
+        spanKind: 'workflow',
+        inputValue: 'What is the capital of France?',
+        outputValue: MOCK_STRING,
+        tags: { ml_app: 'test', integration: 'ai' },
+      })
+    })
+
+    it('creates a span for generateObject from messages without a prompt', async () => {
+      const schema = ai.jsonSchema({
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+          height: { type: 'string' },
+        },
+        required: ['name', 'age', 'height'],
+        additionalProperties: false,
+      })
+
+      await ai.generateObject({
+        model: openai('gpt-4o-mini'),
+        schema,
+        messages: [
+          { role: 'user', content: 'Invent a character' },
+          { role: 'assistant', content: 'Sure, here is one.' },
+          { role: 'user', content: 'Invent a character for a video game' },
+        ],
+        experimental_telemetry: {
+          metadata: MOCK_TELEMETRY_METADATA,
+        },
+      })
+
+      const { apmSpans, llmobsSpans } = await getEvents()
+
+      assertLlmObsSpanEvent(llmobsSpans[0], {
+        span: apmSpans[0],
+        name: 'generateObject',
+        spanKind: 'workflow',
+        inputValue: 'Invent a character for a video game',
+        outputValue: MOCK_STRING,
+        tags: { ml_app: 'test', integration: 'ai' },
+      })
+    })
+
     it('creates a span for embed', async () => {
       await ai.embed({
         model: openai.embedding('text-embedding-ada-002'),