question/contract

Import

Import

import * as api from "@fungi.computer/shiitake-extensions/question";

Exports

Kind	Export	Description
Ttype alias	Question	One decoded decision question.
Ttype alias	OpenAsk	One live or parked ask visible to Session clients.
Ttype alias	Answers	Decoded answers indexed by question identity.
Ttype alias	AnswerInput	Decoded human answer submission.
Ttype alias	DeclineInput	Decoded human decline submission.
Ttype alias	HumanResult	Decoded outcome of a human answer or decline.
Ttype alias	AgentAnswerResult	Decoded result of an authenticated Agent answer.
Ttype alias	EscalateResult	Decoded result of passing an Ask on.
constconstant	Question	A decision question: first option is recommended, free text belongs to the host.
constconstant	Questions	Bounded question set with distinct question identities.
constconstant	OpenAsk	The complete question data shared by ordinary Session clients.
constconstant	AskProjection	Bounded set of open asks projected into the Session.
constconstant	RequestId	Stable identity for a human command and its retry.
constconstant	Answers	Answers keyed by question id, with selected choices and optional free text.
constconstant	AnswerInput	Idempotent human submission of a complete answer set.
constconstant	DeclineInput	Idempotent human refusal to answer an ask.
constconstant	ClosedStatus	Terminal question outcomes, shared by human replies and model withdrawal.
constconstant	HumanResult	Admission, already-closed state, or absence returned to a human reply.
constconstant	SenderRefusal	Only the Agent an Ask waits on may answer or escalate it.
constconstant	AgentAnswerResult	Outcome of the Agent an Ask waits on answering it.
constconstant	AnsweredBy	The Agent that answered, as the host authenticated it.
constconstant	EscalateResult	Outcome of the Agent an Ask waits on passing it on.
constconstant	EscalateInput	The Agent’s request to pass an Ask on; the caller is host context.
constconstant	AnswerFlowInput	The answer conversation carries its draft between decision steps.
constconstant	questionContract	Human reads and the ordinary projection slot; model operations belong to the host.

QuestionTtype alias

Signature

type Question = Schema.Schema.Type<typeof Question>;

One decoded decision question.

---

OpenAskTtype alias

Signature

type OpenAsk = Schema.Schema.Type<typeof OpenAsk>;

One live or parked ask visible to Session clients.

---

AnswersTtype alias

Signature

type Answers = Schema.Schema.Type<typeof Answers>;

Decoded answers indexed by question identity.

---

AnswerInputTtype alias

Signature

type AnswerInput = Schema.Schema.Type<typeof AnswerInput>;

Decoded human answer submission.

---

DeclineInputTtype alias

Signature

type DeclineInput = Schema.Schema.Type<typeof DeclineInput>;

Decoded human decline submission.

---

HumanResultTtype alias

Signature

type HumanResult = Schema.Schema.Type<typeof HumanResult>;

Decoded outcome of a human answer or decline.

---

AgentAnswerResultTtype alias

Signature

type AgentAnswerResult = Schema.Schema.Type<typeof AgentAnswerResult>;

Decoded result of an authenticated Agent answer.

---

EscalateResultTtype alias

Signature

type EscalateResult = Schema.Schema.Type<typeof EscalateResult>;

Decoded result of passing an Ask on.

Questionconstconstant

Signature

const Question: Struct<{
  id: String;
  header: String;
  question: String;
  options: $Array<
    Struct<{
      label: String;
      description: String;
    }>
  >;
  multiple: optionalKey<Boolean>;
}>;

A decision question: first option is recommended, free text belongs to the host.

---

Questionsconstconstant

Signature

const Questions: $Array<
  Struct<{
    id: String;
    header: String;
    question: String;
    options: $Array<
      Struct<{
        label: String;
        description: String;
      }>
    >;
    multiple: optionalKey<Boolean>;
  }>
>;

Bounded question set with distinct question identities.

---

OpenAskconstconstant

Signature

const OpenAsk: Struct<{
  askId: String;
  waitingOn: optionalKey<
    Struct<{
      agentId: NonEmptyString;
      sessionId: NonEmptyString;
      name: NonEmptyString;
    }>
  >;
  questions: $Array<
    Struct<{
      id: String;
      header: String;
      question: String;
      options: $Array<
        Struct<{
          label: String;
          description: String;
        }>
      >;
      multiple: optionalKey<Boolean>;
    }>
  >;
  status: Literals<readonly ["live", "parked"]>;
  createdAt: Number;
  expiresAt: NullOr<Number>;
}>;

The complete question data shared by ordinary Session clients.

---

AskProjectionconstconstant

Signature

const AskProjection: Struct<{
  asks: $Array<Struct<{
     askId: String;
     waitingOn: optionalKey<Struct<{
        agentId: NonEmptyString;
        sessionId: NonEmptyString;
        name: NonEmptyString;
     }>>;
     questions: $Array<Struct<{
        id: String;
        header: String;
        question: String;
        options: $Array<Struct<{
           label: ...;
           description: ...;
        }>>;
        multiple: optionalKey<Boolean>;
     }>>;
     status: Literals<readonly ["live", "parked"]>;
     createdAt: Number;
     expiresAt: NullOr<Number>;
  }>>;
}>;

