Tool Calling ve Structured Output

// app/assistant/tools.ts
import { tool } from 'ai';
import { z } from 'zod';

export const tools = {
  getOrderStatus: tool({
    description: 'Bir siparişin kargo durumunu döndürür.',
    inputSchema: z.object({
      orderId: z.string().describe('Sipariş numarası, örn. TR-1042'),
    }),
    execute: async ({ orderId }) => ({
      orderId,
      status: 'kargoda',
      eta: '2026-10-18',
    }),
  }),

  cancelOrder: tool({
    description: 'Bir siparişi iptal eder. Geri alınamaz.',
    inputSchema: z.object({ orderId: z.string() }),
    execute: async ({ orderId }) => {
      // Gerçekte: await orderService.cancel(orderId)
      return { orderId, cancelled: true };
    },
  }),
};

// app/api/assistant/route.ts
import {
  convertToModelMessages,
  createUIMessageStreamResponse,
  isStepCount,
  streamText,
  toUIMessageStream,
  type UIMessage,
} from 'ai';
import { tools } from '../../assistant/tools';

export async function POST(req: Request) {
  const { messages }: { messages: UIMessage[] } = await req.json();

  const result = streamText({
    model: 'anthropic/claude-sonnet-5.5',
    instructions: 'Sipariş asistanısın. Sipariş iptali istenirse cancelOrder aracını çağır.',
    messages: await convertToModelMessages(messages),
    tools,
    toolApproval: { cancelOrder: 'user-approval' },
    stopWhen: isStepCount(5),
  });

  return createUIMessageStreamResponse({
    stream: toUIMessageStream({ stream: result.stream }),
  });
}

execute: async ({ orderId }) => {
  try {
    return await fetchOrderStatus(orderId);
  } catch (error) {
    console.error('[getOrderStatus]', error); // gerçek hata yalnızca sunucu logunda
    throw new Error('Sipariş servisine şu an ulaşılamıyor.');
  }
},

// app/assistant/types.ts
import type { InferUITools, UIMessage } from 'ai';
import type { tools } from './tools';

export type AssistantMessage = UIMessage<never, never, InferUITools<typeof tools>>;

// app/assistant/parts.tsx
import type { ChatAddToolApproveResponseFunction } from 'ai';
import type { AssistantMessage } from './types';

export function MessageParts({
  message,
  onApproval,
}: {
  message: AssistantMessage;
  onApproval: ChatAddToolApproveResponseFunction;
}) {
  return (
    <>
      {message.parts.map((part, i) => {
        switch (part.type) {
          case 'text':
            return <p key={i}>{part.text}</p>;

          case 'tool-getOrderStatus':
            switch (part.state) {
              case 'input-streaming':
              case 'input-available':
                return <p key={i}>Sipariş sorgulanıyor…</p>;
              case 'output-available':
                return <p key={i}>{part.output.orderId}: {part.output.status}</p>;
              case 'output-error':
                return <p key={i}>Sipariş sorgulanamadı.</p>;
              default:
                return null;
            }

          case 'tool-cancelOrder':
            switch (part.state) {
              case 'approval-requested':
                return (
                  <div key={i}>
                    <p>{part.input.orderId} numaralı sipariş iptal edilsin mi?</p>
                    <button onClick={() => onApproval({ id: part.approval.id, approved: true })}>
                      Evet, iptal et
                    </button>
                    <button onClick={() => onApproval({ id: part.approval.id, approved: false })}>
                      Vazgeç
                    </button>
                  </div>
                );
              case 'output-available':
                return <p key={i}>Sipariş iptal edildi.</p>;
              case 'output-denied':
                return <p key={i}>İptal edilmedi.</p>;
              case 'output-error':
                return <p key={i}>İptal işlemi başarısız oldu.</p>;
              default:
                return null;
            }

          default:
            return null;
        }
      })}
    </>
  );
}

// app/assistant/panel.tsx
'use client';

import { useChat } from '@ai-sdk/react';
import { DefaultChatTransport, lastAssistantMessageIsCompleteWithApprovalResponses } from 'ai';
import { MessageParts } from './parts';
import type { AssistantMessage } from './types';

export default function Assistant() {
  const { messages, addToolApprovalResponse } = useChat<AssistantMessage>({
    transport: new DefaultChatTransport({ api: '/api/assistant' }),
    sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithApprovalResponses,
  });

  return messages.map(message => (
    <MessageParts key={message.id} message={message} onApproval={addToolApprovalResponse} />
  ));
}

toolApproval: {
  cancelOrder: async ({ orderId }) => (orderId.startsWith('VIP') ? 'user-approval' : undefined),
},

pickSize: tool({
  description: 'Kullanıcıya beden seçtirir.',
  inputSchema: z.object({ options: z.array(z.string()).describe('Seçilebilir bedenler') }),
  outputSchema: z.string(), // execute yok: addToolOutput'un tipini bu belirler
}),

type SizeMessage = UIMessage<never, never, InferUITools<typeof clientTools>>;

const { messages, addToolOutput } = useChat<SizeMessage>({
  transport: new DefaultChatTransport({ api: '/api/assistant' }),
  sendAutomaticallyWhen: lastAssistantMessageIsCompleteWithToolCalls,
});

// message.parts.map içinde:
if (part.type !== 'tool-pickSize' || part.state !== 'input-available') return null;
return (
  <div key={`${message.id}-${i}`}>
    {part.input.options.map(size => (
      <button
        key={size}
        onClick={() => addToolOutput({ tool: 'pickSize', toolCallId: part.toolCallId, output: size })}
      >
        {size}
      </button>
    ))}
  </div>
);

import { generateText, Output } from 'ai';
import { z } from 'zod';

const ticketSchema = z.object({
  intent: z.enum(['siparis_durumu', 'iade', 'diger']),
  orderId: z.string().nullable(),
  urgent: z.boolean(),
});

export async function classify(text: string) {
  const { output } = await generateText({
    model: 'anthropic/claude-sonnet-5.5',
    output: Output.object({ schema: ticketSchema }),
    prompt: text,
  });
  return output; // { intent: 'siparis_durumu' | 'iade' | 'diger'; orderId: string | null; urgent: boolean }
}

import { Output, streamText } from 'ai';
import { z } from 'zod';

const recipeSchema = z.object({
  title: z.string(),
  ingredients: z.array(z.string()),
  minutes: z.number(),
});

export async function streamRecipe() {
  const result = streamText({
    model: 'anthropic/claude-sonnet-5.5',
    output: Output.object({ schema: recipeSchema }),
    prompt: 'Mercimek çorbası tarifi ver.',
  });

  for await (const partial of result.partialOutputStream) {
    console.log(partial); // { title?: string; ingredients?: string[]; minutes?: number }
  }

  return await result.output; // şemaya göre doğrulanmış son hâl
}