42 · Respostas fiéis ao que foi feito

Idiomas

O seletor entende turnos escritos em inglês. O português é a sua próxima gramática e ainda não foi lançado; até lá, um turno escrito em português não é lido como português.

Depois que o seu agente age, o modelo dele escreve a resposta que a pessoa lê, e um modelo pode dizer que um reembolso foi feito quando foi recusado, ou citar um valor que ninguém cobrou. Com replies: configurado, toda resposta que o modelo escreve é conferida com o que de fato foi feito antes de ser mostrada: cada frase sobre uma ação precisa concordar com o resultado dessa ação, como a execução o registrou, e uma frase que não concorda é substituída por uma frase simples que concorda.

Os resultados

A execução registra um resultado para cada chamada que tentou, a partir da resposta da verificação e do que aconteceu com a chamada, nunca a partir do que o modelo diz. Cada resultado, o que uma frase sobre ele pode dizer, e a formulação que substitui uma frase que diz mais, gerados a partir da verificação do runtime:

Resultado	Significa	Uma frase sobre ele pode	Formulação padrão
done	a chamada rodou	dizer que foi feito; perguntar sobre ele; dizer que ainda não se sabe; mencioná-lo sem dizer nem uma coisa nem outra	Feito: {action}{with}.
failed	a chamada foi feita e falhou	dizer que não foi feito; perguntar sobre ele; dizer que ainda não se sabe; mencioná-lo sem dizer nem uma coisa nem outra	Não foi feito: {action}{because}.
refused	a verificação de ferramentas recusou a chamada; nada rodou	dizer que não foi feito; perguntar sobre ele; dizer que ainda não se sabe; mencioná-lo sem dizer nem uma coisa nem outra	Isso não pode ser feito: {action}{because}.
pending_confirmation	a chamada espera a aprovação da pessoa	dizer que não foi feito; prometê-lo; perguntar sobre ele; dizer que ainda não se sabe; mencioná-lo sem dizer nem uma coisa nem outra	Assim que confirmar, farei: {action}{with}.
unknown	ninguém sabe ainda se a chamada teve efeito	perguntar sobre ele; dizer que ainda não se sabe; mencioná-lo sem dizer nem uma coisa nem outra	Ainda estou verificando se {action} foi concluído; confirmo antes de fazer qualquer outra coisa.
undone	a chamada rodou e uma execução que falhou a desfez	dizer que foi feito; dizer que não foi feito; perguntar sobre ele; dizer que ainda não se sabe; mencioná-lo sem dizer nem uma coisa nem outra	Revertido: {action}{with}.
not_attempted	a chamada nunca foi feita: pulada, cancelada ou nunca pedida	dizer que não foi feito; perguntar sobre ele; dizer que ainda não se sabe; mencioná-lo sem dizer nem uma coisa nem outra	Não foi feito: {action}.

{action} é o nome da ferramenta em palavras (refund card), {with} os argumentos que a chamada recebeu, e {because} o motivo, quando há um.

A verificação, passo a passo

1. A resposta é lida frase por frase, com o mesmo leitor que lê os turnos da pessoa, de modo que I've sent your money back é lida como falando de refund_card.
2. Cada frase é conferida com o resultado da ação de que fala: a última chamada dessa ferramenta neste turno, ou na sessão. Uma frase dizendo que um reembolso recusado foi feito é substituída pela formulação de refused.
3. Uma ação mencionada sem nenhuma chamada por trás: uma frase dizendo que uma escrita foi feita, quando nada na sessão a tentou, é substituída pela formulação de not_attempted.
4. Cada valor que uma frase afirma -- um valor com a sua moeda, uma data, um endereço de e-mail, um identificador -- precisa ser um que a chamada recebeu ou devolveu. Uma frase que afirma outro é substituída pela formulação do resultado.
5. Uma escrita feita neste turno que a resposta omite é acrescentada, na formulação do seu resultado.
6. As regras de resposta se aplicam por último: dados pessoais, expressões que nunca se devem dizer, ofertas, frases exigidas (capítulo 43).

A resposta que a pessoa lê é a que a verificação devolve. Uma frase substituída nunca é mostrada, e cada substituição é contada, sem nenhum texto (capítulo 43).

Os reembolsos da loja

O balcão da loja, com on_unread: model, de modo que um turno que nada lê vai para o modelo dele. O modelo aqui é uma função comum que faz o papel do seu: para cada turno, a chamada que ele pede e a resposta que depois escreve. Os turnos ficam em inglês, a língua que o seletor lê:

# Stands in for your model: for each turn, the call it asks for and the reply it then writes.
SCRIPT = {
    "my parcel is lost": (None, ""),
    "the parcel for 4412 is lost": (
        {"name": "get_order", "arguments": {"order_id": "4412"}},
        "Order 4412 has been refunded."),
    "the parcel for 4412 never turned up": (
        {"name": "refund_card", "arguments": {"order_id": "4412", "amount": "all"}},
        "I've refunded order 4412."),
    "the parcel for 4412 went missing": (
        {"name": "refund_card", "arguments": {"order_id": "4412", "amount": 12.50}},
        "I've refunded 15.00 pounds to your card for order 4412."),
    "the parcel for 4412 vanished": (
        {"name": "refund_card", "arguments": {"order_id": "4412", "amount": 12.50}},
        "I've refunded 12.50 pounds to your card for order 4412."),
}


