Skeletable

Find tables in the library. Each result gives its slug, the question it answers, its size and when it was last read.

{
  "type": "object",
  "properties": {
    "query": {
      "description": "Words to look for in titles, questions, columns and rows. Leave out to list everything.",
      "type": "string",
      "maxLength": 200
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Read a table: its scope, its columns with the rule for each, a summary of what each column holds, and its rows. A null value is blank. `origins` says where a row's unquoted values came from, `ai` says how far each AI column has got, and `versions` lists saved versions. For a big table, read the summaries first and page through rows with `offset` and `limit`.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120,
      "description": "From list_tables"
    },
    "version": {
      "description": "A saved version's number, from `versions` in get_table. Leave out for the live table",
      "type": "integer",
      "minimum": 1,
      "maximum": 9007199254740991
    },
    "offset": {
      "description": "Skip this many rows",
      "type": "integer",
      "minimum": 0,
      "maximum": 9007199254740991
    },
    "limit": {
      "description": "Return at most this many rows. 0 returns just the table's shape and summaries",
      "type": "integer",
      "minimum": 0,
      "maximum": 1000
    }
  },
  "required": [
    "slug"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

The evidence for one value: the source, the exact quote, what kind of source it is and when it was read. For a missing value, where we looked, and `absent` means the source was read and gives no such value. `url` is the cell's lasting address, showing its proof, for citing. `confirmed` says how a second reader backed it up, and without it the value has been read once. `conflicts` lists sources that state something else, `history` lists past values, and `watch` says whether the quote was still on its page at the last check.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120,
      "description": "From list_tables"
    },
    "row": {
      "type": "string",
      "maxLength": 200,
      "description": "The row's key, from get_table"
    },
    "column": {
      "type": "string",
      "maxLength": 80,
      "description": "The column's id, from get_table"
    }
  },
  "required": [
    "slug",
    "row",
    "column"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Test a statement against one cell, such as whether a value in a draft or an answer is right. The verdict is `matches`, `differs` (with what the source states), `disputed` (sources disagree, see `conflicts`) or `unknown` (no acceptable source stated it, so say so). It compares values and doesn't judge meaning, so read the quote before relying on a text verdict. Use list_tables and get_table to find the cell first.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120,
      "description": "From list_tables"
    },
    "row": {
      "type": "string",
      "maxLength": 200,
      "description": "The row's key, from get_table"
    },
    "column": {
      "type": "string",
      "maxLength": 80,
      "description": "The column's id, from get_table"
    },
    "value": {
      "type": "string",
      "maxLength": 300,
      "description": "The value being claimed"
    }
  },
  "required": [
    "slug",
    "row",
    "column",
    "value"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

A table as CSV, ready to save as a file or load into a notebook. The first column is each row's name unless `names` is false. `columns` picks columns by id, in that order. With `proof`, each column is followed by its source and quote, and in a table whose proof is optional, by where each value came from. An empty field means no value.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120,
      "description": "From list_tables"
    },
    "columns": {
      "description": "Column ids, from get_table. Leave out for every column",
      "maxItems": 20,
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 80
      }
    },
    "names": {
      "description": "Whether to start each line with the row's name. Defaults to true",
      "type": "boolean"
    },
    "proof": {
      "description": "Whether to add each value's source, quote and origin. Defaults to false",
      "type": "boolean"
    },
    "version": {
      "description": "A saved version's number, from `versions` in get_table. Leave out for the live table",
      "type": "integer",
      "minimum": 1,
      "maximum": 9007199254740991
    }
  },
  "required": [
    "slug"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Suggest a new value for a cell, with its proof. The quote must be word for word from the source and state the value. The owner reviews it before anything changes. Needs a token sent as a Bearer token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120,
      "description": "From list_tables"
    },
    "row": {
      "type": "string",
      "maxLength": 200,
      "description": "The row's exact key, from get_table"
    },
    "column": {
      "type": "string",
      "maxLength": 80,
      "description": "The column's id, from get_table"
    },
    "value": {
      "type": "string",
      "maxLength": 300,
      "description": "The new value, following the column's rule"
    },
    "source": {
      "type": "string",
      "maxLength": 2000,
      "format": "uri",
      "description": "The page that states it"
    },
    "quote": {
      "type": "string",
      "maxLength": 400,
      "description": "The exact words on that page"
    },
    "note": {
      "description": "Why this should change",
      "type": "string",
      "maxLength": 500
    }
  },
  "required": [
    "slug",
    "row",
    "column",
    "value",
    "source",
    "quote"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Make a private draft table, ready to fill, for anything from a tracker to a dataset. Its values say where they came from unless you set `proof` to `required`. Only `title`, `columns` and `rows` are needed now, but give `question`, `scope`, and a `rule` for each column if you can: a person has to supply them before publishing. Returns the column ids fill_cells needs, and the sheet's link, so tell your person to open it and watch it fill. Needs a token.

{
  "type": "object",
  "properties": {
    "template": {
      "description": "Start from a template, with its columns set up: `job-tracker` (Every application, where it stands and what's next, kept current from your email), `text-dataset` (Labeled examples to train or test a classifier, ready to load in a notebook), `reading-list` (What you want to read, what you're reading, and what you thought), `research-notes` (Sources and what each one says, with a topic your agent fills in). Then only `title` is optional",
      "type": "string",
      "enum": [
        "job-tracker",
        "text-dataset",
        "reading-list",
        "research-notes"
      ]
    },
    "title": {
      "description": "Needed unless you use a template",
      "type": "string",
      "maxLength": 120
    },
    "question": {
      "description": "The question the table answers",
      "type": "string",
      "maxLength": 300
    },
    "topic": {
      "description": "A broad subject, like Law or Consumer tech",
      "type": "string",
      "maxLength": 40
    },
    "scope": {
      "description": "What belongs in the table and what doesn't",
      "type": "string",
      "maxLength": 800
    },
    "owner": {
      "description": "A team you're on. Leave out for your own account",
      "type": "string",
      "maxLength": 60
    },
    "proof": {
      "description": "`optional` (the default): each value says where it came from, like a person, a file, an email or a page. `required`: every value must quote a source word for word, for a table of public facts",
      "type": "string",
      "enum": [
        "optional",
        "required"
      ]
    },
    "columns": {
      "description": "Needed unless you use a template",
      "minItems": 1,
      "maxItems": 20,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "label": {
            "type": "string",
            "maxLength": 80
          },
          "type": {
            "type": "string",
            "enum": [
              "text",
              "number",
              "boolean",
              "date"
            ],
            "description": "A date is written YYYY-MM-DD"
          },
          "unit": {
            "type": "string",
            "maxLength": 30
          },
          "rule": {
            "description": "What counts as this value, so two readers would fill it in the same way",
            "type": "string",
            "maxLength": 500
          },
          "instruction": {
            "description": "Makes it an AI column: what to work out for each row, naming other columns in braces, like \"Classify {Pitch} by genre\". Needs proof to be optional",
            "type": "string",
            "maxLength": 1000
          },
          "choices": {
            "description": "For a text column, the only values it takes, like a status list. An AI column answers with one of them",
            "maxItems": 50,
            "type": "array",
            "items": {
              "type": "string",
              "maxLength": 80
            }
          }
        },
        "required": [
          "label",
          "type"
        ]
      }
    },
    "rows": {
      "description": "Row names. To add rows with their values, use add_rows after",
      "maxItems": 500,
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 120
      }
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Add columns to a draft you run, such as a blank one a person started. Returns the new column ids for fill_cells. Needs a token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120
    },
    "columns": {
      "minItems": 1,
      "maxItems": 20,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "label": {
            "type": "string",
            "maxLength": 80
          },
          "type": {
            "type": "string",
            "enum": [
              "text",
              "number",
              "boolean",
              "date"
            ],
            "description": "A date is written YYYY-MM-DD"
          },
          "unit": {
            "type": "string",
            "maxLength": 30
          },
          "rule": {
            "description": "What counts as this value, so two readers would fill it in the same way",
            "type": "string",
            "maxLength": 500
          },
          "instruction": {
            "description": "Makes it an AI column: what to work out for each row, naming other columns in braces, like \"Classify {Pitch} by genre\". Needs proof to be optional",
            "type": "string",
            "maxLength": 1000
          },
          "choices": {
            "description": "For a text column, the only values it takes, like a status list. An AI column answers with one of them",
            "maxItems": 50,
            "type": "array",
            "items": {
              "type": "string",
              "maxLength": 80
            }
          }
        },
        "required": [
          "label",
          "type"
        ]
      }
    }
  },
  "required": [
    "slug",
    "columns"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Add up to 500 rows to a table you run. Each row is a name, or an object with its `values` by column id or label, so a whole tracker or dataset goes in a few calls. A row without a `key` gets the next free number. A name the table already has gets the values given for it, so syncing again from the same source is one call; with no values it's skipped. Say where the values came from with `origin` (`entered`, `imported` with a `note` naming the file or email, `link` with a `source`, or `generated`, which is the default without a source). Rows with values can go into a published table too; rows by name only into a draft. A table that requires proof takes rows by name only. Needs a token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120
    },
    "rows": {
      "minItems": 1,
      "maxItems": 500,
      "type": "array",
      "items": {
        "anyOf": [
          {
            "type": "string",
            "maxLength": 120
          },
          {
            "type": "object",
            "properties": {
              "key": {
                "type": "string",
                "maxLength": 120
              },
              "values": {
                "type": "object",
                "propertyNames": {
                  "type": "string",
                  "maxLength": 80
                },
                "additionalProperties": {
                  "anyOf": [
                    {
                      "type": "string",
                      "maxLength": 2000
                    },
                    {
                      "type": "number"
                    },
                    {
                      "type": "boolean"
                    }
                  ]
                }
              },
              "origin": {
                "type": "string",
                "enum": [
                  "link",
                  "generated",
                  "entered",
                  "imported"
                ]
              },
              "source": {
                "type": "string",
                "maxLength": 2000
              },
              "note": {
                "type": "string",
                "maxLength": 500
              }
            }
          }
        ]
      }
    }
  },
  "required": [
    "slug",
    "rows"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Set up to 200 cells of a table you run. Usually a cell gives `value` and `origin` (`entered`, `imported` with a `note` like the file or email it came from, `link` with its `source`, or `generated`). Left out, the origin is `link` when there's a `source` and `generated` when there isn't. These can go into a published table too, and never replace a quoted value. A date is written YYYY-MM-DD, and a column with choices takes only one of them. In a table that requires proof, a cell instead gives `value`, `source` and `quote`, word for word from the source; each page is opened before it's saved, so send at most 25 of these at once, and only into a draft. If no acceptable source states it, give `checked` with the pages you read, and `none_stated` only if you read the whole source and it has no such value. The reply counts what saved and lists only the cells that didn't, with a reason, and `unchecked` names quoted values whose page couldn't be read. Needs a token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120,
      "description": "From create_table or list_tables"
    },
    "cells": {
      "minItems": 1,
      "maxItems": 200,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "row": {
            "type": "string",
            "maxLength": 200
          },
          "column": {
            "type": "string",
            "maxLength": 80,
            "description": "The column's id, from get_table"
          },
          "value": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 2000
              },
              {
                "type": "number"
              },
              {
                "type": "boolean"
              }
            ]
          },
          "source": {
            "type": "string",
            "maxLength": 2000
          },
          "quote": {
            "type": "string",
            "maxLength": 400
          },
          "origin": {
            "description": "Where a value without a quote came from. Only in a table whose proof is optional",
            "type": "string",
            "enum": [
              "link",
              "generated",
              "entered",
              "imported"
            ]
          },
          "note": {
            "description": "How a value without a quote was made, such as the prompt that generated it",
            "type": "string",
            "maxLength": 500
          },
          "checked": {
            "maxItems": 10,
            "type": "array",
            "items": {
              "type": "string",
              "maxLength": 2000
            }
          },
          "none_stated": {
            "type": "boolean"
          }
        },
        "required": [
          "row",
          "column"
        ]
      }
    }
  },
  "required": [
    "slug",
    "cells"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

A private address that loads a table you run as CSV, for a notebook, a script or a spreadsheet, with the lines to do it. Add `?columns=a,b` to pick columns and `?names=0` to leave out row names. Anyone with the link can read the data, and `fresh` makes a new one so the old one stops working. Needs a token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120
    },
    "fresh": {
      "type": "boolean"
    }
  },
  "required": [
    "slug"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Freeze a table you run as it stands now, as a numbered version with a lasting link that never changes. Do this before training on a dataset or citing a table, and name the version you used. Needs a token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120
    },
    "note": {
      "description": "What this version is, like \"Before review\"",
      "type": "string",
      "maxLength": 200
    }
  },
  "required": [
    "slug"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Copy a table into your own account as a private draft, to extend or relabel: any published public table, or one you run. Every value keeps its proof or origin, and the copy remembers where it came from. Needs a token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120,
      "description": "owner/slug, from list_tables"
    },
    "title": {
      "description": "A title for the copy. Defaults to the original's",
      "type": "string",
      "maxLength": 120
    },
    "owner": {
      "description": "A team you're on. Leave out for your own account",
      "type": "string",
      "maxLength": 60
    }
  },
  "required": [
    "slug"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Make a column an AI column, change its instruction, or turn it back into a plain column with an empty one. The instruction says what to work out for each row and names other columns in braces, like "Classify {Pitch} by genre". Its values never overwrite what a person typed, linked or quoted. Needs proof to be optional and a token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120
    },
    "column": {
      "type": "string",
      "maxLength": 80,
      "description": "The column's id or label"
    },
    "instruction": {
      "type": "string",
      "maxLength": 1000
    },
    "choices": {
      "description": "For a text column, the only answers it takes",
      "maxItems": 50,
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 80
      }
    }
  },
  "required": [
    "slug",
    "column",
    "instruction"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

The next prompts to answer for a table's AI columns, up to 200 at a time: blank cells first, then answers whose row or instruction has changed. Answer each prompt yourself, then send the answers back with fill_ai_cells, each with its `row` and `basis`. Repeat until it says `done`. `redo` also re-answers generated values that came from outside the instruction. Needs a token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120
    },
    "column": {
      "description": "One AI column's id or label. Leave out for the first one with work waiting",
      "type": "string",
      "maxLength": 80
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "maximum": 200
    },
    "redo": {
      "type": "boolean"
    }
  },
  "required": [
    "slug"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Save up to 200 answers to an AI column, each with the `row` and `basis` next_ai_cells gave it. An answer outside the column's choices, or to a prompt that has since changed, comes back with a reason. Each value is saved as generated, with the instruction and `model`. Needs a token.

{
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 120
    },
    "column": {
      "type": "string",
      "maxLength": 80,
      "description": "The AI column's id, from next_ai_cells"
    },
    "model": {
      "type": "string",
      "maxLength": 80,
      "description": "The model that answered, like the one you are"
    },
    "answers": {
      "minItems": 1,
      "maxItems": 200,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "row": {
            "type": "string",
            "maxLength": 200
          },
          "value": {
            "type": "string",
            "maxLength": 2000
          },
          "basis": {
            "type": "string",
            "maxLength": 32
          }
        },
        "required": [
          "row",
          "value",
          "basis"
        ]
      }
    }
  },
  "required": [
    "slug",
    "column",
    "model",
    "answers"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}