Bounded set of open asks projected into the Session.

---

RequestIdconstconstant

Signature

const RequestId: String;

Stable identity for a human command and its retry.

---

Answersconstconstant

Signature

const Answers: $Record<
  String,
  Struct<{
    selected: $Array<String>;
    text: optionalKey<String>;
  }>
>;

Answers keyed by question id, with selected choices and optional free text.

---

AnswerInputconstconstant

Signature

const AnswerInput: Struct<{
  askId: String;
  requestId: String;
  answers: $Record<
    String,
    Struct<{
      selected: $Array<String>;
      text: optionalKey<String>;
    }>
  >;
}>;

Idempotent human submission of a complete answer set.

---

DeclineInputconstconstant

Signature

const DeclineInput: Struct<{
  askId: String;
  requestId: String;
  note: optionalKey<String>;
}>;

Idempotent human refusal to answer an ask.

---

ClosedStatusconstconstant

Signature

const ClosedStatus: Literals<
  readonly [
    "answered",
    "declined",
    "withdrawn",
    "expired",
    "cancelled",
    "undeliverable",
  ]
>;

Terminal question outcomes, shared by human replies and model withdrawal.

---

HumanResultconstconstant

Signature

const HumanResult: Union<
  readonly [
    Struct<{
      result: Literal<"accepted">;
      via: Literals<readonly ["in_turn", "follow_up"]>;
      commandId: optionalKey<String>;
    }>,
    Struct<{
      result: Literal<"closed">;
      status: Literals<
        readonly [
          "answered",
          "declined",
          "withdrawn",
          "expired",
          "cancelled",
          "undeliverable",
        ]
      >;
    }>,
    Struct<{
      result: Literal<"not_found">;
    }>,
  ]
>;

Admission, already-closed state, or absence returned to a human reply.

---

SenderRefusalconstconstant

Signature

const SenderRefusal: Struct<{
  result: Literal<"refused">;
  reason: Literal<"not_sender">;
}>;

Only the Agent an Ask waits on may answer or escalate it.

---

AgentAnswerResultconstconstant

Signature

const AgentAnswerResult: Union<
  readonly [
    Union<
      readonly [
        Struct<{
          result: Literal<"accepted">;
          via: Literals<readonly ["in_turn", "follow_up"]>;
          commandId: optionalKey<String>;
        }>,
        Struct<{
          result: Literal<"closed">;
          status: Literals<
            readonly [
              "answered",
              "declined",
              "withdrawn",
              "expired",
              "cancelled",
              "undeliverable",
            ]
          >;
        }>,
        Struct<{
          result: Literal<"not_found">;
        }>,
      ]
    >,
    Struct<{
      result: Literal<"refused">;
      reason: Literal<"not_sender">;
    }>,
  ]
>;

Outcome of the Agent an Ask waits on answering it.

---

AnsweredByconstconstant

Signature

const AnsweredBy: Struct<{
  kind: Literal<"agent">;
  agentId: String;
}>;

The Agent that answered, as the host authenticated it.

---

EscalateResultconstconstant

Signature

const EscalateResult: Union<
  readonly [
    Struct<{
      result: Literal<"escalated">;
      to: Literal<"person">;
    }>,
    Struct<{
      result: Literal<"closed">;
      status: Literals<
        readonly [
          "answered",
          "declined",
          "withdrawn",
          "expired",
          "cancelled",
          "undeliverable",
        ]
      >;
    }>,
    Struct<{
      result: Literal<"not_found">;
    }>,
    Struct<{
      result: Literal<"refused">;
      reason: Literal<"not_sender">;
    }>,
  ]
>;

Outcome of the Agent an Ask waits on passing it on.

---

EscalateInputconstconstant

Signature

const EscalateInput: Struct<{
  askId: String;
}>;

The Agent’s request to pass an Ask on; the caller is host context.

---

AnswerFlowInputconstconstant

Signature

const AnswerFlowInput: Union<
  readonly [
    Struct<{
      askId: String;
      requestId: String;
      index: Number;
      answers: $Record<
        String,
        Struct<{
          selected: $Array<String>;
          text: optionalKey<String>;
        }>
      >;
      stage: Literal<"decision">;
      answer: Struct<{
        selected: $Array<String>;
        text: optionalKey<String>;
      }>;
    }>,
    Struct<{
      askId: String;
    }>,
    Struct<{}>,
  ]
>;

The answer conversation carries its draft between decision steps.

---

questionContractconstconstant

Signature

const questionContract: object;

Human reads and the ordinary projection slot; model operations belong to the host.

Type Declaration