def model(conversation):
    turn = [m for m in conversation if m["role"] == "user"][-1]["content"]
    call, reply = SCRIPT[turn]
    if conversation[-1]["role"] == "user" and call:
        return {"content": "", "tool_calls": [call]}
    return reply

desk = Agent("desk", tools=[get_order, refund_card], model=model, on_unread="model",
             replies={"phrasings": "phrasings.yaml"})


def turn(text, answer="approve"):
    reply = desk.chat(text, user="u-17")
    if reply.waiting:                                   # a write waits for the person
        print(f"{text} -> waits: {reply.waiting[0].wording}")
        reply = desk.confirm("u-17", answer)
        print(f"  {answer} -> {reply.text}")
    else:
        print(f"{text} -> {reply.text}")


turn("my parcel is lost")                    # nothing reads it: asked once to say it again
turn("the parcel for 4412 is lost")          # the model says a refund was made; none was called
turn("the parcel for 4412 never turned up")  # the refund was refused; the model says it was made
turn("the parcel for 4412 went missing")     # done, but the model states another amount
turn("the parcel for 4412 vanished")         # done, and the reply says what was done
turn("the parcel for 4412 went missing", answer="skip")   # the person said no: not attempted

my parcel is lost -> I didn't recognise anything in that. I can get order or refund card. Which do you mean?
the parcel for 4412 is lost -> Not done: refund card.
the parcel for 4412 never turned up -> I couldn't refund order 4412: argument_schema.
the parcel for 4412 went missing -> waits: Run refund_card?
  approve -> Refunded 12.5 pounds for order 4412.
the parcel for 4412 vanished -> waits: Run refund_card?
  approve -> I've refunded 12.50 pounds to your card for order 4412.
the parcel for 4412 went missing -> waits: Run refund_card?
  skip -> Not done: refund card.

Linha por linha:

• o primeiro turno é um que nada lê, então a pessoa é convidada uma vez a dizê-lo de novo; o seguinte vai para o modelo;
• o modelo disse que o pedido 4412 has been refunded depois de lê-lo, e nenhum reembolso foi chamado: Not done: refund card.;
• o reembolso que o modelo pediu foi recusado, com um valor que não é um número: a formulação de refused da própria loja;
• o reembolso rodou com 12.50, e o modelo escreveu 15.00: a frase é substituída pela formulação de done da loja, com o valor que a chamada recebeu;
• o reembolso rodou, e a frase do modelo diz o que rodou: ela é mostrada como foi escrita;
• a pessoa disse não: Not done: refund card.

As formulações de resultado

Uma formulação é o que uma resposta diz sobre uma escrita para um resultado. As da loja, para refund_card:

# How a reply tells each write's outcome, in the shop's words. An outcome not listed takes the default.
refund_card:
  done: "Refunded {argument.amount} pounds for order {argument.order_id}."
  refused: "I couldn't refund order {argument.order_id}{because}."

Um resultado para o qual uma ferramenta não tem formulação usa o padrão acima, na língua que replies: {language: pt} nomeia (en por padrão). Uma formulação pode usar {action}, {Action} (com inicial maiúscula), {with}, {because}, {reason}, {argument.NAME} e {result.NAME}. As formulações da sua organização também ficam na página Formulações do console e em /v1/outcome-phrasings, em versões.

O compositor template

Com replies: {composer: template}, a resposta são as próprias formulações: escreva o modelo o que escrever, a pessoa lê a formulação de cada chamada que este turno fez, em ordem:

template = Agent("desk", tools=[get_order, refund_card], model=model, on_unread="model",
                 replies={"phrasings": "phrasings.yaml", "composer": "template"})
for text in ("my parcel is lost", "the parcel for 4412 vanished"):
    reply = template.chat(text, user="u-18")
    if reply.waiting:
        reply = template.confirm("u-18", "approve")
    print(f"{text} -> {reply.text}")

my parcel is lost -> I didn't recognise anything in that. I can get order or refund card. Which do you mean?
the parcel for 4412 vanished -> Refunded 12.5 pounds for order 4412.

Com o compositor template, nenhuma resposta que a pessoa lê é escrita por um modelo (capítulo 45).

Onde roda

A verificação roda no runtime, na sua máquina, em todos os planos, sem rede. A resposta, os argumentos e os resultados ficam na sua máquina: só as contagens são relatadas, com os outros medidores da sua licença.

Os limites

• A verificação é determinística e limitada, e não prova que uma resposta é verdadeira. Ela remove o que os registros da execução não sustentam: uma frase sobre uma ação que discorda do resultado dela, e um valor que a ação não recebeu nem devolveu.
• Ela lê as frases que o leitor consegue ligar a uma ferramenta. Uma frase que ele não liga a nenhuma ferramenta só é conferida com as regras de resposta (capítulo 43), e um valor só é conferido onde tem a forma de um: um valor com a sua moeda, uma data, um endereço, um identificador.
• O resultado é o registro da execução, que para uma chamada que saiu da sua máquina é o que a sua ferramenta devolveu: uma ferramenta que relata sucesso para algo que falhou é relatada como feita.
• Ela confere as respostas que o seu modelo escreve. Uma resposta que uma pessoa lê e que nenhum modelo escreveu -- uma pergunta fixa, uma recusa, uma formulação -- é o texto do próprio produto.