Name	Type	Default value	Description
id	string & Brand<"ExtensionId">	-	Stable extension identity.
commands	object	-	Human question controls admitted by the Session owner.
commands.answerFlow	object	-	Advance the server-owned answer conversation.
commands.answerFlow.scope	"session"	"session"	The Session owns its asks and replies.
commands.answerFlow.input	Union<readonly [Struct<{ askId: String; requestId: String; index: Number; answers: $Record<String, Struct<{ selected: $Array<…>; text: optionalKey<…>; }>>; stage: Literal<"decision">; answer: Struct<{ selected: $Array<String>; text: optionalKey<String>; }>; }>, Struct<{ askId: String; }>, Struct<{ }>]>	AnswerFlowInput	Decode the current answer-draft step.
commands.answerFlow.output	declare<WhistleCatalogStepV1, WhistleCatalogStepV1>	CatalogStep	Return the next human conversation step.
commands.answer	object	-	Submit a person’s completed answers.
commands.answer.scope	"session"	"session"	The Session owns this ask.
commands.answer.input	Struct<{ askId: String; requestId: String; answers: $Record<String, Struct<{ selected: $Array<String>; text: optionalKey<String>; }>>; }>	AnswerInput	Decode the answer submission.
commands.answer.output	Union<readonly [Struct<{ result: Literal<"accepted">; via: Literals<readonly ["in_turn", "follow_up"]>; commandId: optionalKey<String>; }>, Struct<{ result: Literal<"closed">; status: Literals<readonly ["answered", "declined", "withdrawn", "expired", "cancelled", "undeliverable"]>; }>, Struct<{ result: Literal<"not_found">; }>]>	HumanResult	Return admission or the ask’s terminal state.
commands.answerAgent	object	-	Submit the answer of the Agent this Ask waits on; never a human answer.
commands.answerAgent.scope	"session"	"session"	The child Session owns the Ask; caller authority is host context.
commands.answerAgent.input	Struct<{ askId: String; requestId: String; answers: $Record<String, Struct<{ selected: $Array<String>; text: optionalKey<String>; }>>; }>	AnswerInput	Decode the answer submission without any caller-supplied actor.
commands.answerAgent.output	Struct<{ result: Union<readonly [Union<readonly [Struct<{ result: …; via: …; commandId: …; }>, Struct<{ result: …; status: …; }>, Struct<{ result: …; }>]>, Struct<{ result: Literal<"refused">; reason: Literal<"not_sender">; }>]>; answeredBy: Struct<{ kind: Literal<"agent">; agentId: String; }>; }>	-	Attribute the accepted answer to its authenticated Agent.
commands.escalateAgent	object	-	Pass the Ask on from the Agent it waits on; never a human action.
commands.escalateAgent.scope	"session"	"session"	The child Session owns the Ask; caller authority is host context.
commands.escalateAgent.input	Struct<{ askId: String; }>	EscalateInput	Decode the escalation without any caller-supplied recipient.
commands.escalateAgent.output	Union<readonly [Struct<{ result: Literal<"escalated">; to: Literal<"person">; }>, Struct<{ result: Literal<"closed">; status: Literals<readonly ["answered", "declined", "withdrawn", "expired", "cancelled", "undeliverable"]>; }>, Struct<{ result: Literal<"not_found">; }>, Struct<{ result: Literal<"refused">; reason: Literal<"not_sender">; }>]>	EscalateResult	Where the Ask waits now, or why it did not move.
commands.decline	object	-	Decline an ask with an optional note.
commands.decline.scope	"session"	"session"	The Session owns this ask.
commands.decline.input	Struct<{ askId: String; requestId: String; note: optionalKey<String>; }>	DeclineInput	Decode the decline submission.
commands.decline.output	Union<readonly [Struct<{ result: Literal<"accepted">; via: Literals<readonly ["in_turn", "follow_up"]>; commandId: optionalKey<String>; }>, Struct<{ result: Literal<"closed">; status: Literals<readonly ["answered", "declined", "withdrawn", "expired", "cancelled", "undeliverable"]>; }>, Struct<{ result: Literal<"not_found">; }>]>	HumanResult	Return admission or the ask’s terminal state.
commands.list	object	-	Read the Session’s open asks.
commands.list.scope	"session"	"session"	The Session owns the ask collection.
commands.list.input	Struct<{ }>	-	No additional arguments are required.
commands.list.output	Struct<{ asks: $Array<Struct<{ askId: String; waitingOn: optionalKey<Struct<{ agentId: …; sessionId: …; name: …; }>>; questions: $Array<Struct<{ id: …; header: …; question: …; options: …; multiple: …; }>>; status: Literals<readonly ["live", "parked"]>; createdAt: Number; expiresAt: NullOr<Number>; }>>; }>	AskProjection	Decode the currently visible asks.
projection	object	-	Open asks visible to Session clients.
projection.schema	Struct<{ asks: $Array<Struct<{ askId: String; waitingOn: optionalKey<Struct<{ agentId: NonEmptyString; sessionId: NonEmptyString; name: NonEmptyString; }>>; questions: $Array<Struct<{ id: String; header: String; question: String; options: $Array<…>; multiple: optionalKey<…>; }>>; status: Literals<readonly ["live", "parked"]>; createdAt: Number; expiresAt: NullOr<Number>; }>>; }>	AskProjection	Decoder for projected asks.